def train(student_list, feature_list, start_epoch=0, epochs=10, resume_frm_chck_pt=True, force_save_model=False, reset_optimizer_state=False, restrict_seqlen=4, train_model=True): # Getting inputs and extracting the input size list. data = get_inputs(student_list=student_list, feature_list=feature_list,restrict_seqlen=restrict_seqlen) input_size_list = data[0][1] print("Number of GPUs: {}".format(torch.cuda.device_count())) if not train_model: print("Not in Train Mode") return print("Force-Saving is set to {}".format(force_save_model)) print("######################################################") # Trains on all students in the data list. print("################# No. of Students: {} #################".format(len(data))) for counter, split in enumerate(kfold.get_splits(data)): print("################# Training Split : {} #################".format(counter)) train_set_list, val_set = split val_score = [] # Declaring Network. net = Strain_log_regression(input_size_list=input_size_list) optimizer = optim.Adam(net.parameters(), weight_decay=0.01) net.apply(weights_init) val_soft = torch.nn.Softmax(dim=1) criterion = nn.CrossEntropyLoss(size_average=True) best_score = Variable(torch.from_numpy(np.array([0])).float()) file_name = ROOT_DIR + '/output/loso/loso_model_{}.tar'.format(counter) if torch.cuda.device_count() > 1: print("Using {} GPUs".format(torch.cuda.device_count())) net = nn.DataParallel(net) if torch.cuda.is_available(): print("Training on GPU") net = net.cuda() best_score = best_score.cuda() if resume_frm_chck_pt: model_state, optimizer_state, start_epoch, best_score = chck.load_checkpoint(file_name) net.load_state_dict(model_state) optimizer.load_state_dict(optimizer_state) if reset_optimizer_state: optimizer = optim.Adam(net.parameters(), weight_decay=0.01) for epoch in range(epochs): print("###################### Epoch {} #######################".format(start_epoch + epoch + 1)) for input_list, _, index_list, target in train_set_list: net.train(True) optimizer.zero_grad() y_hat = net.forward(input_list, index_list) loss = criterion(y_hat, target) loss.backward() optimizer.step() ######################## Validating ######################## val_input_list, _, val_index_list, y_true = val_set net.eval() y_pred = net.forward(val_input_list, val_index_list) y_pred = val_soft(y_pred) _, y_pred = y_pred.max(1) accuracy = y_true.eq(y_pred).sum() accuracy = accuracy.float() / len(y_true) # val_score.append(accuracy) if torch.gt(accuracy, best_score).all(): best_score = accuracy is_best = True else: is_best = False # force save model without it being the best accuracy. if force_save_model: is_best = True # generating states. Saving checkpoint after every epoch. state = chck.create_state(net, optimizer, epoch, start_epoch, best_score) chck.save_checkpoint(state, is_best, full_file_name=file_name) print("=> loss of '{}' at epoch {} \n=> accuracy of \n {}".format(loss.data[0], start_epoch + epoch + 1, accuracy)) val_score.append(best_score) avg_score = sum(val_score) / len(val_score) print("######################################################") print("Loso CrossVal Score :", avg_score) print("######################################################")
def train(start_epoch=0, epochs=10, resume_frm_chck_pt=True, force_save_model=False, reset_optimizer_state=False, restrict_seqlen=4, train_model=True): # getting current working directory initialize checkpoint file name. cwd = os.getcwd() file_name = cwd + '/output/log_reg.tar' # Getting inputs. input_list, input_size_list, index_list, target, val_input_list, val_index_list, y_true \ = get_inputs(restrict_seqlen=restrict_seqlen) # Initializing Best_Accuracy as 0 best_accuracy = Variable(torch.from_numpy(np.array([0])).float()) print("Force-Saving is set to {}".format(force_save_model)) if not train_model: return # declaring Network. net = Strain_log_regression(input_size_list=input_size_list) # Using default learning rate for Adam. optimizer = optim.Adam(net.parameters(), weight_decay=0.01) net.apply(weights_init) val_soft = torch.nn.Softmax(dim=1) criterion = nn.CrossEntropyLoss(size_average=True) if torch.cuda.device_count() > 1: print("Using {} GPUs".format(torch.cuda.device_count())) net = nn.DataParallel(net) if torch.cuda.is_available(): print("Training on GPU") net = net.cuda() best_accuracy = best_accuracy.cuda() if resume_frm_chck_pt: model_state, optimizer_state, start_epoch, best_accuracy = chck.load_checkpoint(file_name) net.load_state_dict(model_state) optimizer.load_state_dict(optimizer_state) if reset_optimizer_state: optimizer = optim.Adam(net.parameters(), weight_decay=0.01) print("######################################################") print("Start Epoch :", start_epoch) # Train the network for epoch in range(epochs): print("###################### Epoch {} #######################".format(start_epoch + epoch + 1)) net.train(True) optimizer.zero_grad() y_hat = net.forward(input_list, index_list) loss = criterion(y_hat, target) loss.backward() optimizer.step() ######################## Validating ######################## net.eval() y_pred = net.forward(val_input_list, val_index_list) y_pred = val_soft(y_pred) # y_pred = y_pred.data.numpy().argmax(axis=1) # accuracy = accuracy_score(y_true, y_pred) _, y_pred = y_pred.max(1) accuracy = y_true.eq(y_pred).sum() accuracy = accuracy.float() / len(y_true) # print(type(accuracy), type(best_accuracy)) # print("best accuracy {} accuracy {}".format(best_accuracy, accuracy)) if torch.gt(accuracy, best_accuracy).all(): best_accuracy = accuracy is_best = True else: is_best = False # print("Y_pred {}".format(y_pred)) # print("Y_true {}".format(y_true)) # force save model without it being the best accuracy. if force_save_model: is_best = True # generating states. Saving checkpoint after every epoch. state = chck.create_state(net, optimizer, epoch, start_epoch, accuracy) chck.save_checkpoint(state, is_best, full_file_name=file_name) print("=> loss of '{}' at epoch {} \n=> accuracy of {}".format(loss.data[0], start_epoch + epoch + 1, accuracy)) print("######################################################") print("Best Accuracy :", best_accuracy) print("######################################################")
def train(start_epoch=0, epochs=10, resume_frm_chck_pt=True, force_save_model=False, reset_optimizer_state=False, restrict_seqlen=4): # getting current working directory initialize checkpoint file name. cwd = os.getcwd() file_name = cwd + '/output/linear_reg.tar' # Getting inputs. input_list, input_size_list, index_list, target, val_input_list, val_index_list, y_true \ = get_inputs(restrict_seqlen=restrict_seqlen, standardize=True) target = target.float() y_true = y_true.float() # Initializing Best_mse as 0 best_mse = Variable(torch.from_numpy(np.array([100000000000])).float()) print("Force-Saving is set to {}".format(force_save_model)) if not train: return # declaring Network. net = Strain_linear_reg(input_size_list=input_size_list) # Using default learning rate for Adam. optimizer = optim.Adam(net.parameters(), weight_decay=0.01) net.apply(weights_init) criterion = nn.MSELoss() if torch.cuda.device_count() > 1: print("Using {} GPUs".format(torch.cuda.device_count())) net = nn.DataParallel(net) if torch.cuda.is_available(): print("Training on GPU") net = net.cuda() best_mse = best_mse.cuda() if resume_frm_chck_pt: model_state, optimizer_state, start_epoch, best_mse = chck.load_checkpoint( file_name) net.load_state_dict(model_state) optimizer.load_state_dict(optimizer_state) if reset_optimizer_state: optimizer = optim.Adam(net.parameters(), weight_decay=0.01) print("######################################################") print("Start Epoch :", start_epoch) # Train the network for epoch in range(epochs): print("###################### Epoch {} #######################".format( start_epoch + epoch + 1)) net.train(True) optimizer.zero_grad() y_hat = net.forward(input_list, index_list) loss = criterion(y_hat, target) print("working till here") loss.backward() optimizer.step() ######################## Validating ######################## net.eval() y_pred = net.forward(val_input_list, val_index_list) mse = criterion(y_pred, y_true) if torch.lt(mse, best_mse).all(): best_mse = mse is_best = True else: is_best = False print("Y_pred {}".format(y_pred)) print("Y_true {}".format(y_true)) # force save model without it being the best MSE. if force_save_model: is_best = True # generating states. Saving checkpoint after every epoch. state = chck.create_state(net, optimizer, epoch, start_epoch, mse) chck.save_checkpoint(state, is_best, full_file_name=file_name) print("=> loss of '{}' at epoch {} \n=> mse of {}".format( loss.data[0], start_epoch + epoch + 1, mse)) print("######################################################") print("Best MSE :", best_mse) print("######################################################")
def train(start_epoch=0, epochs=10, resume_frm_chck_pt=True, force_save_model=False, reset_optimizer_state=False, restrict_seqlen=4, train=True): feature_list = [ "activity_details", # "dinning_details" , "sms_details", "audio_details", "conversation_details", "dark_details", "phonecharge_details", "phonelock_details", "gps_details" ] # getting current working directory initialize checkpoint file name. cwd = os.getcwd() file_name = cwd + '/output/baseline.tar' # Getting inputs. train_input_seq, train_target, val_input_seq, val_target \ = generate_baseline_variables(feature_list=feature_list) # squeezing dimensions in target sets. train_target = train_target.squeeze(1) val_target = val_target.squeeze(1) # Extracting shape of input to initilize network. x, y = train_input_seq.shape print("Initializing net with {} - y features and {} - x".format(y, x)) # Initializing Best_Accuracy as 0 best_accuracy = Variable(torch.from_numpy(np.array([0])).float()) print("Force-Saving is set to {}".format(force_save_model)) # declaring Network with number of features. net = StrainBaseline(y) # Using default learning rate for Adam. optimizer = optim.Adam(net.parameters(), weight_decay=0.01) net.apply(weights_init) val_soft = torch.nn.Softmax(dim=1) criterion = nn.CrossEntropyLoss(size_average=True) if not train: return if torch.cuda.device_count() > 1: print("Using {} GPUs".format(torch.cuda.device_count())) net = nn.DataParallel(net) if torch.cuda.is_available(): print("Training on GPU") net = net.cuda() best_accuracy = best_accuracy.cuda() if resume_frm_chck_pt: model_state, optimizer_state, start_epoch, best_accuracy = chck.load_checkpoint( file_name) net.load_state_dict(model_state) optimizer.load_state_dict(optimizer_state) if reset_optimizer_state: optimizer = optim.Adam(net.parameters(), weight_decay=0.01) print("######################################################") print("Start Epoch :", start_epoch) # Train the network for epoch in range(epochs): print("###################### Epoch {} #######################".format( start_epoch + epoch + 1)) net.train(True) optimizer.zero_grad() y_hat = net.forward(train_input_seq) loss = criterion(y_hat, train_target) loss.backward() optimizer.step() ######################## Validating ######################## net.eval() y_pred = net.forward(val_input_seq) y_pred = val_soft(y_pred) _, y_pred = y_pred.max(1) accuracy = val_target.eq(y_pred).sum() accuracy = accuracy.float() / len(val_target) if torch.gt(accuracy, best_accuracy).all(): best_accuracy = accuracy is_best = True else: is_best = False # Force save model if flag is true. if force_save_model: is_best = True # generating states. Saving checkpoint after every epoch. state = chck.create_state(net, optimizer, epoch, start_epoch, accuracy) chck.save_checkpoint(state, is_best, full_file_name=file_name) print("=> loss of '{}' at epoch {} \n=> accuracy of {}".format( loss.data[0], start_epoch + epoch + 1, accuracy)) print("######################################################") print("Best Accuracy :", best_accuracy) print("######################################################") # Initializing Best_Accuracy as 0 best_accuracy = Variable(torch.from_numpy(np.array([0])).float()) print("Force-Saving is set to {}".format(force_save_model))