def train_diffaug(output_name, resume, augments, adv_step, n_repeats, eps):
train_folder = "trainB"
output_root = DATASET_ROOT[:-1] + output_name + "/"
train_output_root = output_root + "train_results/"
if not os.path.exists(output_root):
os.mkdir(output_root)
if not os.path.exists(train_output_root):
os.mkdir(train_output_root)
imagePath = DATASET_ROOT + train_folder + "/"
labelName = get_label_file_name(train_folder)
labelPath = DATASET_ROOT + labelName
outputPath = train_output_root + train_folder + "/"
start_epoch = 0
if resume is not "":
start_epoch = int(resume)
resume = outputPath + "checkpoint/cp-weights-" + resume + ".ckpt"
train_network(imagePath,
labelPath,
outputPath,
modelPath=resume,
augments=augments,
adv_step=adv_step,
n_repeats=n_repeats,
eps=eps,
resume=start_epoch)
def single_test_advbn(adv_step, n_repeats, eps, before_relu):
train_folder = "trainB"
# val_folders = ["valB"]
# val_folders = ["blur", 'distort', 'noise', 'combined',
# 'darkerR', 'darkerG', 'darkerB', 'darkerH', 'darkerS', 'darkerV',
# 'lighterR', 'lighterG', 'lighterB', 'lighterH', 'lighterS', 'lighterV']
# val_folders.extend(["valB_IMGC/" + os.path.basename(f.path) for f in os.scandir(DATASET_ROOT + "valB_IMGC") if f.is_dir()])
# print("testing: ", val_folders)
imagePath = DATASET_ROOT + train_folder + "/"
labelName = get_label_file_name(train_folder)
labelPath = DATASET_ROOT + labelName
outputPath = TRAIN_OUTPUT_ROOT + train_folder + "/"
modelPath = ROOT_DIR + "/Data/udacityA_nvidiaB_advbn2011lr_results/train_results/trainB/checkpoint/cp-weights-199.ckpt"
train_network(imagePath,
labelPath,
outputPath,
modelPath=modelPath,
BN_flag=3,
adv_step=adv_step,
n_repeats=n_repeats,
eps=eps,
before_relu=before_relu)
modelPath_new = outputPath + "/checkpoint/cp-weights-899.ckpt"
def prune_network(args, network=None):
device = torch.device("cuda" if args.gpu_no >= 0 else "cpu")
if network is None:
if args.data_set == 'CIFAR10':
if 'vgg' in args.network:
network = VGG(args.network, args.data_set)
if args.load_path:
check_point = torch.load(args.load_path)
network.load_state_dict(check_point['state_dict'])
# prune network
if 'vgg' in args.network:
network = global_pruning(network, args.prune_ratio)
network = network.to(device)
print("-*-"*10 + "\n\tPruned network\n" + "-*-"*10)
if not args.retrain_flag:
print(network)
torch.save(network, './models/pruning_results/'+args.network+'_pruned_structure.pth')
if args.retrain_flag:
# update arguemtns for retraing pruned network
args.epoch = args.retrain_epoch
args.lr = args.retrain_lr
args.lr_milestone = None # don't decay learning rate
network = train_network(args, network)
return network
def main():
"""Main Function."""
# dataloader parameters
gpu = torch.cuda.is_available()
data_path = 'data/labels_done.txt'
batch_size = 32
num_workers = 2
# network parameters
architecture = 'VGGNet11'
pretrained = True
finetuned = True
# training parameters
learning_rate = 1e-4
max_epochs = 200
criterion = nn.CrossEntropyLoss()
# get dataloader
dataloader, dataset_size = get_loader(data_path, batch_size, num_workers)
print('Dataset Size:', dataset_size)
# create network object
net = SingleFrame(architecture, pretrained, finetuned)
print(net)
# create optimizer
if not finetuned:
optimizer = torch.optim.Adam(net.fc.parameters(), learning_rate)
else:
optimizer = torch.optim.Adam(net.parameters(), learning_rate)
# train the network
best_acc, losses, accuracies = train_network(net, dataloader, dataset_size,
batch_size, criterion, optimizer, max_epochs, gpu)
# plot statistics
print('Best Training Accuracy:', best_acc*100)
def prune_network(args, network=None):
device = torch.device("cuda" if args.gpu_no >= 0 else "cpu")
if network is None:
network = VGG(args.vgg, args.data_set)
if args.load_path:
check_point = torch.load(args.load_path)
network.load_state_dict(check_point['state_dict'])
# prune network
network = prune_step(network, args.prune_layers, args.prune_channels,
args.independent_prune_flag)
network = network.to(device)
print("-*-" * 10 + "\n\tPrune network\n" + "-*-" * 10)
print(network)
if args.retrain_flag:
# update arguemtns for retraing pruned network
args.epoch = args.retrain_epoch
args.lr = args.retrain_lr
args.lr_milestone = None # don't decay learning rate
network = train_network(args, network)
return network
def main():
"""Main Function."""
# dataloader parameters
gpu = torch.cuda.is_available()
train_path = 'data/train_data.txt'
valid_path = 'data/valid_data.txt'
batch_size = 20
sequence_len = 50
num_workers = 2
# training parameters
max_epochs = 200
learning_rate = 1e-4
criterion = nn.CrossEntropyLoss()
# get dataloaders
dataloaders, dataset_sizes = get_loaders(train_path, valid_path,
batch_size, sequence_len,
num_workers, gpu)
# create network and optimizier
net = SingleFrame('VGGNet19')
print(net)
optimizer = torch.optim.Adam(net.parameters(), learning_rate)
# train the network
net, val_acc, losses, accuracies = train_network(net, dataloaders,
dataset_sizes, batch_size,
sequence_len, criterion,
optimizer, max_epochs,
gpu)
print('Best Validation Acc:', val_acc)
# plot
plot_data(losses, accuracies, 'outputs/online/SingleFramePlots.png')
# save network
torch.save(net.state_dict(), 'outputs/online/SingleFrameParams.pkl')
def main():
""" Load Arguments """
args = parse_args()
args.description = "Pytorch implementation of Multi-depth Hologram Generation Network (MDHGN)"
""" Define Network """
network = MDHGN(args)
""" CPU2GPU """
if args.is_cuda_available:
torch.cuda.set_device(args.device_number)
network.cuda()
""" initialization """
write_start_time(args)
make_csvfile_and_folders(args)
summary_architecture_of_network_(
args, network, (1, args.size_of_images, args.size_of_images))
""" Train Network """
train_network(args, network)
def train(self, dataset):
"""Train the network and record the accuracy.
Args:
dataset (str): Name of dataset to use.
"""
print("training!")
# if self.accuracy == 0.:
self.accuracy, self.mal_accuracy = train_network(self.network, dataset)
return self.accuracy, self.mal_accuracy
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-s",
"--source",
help="Source sensor [VI, MSI, OLI, OLCI, AER]")
parser.add_argument("-t",
"--target",
help="Target sensor [VI, MSI, OLI, OLCI, AER]")
parser.add_argument("--filename", help="Name of file to convert")
parser.add_argument("--datadir",
help="Directory data is located in",
default="Data")
parser.add_argument("--preddir",
help="Directory predictions should go in",
default="Predictions")
parser.add_argument("--builddir",
help="Directory DNN build is located in",
default="Build")
parser.add_argument("--gridsearch",
help="Flag to turn on hyperparameter gridsearch",
default=False)
parser.add_argument(
"--trainfmt",
help=
"Format of training file(s), with %%s identifying the source/target name (i.e. Rrs_LUT_%%s)",
default="Rrs_LUT_%s")
parser.add_argument(
"--testfmt",
help=
"Format of file(s) to be converted, with %%s identifying the source/target name (i.e. Rrs_LUT_%%s)",
default="Rrs_insitu_%s")
args = parser.parse_args()
train_network(
sensor_source=args.source,
sensor_target=args.target,
data_path=args.datadir,
save_path=args.preddir,
build_path=args.builddir,
train_fmt=args.trainfmt,
test_fmt=args.testfmt,
filename=args.filename,
gridsearch=args.gridsearch,
)
def make_kfold():
'''
Faz para cada um dos tres exames e para cada um dos tres modelos de rede
neural o treinalmento usando stratified k-fold cross validation. Retorna
uma matriz 3D que contem para cada cambinacao de exame e rede uma lista
com quatro valores: acuracia e loss no conjunto de treinamento e no de
validacao.
'''
raw_data = load_data()
n_folds = 5
resultado = np.zeros((3, 3, 4)) # [tr_lss,tr_acc, vl_lss,vl_acc]
for exam_type, name in [(0, 'IGG'), (1, 'IGM'), (2, 'PCR')]:
print('\n-------------------------------------------')
print('----------- Rede para ' + name + '------------------')
print('-------------------------------------------\n')
x, y = process_data(raw_data, exam_type)
x = x.to_numpy()
y = y.to_numpy()
print("Formato conjunto treinamento: {0} e de teste: {1}\n"\
.format(x.shape, y.shape))
skf = StratifiedKFold(n_splits=n_folds)
fold_iter = 1
for train, val in skf.split(x, y):
# cada iteracao é um novo fold
# (x_train_f, y_train_f, x_val_f, y_val_f)
fold_data = create_fold(x, y, train, val)
for model_n in NN:
# cada iteracao testa um modelo
if model_n == 0: network = NN1(fold_data[0].shape[1])
elif model_n == 1: network = NN2(fold_data[0].shape[1])
else: network = NN3(fold_data[0].shape[1])
optimizer = torch.optim.Adam(network.parameters(),
lr=LEARNING_RATE)
criterion = torch.nn.BCELoss()
valores = train_network(fold_data, network, optimizer, \
criterion, MODEL_PATH[exam_type])
resultado[exam_type][model_n] = np.sum([resultado[exam_type][model_n], \
np.asarray(valores)], axis=0)
print("Fold[{0}] model[{1}] accuracy on validation {2:.2f}% and train {3:.2f}%"\
.format(fold_iter, model_n+1, valores[3]*100, valores[1]*100))
fold_iter += 1
return np.divide(resultado, n_folds)
def main():
"""Main Function."""
# dataloader parameters
gpu = torch.cuda.is_available()
train_path = 'data/train_data.txt'
valid_path = 'data/valid_data.txt'
batch_size = 2
sequence_len = 50
window_size = 5
flow = False
num_workers = 2
# network parameters
model = 'VGGNet19'
rnn_hidden = 512
rnn_layers = 1
# training parameters
max_epochs = 1
learning_rate = 1e-4
criterion = nn.CrossEntropyLoss()
# get loaders
dataloaders, dataset_sizes = get_loaders(train_path, valid_path,
batch_size, sequence_len,
window_size, flow, num_workers,
gpu)
# create network and optimizer
net = SingleStream(model, rnn_hidden, rnn_layers, pretrained=True)
print(net)
optimizer = torch.optim.Adam(net.parameters(), learning_rate)
# train the network
net, val_acc, losses, accuracies = train_network(net, dataloaders,
dataset_sizes, batch_size,
sequence_len, window_size,
criterion, optimizer,
max_epochs, gpu)
# plot
if flow:
s_plots = 'outputs/online/SingleStreamFlowPlots.png'
s_params = 'outputs/online/SingleStreamFlowParams.pkl'
else:
s_plots = 'outputs/online/SingleStreamAppPlots.png'
s_params = 'outputs/online/SingleStreamAppParams.pkl'
# plot
plot_data(losses, accuracies, s_plots)
# save network
torch.save(net.state_dict(), s_params)
def main():
"""Main Function."""
# dataloader parameters
train_path = 'data/train_data.txt'
valid_path = 'data/valid_data.txt'
batch_size = 1
num_workers = 2
# network parameters
models = ['VGGNet11', 'VGGNet16', 'VGGNet19', 'ResNet18', 'ResNet34']
hidden_size = 128
rnn_layers = 1
pretrained = True
finetuned = False
# training parameters
learning_rate = 1e-4
max_epochs = 100
criterion = nn.CrossEntropyLoss()
# for each hyper-parameter
for i, model in enumerate(models):
print('Model:', model)
best_acc = 0
# get dataloaders
dataloaders, dataset_sizes = get_loaders(train_path,
valid_path,
batch_size,
num_workers,
shuffle=True)
print('Dataset Sizes:', dataset_sizes)
# create network object
net = SingleStream(model, hidden_size, rnn_layers, pretrained,
finetuned)
# create optimizer
p = list(net.lstm.parameters()) + list(net.fc.parameters())
optimizer = torch.optim.Adam(p, learning_rate)
# train the network
net, valid_acc, losses, accuracies = train_network(
net, dataloaders, dataset_sizes, criterion, optimizer, max_epochs)
# plot statistics
print('Best Validation Accuracy:', round(valid_acc * 100, 2))
plot_data(losses, accuracies, 'outputs/SingleStream-{}.png'.format(i))
print()
# save best network to disk
if valid_acc > best_acc:
torch.save(net.state_dict(), 'outputs/SingleStream-net_params.pkl')
def run_network_and_gen_preds(n_layers, dense_units, hidden_units, l2_reg_lambda,
dropout_keep_prob, attention, multiply, basic_lstm,
ignore_one_in_every):
max_doc_length = 50
embedding_dim = 300
batch_size = 1024
num_epochs = 20
evaluate_every = 1
lr = 1e-3
(checkpoint_file, loss) = train_network(n_layers=n_layers,
dense_units=dense_units,
max_doc_length=max_doc_length,
embedding_dim=embedding_dim, hidden_units=hidden_units,
l2_reg_lambda=l2_reg_lambda,
batch_size=batch_size, num_epochs=num_epochs,
evaluate_every=evaluate_every,
dropout_keep_prob=dropout_keep_prob, lr=lr,
multiply=multiply, basic_lstm=basic_lstm,
ignore_one_in_every=ignore_one_in_every)
csv_suffix = ("""layers_%(layers)s-dense_units_%(dense_units)s-hidden_%(hidden)s
-l2_%(l2)s-dropout_%(dropout)s-multiply%(multiply)s-basiclstm_%(basic_lstm)s
-ignore_%(ignore)s-loss_%(loss)s
""" % {"layers": n_layers, "dense_units": dense_units,
"hidden": hidden_units, "l2": l2_reg_lambda,
"dropout": dropout_keep_prob, "multiply": multiply,
"basic_lstm": basic_lstm, "ignore": ignore_one_in_every,
"loss": loss}).replace('\n', ' ').replace('\r', '')
csv_suffix = "".join(csv_suffix.split())
print(csv_suffix)
train_pred = generate_prediction(checkpoint_file= checkpoint_file, batch_size=1024,
batch_generator=train_batch_iter, has_labels=True)
train_pred.to_csv(("train-" + csv_suffix), index = False)
valid_pred = generate_prediction(checkpoint_file=checkpoint_file, batch_size=1024,
batch_generator=val_batch_iter, has_labels=True)
valid_pred.to_csv("valid-" + csv_suffix, index=False)
test_pred = generate_prediction(checkpoint_file=checkpoint_file, batch_size=1024,
batch_generator=test_batch_iter, has_labels=False)
test_pred.to_csv("test-" + csv_suffix, index = False)
def main():
"""Main Function."""
# dataloader parameters
gpu = torch.cuda.is_available()
data_path = 'data/labels.txt'
batch_size = 2
num_workers = 2
window_size = 10
# network parameters
architecture = 'AlexNet'
hidden_size = 512
rnn_layers = 2
pretrained = True
finetuned = False
# training parameters
learning_rate = 1e-4
max_epochs = 100
criterion = nn.CrossEntropyLoss()
# get dataloader
dataloaders, dataset_sizes = get_loader(data_path, window_size, batch_size,
num_workers)
print('Dataset Size:', dataset_sizes)
# create network object
net = DynamicAttention(architecture, hidden_size, rnn_layers, pretrained,
finetuned)
# create optimizer
if not finetuned:
p = list(net.embedding.parameters()) + list(net.attn.parameters()) \
+ list(net.attn_combine.parameters()) \
+ list(net.lstm.parameters()) + list(net.fc.parameters())
optimizer = torch.optim.Adam(p, learning_rate)
else:
optimizer = torch.optim.Adam(net.parameters(), learning_rate)
# train the network
best_acc, losses, accuracies = train_network(net, dataloaders,
dataset_sizes, criterion,
optimizer, max_epochs, gpu)
# plot statistics
print('Best Training Accuracy:', best_acc * 100)
plot_data(losses, accuracies)
def emotion_classifier(audio_source_path, storage_name, action):
get_observed_emotions_codes = get_emotion_code_from_description(emotion_labels)(observed_emotions)
[extraction_active, train_active] = parse_action(action)
print("Starting...")
print("Feature extraction: {0}".format(extraction_active))
print("Network train: {0}".format(train_active))
execute = (pipe
| get_features(
mfcc_required=True,
chroma_required=True,
mel_required=True,
storage_name=storage_name,
active=extraction_active)
| partial(filter, filter_dataset(get_observed_emotions_codes))
| list
| train_network())
execute(audio_source_path)
def main():
"""Main Function."""
# dataloader parameters
gpu = torch.cuda.is_available()
train_path = 'data/train_data.txt'
valid_path = 'data/valid_data.txt'
batch_size = 2
sequence_len = 10
num_workers = 2
# network parameters
spat_model = 'VGGNet11'
temp_model = 'VGGNet11'
rnn_hidden = 32
rnn_layers = 1
# training parameters
max_epochs = 2
learning_rate = 1e-4
window_size = 5
criterion = nn.CrossEntropyLoss()
# get loaders
dataloaders, dataset_sizes = get_loaders(train_path, valid_path,
batch_size, sequence_len, flow,
num_workers, gpu)
# create network and optimizer
net = TwoStreamFusion(spat_model,
temp_model,
rnn_hidden,
rnn_layers,
pretrained=False)
print(net)
optimizer = torch.optim.Adam(net.parameters(), learning_rate)
# train the network
net, val_acc, losses, accuracies = train_network(
net, dataloaders, dataset_sizes, batch_size, sequence_len - 1,
window_size, criterion, optimizer, max_epochs, gpu)
# plot
plot_data(losss, accuracies, 'outputs/online/TwoStreamPlots.png')
# save network
torch.save(net.state_dict(), 'outputs/online/TwoStreamParams.pkl')
def main():
"""Main Function."""
# dataloaders parameters
gpu = torch.cuda.is_available()
train_path = 'data/train_data.txt'
valid_path = 'data/valid_data.txt'
test_path = 'data/test_data.txt'
batch_size = 32
num_workers = 2
# network parameters
model = 'VGGNet19'
rnn_hidden = 512
rnn_layers = 2
# training parameters
max_epochs = 100
learning_rate = 1e-4
criterion = nn.CrossEntropyLoss()
# create dataloaders
dataloaders, dataset_sizes = get_loaders(train_path,
valid_path,
batch_size,
num_workers,
gpu=True)
print('Dataset Sizes:')
print(dataset_sizes)
# create network object and optimizer
net = SingleStream(model, rnn_hidden, rnn_layers, pretrained=True)
print(net)
optimizer = torch.optim.Adam(net.parameters(), learning_rate)
# train the network
net, val_acc, losses, accuracies = train_network(net, dataloaders,
dataset_sizes, batch_size,
criterion, optimizer,
max_epochs, gpu)
# plot
plot_data(losses, accuracies, 'outputs/offline/SingleStreamPlots.png')
# save network
torch.save(net.state_dict(), 'outputs/offline/SingleStreamParams.pkl')
def prune_network(args, network=None):
resnet_prune_layer = 1
device = torch.device("cuda" if args.gpu_no >= 0 else "cpu")
if args.net == 'resnet50' and network is None:
network = resnet()
if args.load_path:
check_point = torch.load(args.load_path)
network.load_state_dict(check_point['state_dict'])
elif network is None:
network = VGG(args.net, args.data_set)
if args.load_path:
check_point = torch.load(args.load_path)
network.load_state_dict(check_point['state_dict'])
# prune network
if args.net == 'resnet50':
if resnet_prune_layer == 1:
network = prune_resnet_1(network, args.prune_layers, args.independent_prune_flag)
if resnet_prune_layer == 2:
network = prune_resnet_2(network, args.prune_layers, args.independent_prune_flag)
if resnet_prune_layer == 3:
network = prune_resnet_3(network, args.prune_layers, args.independent_prune_flag)
else:
network = prune_step(network, args.prune_layers, args.prune_channels, args.independent_prune_flag)
network = network.to(device)
print("-*-"*10 + "\n\tPrune network\n" + "-*-"*10)
print(network)
if args.retrain_flag:
# update arguments for retraining pruned network
args.epoch = args.retrain_epoch
args.lr = args.retrain_lr
args.lr_milestone = None # don't decay learning rate
network = train_network(args, network)
return network
def run_experiment(stage=0):
experiment_dir = os.path.join(EXPERIMENT_ROOT_DIR, EXPERIMENT_TAG)
wav_output_dir = os.path.join(experiment_dir, "separate")
validation_loss_file = os.path.join(experiment_dir,
"validation_loss.npy.txt")
train_num_full_chunks = SAMPLERATE_HZ * TRAIN_UTTERANCE_LENGTH_IN_SECONDS // NETWORK_CHUNK_SIZE
separate_max_num_full_chunks = (SAMPLERATE_HZ *
SEPARATE_MAX_UTTERANCE_LENGTH_IN_SECONDS //
NETWORK_CHUNK_SIZE)
if stage <= 0: # Start with training
if os.path.exists(experiment_dir):
sys.exit("Experiment tag already in use. Change tag and run again")
os.mkdir(experiment_dir)
config_backup_file = os.path.join(experiment_dir, "config.py")
copyfile(os.path.realpath(__file__), config_backup_file)
os.chmod(config_backup_file, S_IREAD | S_IRGRP | S_IROTH)
if RESUME_TRAINING:
model_weights_file = os.path.join(
RESUME_FROM_MODEL_DIR,
"state_epoch_" + str(RESUME_FROM_EPOCH) + ".h5")
else:
model_weights_file = None
# Generate network
tasnet = TasnetWithDprnn(
batch_size=BATCH_SIZE,
model_weights_file=model_weights_file,
num_filters_in_encoder=NETWORK_NUM_FILTERS_IN_ENCODER,
encoder_filter_length=NETWORK_ENCODER_FILTER_LENGTH,
chunk_size=NETWORK_CHUNK_SIZE,
num_full_chunks=train_num_full_chunks,
units_per_lstm=NETWORK_NUM_UNITS_PER_LSTM,
num_dprnn_blocks=NETWORK_NUM_DPRNN_BLOCKS,
)
# Train network
tensorboard_dir = os.path.join(experiment_dir, "tensorboard_logs")
print(
"Run follwing command to run Tensorboard: \n",
"tensorboard --bind_all --logdir " + tensorboard_dir,
)
validation_loss = train_network(
experiment_dir=experiment_dir,
tensorboard_dir=tensorboard_dir,
batch_size=BATCH_SIZE,
num_batches_train=NUM_BATCHES_TRAIN,
num_batches_valid=NUM_BATCHES_VALID,
num_epochs=NUM_EPOCHS,
num_epochs_for_early_stopping=NUM_EPOCHS_FOR_EARLY_STOPPING,
optimizer_clip_l2_norm_value=OPTIMIZER_CLIP_L2_NORM_VALUE,
utterance_length_in_seconds=TRAIN_UTTERANCE_LENGTH_IN_SECONDS,
wav_data_dir_train=WAV_DIR_TRAIN,
wav_data_dir_valid=WAV_DIR_VALID,
file_list_path_train=FILE_LIST_PATH_TRAIN,
file_list_path_valid=FILE_LIST_PATH_VALID,
tasnet=tasnet,
)
np.savetxt(validation_loss_file, validation_loss, fmt="%.2f")
if stage <= 1: # Start with separation
if os.path.exists(wav_output_dir):
sys.exit("Separation folder already exists")
os.mkdir(wav_output_dir)
validation_loss_per_epoch = np.loadtxt(validation_loss_file)
epoch_with_best_validation_result = np.argmin(
validation_loss_per_epoch) + 1
model_weights_file = os.path.join(
experiment_dir,
"state_epoch_" + str(epoch_with_best_validation_result) + ".h5")
# Generate trained network
tasnet = TasnetWithDprnn(
batch_size=1,
model_weights_file=model_weights_file,
num_filters_in_encoder=NETWORK_NUM_FILTERS_IN_ENCODER,
encoder_filter_length=NETWORK_ENCODER_FILTER_LENGTH,
chunk_size=NETWORK_CHUNK_SIZE,
num_full_chunks=separate_max_num_full_chunks,
units_per_lstm=NETWORK_NUM_UNITS_PER_LSTM,
num_dprnn_blocks=NETWORK_NUM_DPRNN_BLOCKS,
)
# Use network to separate list of wav files
separator = Separator(
tasnet=tasnet,
input_dir=os.path.join(WAV_DIR_TEST, "mix_clean"),
output_dir=wav_output_dir,
max_num_chunks=separate_max_num_full_chunks,
)
separator.process_file_list(FILE_LIST_PATH_TEST)
if stage <= 2: # Start with evaluation
# Evaluate list of separated wav files
evaluator = Evaluator(
estimate_wav_dir=wav_output_dir,
groundtruth_wav_dir=WAV_DIR_TEST,
sample_list_path=FILE_LIST_PATH_TEST,
)
print("SI-SNR Performance on Test Set:", evaluator.mean_sisnr)
np.savetxt(os.path.join(experiment_dir, "results.npy.txt"),
evaluator.results,
fmt="%.2f")
np.savetxt(
os.path.join(experiment_dir, "mean_result.npy.txt"),
np.array([evaluator.mean_sisnr]),
fmt="%.2f",
)
print('\n------------------------\n')
print('[REDE ' + name + '] SEPARANDO DADOS PARA TREINAMENTO...')
processed_data = process_data(data, exam_type)
print('[REDE ' + name + '] ADEQUANDO DADOS PARA TREINAMENTO...')
splitted_data = split_data(processed_data)
print('[REDE ' + name + '] MONTANDO MODELO...')
x_train = splitted_data[0]
y_train = splitted_data[2]
print('[REDE ' + name + '] ' + str(len(x_train)) + \
' ELEMENTOS NO CONJUNTO DE TREINAMENTO...')
print('[REDE ' + name + '] ' + str(len(y_train)) + \
' ELEMENTOS NO CONJUNTO DE VALIDAÇÃO...')
print('[REDE ' + name + '] INSTANCIANDO REDES...')
network = NN2(x_train.shape[1])
optimizer = torch.optim.Adam(network.parameters(), lr=LEARNING_RATE)
criterion = torch.nn.BCELoss()
print('[REDE ' + name + '] TREINANDO...\n')
train_network(splitted_data, network, optimizer, criterion, \
MODEL_PATH[exam_type], True, True)
print('MODELO TREINADO. (Salvo em ' + MODEL_PATH[exam_type] + ')')
end = time.time()
print('\nTEMPO GASTO: %.2fs' % (end - start))
print('FIM.')
default=1.0)
parser.add_argument("--save-path",
type=str,
help="save path",
default=None)
parser.add_argument("--check-point",
type=str,
help="check point path to load trained model",
default=None)
parser.add_argument("--image",
type=str,
help="test image path",
default=None)
args = parser.parse_args()
print("-*-" * 10, "arguments", "-*-" * 10)
for key, value in vars(args).items():
print("%s: %s" % (key, value))
if args.gpu_no >= 0:
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_no)
if args.train_flag:
discriminator, generator = train_network(args)
else:
evaluate_network(args)
model = None
criterion = None
optimizer = None
actions = ['predict', 'build', 'train', 'exit']
device = helper.get_device()
while (flag != True):
action = input(
"\nWhat would you like to do? Actions include: \n{}\n".format(actions))
if (action == actions[0]):
if (model != None):
predict.predict(model)
else:
predict.predict(None)
elif (action == actions[1]):
model = helper.build_new_network()
elif (action == actions[2]):
if (model != None):
model = train.train_network(model)
else:
model = train.train_network(None)
elif (action == actions[3]):
flag = False
else:
print('Invalid selection. Please select from: \n{}\n'.format(actions))
config.f_tensorboard = args.tensorboard_saving_freq
config.sb_blocks = args.small_blocks
config.batch_size = args.batch_size
config.sequence_length = args.sequence_length
config.alt_dir = args.deploy_path
config.lr_max = args.max_learn_rate
config.lr_min = args.min_learn_rate
config.period = args.period
config.encoder_mlp_layers = args.encoder_mlp_layers
config.sdf_state = args.sdf_state_size
config.save_gif = args.gif_saver_f
if os.path.isdir(args.grid_path):
config.grid_dir = args.grid_path
config.use_fem = args.use_differential_kernels
config.fem_loss = args.fem_difference
config.conv = args.convolution
if args.train:
train.train_network()
elif args.train_integrator:
train.train_integrator()
else:
print('Inference AE with random field')
inference.restore_ae(data=config.data_path,
graph_path=config.path_e,
grid=config.grid_dir,
frame=args.iframe)
MODEL_PATH = 'FFN_2HLayers_weather.pt'
if __name__ == "__main__":
print('CARREGANDO DADOS...')
raw_data = load_data()
print('PRE-PROCESSANDO DADOS...')
processed_data = pre_processing(raw_data)
print('GERANDO VISUAIZACOES DOS DADOS...')
visualize_data(processed_data)
print('ADEQUANDO DADOS PARA TREINAMENTO...')
splitted_data = split_data(processed_data)
print('MONTANDO MODELO...')
x_train = splitted_data[0]
network = FFN_2HLayers(x_train.shape[1], N_HL1, N_HL2)
optimizer = torch.optim.Adam(network.parameters(), lr=LEARNING_RATE)
criterion = torch.nn.BCELoss()
print('TREINANDO...')
train_network(splitted_data, network, optimizer, criterion, MODEL_PATH)
print('MODELO TREINADO. (Salvo em ' + MODEL_PATH + ')')
# Uso iterativo do modelo:
print('Use o menu a seguir para explorar o modelo iterativamente:\n')
use_iteratively()
print('FIM.')
def train():
tkMessageBox.showinfo("Neural Network Trainer","Press Ok to start training")
train_network(net)
tkMessageBox.showinfo("Neural Network Trainer","Training Done")
parser.add_argument('--train_step', '-t_step', type=int, default=3,
help='The step of frame sequence.')
parser.add_argument('--sample_step', '-s_step', type=int, default=3,
help='The length of frame sequence as network input.')
config = parser.parse_args()
if config.train or config.resume:
if config.split_video:
print('-- Start Splitting Video to Frames')
utils.split_video(config.video_a_input, config.dataset_a_dir)
print('-- Complete Splitting %s' % config.video_a_input)
utils.split_video(config.video_b_input, config.dataset_b_dir)
print('-- Complete Splitting %s' % config.video_b_input)
utils.split_video(config.video_sample_input, config.sample_dir)
print('-- Complete Splitting %s' % config.video_sample_input)
train.train_network(config)
elif config.generate_video:
if config.split_video:
print('-- Start Splitting Video to Frames')
utils.split_video(config.video_sample_input, config.sample_dir)
print('-- Complete Splitting %s' % config.video_sample_input)
train.test_network(config)
print('-- Start Generating Video from Frames')
utils.generate_video_from_epoch(config, 0)
print('-- Result Video Saved')
else:
print('-- Command Error')
print('-- Please Enter Add -h Argument to See Usage')
from parameter import get_parameter
from train import train_network
from evaluate import test_network
from prune import prune_network
import math
if __name__ == '__main__':
args = get_parameter()
network = None
if args.train_flag:
network = train_network(args, network=network)
if args.prune_flag:
network = prune_network(args, network=network)
test_network(args, network=network)
cross_validation = k_folder_cross_validation(
5, opt, dataset="pingpong_dataset")
train_loader, train_logger, train_batch_logger, val_loader, val_logger = (
cross_validation())
demo_loader = get_demo_dataloader(opt)
for i in range(opt.begin_epoch, opt.n_epochs + 1):
if not opt.no_train:
print("training at epoch: {}".format(i))
train_network(
opt=opt,
model=model,
criterion=criterion,
optimizer=optimizer,
train_logger=train_logger,
dataloader=train_loader,
epoch=i,
)
if not opt.no_val:
print("validation at epoch: {}".format(i))
val_loss = validate_network(
opt=opt,
model=model,
dataloader=val_loader,
val_log=val_logger,
criterion=criterion,
epoch=i,
)
def create_data():
''' Gather all results in consistent format, then write to output file '''
if not os.path.exists('Results'):
os.mkdir('Results')
num_points = None
sensor_data = {}
write_data = []
for k, source_sensor in enumerate(sorted(sensor_labels)):
for k2, target_sensor in enumerate(sorted(sensor_labels)):
if source_sensor == target_sensor:
continue
target = load_Rrs(insitu_file_fmt % target_sensor)
source = load_Rrs(insitu_file_fmt % source_sensor)
if source_sensor == 'MSI': source = source[:, :4]
if target_sensor == 'MSI': target = target[:, :4]
DNN_filename = DNN_file_fmt % (source_sensor, target_sensor)
SM_filename = SM_file_fmt % (source_sensor, target_sensor)
if not os.path.exists(DNN_filename):
train_network(source_sensor, target_sensor)
if not os.path.exists(SM_filename): continue
if num_points is not None:
assert (target.shape[0] == num_points
), 'Different number of samples: %s != %s' % (
target.shape[0], num_points)
num_points = target.shape[0]
target_wave = np.array(wavelengths[target_sensor][:9])
source_wave = np.array(wavelengths[source_sensor][:9])
f = {
'Mélin & Sclep (2015)':
(lambda: melin(source, source_wave, target_wave).T),
'Spectral Matching': (lambda: np.load(SM_filename)),
'Cubic Spline': (lambda: CubicSpline(
source_wave, source.T, axis=0, extrapolate=True)
(target_wave).T),
'Deep Neural Network': (lambda: load_Rrs(DNN_filename)),
}
method_data = {}
for name in names:
v = f[name]()
if target_sensor == 'MSI': v = v[:, :4]
method_data[name] = v
write_data.append({
'Method':
name,
'Reference':
source_sensor,
'Target':
target_sensor,
'RMSE':
np.mean(
[float(rmse(vv, t)) for vv, t in zip(v.T, target.T)]),
'RRMS':
rrms(target, v),
'Diff_mean':
bias_mean(target, v),
'Diff_med':
bias_med(target, v),
'Diff_std':
bias_std(target, v),
'RMSE_band':
[float(rmse(vv, t)) for vv, t in zip(v.T, target.T)],
'RRMS_band':
[float(rrms(vv, t)) for vv, t in zip(v.T, target.T)],
'Diff_mean_band':
[float(bias_mean(vv, t)) for vv, t in zip(v.T, target.T)],
'Diff_med_band':
[float(bias_med(vv, t)) for vv, t in zip(v.T, target.T)],
'Diff_std_band':
[float(bias_std(vv, t)) for vv, t in zip(v.T, target.T)],
'Slope_band':
[linregress(vv, t)[0] for vv, t in zip(v.T, target.T)],
'Intercept_band':
[linregress(vv, t)[1] for vv, t in zip(v.T, target.T)],
'Rsquared_band':
[linregress(vv, t)[2] for vv, t in zip(v.T, target.T)],
})
sensor_data[(source_sensor, target_sensor)] = method_data
with open(data_filename, 'wb+') as f:
pkl.dump(sensor_data, f)
write_keys = [
'Reference', 'Target', 'Method', 'RMSE', 'RRMS', 'Diff_mean',
'Diff_med', 'Diff_std', 'RMSE_band', 'RRMS_band', 'Diff_mean_band',
'Diff_med_band', 'Diff_std_band', 'Slope_band', 'Intercept_band',
'Rsquared_band'
]
max_num_bands = max(len(wavelengths[k]) for k in sensor_labels)
with open('Results/stats.csv', 'w+') as f:
band_keys = [w for w in write_keys if '_band' in w]
over_keys = [w for w in write_keys if '_band' not in w]
w_keys = over_keys + [
k for w in band_keys
for k in ['%s_%s' % (w, i) for i in range(max_num_bands)]
]
f.write(','.join(w_keys) + '\n')
for line in write_data:
vals = [str(line[w]).replace(',', ';') for w in over_keys]
for w in band_keys:
vals += [str(k) for k in line[w]]
if len(line[w]) < max_num_bands:
vals += [''] * (max_num_bands - len(line[w]))
f.write(','.join(vals) + '\n')
def gen_population(generations, population, nn_param_choices):
optimizer = Optimizer(nn_param_choices) #choices are unimportant
networks = optimizer.create_population(population)
# Evolve the generation.
mnist = tf.contrib.learn.datasets.load_dataset("mnist")
F = open("results_sorted_exp_10.txt", "w")
for i in range(generations):
logging.info("***Doing generation %d of %d***" %
(i + 1, generations))
# Train and get accuracy for networks.
accuracys, accuracys_mal = train_network(networks, "mnist", population, mnist)
# accuracys, sess = test_with_weights(networks, accuracys_run, population, mnist)
for j in range(population):
# print("training in perm")
# print(net.network)
# acc, acc_mal = net.train("mnist")
# get from our calculated
acc = accuracys[j]
acc_mal = accuracys_mal[j]
#let the net know how it performed!
networks[j].set_accuracies(acc, acc_mal)
F.write("Net accuracy:%.2f\n" % acc)
F.write("\n")
# print(acc)
F.write("Net accuracy mal:%.2f\n" % acc_mal)
F.write("\n")
print("Net accuracy:%.2f\n" % acc)
print("\n")
# print(acc)
print("Net accuracy mal:%.2f\n" % acc_mal)
print("\n")
connects = networks[j].get_conns()
F.write("Connections in net:%.2f\n" % connects)
F.write("\n")
print("Connections in net:%.2f\n" % connects)
print("\n")
# print(acc_mal)
accuracys.append(acc)
accuracys_mal.append(acc_mal)
# Get the average accuracy for this generation.
average_accuracy = np.mean(accuracys)
average_accuracy_mal = np.mean(accuracys_mal)
# Print out the average accuracy each generation.
F.write("Generation average: %.2f\n" % (average_accuracy * 100))
F.write("Generation average mal: %.2f\n" % (average_accuracy_mal * 100))
print("Generation average: %.2f\n" % (average_accuracy * 100))
print("Generation average mal: %.2f\n" % (average_accuracy_mal * 100))
# logging.info('-'*80)
# Evolve, except on the last iteration.
if i != generations - 1:
# Do the evolution.
networks = optimizer.evolve(networks)
# Sort our final population.
networks = sorted(networks, key=lambda x: 1/x.mal_accuracy, reverse=True)
for net in networks[:5]:
F.write("acc ")
F.write('{}'.format(net.accuracy))
F.write("\n")
F.write("acc_mal ")
F.write('{}'.format(net.mal_accuracy))
F.write("\n")
F.write("setup ")
F.write('{}'.format(net.network))
F.write("\n")
from parameter import get_parameter
from utils import load_network, save_network
from train import train_network
from evaluate import test_network
from hardprune import hard_prune_network
from softprune import soft_prune_network
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
if __name__ == '__main__':
args = get_parameter()
network = load_network(args)
print(network)
if args.train_flag:
print('args.train_flag:', args.train_flag)
network = train_network(network, args)
elif args.hard_prune_flag:
print('hard_prune_flag:', args.hard_prune_flag)
network = hard_prune_network(network, args)
elif args.soft_prune_flag:
network = soft_prune_network(network, args)
print(network)
test_network(network, args)
# network = train_network(network, args)
save_network(network, args)
