def train_model(net, loss_type, learning_rate, epochs=1000, gamma=0.001, print_every=50, eval_every=50, verbose=1, Lambda=1, alpha=0.5): optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate) criterion = torch.nn.MSELoss() huber_loss = torch.nn.SmoothL1Loss() for epoch in range(epochs): for i, data in enumerate(trainloader, 0): inputs, target, _ = data inputs = torch.tensor(inputs, dtype=torch.float32).to(device) target = torch.tensor(target, dtype=torch.float32).to(device) batch_size, N_output = target.shape[0:2] # forward + backward + optimize outputs = net(inputs) loss_mse, loss_shape, loss_temporal = torch.tensor( 0), torch.tensor(0), torch.tensor(0) if (loss_type == 'mse'): loss_mse = criterion(target, outputs) loss = loss_mse if (loss_type == 'dilate_shape'): loss, loss_shape, loss_temporal = dilate_loss( target, outputs, alpha, gamma, device) loss = loss_shape if (loss_type == 'dilate'): loss, loss_shape, loss_temporal = dilate_loss( target, outputs, alpha, gamma, device) if (loss_type == 'huber'): loss = huber_loss(target, outputs) optimizer.zero_grad() loss.backward() optimizer.step() if (verbose): if (epoch % print_every == 0): print('epoch ', epoch, ' loss ', loss.item(), ' loss shape ', loss_shape.item(), ' loss temporal ', loss_temporal.item()) eval_model(net, testloader, gamma, verbose=1)
def train_model(net,trainloader,testloader,loss_type,nsamples,learning_rate, device, epochs=1000, gamma = 0.001, print_every=50,eval_every=50, verbose=1, Lambda=1, alpha=0.5, regul_entropy=False, lambda_entropy=1): optimizer = torch.optim.Adam(net.parameters(),lr=learning_rate) scheduler = ReduceLROnPlateau(optimizer, mode='min', patience=3,factor=0.1,verbose=True) criterion = torch.nn.MSELoss() epoch_list = [] mse_list,dtw_list,tdi_list,dilate_list,best_mse_list,best_dtw_list,best_tdi_list,best_dilate_list,card_shape_list,card_time_list=[],[],[],[],[],[],[],[],[],[] best_mse = float('inf') for epoch in range(epochs): net.train() t0 = time.time() for i, data in enumerate(trainloader, 0): inputs, target = data inputs = torch.tensor(inputs, dtype=torch.float32).to(device) target = torch.tensor(target, dtype=torch.float32).to(device) batch_size, N_output = target.shape[0:2] outputs, z_mu, z_logvar = net(inputs, target) # outputs [batch, seq_len, nfeatures] loss_recons, loss_KL = 0,0 if (loss_type=='mse'): loss_mse = criterion(target,outputs) loss_recons = loss_mse if (loss_type=='dilate'): loss_dilate, loss_shape, loss_temporal = dilate_loss(target,outputs,alpha, gamma, device) loss_recons = loss_dilate loss_KL = loss_kullback_leibler(z_mu, z_logvar) # Kullback-Leibler loss = loss_recons + loss_KL if (regul_entropy): nsamples_entropy = 10 loss_entropy = torch.tensor([0],dtype=torch.float32).to(device) #for b in range(0,batch_size): b = 0 for k in range(nsamples_entropy): output_k = net.sample(inputs[b:b+1, :,:], target[b:b+1, :,:]) # output_k [1, seq_len, nfeatures] loss_entropy += criterion(output_k,target[b:b+1, :,:]) loss_entropy = loss_entropy /(batch_size * nsamples_entropy) loss = loss + lambda_entropy * loss_entropy optimizer.zero_grad() loss.backward() optimizer.step() if(verbose): if (epoch % print_every == 0): print('ep ', epoch, ' loss ',loss.item(), ' rec ',loss_recons.item(),' KL=',loss_KL.item(),' time ',time.time()-t0) if (epoch % eval_every == 0): mse,dilate = eval_model(net,testloader,nsamples,device,gamma,'vae') scheduler.step(dilate) mse_list.append(mse) dilate_list.append(dilate) epoch_list.append(epoch) return 0
def train_model(self, net, batch_size, loss_type, learning_rate, epochs=1000, gamma=0.001, print_every=50, eval_every=50, verbose=1, Lambda=1, alpha=0.5): optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate) criterion = torch.nn.MSELoss() criterion_softdtw = SoftDTW(gamma=gamma, normalize=True) for epoch in range(epochs): for i, data in enumerate(self.trainloader, 0): inputs, target = data inputs = torch.tensor(inputs, dtype=torch.float32).to(self.device) target = torch.tensor(target, dtype=torch.float32).to(self.device) # batch_size, N_output = target.shape[0:2] # forward + backward + optimize outputs = net(inputs) loss_mse, loss_shape, loss_temporal = torch.tensor( 0), torch.tensor(0), torch.tensor(0) ## TODO next run with dtw implementation if (loss_type == 'dtw'): loss_dtw = criterion_softdtw(outputs, target) loss = torch.mean(loss_dtw) if (loss_type == 'mse'): loss_mse = criterion(target, outputs) loss = loss_mse if (loss_type == 'dilate'): loss, loss_shape, loss_temporal = dilate_loss( outputs, target, alpha, gamma, self.device) # print(loss) optimizer.zero_grad() loss.backward() optimizer.step() if (verbose): if (epoch % print_every == 0): print('epoch ', epoch, ' loss ', loss.item(), ' loss shape ', loss_shape.item(), ' loss temporal ', loss_temporal.item()) self.eval_model(net, self.testloader, batch_size, gamma, verbose=1)
def diversity_loss(predictions, target, quality, diversity_kernel, alpha, gamma, ldtw, device): # predictions [batch_size, nsamples, seq_len, nfeatures] # target [batch_size, seq_len, nfeatures] criterion = torch.nn.MSELoss() nsamples = predictions.shape[1] S = torch.zeros((nsamples, nsamples)).to(device) # similarity matrix for i in range(0, nsamples): for j in range(0, nsamples): if i <= j: if diversity_kernel == 'dtw': dtw = dtw_loss(predictions[:, i, :, :], predictions[:, j, :, :], gamma, device) S[i, j] = dtw if diversity_kernel == 'tdi': dilate, shape, tdi = dilate_loss(predictions[:, i, :, :], predictions[:, j, :, :], alpha, gamma, device) S[i, j] = tdi if diversity_kernel == 'mse': S[i, j] = criterion(predictions[:, i, :, :], predictions[:, j, :, :]) S[j, i] = S[i, j] # matrix symmetrization # Kernel computation: S_mean = torch.mean(S) if diversity_kernel == 'dtw': Lambda = 1 / torch.abs(S_mean) K = torch.exp(-Lambda * S) if diversity_kernel == 'tdi': Lambda = 1 / torch.abs(S_mean) K = torch.exp(10 * Lambda * S) if diversity_kernel == 'mse': Lambda = S_mean K = torch.exp(-Lambda * S) I = torch.eye((nsamples)).to(device) M = I - torch.inverse(K + I) dpp_loss = -torch.trace(M) return dpp_loss
def train_model(net, batch_size, loss_type, learning_rate, epochs=1000, gamma=0.001, print_every=50, eval_every=50, verbose=1, Lambda=1, alpha=0.5, target_mean=0, target_std=0): optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate) criterion = torch.nn.MSELoss() criterion_softdtw = SoftDTW(gamma=gamma, normalize=True) for epoch in range(epochs): for i, data in enumerate(trainloader, 0): ## TODO modified for CustomDS try: inputs, target, _ = data except: try: inputs, target = data except: pass inputs = torch.tensor(inputs, dtype=torch.float32).to(device) target = torch.tensor(target, dtype=torch.float32).to(device) # batch_size, N_output = target.shape[0:2] # forward + backward + optimize # print(f"input size: {inputs.size()}") # print(f"input size -1: {inputs.size(-1)}") # print(net) outputs = net(inputs) loss_mse, loss_shape, loss_temporal = torch.tensor( 0), torch.tensor(0), torch.tensor(0) ## TODO next run with dtw implementation if (loss_type == 'dtw'): loss_dtw = criterion_softdtw(outputs, target) loss = torch.mean(loss_dtw) if (loss_type == 'mse'): loss_mse = criterion(target, outputs) loss = loss_mse if (loss_type == 'dilate'): loss, loss_shape, loss_temporal = dilate_loss( outputs, target, alpha, gamma, device) # print(loss) optimizer.zero_grad() loss.backward() optimizer.step() if epoch > 300: for z in range(len(outputs.to(device).detach().cpu().numpy())): preds_arr = outputs.to(device).detach().cpu().numpy()[ z, :, :] * target_std + target_mean input_arr = inputs.detach().cpu().numpy()[ z, :, idx_tgt_col] * target_std + target_mean target_arr = target.detach().cpu().numpy()[ z, :, :] * target_std + target_mean plt.plot(range(0, len(input_arr)), input_arr, label='input', linewidth=1) plt.plot(range( len(input_arr) - 1, len(input_arr) + len(target_arr)), np.concatenate([ input_arr[len(input_arr) - 1:len(input_arr)], target_arr.ravel() ]), label='target', linewidth=1) plt.plot(range( len(input_arr) - 1, len(input_arr) + len(target_arr)), np.concatenate([ input_arr[len(input_arr) - 1:len(input_arr)], preds_arr.ravel() ]), label='prediction', linewidth=1) plt.title( f"f{loss_type}: {loss.item()}, loss shape: {loss_shape.item()}, loss temporal: {loss_temporal.item()}" ) plt.show() if (verbose): if (epoch % print_every == 0): print('epoch ', epoch, ' loss ', loss.item(), ' loss shape ', loss_shape.item(), ' loss temporal ', loss_temporal.item()) eval_model(net, testloader, gamma, verbose=1)
def train_model(net, trainloader, validationloader, loss_type, learning_rate, epochs=1000, gamma=0.001, print_every=50, eval_every=50, verbose=1, Lambda=1, alpha=0.5, scalerY=[], modelSaver=[], save=True, device=[]): #Using Adam optimizer optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate) criterion = torch.nn.MSELoss() criterion2 = torch.nn.L1Loss() train_loss_hist = [] # save training loss at every epoch val_mse_hist = [ ] # save validation *mse* at every epoch such that epoch%print_every == 0 val_mae_hist = [ ] # save validation *mae* at every epoch such that epoch%print_every == 0 val_dtw_hist = [ ] # save validation *dtw* at every epoch such that epoch%print_every == 0, for DILATE Loss val_tdi_hist = [ ] # save validation *tdi* at every epoch such that epoch%print_every == 0, for DILATE Loss #scale: constant multiplier of the output normalizer scalerY. # An output value X(in the original range) is scaled as X*scale(to the zero-max normalized range) scale = torch.from_numpy(scalerY.scale_).to(device).float() train_loss_epoch = [ ] #temporary storage for losses over batches in a single epoch best_loss = 10000000000000 #track the best VALIDATION loss for early stopping for epoch in range(epochs): net.train() train_loss_epoch = [] # You can schedule the learning rate by modifying here, # E.g. At 10th and 25th epoch, divide the learning rate by 10 as: # if(epoch==10 or epoch==25): # for param_group in optimizer.param_groups: # learning_rate = learning_rate*0.1 # param_group['lr'] = learning_rate for i, data in enumerate(trainloader, 0): #Get a batch of data from the trainloader inputs_Encoder, inputs_Decoder, inputs_Encoder_global, inputs_Decoder_global, target = data inputs_Encoder = torch.tensor(inputs_Encoder, dtype=torch.float32).to(device) inputs_Decoder = torch.tensor(inputs_Decoder, dtype=torch.float32).to(device) inputs_Encoder_global = torch.tensor( inputs_Encoder_global, dtype=torch.float32).to(device) inputs_Decoder_global = torch.tensor( inputs_Decoder_global, dtype=torch.float32).to(device) target = torch.tensor(target, dtype=torch.float32).to(device) batch_size, N_output = target.shape[0:2] # Forward outputs = net(inputs_Encoder, inputs_Decoder, inputs_Encoder_global, inputs_Decoder_global) loss_mse, loss_shape, loss_temporal = torch.tensor( 0), torch.tensor(0), torch.tensor(0) # Loss if (loss_type == 'mse'): loss_mse = criterion(target[:, :, 0] * scale, outputs[:, :, 0]) loss = loss_mse if (loss_type == 'dilate'): loss, loss_shape, loss_temporal = dilate_loss( target * scale, outputs, alpha, gamma, device) if (loss_type == 'mae'): loss_mae = criterion2(target[:, :, 0] * scale, outputs[:, :, 0]) loss = loss_mae # Backward + Optimize optimizer.zero_grad() loss.backward() optimizer.step() train_loss_epoch.append(loss.item()) train_loss_hist.append(np.mean(train_loss_epoch)) if (verbose): if (epoch % print_every == 0): #Evaluate on validation net.eval() val_mse, val_mae, val_dtw, val_tdi = eval_model( net, validationloader, device, gamma=gamma, verbose=1, scalerY=scalerY) print('Epoch: ', epoch, '| Train loss: ', np.mean(train_loss_epoch), '| Val mae loss: ', val_mae * scalerY.scale_) print( '|--------------------------------------------------------|' ) val_mse_hist.append(val_mse) val_mae_hist.append(val_mae) val_dtw_hist.append(val_dtw) val_tdi_hist.append(val_tdi) if (val_mae < best_loss): #save model with respect to validation mae best_loss = val_mae if (save): modelSaver.saveNetwork(network) modelSaver.best_epoch = epoch modelSaver.best_net = network return train_loss_hist, val_mse_hist, val_mae_hist, val_dtw_hist, val_tdi_hist