def load_model(self, path): # torch.load最后返回的是一个dict,里面包含了保存模型时的一些参数和模型 checkpoint = torch.load(path, map_location='cpu') self.generator = self.get_generator(checkpoint) # AttrDict是根据参数中的dict内容生成一个更加方便访问的dict实例 self.args = AttrDict(checkpoint['args']) train_path = get_dset_path(self.args.dataset_name, "train") test_path = get_dset_path(self.args.dataset_name, "test") self.args.batch_size = 1 _, self.loader = data_loader(self.args, train_path) _, self.test_loader = data_loader(self.args, test_path) self.metrics_val = checkpoint['metrics_val'] self.metrics_train = checkpoint['metrics_train']
def main(args): test_path = get_dset_path(args.dataset_name, 'test') logger.info("Initializing test dataset") test_dset, test_loader = data_loader(args, test_path) net = LSTM_model(args) net = net.cuda() checkpoint_path = ".\model\lstm767.tar" checkpoint = torch.load(checkpoint_path) net.load_state_dict(checkpoint['state_dict']) net.eval() batch_error = 0 batch_fde = 0 for idx, batch in enumerate(test_loader): (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, non_linear_ped, loss_mask, seq_start_end) = batch num_ped = obs_traj.size(1) # (8 n 2) pred_traj_gt = pred_traj_gt.cuda() pred_traj = net(obs_traj.cuda(), num_ped, pred_traj_gt) ade_1 = get_mean_error(pred_traj, pred_traj_gt) ade_2 = displacement_error(pred_traj, pred_traj_gt) / (pred_traj.size(1) * 12) fde = final_displacement_error(pred_traj, pred_traj_gt) / pred_traj.size(1) batch_error += ade_2 batch_fde += fde ade = batch_error / (idx+1) fin_fde = batch_fde / (idx+1) logger.info("ade is {:.2f}".format(ade)) logger.info("ade is {:.2f}".format(fin_fde))
def polyfit_visualize(args,data_path): degree=2 #degree of polynomial to be fitted coeff=np.ones(3) obs_len=args.obs_len pred_len=args.pred_len dataset,dataloader=loader.data_loader(args,data_path) for i,batch in enumerate(dataloader): observed_batch=batch[0].numpy() #observed trajectory batch target_batch=batch[1].numpy() #Target trajectory batch trajec=observed_batch+target_batch seq,peds,coords=observed_batch.shape for j in range(peds): z=np.polyfit(observed_batch[:,j,0],observed_batch[:,j,1],degree) coeff=np.column_stack((coeff,z)) if(i>15): break plt.figure() for i in range(degree+1): plt.plot(coeff[i,1:],label='{} order coefficient'.format(i)) plt.xlabel('Pedestrian Trajectories') plt.ylabel('Coefficients of Plynomial') plt.title("Fitted polynomial to dataset:{}".format(cur_dataset)) plt.legend() # plt.show(block=True) plt.savefig("./saved_figs/" + 'lstm_polyfit_'+cur_dataset+'predlen_' + str(pred_len) +'_obs'+str(obs_len)+'.png')
def main(args): '''define parameters for training and testing loops!''' # num_epoch = 20 # pred_len = 12 # learning_rate = 0.001 num_epoch = 2 #args.num_epochs pred_len =8 #args.pred_len learning_rate = 0.0017 #args.learning_rate # retrieve dataloader dataset, dataloader = loader.data_loader(args, data_dir) ''' define the network, optimizer and criterion ''' # lstm_net = lstmNet() # criterion = nn.MSELoss() # MSE works best for difference between predicted and actual coordinate paths # # optimizer = optim.Adam(lstm_net.parameters(), lr=learning_rate) # # initialize lists for capturing losses/errors # test_loss = [] # avg_test_loss = [] # test_finalD_error=[] # test_avgD_error=[] # std_test_loss = [] #calling the test function and calculating the test losses test_observed_batch,test_target_batch,out=test(lstm_net,args,pred_len,data_dir) pass
def test(args): test_data_dir = "/home/roongtaaahsih/ped_traj/sgan_ab/scripts/datasets/zara1/test" # retrieve dataloader dataset, dataloader = loader.data_loader(args, test_data_dir) # define parameters for training and testing loops pred_len = 12 criterion = nn.MSELoss( ) # MSE works best for difference between predicted and actual coordinate paths # initialize lists for capturing losses test_loss = [] # now, test the model for i, batch in enumerate(dataloader): test_observed_batch = batch[0] test_target_batch = batch[1] out = gru_net( test_observed_batch, pred_len=pred_len) # forward pass of gru network for training print("out's shape:", out.shape) cur_test_loss = criterion(out, test_target_batch) # calculate MSE loss print('Current test loss: {}'.format( cur_test_loss.item())) # print current test loss test_loss.append(cur_test_loss.item()) avg_testloss = sum(test_loss) / len(test_loss) print("========== Average test loss:", avg_testloss, "==========") pass
def main(args): if os.path.isdir(args.model_path): filenames = os.listdir(args.model_path) filenames.sort() paths = [os.path.join(args.model_path, file_) for file_ in filenames] else: paths = [args.model_path] for path in paths: checkpoint = torch.load(path) generator = get_generator(checkpoint) _args = AttrDict(checkpoint['args']) path = get_dset_path(_args.dataset_name, args.dset_type) _, loader = data_loader(_args, path) ade, fde, trajs = evaluate(_args, loader, generator, args.num_samples) print('Dataset: {}, Pred Len: {}, ADE: {:.2f}, FDE: {:.2f}'.format( _args.dataset_name, _args.pred_len, ade, fde)) path = "trajs_dumped/" + "/".join(_args.dataset_name.split("/")[:-1]) pathlib.Path(path).mkdir(parents=True, exist_ok=True) with open( "trajs_dumped/" + args.model_path.split("/")[-1].split(".")[0] + "_" + args.dset_type + "_trajs.pkl", 'wb+') as f: pickle.dump(trajs, f) print( "trajs dumped at ", args.model_path.split("/")[-1].split(".")[0] + "_" + args.dset_type + "_trajs.pkl")
def polyfit_visualize(args, data_path): coeff = np.ones(3) ped_c = 0 dataset, dataloader = loader.data_loader(args, data_path) for i, batch in enumerate(dataloader): observed_batch = batch[0].numpy() #observed trajectory batch target_batch = batch[1].numpy() #Target trajectory batch trajec = observed_batch + target_batch seq, peds, coords = observed_batch.shape ped_c += peds for j in range(peds): z = np.polyfit(observed_batch[:, j, 0], observed_batch[:, j, 1], degree) coeff = np.column_stack( (coeff, z) ) #adding the coefficients of each polynomial fitted to columns of coeff array if (ped_c > 60 ): #Just a random cap on the number of pedestrians in each dataset break # plt.figure() # for i in range(degree+1): # plt.plot(coeff[i,1:],label='{} order coefficient'.format(i)) # plt.xlabel('Pedestrian Trajectories') # plt.ylabel('Coefficients of Plynomial') # plt.title("Fitted polynomial to dataset:{}".format(cur_dataset)) # plt.legend() # # plt.show(block=True) # plt.savefig("./saved_figs/" + 'lstm_polyfit_'+cur_dataset+'predlen_' + str(pred_len) +'_obs'+str(obs_len)+'.png') return coeff
def json_dump(args): # Some preparation torch.cuda.manual_seed(1000) print ('Loading data') if args.imgf_path ==None: #default bottom-up top-down loader = data_loader(b_size=512, train=False) else: loader = data_loader(b_size=512,image_path=args.imgf_path, train=False) model = Model(v_size=loader.v_size, K=loader.K, f_dim=loader.f_dim, h_dim=512, o_dim=loader.o_dim, pretrained_we=loader.we_matrix) model = model.cuda() if args.savedmodel and os.path.isfile(args.savedmodel): print('Reading Saved model {}'.format(args.savedmodel)) ckpt = torch.load(args.savedmodel) model.load_state_dict(ckpt['state_dict']) else: print('Wrong Modelpath') result = [] for step in range(loader.n_batch+1): # Batch preparation q_batch, a_batch, i_batch = loader.next_batch() q_batch = Variable(torch.from_numpy(q_batch)) i_batch = Variable(torch.from_numpy(i_batch)) if step == loader.n_batch+1: q_batch = Variable(torch.from_numpy(q_batch))[:loader.q_num-loader.n_batch*loader.b_size] i_batch = Variable(torch.from_numpy(i_batch))[:loader.q_num-loader.n_batch*loader.b_size] a_batch = Variable(torch.from_numpy(a_batch))[:loader.q_num-loader.n_batch*loader.b_size] q_batch, i_batch = q_batch.cuda(), i_batch.cuda() output = model(q_batch, i_batch) _, ix = output.data.max(1) for i, qid in enumerate(a_batch): result.append({ 'question_id': (int)(qid), 'answer': loader.a_itow[ix[i]] }) outfile = open(args.savedmodel+'result.json','w') json.dump(result,outfile) print ('Validation done')
def test(gru_net, args, pred_len=0): test_data_dir = os.path.join( '/home/ashishpc/Desktop/sgan_ab/scripts/datasets/', cur_dataset + '/train') # retrieve dataloader dataset, dataloader = loader.data_loader(args, test_data_dir) # define parameters for training and testing loops criterion = nn.MSELoss( ) # MSE works best for difference between predicted and actual coordinate paths # initialize lists for capturing losses test_loss = [] test_avgD_error = [] test_finalD_error = [] # now, test the model for i, batch in enumerate(dataloader): test_observed_batch = batch[0] test_target_batch = batch[1] out = gru_net( test_observed_batch, pred_len=pred_len) # forward pass of lstm network for training cur_test_loss = criterion(out, test_target_batch) # calculate MSE loss test_loss.append(cur_test_loss.item()) out1 = out target_batch1 = test_target_batch #making a copy of the tensors to convert them to array seq, peds, coords = test_target_batch.shape avgD_error = (np.sum( np.sqrt( np.square(out1[:, :, 0].detach().numpy() - target_batch1[:, :, 0].detach().numpy()) + np.square(out1[:, :, 1].detach().numpy() - target_batch1[:, :, 1].detach().numpy())))) / ( pred_len * peds) test_avgD_error.append(avgD_error) # final displacement error finalD_error = (np.sum( np.sqrt( np.square(out1[pred_len - 1, :, 0].detach().numpy() - target_batch1[pred_len - 1, :, 0].detach().numpy()) + np.square(out1[pred_len - 1, :, 1].detach().numpy() - target_batch1[pred_len - 1, :, 1].detach().numpy()))) ) / peds test_finalD_error.append(finalD_error) avg_testloss = sum(test_loss) / len(test_loss) avg_testD_error = sum(test_avgD_error) / len(test_avgD_error) avg_testfinalD_error = sum(test_finalD_error) / len(test_finalD_error) print("============= Average test loss:", avg_testloss, "====================") return avg_testloss, avg_testD_error, avg_testfinalD_error
def test(vanilla_lstm_net, args, pred_len=0): test_data_dir = "/home/roongtaaahsih/ped_traj/sgan_ab/scripts/datasets/eth/test" # retrieve dataloader dataset, dataloader = loader.data_loader(args, test_data_dir) # define parameters for training and testing loops criterion = nn.MSELoss( ) # MSE works best for difference between predicted and actual coordinate paths # initialize lists for capturing losses test_loss = [] test_avgD_error = [] test_finalD_error = [] # now, test the model for i, batch in enumerate(dataloader): test_observed_batch = batch[0] test_target_batch = batch[1] out = vanilla_lstm_net( test_observed_batch, pred_len=pred_len) # forward pass of lstm network for training # print("vnet out's shape",out.shape) cur_test_loss = criterion(out, test_target_batch) # calculate MSE loss test_loss.append(cur_test_loss.item()) out1 = out target_batch1 = test_target_batch #making a copy of the tensors to convert them to array seq, peds, coords = test_target_batch.shape # q is number of pedestrians avgD_error = (np.sum( np.sqrt( np.square(out1[:, :, 0].detach().numpy() - target_batch1[:, :, 0].detach().numpy()) + np.square(out1[:, :, 1].detach().numpy() - target_batch1[:, :, 1].detach().numpy())))) / ( pred_len * peds) test_avgD_error.append(avgD_error) # print("current avg Disp error:",avgD_error) #calculating final displacement error finalD_error = (np.sum( np.sqrt( np.square(out1[pred_len - 1, :, 0].detach().numpy() - target_batch1[pred_len - 1, :, 0].detach().numpy()) + np.square(out1[pred_len - 1, :, 1].detach().numpy() - target_batch1[pred_len - 1, :, 1].detach().numpy()))) ) / peds test_finalD_error.append(finalD_error) avg_testloss = sum(test_loss) / len(test_loss) avg_testD_error = sum(test_avgD_error) / len(test_avgD_error) avg_testfinalD_error = sum(test_finalD_error) / len(test_finalD_error) print("============= Average test loss:", avg_testloss, "====================") return avg_testloss, avg_testD_error, avg_testfinalD_error
def main(args): '''define parameters for training and testing loops!''' # num_epoch = 20 # pred_len = 12 # learning_rate = 0.001 num_epoch = args.num_epochs pred_len = args.pred_len learning_rate = args.learning_rate # retrieve dataloader dataset, dataloader = loader.data_loader(args, data_dir) ''' define the network, optimizer and criterion ''' # gru_net = GRUNet() criterion = nn.MSELoss( ) # MSE works best for difference between predicted and actual coordinate paths # optimizer = optim.Adam(gru_net.parameters(), lr=learning_rate) # # initialize lists for capturing losses/errors # test_loss = [] # avg_test_loss = [] # test_finalD_error=[] # test_avgD_error=[] # std_test_loss = [] #calling the test function and calculating the test losses avg_test_loss, test_avgD_error, test_finalD_error = test( gru_net, args, pred_len, data_dir) # save results to text file txtfilename = os.path.join( "./txtfiles/", r"Trained_all_Results_table_lr_" + str(learning_rate) + ".txt") os.makedirs(os.path.dirname("./txtfiles/"), exist_ok=True) # make directory if it doesn't exist with open( txtfilename, "a+" ) as f: #will append to a file, create a new one if it doesn't exist if (pred_len == 2): #To print the heading in the txt file f.write("Pred_Len" + "\t" + "Avg_Test_Loss" + "\t" + "Test_AvgD_Error" + "\t" + "Test_FinalDisp_Error" + "\n") #f.write("\n==============Average train loss vs. epoch:===============") f.write(str(pred_len) + "\t") #f.write("\n==============avg test loss vs. epoch:===================") f.write(str(avg_test_loss) + "\t") #f.write("\n==============Avg test displacement error:===================") f.write(str(test_avgD_error) + "\t") #f.write("\n==============final test displacement error:===================") f.write(str(test_finalD_error) + "\n") f.close() print( "saved average and std of training losses to text file in: ./txtfiles")
def main(): """run the pipeline """ test, train = data_loader(data_path) X_train, tfidf = preprocess(train, True) X_test, _ = preprocess(test, tfidf) y_train = train.author model = train_model(X_train, y_train) sub = pd.Series(model.predict(X_test)) sub.to_csv(os.path.join(output_path, "simple_submission.csv"), index=False)
def test(vanilla_lstm_net,args,pred_len): test_data_dir = os.path.join('/home/roongtaaahsih/ped_trajectory_prediction/sgan_ab/scripts/datasets/', cur_dataset + '/test') # retrieve dataloader dataset, dataloader = loader.data_loader(args, test_data_dir) # define parameters for training and testing loops criterion = nn.MSELoss() # MSE works best for difference between predicted and actual coordinate paths # initialize lists for capturing losses test_loss = [] test_avgD_error=[] test_finalD_error=[] # now, test the model for i, batch in enumerate(dataloader): test_observed_batch = batch[0] test_target_batch = batch[1] # out = vanilla_lstm_net(test_observed_batch, pred_len=pred_len) # forward pass of vanilla_lstm network for training seq, peds, coords = test_observed_batch.shape # q is number of pedestrians output_seq=[] ht = torch.zeros(test_observed_batch.size(1), vanilla_lstm_net.rnn_size, dtype=torch.float) ct = torch.zeros(test_observed_batch.size(1), vanilla_lstm_net.rnn_size, dtype=torch.float) for step in range(seq): out,ht,ct = vanilla_lstm_net(test_observed_batch[step,:,:],ht,ct) # forward pass of vanilla_lstm network for training # print("out's shape:", out.shape) for step in range(pred_len): out,ht,ct=vanilla_lstm_net(out,ht,ct) output_seq+=[out] output_seq = torch.stack(output_seq).squeeze() # convert list to tensor cur_test_loss = criterion(output_seq, test_target_batch) # calculate MSE loss test_loss.append(cur_test_loss.item()) out1=output_seq target_batch1=test_target_batch #making a copy of the tensors to convert them to array seq, peds, coords = test_target_batch.shape avgD_error=(np.sum(np.sqrt(np.square(out1[:,:,0].detach().numpy()-target_batch1[:,:,0].detach().numpy())+ np.square(out1[:,:,1].detach().numpy()-target_batch1[:,:,1].detach().numpy()))))/(pred_len*peds) test_avgD_error.append(avgD_error) # final displacement error finalD_error=(np.sum(np.sqrt(np.square(out1[pred_len-1,:,0].detach().numpy()-target_batch1[pred_len-1,:,0].detach().numpy())+ np.square(out1[pred_len-1,:,1].detach().numpy()-target_batch1[pred_len-1,:,1].detach().numpy()))))/peds test_finalD_error.append(finalD_error) avg_testloss = sum(test_loss)/len(test_loss) avg_testD_error=sum(test_avgD_error)/len(test_avgD_error) avg_testfinalD_error=sum(test_finalD_error)/len(test_finalD_error) print("============= Average test loss:", avg_testloss, "====================") return avg_testloss, avg_testD_error,avg_testfinalD_error
def test(lstm_net,args,pred_len,data_dir): test_data_dir = data_dir #os.path.join('/home/ashishpc/Desktop/sgan_ab/scripts/datasets/', cur_dataset + '/train') # retrieve dataloader dataset, dataloader = loader.data_loader(args, test_data_dir) # define parameters for training and testing loops criterion = nn.MSELoss() # MSE works best for difference between predicted and actual coordinate paths # initialize lists for capturing losses test_loss = [] test_avgD_error=[] test_finalD_error=[] # obs=[] # predict=[] # ground_truth=[] plt.figure(figsize=(32,20)) plt.xlabel("X coordinates of pedestrians") plt.ylabel("Y coordinates of pedestrians") # now, test the model for i, batch in enumerate(dataloader): test_observed_batch = batch[0] test_target_batch = batch[1] out = lstm_net(test_observed_batch, pred_len=pred_len) # forward pass of lstm network for training # cur_test_loss = criterion(out, test_target_batch) # calculate MSE loss # test_loss.append(cur_test_loss.item()) s,peds,c=out.shape out1=out.detach().numpy() target1=test_target_batch.detach().numpy() observed1=test_observed_batch.detach().numpy() print("observed 1 shape:",observed1.shape) print("target1 shape:", target1.shape) print("out 1 shape", out1.shape) out2=np.vstack((observed1,out1)) target2=np.vstack((observed1,target1)) print("out2 shape",out2.shape) for t in range(6): plt.plot(observed1[:,t,0],observed1[:,t,1],color='b',marker='o',linewidth=5,markersize=12) plt.plot(target2[s-1:s+pred_len,t,0],target2[s-1:s+pred_len,t,1],color='red',marker='o',linewidth=5,markersize=12) plt.plot(out2[s-1:s+pred_len,t,0],out2[s-1:s+pred_len,t,1],color='g',marker='o',linewidth=5,markersize=12) plt.legend(["Observed","Ground Truth","Predicted"]) plt.show(block=True) # out1=out # target_batch1=test_target_batch #making a copy of the tensors to convert them to array # seq, peds, coords = test_target_batch.shape return test_observed_batch,test_target_batch,out
def main(args): if os.path.isdir(args.model_path): filenames = os.listdir(args.model_path) filenames.sort() paths = [os.path.join(args.model_path, file_) for file_ in filenames] else: paths = [args.model_path] for path in paths: checkpoint = torch.load(path) generator = get_generator(checkpoint) _args = AttrDict(checkpoint['args']) path = get_dset_path(_args.dataset_name, args.dset_type) _, loader = data_loader(_args, path) ade, fde = evaluate(_args, loader, generator, args.num_samples) print('Dataset: {}, Pred Len: {}, ADE: {:.2f}, FDE: {:.2f}'.format( _args.dataset_name, _args.pred_len, ade, fde))
def main(args): if os.path.isdir(args.model_path): filenames = os.listdir(args.model_path) filenames.sort() paths = [os.path.join(args.model_path, file_) for file_ in filenames] else: paths = [args.model_path] accuracy = [] confusionmatrix = [] for ind, path in enumerate(paths): checkpoint = torch.load(path) model = get_model(checkpoint) _args = AttrDict(checkpoint['args']) _args.batch_size = 40 data_dset, loader = data_loader(_args, args.sample_path) with torch.no_grad(): for batch in loader: (groupInput, target) = batch groupInput = groupInput.to(device) target = target.to(device) TAtt, BAtt, groupAttention, groupOutput = model( groupInput) # TAtt: 40X4X37X60, BAtt:40X4X37 # frame=2 # agent=3 # timelist=[90,180,360] # bodyweights=BAtt[frame,agent,:] # bodyweights=bodyweights.cpu().numpy() # vissingle(ind,agent, bodyweights, timelist) data = TAtt[frame, agent, :, :] data = data.cpu().numpy() ax = sb.heatmap(data, vmin=0, vmax=0.022, cmap=sb.cubehelix_palette(n_colors=100, light=.95, dark=.08)) # vissingle(ind,agent) plt.savefig('temporal/model_' + str(ind) + 'frame_' + str(frame) + '__agentID__' + str(agent) + '.png') plt.close()
def run_episode(self, train_mode): if train_mode: way = self.cfg['way'] shot = self.cfg['shot'] query_way = self.cfg['query_way'] query_shot = self.cfg['query_shot'] image_size = self.cfg['images_size'] image_path = self.cfg['images_path'] else: way = self.cfg['val_way'] shot = self.cfg['val_shot'] query_way = self.cfg['val_query_way'] query_shot = self.cfg['val_query_shot'] image_size = self.cfg['images_size'] image_path = self.cfg['val_images_path'] loader = data_loader(way, shot, query_way, query_shot, image_size, image_path) for data_batch in loader: self.episode_processor(data_batch, way, shot, query_way, query_shot)
def main(args): os.environ["CUDA_VISIBLE_DEVICES"] = "0,1" device_ids = [0, 1] test_path = get_dset_path(args.dataset_name, 'test') logger.info("Initializing test dataset") test_dset, test_loader = data_loader(args, test_path) net = LSTM_model(args) #net = net.cuda(device_ids[1]) checkpoint_path = "./model/lstm348.tar" checkpoint = torch.load(checkpoint_path) net.load_state_dict(checkpoint['state_dict']) net.eval() count = 0 total_ade = 0 total_fde = 0 for batch in test_loader: (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, non_linear_ped, loss_mask, seq_start_end) = batch num_ped = obs_traj.size(1) # (8 n 2) #pred_traj_gt = pred_traj_gt.cuda(device_ids[1]) pred_traj = net(obs_traj, num_ped, pred_traj_gt, seq_start_end) ade = get_mean_error(pred_traj, pred_traj_gt) total_ade += ade fde = final_displacement_error(pred_traj[-1], pred_traj_gt[-1]) total_fde += (fde / num_ped) #logger.info("ade is {:.2f}".format(ade)) count += 1 ade_fin = total_ade / count fde_fin = total_fde / count logger.info("ade is {:.2f}".format(ade_fin)) logger.info("fde is {:.2f}".format(fde_fin))
def main(args): os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_num train_path = get_dset_path(args.dataset_name, 'train') val_path = get_dset_path(args.dataset_name, 'val') long_dtype, float_dtype = get_dtypes(args) logger.info("Initializing train dataset") train_dset, train_loader = data_loader(args, train_path) logger.info("Initializing val dataset") _, val_loader = data_loader(args, val_path) iterations_per_epoch = len(train_dset) / args.batch_size / args.d_steps if args.num_epochs: args.num_iterations = int(iterations_per_epoch * args.num_epochs) logger.info( 'There are {} iterations per epoch'.format(iterations_per_epoch)) generator = TrajectoryGenerator( obs_len=args.obs_len, pred_len=args.pred_len, embedding_dim=args.embedding_dim, encoder_h_dim=args.encoder_h_dim_g, decoder_h_dim=args.decoder_h_dim_g, mlp_dim=args.mlp_dim, num_layers=args.num_layers, noise_dim=args.noise_dim, noise_type=args.noise_type, noise_mix_type=args.noise_mix_type, pooling_type=args.pooling_type, pool_every_timestep=args.pool_every_timestep, dropout=args.dropout, bottleneck_dim=args.bottleneck_dim, neighborhood_size=args.neighborhood_size, grid_size=args.grid_size, batch_norm=args.batch_norm) generator.apply(init_weights) generator.type(float_dtype).train() logger.info('Here is the generator:') logger.info(generator) # discriminator = TrajectoryDiscriminator( # obs_len=args.obs_len, # pred_len=args.pred_len, # embedding_dim=args.embedding_dim, # h_dim=args.encoder_h_dim_d, # mlp_dim=args.mlp_dim, # num_layers=args.num_layers, # dropout=args.dropout, # batch_norm=args.batch_norm, # d_type=args.d_type) # discriminator.apply(init_weights) # discriminator.type(float_dtype).train() logger.info('Here is the discriminator:') # logger.info(discriminator) g_loss_fn = gan_g_loss d_loss_fn = gan_d_loss optimizer_g = optim.Adam(generator.parameters(), lr=args.g_learning_rate) # optimizer_d = optim.Adam( # discriminator.parameters(), lr=args.d_learning_rate # ) # Maybe restore from checkpoint restore_path = None if args.checkpoint_start_from is not None: restore_path = args.checkpoint_start_from elif args.restore_from_checkpoint == 1: restore_path = os.path.join(args.output_dir, '%s_with_model.pt' % args.checkpoint_name) if restore_path is not None and os.path.isfile(restore_path): logger.info('Restoring from checkpoint {}'.format(restore_path)) checkpoint = torch.load(restore_path) generator.load_state_dict(checkpoint['g_state']) # discriminator.load_state_dict(checkpoint['d_state']) optimizer_g.load_state_dict(checkpoint['g_optim_state']) # optimizer_d.load_state_dict(checkpoint['d_optim_state']) t = checkpoint['counters']['t'] epoch = checkpoint['counters']['epoch'] checkpoint['restore_ts'].append(t) else: # Starting from scratch, so initialize checkpoint data structure t, epoch = 0, 0 checkpoint = { 'args': args.__dict__, 'G_losses': defaultdict(list), 'D_losses': defaultdict(list), 'losses_ts': [], 'metrics_val': defaultdict(list), 'metrics_train': defaultdict(list), 'sample_ts': [], 'restore_ts': [], 'norm_g': [], 'norm_d': [], 'counters': { 't': None, 'epoch': None, }, 'g_state': None, 'g_optim_state': None, 'd_state': None, 'd_optim_state': None, 'g_best_state': None, 'd_best_state': None, 'best_t': None, 'g_best_nl_state': None, 'd_best_state_nl': None, 'best_t_nl': None, } t0 = None while t < args.num_iterations: gc.collect() d_steps_left = args.d_steps g_steps_left = args.g_steps epoch += 1 logger.info('Starting epoch {}'.format(epoch)) for batch in train_loader: # if args.timing == 1: # torch.cuda.synchronize() # t1 = time.time() # Decide whether to use the batch for stepping on discriminator or # generator; an iteration consists of args.d_steps steps on the # discriminator followed by args.g_steps steps on the generator. # if d_steps_left > 0: # step_type = 'd' # losses_d = discriminator_step(args, batch, generator, # discriminator, d_loss_fn, # optimizer_d) # checkpoint['norm_d'].append( # get_total_norm(discriminator.parameters())) # d_steps_left -= 1 # elif g_steps_left > 0: step_type = 'g' losses_g = generator_step(args, batch, generator, optimizer_g) checkpoint['norm_g'].append(get_total_norm(generator.parameters())) g_steps_left -= 1 # if args.timing == 1: # torch.cuda.synchronize() # t2 = time.time() # logger.info('{} step took {}'.format(step_type, t2 - t1)) # Skip the rest if we are not at the end of an iteration # if d_steps_left > 0 or g_steps_left > 0: # continue # if args.timing == 1: # if t0 is not None: # logger.info('Interation {} took {}'.format( # t - 1, time.time() - t0 # )) # t0 = time.time() # Maybe save loss if t % args.print_every == 0: print( "ARSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" ) logger.info('t = {} / {}'.format(t + 1, args.num_iterations)) # for k, v in sorted(losses_d.items()): # logger.info(' [D] {}: {:.3f}'.format(k, v)) # checkpoint['D_losses'][k].append(v) for k, v in sorted(losses_g.items()): print(k) print(v) logger.info(' [G] {}: {:.3f}'.format(k, v)) checkpoint['G_losses'][k].append(v) checkpoint['losses_ts'].append(t) # Maybe save a checkpoint # if t > 0 and t % args.checkpoint_every == 0: if t > 0: checkpoint['counters']['t'] = t checkpoint['counters']['epoch'] = epoch checkpoint['sample_ts'].append(t) # Check stats on the validation set logger.info('Checking stats on val ...') metrics_val = check_accuracy(args, val_loader, generator) logger.info('Checking stats on train ...') metrics_train = check_accuracy( args, train_loader, generator, # d_loss_fn, limit=True) for k, v in sorted(metrics_val.items()): logger.info(' [val] {}: {:.3f}'.format(k, v)) checkpoint['metrics_val'][k].append(v) for k, v in sorted(metrics_train.items()): logger.info(' [train] {}: {:.3f}'.format(k, v)) checkpoint['metrics_train'][k].append(v) min_ade = min(checkpoint['metrics_val']['ade']) min_ade_nl = min(checkpoint['metrics_val']['ade_nl']) if metrics_val['ade'] == min_ade: logger.info('New low for avg_disp_error') checkpoint['best_t'] = t checkpoint['g_best_state'] = generator.state_dict() # checkpoint['d_best_state'] = discriminator.state_dict() if metrics_val['ade_nl'] == min_ade_nl: logger.info('New low for avg_disp_error_nl') checkpoint['best_t_nl'] = t checkpoint['g_best_nl_state'] = generator.state_dict() # checkpoint['d_best_nl_state'] = discriminator.state_dict() # Save another checkpoint with model weights and # optimizer state checkpoint['g_state'] = generator.state_dict() checkpoint['g_optim_state'] = optimizer_g.state_dict() # checkpoint['d_state'] = discriminator.state_dict() # checkpoint['d_optim_state'] = optimizer_d.state_dict() checkpoint_path = os.path.join( args.output_dir, '%s_with_model.pt' % args.checkpoint_name) logger.info('Saving checkpoint to {}'.format(checkpoint_path)) torch.save(checkpoint, checkpoint_path) logger.info('Done.') # Save a checkpoint with no model weights by making a shallow # copy of the checkpoint excluding some items checkpoint_path = os.path.join( args.output_dir, '%s_no_model.pt' % args.checkpoint_name) logger.info('Saving checkpoint to {}'.format(checkpoint_path)) key_blacklist = [ 'g_state', 'd_state', 'g_best_state', 'g_best_nl_state', 'g_optim_state', 'd_optim_state', 'd_best_state', 'd_best_nl_state' ] small_checkpoint = {} for k, v in checkpoint.items(): if k not in key_blacklist: small_checkpoint[k] = v torch.save(small_checkpoint, checkpoint_path) logger.info('Done.') t += 1 # d_steps_left = args.d_steps g_steps_left = args.g_steps if t >= args.num_iterations: break
def main(args): os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_num # train_path = get_dset_path(args.dataset_name, 'train') # val_path = get_dset_path(args.dataset_name, 'val') data_path = get_dset_path(args.dataset_name) long_dtype, float_dtype = get_dtypes(args) logger.info("Initializing dataset") data_dset, data_load = data_loader(args, data_path) # logger.info("Initializing val dataset") # _, val_loader = data_loader(args, val_path) logger.info('{} data trials are loaded'.format(len(data_dset))) iterations_per_epoch = len(data_dset) / args.batch_size if args.num_epochs: args.num_iterations = int(iterations_per_epoch * args.num_epochs) logger.info( 'There are {} iterations per epoch'.format(iterations_per_epoch)) model = GroupEncoder(embedding_dim=args.embedding_dim, seq_len=args.seq_len, n_head=args.n_head, d_k=args.d_k, d_v=args.d_v, d_inner=args.d_inner, h_dim=args.h_dim, num_layers=args.num_layers, dropout=args.dropout, num_markers=37) cv = KFold(n_splits=5, random_state=42, shuffle=False) foldcounter = 0 accuracy10fold = [] for ifold, (train_index, valid_index) in enumerate(cv.split(data_dset)): train = torch.utils.data.Subset(data_dset, train_index) valid = torch.utils.data.Subset(data_dset, valid_index) train_loader = torch.utils.data.DataLoader( train, batch_size=args.batch_size, shuffle=True, num_workers=args.loader_num_workers) vaild_loader = torch.utils.data.DataLoader( valid, batch_size=args.batch_size, shuffle=True, num_workers=args.loader_num_workers) model.apply(init_weights) model.type(float_dtype).train() logger.info('The {}th fold test'.format(foldcounter)) foldcounter += 1 logger.info('Here is the model:') logger.info(model) model_loss_fn = model_loss optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay) scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.steps, gamma=0.1) model = model.to(args.device_ids[0]) if len(args.device_ids) > 1: if torch.cuda.device_count() >= len(args.device_ids): model = nn.DataParallel(model, device_ids=args.device_ids) else: raise ValueError("the machine don't have {} gpus".format( str(len(args.device_ids)))) # Maybe restore from checkpoint restore_path = None if args.checkpoint_start_from is not None: restore_path = args.checkpoint_start_from elif args.restore_from_checkpoint == 1: restore_path = os.path.join( args.output_dir, '%s_%s_with_model.pt' % (args.checkpoint_name, str(ifold))) if restore_path is not None and os.path.isfile(restore_path): logger.info('Restoring from checkpoint {}'.format(restore_path)) checkpoint = torch.load(restore_path) model.load_state_dict(checkpoint['state']) optimizer.load_state_dict(checkpoint['optim_state']) t = checkpoint['counters']['t'] epoch = checkpoint['counters']['epoch'] checkpoint['restore_ts'].append(t) else: # Starting from scratch, so initialize checkpoint data structure t, epoch = 0, 0 checkpoint = { 'args': args.__dict__, 'losses': [], 'losses_ts': [], 'metrics_val': defaultdict(list), 'metrics_train': defaultdict(list), 'sample_ts': [], 'restore_ts': [], 'norm': [], 'accuracy': [], 'confusionmatrix': [], 'counters': { 't': None, 'epoch': None, }, 'state': None, 'optim_state': None, 'best_state': None, 'best_accuracy': None, 'd_best_state': None, 'best_t': None, } t0 = None best_accuracy = 0 while t < args.num_iterations: gc.collect() epoch += 1 logger.info('Starting {}th fold epoch {}'.format( foldcounter, epoch)) for batch in train_loader: if args.timing == 1: torch.cuda.synchronize() t1 = time.time() losses = {} # print(batch) # batch = [tensor.cuda() for tensor in batch] (groupInput, target) = batch groupInput = groupInput.to(device) target = target.to(device) _, _, _, groupOutput = model(groupInput) loss = model_loss_fn(groupOutput, target) # loss=nn.BCELoss(groupOutput,target) logger.info('loss is {}'.format(loss)) losses['loss'] = loss optimizer.zero_grad() loss.backward() # if args.clipping_threshold > 0: # nn.utils.clip_grad_norm_( # model.parameters(), args.clipping_threshold # ) optimizer.step() checkpoint['norm'].append(get_total_norm(model.parameters())) if args.timing == 1: torch.cuda.synchronize() t2 = time.time() logger.info('it took {}'.format(t2 - t1)) if args.timing == 1: if t0 is not None: logger.info('Interation {} took {}'.format( t - 1, time.time() - t0)) t0 = time.time() # Maybe save loss if t % args.print_every == 0: logger.info('t = {} / {}'.format(t + 1, args.num_iterations)) # for k, v in sorted(losses.items()): # logger.info(' [Loss] {}: {:.3f}'.format(k, v)) checkpoint['losses'].append(loss) checkpoint['losses_ts'].append(t) # Maybe save a checkpoint if t > 0 and t % args.checkpoint_every == 0: checkpoint['counters']['t'] = t checkpoint['counters']['epoch'] = epoch checkpoint['sample_ts'].append(t) # Check stats on the validation set logger.info('Checking stats on val ...') metrics_val, accuracy, confumatrix = check_accuracy( args, vaild_loader, model, model_loss_fn) checkpoint['accuracy'].append(accuracy) logger.info(' [val] accuracy: {:.3f}'.format(accuracy)) logger.info( ' [val] confusion matrix: {}'.format(confumatrix)) for k, v in sorted(metrics_val.items()): logger.info(' [val] {}: {:.3f}'.format(k, v)) checkpoint['metrics_val'][k].append(v) min_loss = min(checkpoint['metrics_val']['loss']) if metrics_val['loss'] == min_loss: logger.info('New low for avg_error') checkpoint['best_t'] = t checkpoint['best_state'] = model.state_dict() checkpoint['best_accuracy'] = accuracy checkpoint['confusionmatrix'] = confumatrix best_accuracy = accuracy # Save another checkpoint with model weights and # optimizer state checkpoint['state'] = model.state_dict() checkpoint['optim_state'] = optimizer.state_dict() checkpoint_path = os.path.join( args.output_dir, '%s_%s_with_model.pt' % (args.checkpoint_name, str(ifold))) logger.info( 'Saving checkpoint to {}'.format(checkpoint_path)) torch.save(checkpoint, checkpoint_path) logger.info('Done.') t += 1 if t >= args.num_iterations: break scheduler.step() accuracy10fold.append(best_accuracy) # scores = cross_val_score(model, X_data, y_data, cv=10, scoring="accuracy") logger.info('accuracy10fold'.format(accuracy10fold))
datapath = '/media/einhard/Seagate Expansion Drive/3380_data/data/' print('Loading USE...') embed = hub.load( '/media/einhard/Seagate Expansion Drive/3380_data/tensorflow_hub/universal-sentence-encoder_4' ) print('Success!') print('Loading word embeddings') sentence_array = joblib.load( '/media/einhard/Seagate Expansion Drive/3380_data/3380-Book-Recommendations/Models/Summarizer/reviewEmbeddings.pkl' ) print('Loading reviews and books') books, reviews = data_loader(datapath, 'filtered_books.csv', 'filtered_reviews.csv') def find_reviews(query, reviews=reviews, n_results=10): # Create vector from query and compare with global embedding sentence = [query] sentence_vector = np.array(embed(sentence)) inner_product = np.inner(sentence_vector, sentence_array)[0] # Find sentences with highest inner products top_n_sentences = pd.Series(inner_product).nlargest(n_results + 1) top_n_indices = top_n_sentences.index.tolist() top_n_list = list(reviews.review_text.iloc[top_n_indices][1:]) print(f'Input sentence: "{query}"\n') print(f'{n_results} most semantically similar reviews: \n\n')
def main(args): train_path = get_dset_path(args.dataset_name, 'train') val_path = get_dset_path(args.dataset_name, 'val') # 随机种子 # torch.manual_seed(2) # np.random.seed(2) # if args.use_gpu: # torch.cuda.manual_seed_all(2) logger.info("Initializing train dataset") train_dset, train_loader = data_loader(args, train_path) logger.info("Initializing val dataset") _, val_loader = data_loader(args, val_path) log_path = './log/' log_file_curve = open(os.path.join(log_path, 'log_loss.txt'), 'w+') log_file_curve_val = open(os.path.join(log_path, 'log_loss_val.txt'), 'w+') log_file_curve_val_ade = open( os.path.join(log_path, 'log_loss_val_ade.txt'), 'w+') net = LSTM_model(args) if args.use_gpu: net = net.cuda() optimizer = torch.optim.Adam(net.parameters(), lr=args.learning_rate) #scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.98) #接着上次训练的地方继续训练 # restore_path = '.\model\lstm294.tar' # logger.info('Restoring from checkpoint {}'.format(restore_path)) # checkpoint = torch.load(restore_path) # net.load_state_dict(checkpoint['state_dict']) # optimizer.load_state_dict(checkpoint['optimizer_state_dict']) # # for i_epoch in range(checkpoint['epoch']+1): # if (i_epoch + 1) % 100 == 0: # args.learning_rate *= 0.98 epoch_loss_min = 160 epoch_smallest = 0 #for epoch in range(checkpoint['epoch']+1, args.num_epochs): for epoch in range(args.num_epochs): count = 0 batch_loss = 0 for batch in train_loader: # Zero out gradients net.zero_grad() optimizer.zero_grad() (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, non_linear_ped, loss_mask, seq_start_end) = batch num_ped = obs_traj.size(1) pred_traj_gt = pred_traj_gt #model_teacher.py pred_traj = net(obs_traj, num_ped, pred_traj_gt, seq_start_end) loss = displacement_error(pred_traj, pred_traj_gt) #loss = get_mean_error(pred_traj, pred_traj_gt) # Compute gradients loss.backward() # Clip gradients torch.nn.utils.clip_grad_norm_(net.parameters(), args.grad_clip) # Update parameters optimizer.step() batch_loss += loss count += 1 #print(loss / num_ped) if (epoch + 1) % 6 == 0: pass #scheduler.step() logger.info('epoch {} train loss is {}'.format(epoch, batch_loss / count)) log_file_curve.write(str(batch_loss.item() / count) + "\n") batch_loss = 0 val_ade = 0 total_ade = 0 for idx, batch in enumerate(val_loader): (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, non_linear_ped, loss_mask, seq_start_end) = batch num_ped = obs_traj.size(1) pred_traj_gt = pred_traj_gt # model_teacher.py pred_traj = net(obs_traj, num_ped, pred_traj_gt, seq_start_end) loss = displacement_error(pred_traj, pred_traj_gt) batch_loss += loss val_ade += loss / (num_ped * 12) total_ade += val_ade count += 1 fin_ade = total_ade / (idx + 1) log_file_curve_val_ade.write(str(fin_ade.item()) + "\n") epoch_loss = batch_loss / count if epoch_loss_min > epoch_loss: epoch_loss_min = epoch_loss epoch_smallest = epoch logger.info('Saving model') torch.save( { 'epoch': epoch, 'state_dict': net.state_dict(), 'optimizer_state_dict': optimizer.state_dict() }, checkpoint_path(epoch)) logger.info('epoch {} val loss is {}'.format(epoch, epoch_loss)) log_file_curve_val.write(str(epoch_loss.item()) + "\n") logger.info('epoch {} is smallest loss is {}'.format( epoch_smallest, epoch_loss_min)) logger.info('the smallest ade is {}'.format(total_ade / (idx + 1))) logger.info("-" * 50)
import pandas as pd import numpy as np import os from loader import data_read, data_loader from models import xgb_model if __name__ == '__main__': print('yo! here we go') data = data_read() print('data columns', data.df.columns) print('data head', data.df.head(2)) loader = data_loader(data.train, data.df) model = xgb_model(loader.xg_train_s, loader.xg_val, loader.xg_test, loader.xg_train, loader.target_train_s, loader.target_val, loader.target_train, loader.Unique_ID) submit = model.submit.append(data.test_manual, ignore_index=True) submit.to_csv("submit.csv", index=False)
def train(vanilla_lstm_net,args): num_epoch = args.num_epochs pred_len = args.pred_len learning_rate = args.learning_rate # retrieve dataloader dataset, dataloader = loader.data_loader(args, data_dir) ''' define the network, optimizer and criterion ''' name="estep_1Opt" # to add to the name of files # if (cur_dataset == "eth"): # vanilla_lstm_net = VanillaLSTMNet() criterion = nn.MSELoss() # MSE works best for difference between predicted and actual coordinate paths optimizer = optim.Adam(vanilla_lstm_net.parameters(), lr=learning_rate) # initialize lists for capturing losses/errors train_loss = [] test_loss = [] avg_train_loss = [] avg_test_loss = [] train_avgD_error=[] train_finalD_error=[] avg_train_avgD_error=[] avg_train_finalD_error=[] test_finalD_error=[] test_avgD_error=[] std_train_loss = [] std_test_loss = [] for i in range(num_epoch): print('======================= Epoch: {cur_epoch} / {total_epochs} =======================\n'.format(cur_epoch=i, total_epochs=num_epoch)) for i, batch in enumerate(dataloader): train_batch = batch[0] target_batch = batch[1] # print("train_batch's shape", train_batch.shape) # print("target_batch's shape", target_batch.shape) seq, peds, coords = train_batch.shape # q is number of pedestrians output_seq=[] ht = torch.zeros(train_batch.size(1), vanilla_lstm_net.rnn_size, dtype=torch.float) ct = torch.zeros(train_batch.size(1), vanilla_lstm_net.rnn_size, dtype=torch.float) for step in range(seq): out,ht,ct = vanilla_lstm_net(train_batch[step,:,:],ht,ct) # forward pass of vanilla_lstm network for training # print("out's shape:", out.shape) for step in range(pred_len): out,ht,ct=vanilla_lstm_net(out,ht,ct) output_seq+=[out] optimizer.zero_grad() step_loss=criterion(out,target_batch[step,:,:]) step_loss.backward(retain_graph=True) #backward prop optimizer.step() #updating weights after each step prediction optimizer.zero_grad() # zero out gradients # print("output: {}".format(output_seq)) output_seq = torch.stack(output_seq).squeeze() # convert list to tensor cur_train_loss = criterion(output_seq, target_batch) # calculate MSE loss # print('Current training loss: {}'.format(cur_train_loss.item())) # print current training loss # print('Current training loss: {}'.format(cur_train_loss.item())) # print current training loss #calculating average deisplacement error out1=output_seq target_batch1=target_batch #making a copy of the tensors to convert them to array avgD_error=(np.sum(np.sqrt(np.square(out1[:,:,0].detach().numpy()-target_batch1[:,:,0].detach().numpy())+ np.square(out1[:,:,1].detach().numpy()-target_batch1[:,:,1].detach().numpy()))))/(pred_len*peds) train_avgD_error.append(avgD_error) #calculate final displacement error finalD_error=(np.sum(np.sqrt(np.square(out1[pred_len-1,:,0].detach().numpy()-target_batch1[pred_len-1,:,0].detach().numpy())+ np.square(out1[pred_len-1,:,1].detach().numpy()-target_batch1[pred_len-1,:,1].detach().numpy()))))/peds train_finalD_error.append(finalD_error) train_loss.append(cur_train_loss.item()) cur_train_loss.backward() # backward prop # optimizer.step() # step like a mini-batch (after all pedestrians) # optimizer.step() # update weights # save model at every epoch (uncomment) # torch.save(vanilla_lstm_net, './saved_models/vanilla_lstm_model_v3.pt') # print("Saved vanilla_lstm_net!") avg_train_loss.append(np.sum(train_loss)/len(train_loss)) avg_train_avgD_error.append(np.sum(train_avgD_error)/len(train_avgD_error)) avg_train_finalD_error.append(np.sum(train_finalD_error)/len(train_finalD_error)) std_train_loss.append(np.std(np.asarray(train_loss))) train_loss = [] # empty train loss print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") print("average train loss: {}".format(avg_train_loss[-1])) print("average std loss: {}".format(std_train_loss[-1])) avgTestLoss,avgD_test,finalD_test=test(vanilla_lstm_net,args,pred_len) avg_test_loss.append(avgTestLoss) test_finalD_error.append(finalD_test) test_avgD_error.append(avgD_test) print("test finalD error: ",finalD_test) print("test avgD error: ",avgD_test) #avg_test_loss.append(test(vanilla_lstm_net,args,pred_len)) ##calliing test function to return avg test loss at each epoch # '''after running through epochs, save your model and visualize. # then, write your average losses and standard deviations of # losses to a text file for record keeping.''' save_path = os.path.join('./saved_models/', 'vanilla_lstm_model_'+name+'_lr_' + str(learning_rate) + '_epoch_' + str(num_epoch) + '_predlen_' + str(pred_len) + '.pt') # torch.save(vanilla_lstm_net, './saved_models/vanilla_lstm_model_lr001_ep20.pt') torch.save(vanilla_lstm_net, save_path) print("saved vanilla_lstm_net! location: " + save_path) ''' visualize losses vs. epoch''' plt.figure() # new figure plt.title("Average train loss vs {} epochs".format(num_epoch)) plt.plot(avg_train_loss,label='avg train_loss') plt.plot(avg_test_loss,color='red',label='avg test_loss') plt.legend() plt.savefig("./saved_figs/" + "vanilla_lstm_"+name+"_avgtrainloss_lr_"+ str(learning_rate) + '_epochs_' + str(num_epoch) + '_predlen_' + str(pred_len) + '.jpeg') # plt.show() # plt.show(block=True) plt.figure() # new figure plt.title("Average and final displacement error {} epochs".format(num_epoch)) plt.plot(avg_train_finalD_error,label='train:final disp. error') plt.plot(avg_train_avgD_error,color='red',label='train:avg disp. error') plt.plot(test_finalD_error,color='green',label='test:final disp. error') plt.plot(test_avgD_error,color='black',label='test:avg disp. error') plt.ylim((0,10)) plt.legend() # plt.show() plt.savefig("./saved_figs/" + "vanilla_lstm_"+name+"_avg_final_displacement_lr_"+ str(learning_rate) + '_epochs_' + str(num_epoch) + '_predlen_' + str(pred_len) + '.jpeg') plt.figure() plt.title("Std of train loss vs epoch{} epochs".format(num_epoch)) plt.plot(std_train_loss) plt.savefig("./saved_figs/" + "vanilla_lstm_"+name+"_stdtrainloss_lr_"+ str(learning_rate) + '_epochs_' + str(num_epoch) + '_predlen_' + str(pred_len) + '.jpeg') # plt.show(block=True) print("saved images for avg training losses! location: " + "./saved_figs") # save results to text file txtfilename = os.path.join("./txtfiles/", "vanilla_lstm_"+name+"_avgtrainlosses_lr_"+ str(learning_rate) + '_epochs_' + str(num_epoch) + '_predlen_' + str(pred_len) + ".txt") os.makedirs(os.path.dirname("./txtfiles/"), exist_ok=True) # make directory if it doesn't exist with open(txtfilename, "w") as f: f.write("\n==============Average train loss vs. epoch:===============\n") f.write(str(avg_train_loss)) f.write("\nepochs: " + str(num_epoch)) f.write("\n==============Std train loss vs. epoch:===================\n") f.write(str(std_train_loss)) f.write("\n==============Avg test loss vs. epoch:===================\n") f.write(str(avg_test_loss)) f.write("\n==============Avg train displacement error:===================\n") f.write(str(avg_train_avgD_error)) f.write("\n==============Final train displacement error:===================\n") f.write(str(avg_train_finalD_error)) f.write("\n==============Avg test displacement error:===================\n") f.write(str(test_avgD_error)) f.write("\n==============Final test displacement error:===================\n") f.write(str(test_finalD_error)) print("saved average and std of training losses to text file in: ./txtfiles")
def main(args): # define parameters for training and testing loops num_epoch = 5 # pred_freq = 1 pred_len = 12 learning_rate = 0.0005 # get data # train_input, train_target, test_input, test_target = getData() dataset, dataloader = loader.data_loader(args, data_dir) # define the network and criterion vanilla_lstm_net = VanillaLSTMNet() # vanilla_lstm_net.double() # casts tensor to double criterion = nn.MSELoss( ) # MSE works best for difference between predicted and actual coordinate paths # define the optimizer optimizer = optim.Adam(vanilla_lstm_net.parameters(), lr=learning_rate) # initialize lists for capturing losses train_loss = [] test_loss = [] avg_train_loss = [] avg_test_loss = [] train_avgD_error = [] train_finalD_error = [] avg_train_avgD_error = [] avg_train_finalD_error = [] test_finalD_error = [] tets_avgD_error = [] std_train_loss = [] std_test_loss = [] '''train for 'num_epoch' epochs and test every 'pred_freq' epochs & when predicting use pred_len=6''' ### TRAINING FUNCTION ### for i in range(num_epoch): print( '======================= Epoch: {cur_epoch} / {total_epochs} =======================' .format(cur_epoch=i, total_epochs=num_epoch)) def closure(): for i, batch in enumerate(dataloader): # print("batch length:", len(batch)) # DEBUG train_batch = batch[0] target_batch = batch[1] print("train_batch's shape", train_batch.shape) print("target_batch's shape", target_batch.shape) seq, peds, coords = train_batch.shape # q is number of pedestrians #forward pass out = vanilla_lstm_net( train_batch, pred_len=pred_len ) # forward pass of lstm network for training print("out's shape:", out.shape) optimizer.zero_grad() # zero out gradients cur_train_loss = criterion(out, target_batch) # calculate MSE loss print('Current training loss: {}'.format( cur_train_loss.item())) # print current training loss #calculating average deisplacement error out1 = out target_batch1 = target_batch #making a copy of the tensors to convert them to array avgD_error = (np.sum( np.sqrt( np.square(out1[:, :, 0].detach().numpy() - target_batch1[:, :, 0].detach().numpy()) + np.square(out1[:, :, 1].detach().numpy() - target_batch1[:, :, 1].detach().numpy()))) ) / (pred_len * peds) train_avgD_error.append(avgD_error) print("current avg Disp error:", avgD_error) #calculating final displacement error finalD_error = (np.sum( np.sqrt( np.square(out1[pred_len - 1, :, 0].detach().numpy() - target_batch1[pred_len - 1, :, 0].detach().numpy()) + np.square(out1[pred_len - 1, :, 1].detach().numpy() - target_batch1[pred_len - 1, :, 1].detach().numpy())))) / peds train_finalD_error.append(finalD_error) print("current final displacement error:", finalD_error) train_loss.append(cur_train_loss.item()) cur_train_loss.backward() # backward prop optimizer.step( ) # step like a mini-batch (after all pedestrians) ### end prototyping ### return cur_train_loss optimizer.step(closure) # update weights # save model at every epoch (uncomment) # torch.save(vanilla_lstm_net, './saved_models/vanilla_lstm_model_lr0005.pt') # print("Saved vanilla_lstm_net!") avg_train_loss.append(np.sum(train_loss) / len(train_loss)) avg_train_avgD_error.append( np.sum(train_avgD_error) / len(train_avgD_error)) avg_train_finalD_error.append( np.sum(train_finalD_error) / len(train_finalD_error)) std_train_loss.append(np.std(np.asarray(train_loss))) train_loss = [] # empty train loss print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") print("average train loss: {}".format(avg_train_loss)) print("average std loss: {}".format(std_train_loss)) avg_test_loss.append( test(vanilla_lstm_net, args) ) ##calliing test function to return avg test loss at each epoch # all epochs have ended, so now save your model torch.save(vanilla_lstm_net, './saved_models/Vlstm_model_lr0005_ep5.pt') print("Saved vanilla_lstm_net!" + './saved_models/Vlstm_model_lr0005_ep5.pt') ''' visualize losses vs. epoch''' plt.figure() # new figure plt.title( "Average train & test loss v/s epoch {} epochs".format(num_epoch)) plt.plot(avg_train_loss, label='avg train_loss') plt.plot(avg_test_loss, color='red', label='avg test_loss') plt.legend() plt.show(block=True) # plt.show() plt.figure() # new figure plt.title( "Average and final displacement error {} epochs".format(num_epoch)) plt.plot(avg_train_finalD_error, label='final displacement error') plt.plot(avg_train_avgD_error, color='red', label='avg displacement error') plt.legend() plt.show(block=True) #visualizing std deviation v/s epoch plt.figure() plt.title("Std of train loss vs epoch") plt.plot(std_train_loss) plt.show(block=True)
def train(args): torch.cuda.manual_seed(1000) print('Loading data') if args.imgf_path == None: #default bottom-up top-down loader = data_loader(b_size=args.b_size) else: loader = data_loader(b_size=args.b_size, image_path=args.imgf_path) model = Model(v_size=loader.v_size, K=loader.K, f_dim=loader.f_dim, h_dim=args.hidden, o_dim=loader.o_dim, pretrained_we=loader.we_matrix) criterion = nn.BCEWithLogitsLoss() # Move it to GPU model = model.cuda() criterion = criterion.cuda() if args.optim == 'adam': optim = torch.optim.Adam(model.parameters(), lr=args.lr) elif args.optim == 'adadelta': optim = torch.optim.Adadelta(model.parameters(), lr=args.lr) elif args.optim == 'adagrad': optim = torch.optim.Adagrad(model.parameters(), lr=args.lr) elif args.optim == 'SGD': optim = torch.optim.SGD(model.parameters(), lr=args.lr) else: sys.exit('Invalid optimizer.(adam, adadelta, adagrad, SGD)') # Continue training from saved model if args.savedmodel and os.path.isfile(args.savedmodel): print('Reading Saved model {}'.format(args.savedmodel)) ckpt = torch.load(args.savedmodel) model.load_state_dict(ckpt['state_dict']) optim.load_state_dict(ckpt['optimizer']) # Training script print('Start training.') # for model save path_num = 1 while os.path.exists('save/model_{}'.format(path_num)): path_num += 1 for ep in range(args.epoch): ep_loss = 0 ep_correct = 0 for step in range(loader.n_batch): # Batch preparation q_batch, a_batch, i_batch = loader.next_batch() q_batch = Variable(torch.from_numpy(q_batch)) a_batch = Variable(torch.from_numpy(a_batch)) i_batch = Variable(torch.from_numpy(i_batch)) q_batch, a_batch, i_batch = q_batch.cuda(), a_batch.cuda( ), i_batch.cuda() # Do model forward output = model(q_batch, i_batch) # print(output.shape) loss = criterion(output, a_batch) if step % 400 == 0: _, oix = output.data.max(1) _, aix = a_batch.data.max(1) correct = torch.eq(oix, aix).sum() ep_correct += correct ep_loss += loss.data[0] print( 'Epoch %02d(%03d/%03d), loss: %.3f, correct: %3d / %d (%.2f%%)' % (ep + 1, step, loader.n_batch, loss.data[0], correct, args.b_size, correct * 100 / args.b_size)) # compute gradient and do optim step optim.zero_grad() loss.backward() optim.step() # Save model after every epoch tbs = { 'epoch': ep + 1, 'loss': ep_loss / loader.n_batch, 'accuracy': ep_correct * 100 / (loader.n_batch * args.b_size), 'state_dict': model.state_dict(), 'optimizer': optim.state_dict() } save_model(tbs, path_num, ep, args)
def main(args): # define parameters for training and testing loops num_epoch = 10 # pred_freq = 1 pred_len = 12 learning_rate = 0.0005 # get data # train_input, train_target, test_input, test_target = getData() dataset, dataloader = loader.data_loader(args, data_dir) # define the network and criterion gru_net = GRUNet() criterion = nn.MSELoss( ) # MSE works best for difference between predicted and actual coordinate paths # define the optimizer optimizer = optim.Adam(gru_net.parameters(), lr=learning_rate) # initialize lists for capturing losses train_loss = [] test_loss = [] avg_train_loss = [] avg_test_loss = [] std_train_loss = [] std_test_loss = [] '''train for 'num_epoch' epochs and test every 'pred_freq' epochs & when predicting use pred_len=6''' ### TRAINING FUNCTION ### for i in range(num_epoch): print( '======================= Epoch: {cur_epoch} / {total_epochs} =======================' .format(cur_epoch=i, total_epochs=num_epoch)) def closure(): for i, batch in enumerate(dataloader): # print("batch length:", len(batch)) # DEBUG train_batch = batch[0] target_batch = batch[1] print("train_batch's shape", train_batch.shape) print("target_batch's shape", target_batch.shape) seq, peds, coords = train_batch.shape # q is number of pedestrians #forward pass out = gru_net(train_batch, pred_len=pred_len ) # forward pass of GRU network for training print("out's shape:", out.shape) optimizer.zero_grad() # zero out gradients cur_train_loss = criterion(out, target_batch) # calculate MSE loss print('Current training loss: {}'.format( cur_train_loss.item())) # print current training loss train_loss.append(cur_train_loss.item()) cur_train_loss.backward() # backward prop optimizer.step( ) # step like a mini-batch (after all pedestrians) ### end prototyping ### return cur_train_loss optimizer.step(closure) # update weights # save model at every epoch (uncomment) # torch.save(gru_net, './saved_models/name_of_model.pt') # print("Saved gru_net!") avg_train_loss.append(sum(train_loss) / len(train_loss)) std_train_loss.append(np.std(np.asarray(train_loss))) train_loss = [] # empty train loss print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") print("average train loss: {}".format(avg_train_loss)) print("average std loss: {}".format(std_train_loss)) # all epochs have ended, so now save your model torch.save(gru_net, './saved_models/GRU_lr0005_ep10.pt') print("Saved GRU_net!" + './saved_models/GRU_lr0005_ep10.pt') ''' visualize losses vs. epoch''' plt.figure() # new figure plt.title("Average train loss vs epoch") plt.plot(avg_train_loss) plt.show(block=True) # plt.show() #visualizing std deviation v/s epoch plt.figure() plt.title("Std of train loss vs epoch") plt.plot(std_train_loss) plt.show(block=True)
default=8, help='Frequency number(epoch) of learning decay for optimizer') # store grids in epoch 0 and use further.2 times faster -> Intensive memory use around 12 GB parser.add_argument('--grid', action="store_true", default=True, help='Whether store grids and use further epoch') # Dataset options parser.add_argument('--dataset_name', default='zara1', type=str) parser.add_argument('--delim', default='\t') parser.add_argument('--loader_num_workers', default=4, type=int) parser.add_argument('--obs_len', default=8, type=int) parser.add_argument('--pred_len', default=8, type=int) parser.add_argument('--skip', default=1, type=int) args = parser.parse_args() # In[67]: dataset, dataloader = loader.data_loader(args, data_dir) # for i, f****r in enumerate(dataloader): # print("this is f****r's shape:\n", len(f****r)) # returns list of 7 # for j, subfucker in enumerate(f****r): # # print("this is subfucker\n", subfucker) # print("subfucker's shape\n", subfucker.shape) print(dataset) print(dataloader)
def main(args): if args.use_gpu == 1: os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_num print("Using GPU", args.gpu_num) else: print("Not using GPU") train_dir = "train" val_dir = "val" long_dtype, float_dtype = get_dtypes(args) print("Initializing train dataset") train_dset, train_loader = data_loader(args.dataset_folder, train_dir, args.batch_size) print("Initializing val dataset") val_dset, val_loader = data_loader(args.dataset_folder, val_dir, args.batch_size) print("Training for %d" % args.num_epochs) print("Arguments", args.__dict__) model = PredictFromNightBaseline() # model = PredictFromDayBaseline() # model = PredictBaseline() model.type(float_dtype) print(model) optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=args.learning_rate) # criterion = nn.BCELoss() criterion = nn.CrossEntropyLoss() max_val_acc = 0.0 for epoch in range(args.num_epochs): gc.collect() # Train epoch model.train() loss_avg = RunningAverage() acc_avg = RunningAverage() with tqdm(total=len(train_loader)) as t: for i, train_batch in enumerate(train_loader): train_batch = [ tensor.cuda() if args.use_gpu else tensor for tensor in train_batch ] X_day, X_night, Y = train_batch out = model(X_day, X_night) loss = criterion(out, Y) optimizer.zero_grad() loss.backward() optimizer.step() acc_avg.update_step(calc_accuracy(out, Y), Y.shape[0]) loss_avg.update_step(loss.item(), Y.shape[0]) t.set_postfix(loss='{:05.3f}'.format(loss_avg()), acc='{:05.3f}'.format(acc_avg())) t.update() #why doesnt the code go here # Val metrics model.eval() val_loss = RunningAverage() val_acc = RunningAverage() for i, val_batch in enumerate(val_loader): val_batch = [ tensor.cuda() if args.use_gpu else tensor for tensor in val_batch ] X_day, X_night, Y = val_batch out = model(X_day, X_night) loss = criterion(out, Y) val_loss.update_step(loss.item(), Y.shape[0]) val_acc.update_step(calc_accuracy(out, Y), Y.shape[0]) metrics_string = "Loss: {:05.3f} ; Acc: {:05.3f}".format( loss_avg(), acc_avg()) val_metrics = "Loss: {:05.3f} ; Acc: {:05.3f}".format( val_loss(), val_acc()) print("Epoch [%d/%d] - Train -" % (epoch + 1, args.num_epochs), metrics_string, "- Val -", val_metrics) if val_acc() > max_val_acc and args.save_model_weights: torch.save(model.state_dict(), os.path.join(model_path, str(epoch)))
print('The journey begins! ML automation with Pytorch') #Call the class data_read() data = data_read(config["directory"], config['dataframe_list'] ,config['date_list'] , config['target_list'] , config['idx'], config['multiclass_discontinuous'],config['text'] , config['remove_list']) # #call the class data_prep() dataframe_list = data.df_list base_join = data.df_list[0] join_list = [[data.df_list[1] , ['campaign_id'] , ['left']]] prep = data_prep(dataframe_list, base_join , join_list) print('lets check the data prepared' , prep.dataframe.head(2) , prep.dataframe.shape) # #call the classes from loader data_loader() , data_loader_pytorch() load = data_loader(prep.dataframe , data.dtype_list) load_text = data_loader_text(load.dataframe , config['text'] , load.in_emb_list , load.out_emb_list , load.mlp_features , load.emb_features) load_torch = data_loader_pytorch(load_text.dataframe , load_text.mlp_features , load_text.emb_features,load_text.emb_text_data , load.target) # #call the class Neural_Network() model = Neural_Network(load.in_emb_list , load.out_emb_list ,load_text.in_text_emb_list,load_text.out_text_emb_list ,inp_mlp_dim = 38, out_mlp_dim = 1) criterion = torch.nn.BCELoss(size_average = True) optimizer = torch.optim.SGD(model.parameters() , lr = 0.1) for epoch in range(10): target , mlp , embed , emb_text_data = load_torch.target ,load_torch.mlp , load_torch.emb , load_torch.emb_text_data pred = model(embed , mlp , emb_text_data) print('pred & target' , pred) loss = criterion(pred.float() , target.float()) ; print(epoch , loss) optimizer.zero_grad()