def run_SCADANN_training_sessions(examples_datasets, labels_datasets, num_neurons, feature_vector_input_length, path_weights_to_save_to="../weights_SCADANN_One_cycle", path_weights_Adversarial_training="../weights_REDUCED_DANN_TSD_TWO_Cycles", path_weights_Normal_training="../Weights/weights_TSD_ELVEN_Gestures", number_of_cycle_for_first_training=1, number_of_cycles_rest_of_training=1, gestures_to_remove=None, number_of_classes=11, percentage_same_gesture_stable=0.65, learning_rate=0.001316): participants_train, _, _ = load_dataloaders_training_sessions( examples_datasets, labels_datasets, batch_size=512, number_of_cycle_for_first_training=number_of_cycle_for_first_training, number_of_cycles_rest_of_training=number_of_cycles_rest_of_training, drop_last=False, get_validation_set=False, shuffle=False, ignore_first=True, gestures_to_remove=gestures_to_remove) for participant_i in range(len(participants_train)): for session_j in range(1, len(participants_train[participant_i])): model = TSD_Network(number_of_class=number_of_classes, num_neurons=num_neurons, feature_vector_input_length=feature_vector_input_length).cuda() # Define Loss functions cross_entropy_loss_classes = nn.CrossEntropyLoss(reduction='mean').cuda() # Define Optimizer learning_rate = 0.001316 print(model.parameters()) optimizer = optim.Adam(model.parameters(), lr=learning_rate, betas=(0.5, 0.999)) # Define Scheduler precision = 1e-8 model, optimizer, _, start_epoch = load_checkpoint( model=model, optimizer=optimizer, scheduler=None, filename=path_weights_Adversarial_training + "/participant_%d/best_state_%d.pt" % (participant_i, session_j)) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, mode='min', factor=.2, patience=5, verbose=True, eps=precision) models_array = [] for j in range(0, session_j + 1): model_temp = TSD_Network(number_of_class=number_of_classes, num_neurons=num_neurons, feature_vector_input_length=feature_vector_input_length).cuda() if j == 0: model_temp, _, _, _ = load_checkpoint( model=model_temp, optimizer=None, scheduler=None, filename=path_weights_Normal_training + "/participant_%d/best_state_%d.pt" % (participant_i, j)) else: model_temp, _, _, _ = load_checkpoint( model=model_temp, optimizer=None, scheduler=None, filename=path_weights_Adversarial_training + "/participant_%d/best_state_%d.pt" % ( participant_i, j)) models_array.append(model_temp) print(np.shape(models_array)) train_dataloader_replay, validationloader_replay, train_dataloader_pseudo, validationloader_pseudo = \ generate_dataloaders_for_SCADANN(dataloader_sessions=participants_train[participant_i], models=models_array, current_session=session_j, validation_set_ratio=0.2, batch_size=64, percentage_same_gesture_stable=percentage_same_gesture_stable) best_state = SCADANN_BN_training(replay_dataset_train=train_dataloader_replay, target_validation_dataset=validationloader_pseudo, target_dataset=train_dataloader_pseudo, model=model, crossEntropyLoss=cross_entropy_loss_classes, optimizer_classifier=optimizer, scheduler=scheduler, patience_increment=10, max_epochs=500, domain_loss_weight=1e-1) if not os.path.exists(path_weights_to_save_to + "/participant_%d" % participant_i): os.makedirs(path_weights_to_save_to + "/participant_%d" % participant_i) print(os.listdir(path_weights_to_save_to)) torch.save(best_state, f=path_weights_to_save_to + "/participant_%d/best_state_%d.pt" % (participant_i, session_j))
def run_AdaBN_evaluation_sessions(examples_datasets_evaluations, labels_datasets_evaluation, algo_name, num_neurons, path_weights_to_load_from, path_weights_SCADANN, batch_size=512, use_recalibration_data=False, number_of_classes=11, feature_vector_input_length=385): # Get the data to use as the TARGET from the evaluation sessions participants_evaluation_dataloader = load_dataloaders_test_sessions( examples_datasets_evaluation=examples_datasets_evaluations, labels_datasets_evaluation=labels_datasets_evaluation, batch_size=batch_size, shuffle=False, drop_last=True) for participant_i in range(len(participants_evaluation_dataloader)): print("SHAPE SESSIONS: ", np.shape(participants_evaluation_dataloader[participant_i])) for session_j in range( 0, len(participants_evaluation_dataloader[participant_i])): # There is two evaluation session for every training session. We train on the first one if session_j % 2 == 0: # Classifier and discriminator model = TSD_Network( number_of_class=number_of_classes, num_neurons=num_neurons, feature_vector_input_length=feature_vector_input_length ).cuda() # loss functions crossEntropyLoss = nn.CrossEntropyLoss().cuda() # optimizer precision = 1e-8 learning_rate = 0.001316 optimizer_classifier = optim.Adam(model.parameters(), lr=learning_rate, betas=(0.5, 0.999)) scheduler = optim.lr_scheduler.ReduceLROnPlateau( optimizer=optimizer_classifier, mode='min', factor=.2, patience=5, verbose=True, eps=precision) if use_recalibration_data: model, optimizer_classifier, scheduler, start_epoch = load_checkpoint( model=model, optimizer=optimizer_classifier, scheduler=scheduler, filename=path_weights_to_load_from + "/participant_%d/best_state_%d.pt" % (participant_i, int(session_j / 2))) else: model, optimizer_classifier, scheduler, start_epoch = load_checkpoint( model=model, optimizer=optimizer_classifier, scheduler=scheduler, filename=path_weights_to_load_from + "/participant_%d/best_state_%d.pt" % (participant_i, 0)) # Freeze all the weights except those associated with the BN statistics model.freeze_all_except_BN() best_state = AdaBN_adaptation( model=model, scheduler=scheduler, optimizer_classifier=optimizer_classifier, dataloader=participants_evaluation_dataloader[ participant_i][session_j]) if use_recalibration_data: if not os.path.exists(path_weights_SCADANN + algo_name + "/participant_%d" % participant_i): os.makedirs(path_weights_SCADANN + algo_name + "/participant_%d" % participant_i) torch.save( best_state, f=path_weights_SCADANN + algo_name + "/participant_%d/best_state_WITH_recalibration%d.pt" % (participant_i, session_j)) else: if not os.path.exists(path_weights_SCADANN + algo_name + "/participant_%d" % participant_i): os.makedirs(path_weights_SCADANN + algo_name + "/participant_%d" % participant_i) print(os.listdir(path_weights_SCADANN + algo_name)) torch.save( best_state, f=path_weights_SCADANN + algo_name + "/participant_%d/best_state_NO_recalibration%d.pt" % (participant_i, session_j))
def run_SCADANN_evaluation_sessions(examples_datasets_evaluations, labels_datasets_evaluation, examples_datasets_train, labels_datasets_train, algo_name, num_kernels, filter_size, path_weights_to_load_from, path_weights_SCADANN, batch_size=512, patience_increment=10, use_recalibration_data=False, number_of_cycle_for_first_training=4, number_of_cycles_rest_of_training=4, feature_vector_input_length=385, learning_rate=0.001316): # Get the data to use as the SOURCE from the training sessions participants_train, _, _ = load_dataloaders_training_sessions_spectrogram( examples_datasets_train, labels_datasets_train, batch_size=batch_size, number_of_cycle_for_first_training=number_of_cycle_for_first_training, get_validation_set=False, number_of_cycles_rest_of_training=number_of_cycles_rest_of_training, gestures_to_remove=None, ignore_first=True, shuffle=False, drop_last=False) # Get the data to use as the TARGET from the evaluation sessions participants_evaluation_dataloader = load_dataloaders_test_sessions( examples_datasets_evaluation=examples_datasets_evaluations, labels_datasets_evaluation=labels_datasets_evaluation, batch_size=batch_size, shuffle=False, drop_last=False) for participant_i in range(len(participants_evaluation_dataloader)): print("SHAPE SESSIONS: ", np.shape(participants_evaluation_dataloader[participant_i])) for session_j in range(0, len(participants_evaluation_dataloader[participant_i])): # There is two evaluation session for every training session. We train on the first one if session_j % 2 == 0: # Classifier and discriminator model = TSD_Network(number_of_class=number_of_classes, num_neurons=num_kernels, feature_vector_input_length=feature_vector_input_length).cuda() # loss functions crossEntropyLoss = nn.CrossEntropyLoss().cuda() # optimizer precision = 1e-8 optimizer_classifier = optim.Adam(model.parameters(), lr=learning_rate, betas=(0.5, 0.999)) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer_classifier, mode='min', factor=.2, patience=5, verbose=True, eps=precision) if use_recalibration_data: model, optimizer_classifier, _, start_epoch = load_checkpoint( model=model, optimizer=optimizer_classifier, scheduler=None, filename=path_weights_to_load_from + "/participant_%d/best_state_WITH_recalibration%d.pt" % (participant_i, session_j)) models_array = [] for j in range(0, int(session_j / 2) + 1): model_temp = TSD_Network(number_of_class=number_of_classes, num_neurons=num_kernels, feature_vector_input_length=feature_vector_input_length).cuda() model_temp, _, _, _ = load_checkpoint( model=model_temp, optimizer=None, scheduler=None, filename=path_weights_to_load_from + "/participant_%d/best_state_WITH_recalibration%d.pt" % (participant_i, int(j * 2))) models_array.append(model_temp) else: model, optimizer_classifier, _, start_epoch = load_checkpoint( model=model, optimizer=optimizer_classifier, scheduler=None, filename=path_weights_to_load_from + "/participant_%d/best_state_NO_recalibration%d.pt" % (participant_i, session_j)) models_array = [] for j in range(0, int(session_j / 2) + 1): model_temp = TSD_Network(number_of_class=number_of_classes, num_neurons=num_kernels, feature_vector_input_length=feature_vector_input_length).cuda() model_temp, _, _, _ = load_checkpoint( model=model_temp, optimizer=None, scheduler=None, filename=path_weights_to_load_from + "/participant_%d/best_state_NO_recalibration%d.pt" % ( participant_i, int(j * 2))) models_array.append(model_temp) corresponding_training_session_index = 0 if use_recalibration_data is False else int(session_j / 2) train_dataloader_replay, validationloader_replay, train_dataloader_pseudo, validationloader_pseudo = \ generate_dataloaders_evaluation_for_SCADANN( dataloader_session_training=participants_train[participant_i][ corresponding_training_session_index], dataloader_sessions_evaluation=participants_evaluation_dataloader[participant_i], models=models_array, current_session=session_j, validation_set_ratio=0.2, batch_size=512, use_recalibration_data=use_recalibration_data) best_state = SCADANN_BN_training(replay_dataset_train=train_dataloader_replay, target_validation_dataset=validationloader_pseudo, target_dataset=train_dataloader_pseudo, model=model, crossEntropyLoss=crossEntropyLoss, optimizer_classifier=optimizer_classifier, scheduler=scheduler, patience_increment=patience_increment, max_epochs=500, domain_loss_weight=1e-1) if use_recalibration_data: if not os.path.exists(path_weights_SCADANN + algo_name + "/participant_%d" % participant_i): os.makedirs(path_weights_SCADANN + algo_name + "/participant_%d" % participant_i) torch.save(best_state, f=path_weights_SCADANN + algo_name + "/participant_%d/best_state_WITH_recalibration%d.pt" % (participant_i, session_j)) else: if not os.path.exists(path_weights_SCADANN + algo_name + "/participant_%d" % participant_i): os.makedirs(path_weights_SCADANN + algo_name + "/participant_%d" % participant_i) print(os.listdir(path_weights_SCADANN + algo_name)) torch.save(best_state, f=path_weights_SCADANN + algo_name + "/participant_%d/best_state_NO_recalibration%d.pt" % ( participant_i, session_j))
def run_MultipleVote_training_sessions( examples_datasets, labels_datasets, num_kernels, filter_size=(4, 10), path_weights_to_save_to="../weights_SLADANN_One_cycle", path_weights_normal_training="../weights_REDUCED_DANN_Spectrogram_TWO_Cycles", number_of_cycle_for_first_training=1, number_of_cycles_rest_of_training=1, gestures_to_remove=None, number_of_classes=11, feature_vector_input_length=385): participants_train, _, _ = load_dataloaders_training_sessions( examples_datasets, labels_datasets, batch_size=512, number_of_cycle_for_first_training=number_of_cycle_for_first_training, number_of_cycles_rest_of_training=number_of_cycles_rest_of_training, drop_last=False, get_validation_set=False, shuffle=False, ignore_first=True, gestures_to_remove=gestures_to_remove) for participant_i in range(len(participants_train)): for session_j in range(1, len(participants_train[participant_i])): model = TSD_Network( number_of_class=number_of_classes, feature_vector_input_length=feature_vector_input_length, num_neurons=num_neurons).cuda() # Define Loss functions cross_entropy_loss_classes = nn.CrossEntropyLoss( reduction='mean').cuda() # Define Optimizer learning_rate = 0.001316 print(model.parameters()) optimizer = optim.Adam(model.parameters(), lr=learning_rate, betas=(0.5, 0.999)) # Define Scheduler precision = 1e-8 scheduler = optim.lr_scheduler.ReduceLROnPlateau( optimizer=optimizer, mode='min', factor=.2, patience=5, verbose=True, eps=precision) model, optimizer, _, start_epoch = load_checkpoint( model=model, optimizer=optimizer, scheduler=None, filename=path_weights_normal_training + "/participant_%d/best_state_%d.pt" % (participant_i, 0)) train_dataloader_pseudo, validationloader_pseudo = \ generate_dataloaders_for_MultipleVote(dataloader_sessions=participants_train[participant_i], model=model, current_session=session_j, validation_set_ratio=0.2, batch_size=256) best_state = train_model_standard( model=model, criterion=cross_entropy_loss_classes, optimizer=optimizer, scheduler=scheduler, dataloaders={ "train": train_dataloader_pseudo, "val": validationloader_pseudo }, precision=precision, patience=10, patience_increase=10) if not os.path.exists(path_weights_to_save_to + "/participant_%d" % participant_i): os.makedirs(path_weights_to_save_to + "/participant_%d" % participant_i) print(os.listdir(path_weights_to_save_to)) torch.save(best_state, f=path_weights_to_save_to + "/participant_%d/best_state_%d.pt" % (participant_i, session_j))