def train(args, model, device, train_loader, optim, epoch): loss_classify_list = [] loss_regression_list = [] model.train() for idx, (data, box, label) in enumerate(train_loader): data, box, label = data.to(device), box.to(device), label.to(device) optim.zero_grad() c, r = model(data) loss_classify = CELoss( c, label.long()) # cross entropy loss for classify path loss_regression = SmoothL1(r, box) loss = loss_classify + 0.1 * loss_regression loss.backward() optim.step() if idx % 5 == 0: print('epoch: ' + str(epoch) + '\ttrain iter: ' + str(idx * len(data)) + '\tclassify loss: ' + str(loss_classify.item()) + '\tregression loss: ' + str(loss_regression.item())) loss_classify_list.append(loss_classify.item()) loss_regression_list.append(0.1 * loss_regression.item()) return loss_classify_list, loss_regression_list
def fit(epoch, model, data_loader, phase, volatile=False): #自定义的训练和验证的函数 if phase == 'training': torch.set_grad_enabled(True) model.train() if phase == 'validation': torch.set_grad_enabled(False) model.eval() volatile = True running_loss = 0.0 accuracy = 0.0 running_acc = 0.0 total = 0 #记录i取到的最大值(即每个epoch的step数) for i, data in enumerate(data_loader): img, lab = data if phase == 'training': optim.zero_grad() out = model(img.to(device, torch.float)) predict = out.argmax(dim=1) accuracy += (predict.data.cpu() == lab.data).sum() loss = loss_function(out, lab.to(device, torch.long)) running_loss += loss total = i if phase == 'training': loss.backward() optim.step() scheduler.step() running_loss = running_loss / (total + 1) #计算该轮次中loss平均值 running_acc = accuracy / ((total + 1) * batch_size) #计算该轮次的平均准确率 return running_loss, running_acc
def fit(epoch, model, data_loader, phase='training', volatile=False): if phase == 'training': model.train() if phase == 'validation': model.eval() volatile = True running_loss = 0.0 running_correct = 0 for batch_idx, (data, target) in enumerate(data_loader): if is_cuda: data, target = data.cuda(), target.cuda() data, target = Variable(data, volatile), Variable(target) if phase == 'training': optimizer.zero_grad() output = model(data) loss = F.nll_loss(output, target) running_loss += F.nll_loss(output, target, size_average=False).item() preds = output.data.max(dim=1, keepdim=True)[1] running_correct += preds.eq(target.data.view_as(preds)).cpu().sum() if phase == 'training': loss.backward() optimizer.step() loss = running_loss / len(data_loader.dataset) accuracy = running_correct.__float__() / len(data_loader.dataset) print(f'第{epoch}次迭代, {phase} loss is {loss} and {phase} accuracy is {accuracy}') return loss, accuracy
def animate(i,config,net,optim,data): print(i,'/',iternum); net.train(); out = net(data); loss = config.loss(data,out); optim.zero_grad(); loss['overall'].backward(); optim.step(); print(loss['overall'].data.cpu().numpy()); net.eval(); with torch.no_grad(): out = net(data); box2d_src = data[1].data.cpu().numpy(); box3d_src = data[2].data.cpu().numpy(); box2d_tgt = data[3].data.cpu().numpy(); box3d_tgt = data[4].data.cpu().numpy(); r = data[5].data.cpu().numpy(); gts = data[6].data.cpu().numpy(); y = out['y'].data.cpu().numpy(); num = box3d_src.shape[0]; col = int(np.sqrt(num)); row = num // col; for ri in range(row): for cj in range(col): ni = ri*col+cj; ymap = y[ni,...]; ymap *= np.pi; ymap[1] *= 2; c3d = recon(box3d_src[ni,...],r[ni,...],ymap); pv[ni].set_data(c3d[:,0],c3d[:,1]); pv[ni].set_3d_properties(c3d[:,2]); if i == iternum-1: exit(); return pv;
def train(model, data): total_epoch_loss = 0 total_epoch_acc = 0 model.to('cpu') model.train() # print(len(train_data)) for idx, batch in enumerate(data): data_in = batch target = torch.LongTensor(batch['label'][num_of_classes]) # print(batch['meta']) optim.zero_grad() prediction = model(data_in) loss = F.cross_entropy(prediction, target) num_corrects = (torch.max(prediction, 1)[1].view( target.size()).data == target.data).float().sum() # print(num_corrects, len(batch['statement'])) acc = 100.0 * num_corrects / len(batch['statement']) loss.backward() # clip_gradient(model, 1e-1) optim.step() total_epoch_loss += loss.item() total_epoch_acc += acc.item() return total_epoch_loss / len(data), total_epoch_acc / len(data)
def training(model, optim, criterion_cls, train_iter, epoch): model.train() losses = [] label = [] preds = [] softmax = nn.Softmax(dim = -1) print('\nTrain_Epoch:', epoch) for batch in tqdm.tqdm(train_iter): optim.zero_grad() input_ids = batch['input_ids'].cuda() attn_mask = batch['attention_mask'].cuda() token_type_ids = batch['token_type_ids'].cuda() truelabel_cls = batch['cls_label'].cuda() logits_cls = model(input_ids, attn_mask, token_type_ids) ## if out dim is (bs x seqlen x numclass) -> (total_words_batch x numclass) ## if true label is (bs x seqlen) -> (total_words_batch) loss_cls = criterion_cls (logits_cls.view(-1, 2), truelabel_cls.view(-1, )) loss = loss_cls losses.append(loss.item()) #for now we are only interested in accuracy and f1 of the classification task label.extend(truelabel_cls.cpu().detach().numpy()) preds_cls = softmax(logits_cls).argmax(1) preds.extend(preds_cls.view(-1).cpu().detach().numpy()) loss.backward() optim.step() return losses, label, preds
def optimize(): log_dir = opt.logging_root cond_mkdir(log_dir) summaries_dir = os.path.join(log_dir, opt.experiment_name) cond_mkdir(summaries_dir) m = DiffusionModel(us_init=opt.us_init, ua_init=opt.ua_init, n_init=opt.n_init) m.to(device) optim = torch.optim.Adam(m.parameters(), lr=opt.lr, amsgrad=True) writer = SummaryWriter(summaries_dir) converged = False converged_eps = opt.convergence prev_loss = 1e6 for ii in range(opt.num_iters): loss, model, data = objective(m) optim.zero_grad() # write summary writer.add_scalar('mse', loss, ii) if not ii % opt.steps_til_summary: write_summary(writer, m, loss, model, data, ii) print(f'{ii}: {loss.detach().cpu().numpy():03f}') loss.backward() optim.step() # values should be non-negative def clamp_nonnegative(m): m.ua.data = torch.clamp(m.ua.data, min=0) m.us.data = torch.clamp(m.us.data, min=0) m.apply(clamp_nonnegative) if torch.abs(loss - prev_loss) < converged_eps: converged = True break prev_loss = loss.clone() out = { 'us': m.us.detach().cpu().numpy().squeeze().item() * m.us_scale, 'ua': m.ua.detach().cpu().numpy().squeeze().item(), 't0': m.t0.detach().cpu().numpy().squeeze(), 'us_init': opt.us_init, 'ua_init': opt.ua_init, 'n_init': opt.n_init, 'mse': loss.detach().cpu().numpy().squeeze().item(), 'iters': ii, 'converged': converged, 'converged_eps': converged_eps } np.save(os.path.join(summaries_dir, 'out.npy'), out)
def test_save_and_load(self): lin = pyro.module("mymodule", self.linear_module) pyro.module("mymodule2", self.linear_module2) x = torch.randn(1, 3) myparam = pyro.param("myparam", 1.234 * torch.ones(1)) cost = torch.sum(torch.pow(lin(x), 2.0)) * torch.pow(myparam, 4.0) cost.backward() params = list(self.linear_module.parameters()) + [myparam] optim = torch.optim.Adam(params, lr=0.01) myparam_copy_stale = copy(pyro.param("myparam").detach().cpu().numpy()) optim.step() myparam_copy = copy(pyro.param("myparam").detach().cpu().numpy()) param_store_params = copy(pyro.get_param_store()._params) param_store_param_to_name = copy(pyro.get_param_store()._param_to_name) assert len(list(param_store_params.keys())) == 5 assert len(list(param_store_param_to_name.values())) == 5 pyro.get_param_store().save("paramstore.unittest.out") pyro.clear_param_store() assert len(list(pyro.get_param_store()._params)) == 0 assert len(list(pyro.get_param_store()._param_to_name)) == 0 pyro.get_param_store().load("paramstore.unittest.out") def modules_are_equal(): weights_equal = (np.sum( np.fabs(self.linear_module3.weight.detach().cpu().numpy() - self.linear_module.weight.detach().cpu().numpy())) == 0.0) bias_equal = (np.sum( np.fabs(self.linear_module3.bias.detach().cpu().numpy() - self.linear_module.bias.detach().cpu().numpy())) == 0.0 ) return weights_equal and bias_equal assert not modules_are_equal() pyro.module("mymodule", self.linear_module3, update_module_params=False) assert id(self.linear_module3.weight) != id( pyro.param("mymodule$$$weight")) assert not modules_are_equal() pyro.module("mymodule", self.linear_module3, update_module_params=True) assert id(self.linear_module3.weight) == id( pyro.param("mymodule$$$weight")) assert modules_are_equal() myparam = pyro.param("myparam") store = pyro.get_param_store() assert myparam_copy_stale != myparam.detach().cpu().numpy() assert myparam_copy == myparam.detach().cpu().numpy() assert sorted(param_store_params.keys()) == sorted( store._params.keys()) assert sorted(param_store_param_to_name.values()) == sorted( store._param_to_name.values()) assert sorted(store._params.keys()) == sorted( store._param_to_name.values())
def train_batch(self, batch, loss_fn, optim=None, ret_images=False, eval=False): """ Train network on a single batch Args batch (tuple) Tuple containing output labels tensor, input images tensor and output images tensor loss_fn (nn.Module) Loss function instance optim (nn.Module) Optimizer used during weights update ret_images (bool) Wether to return test images either eval (bool) Wether to do training or evaluation (test) Return (float) Current batch loss (torch.Tensor) Eventually return reconstructed images either Raise (ValueError) In case training mode has been chosen without defining an optimizer instance """ # Check that optimizer has been set in training mode if (not eval) and (optim is None): # Raise exception raise ValueError('optimizer must be set for training') # Retrieve device device = self.device # Retrieve output labels, input image and output image out_labels, in_images, out_images = batch # Move input and output images to device in_images, out_images = in_images.to(device), out_images.to(device) # Make forward pass net_images, mu, logvar = self(in_images) # Case loss function is not the regularized one (e.g. MSE) if loss_fn != self.loss_fn: # Give only reconstructed images to loss loss = loss_fn(net_images, out_images) # Case loss function is the regularized one if loss_fn == self.loss_fn: # Compute loss using either distribution parameters loss = loss_fn(net_images, out_images, mu, logvar) # Training mode if not eval: # Clean previous optimizer state optim.zero_grad() # Make backward pass (update weights) loss.backward() # Update weights optim.step() # Case images have been required if ret_images: # Return either loss and images return float(loss.data), net_images # Return loss return float(loss.data)
def train(model, optim, loader): model.train() top1_cnt = 0 total_cnt = 0 t_start = time() for i, batch in enumerate(loader): if i and i % print_every_train == 0: avg_loss = sum( stats['train_loss'][-print_every_train:]) / print_every_train avg_time = (time() - t_start) / print_every_train cur_acc = top1_cnt / total_cnt if total_cnt else -1 print('{:d}-{:d}: avg_loss={:f} / avg_time={:f}s / cur_acc={:f}'. format(i - print_every_train, i, avg_loss, avg_time, cur_acc)) sys.stdout.flush() t_start = time() # unroll a batch q_embed, a_embeds, img_feats, gt = batch # Variable for autograd q_embed_var = Variable( q_embed.view(q_embed.size(0) * q_embed.size(1), q_embed.size(2))).type( dtype) # Variable(q_embed.mean(1)).type(dtype) img_feats_var = Variable( img_feats.view( img_feats.size(0) * img_feats.size(1), img_feats.size(2))).type(dtype) a_embeds_var = Variable( a_embeds.view( a_embeds.size(0) * a_embeds.size(1), a_embeds.size(2)) ).type( dtype ) # [Variable(a_embed).type(dtype) for a_embed in a_embeds] # [Variable(a_embed.mean(1)).type(dtype) for a_embed in a_embeds] gt_var = Variable(gt.view(gt.size(0) * gt.size(1), gt.size(2))).type(dtype) # Concatenate features: question + img + answers concated = torch.cat([q_embed_var, img_feats_var, a_embeds_var], dim=1) if USE_GPU: concated = concated.cuda() gt_var = gt_var.cuda() # forward out = model(concated) _, idx = out.view(q_embed.size(0), q_embed.size(1)).sort(dim=1, descending=True) loss = loss_fn(out, gt_var) # update stats top1_cnt += sum(idx[:, 0] == 0).data[0] total_cnt += idx.size(0) stats['train_loss'].append(loss.data[0]) # backward optim.zero_grad() loss.backward() optim.step() acc = top1_cnt / total_cnt if total_cnt else -1 stats['train_acc'].append(acc) print("train top@1 accuracy:", acc)
def Trainer(model, loss, optim, trainSet, devSet, epoch, epoches, device, eval = True): ''' This function is used to train the model.\n Params:\n - model: The neural network model. - loss: The loss function. - optim: The optimizer. - trainSet: The training dataset. - devSet: The evaluating dataset. - epoch: The current training epoch. - epoches: The total training epoches. - device: The device setting. - eval: The boolean value to indicate whether doing the test during the training. ''' # Initialize the training loss and accuracy. trainLoss = [] trainAcc = [] # Set the training loading bar. with tqdm(total = len(trainSet), desc = f'Epoch {epoch + 1}/{epoches}', unit = 'batch', dynamic_ncols = True) as pbars: # Get the training data. for i, (data, label) in enumerate(trainSet): # Send the data into corresponding device. data = Variable(data).to(device) label = Variable(label).to(device) # Compute the prediction. prediction = model(data) # Compute the loss. cost = loss(prediction, label) # Store the cost. trainLoss.append(cost.item()) # Clear the previous gradient. optim.zero_grad() # Compute the backward. cost.backward() # Update the parameters. optim.step() # Compute the accuracy. accuracy = (torch.argmax(prediction, 1) == label) accuracy = accuracy.sum().float() / len(accuracy) # Store the accuracy. trainAcc.append(accuracy.item()) # Update the loading bar. pbars.update(1) # Update the training info. pbars.set_postfix_str(' - Train Loss %.4f - Train Acc %.4f' % (np.mean(trainLoss), np.mean(trainAcc))) # Close the loading bar. pbars.close() # Check whether do the evaluation. if eval == True: # Print the hint for evaluation. print('Evaluating...', end = ' ') # Evaluate the model. evalLoss, evalAcc = Trainer.Evaluator(model.eval(), loss, devSet, device) # Print the evaluating result. print('- Eval Loss %.4f - Eval Acc %.4f' % (evalLoss, evalAcc), end = ' ') # Return the training result. return model.train(), np.mean(trainLoss), np.mean(trainAcc), evalLoss, evalAcc # Return the training result. return model.train(), np.mean(trainLoss), np.mean(trainAcc), None, None
def update_layer(self, layer, index, extra): opt = self.layers[layer][6] opt.zero_grad() loss = self.lp_loss(layer, index, extra, compute_grad=False) loss.backward() loss = loss.detach().cpu().numpy() opt.step() return loss
def train(args, model, optim, loader): model.train() top1_cnt = 0 total_cnt = 0 t_start = time.time() for i,batch in enumerate(loader): if i and i%args.print_every_train==0: avg_loss = sum(stats['train_loss'][-args.print_every_train:])/args.print_every_train avg_time = (time.time()-t_start)/args.print_every_train cur_acc = top1_cnt/total_cnt if total_cnt else -1 print('{:d}-{:d}: avg_loss={:f} / avg_time={:f}s / cur_acc={:f}'.format(i-args.print_every_train, i, avg_loss, avg_time, cur_acc)) sys.stdout.flush() t_start = time.time() # unroll a batch seq_lens, indices, qa_embeds, img_feats, gt = batch this_batch_size = int(seq_lens.size(0)/4) # Variable for autograd qa_embeds_var = Variable(qa_embeds).type(torch.LongTensor) # lookup indices to nn.Embeddings have to be LongTensor img_feats_var = Variable(img_feats).type(dtype) gt_var = Variable(gt).type(dtype) if USE_GPU: qa_embeds_var = qa_embeds_var.cuda() img_feats_var = img_feats_var.cuda() gt_var = gt_var.cuda() # forward out = model(qa_embeds_var, img_feats_var, seq_lens) if args.loss == 'BCE': loss = loss_fn(out, gt_var) elif args.loss == 'rank': # pos_col = out[indices[0::4]].expand(this_batch_size, 3).view(-1) _, unsort_ind = indices.sort() out_orig_order = out[unsort_ind].view(-1, 4) pos_col = out_orig_order[:,0] neg_col = out_orig_order[:,1:].mean(dim=1) flag_col = torch.ones_like(pos_col) if USE_GPU: pos_col = pos_col.cuda() neg_col = neg_col.cuda() flag_col = flag_col.cuda() loss = loss_fn(pos_col, neg_col, flag_col) # unsort out _, unsort_ind = indices.sort(0) out = out[unsort_ind] # update stats _, idx = out.view(this_batch_size, -1).sort(dim=1, descending=True) top1_cnt += sum(idx[:, 0] == 0).data[0] total_cnt += idx.size(0) stats['train_loss'].append(loss.data[0]) # backward optim.zero_grad() loss.backward() optim.step() acc = top1_cnt/total_cnt if total_cnt else -1 stats['train_acc'].append(acc) print("train top@1 accuracy:", acc)
def learn(self): alpha = self.network.log_alpha.exp().detach() states, actions, rewards, next_states, dones = self.memory.sample() dones = dones.unsqueeze(-1) rewards = rewards.unsqueeze(-1) # Compute target Q and Target V next_targeted_value = self.network.value_target(states) target_q = (rewards + self.GAMMA * (1 - dones) * next_targeted_value).detach() assert next_targeted_value.shape == dones.shape, " next_targeted_value {} != dones {}".format( next_targeted_value.shape, dones.shape) assert next_targeted_value.shape == rewards.shape, " next_targeted_value {} != rewards {}".format( next_targeted_value.shape, rewards.shape) new_actions, new_log_probs = self.network.get_with_probabilities( states) concatenated = torch.cat((states, new_actions), dim=-1) current_q = torch.stack( [critic(concatenated) for critic in self.network.critics_local]) min_current_q, _ = current_q.min(dim=0) assert min_current_q.shape == new_log_probs.shape, " min_current_q {} != new_log_probs {}".format( min_current_q.shape, new_log_probs.shape) self.estimation = min_current_q.mean().detach().cpu().numpy().item() target_v = (min_current_q - alpha * new_log_probs).detach() for optim, critic, i in zip(self.critic_optims, self.network.critics_local, range(len(self.network.critics_local))): concatenated = torch.cat((states, actions), dim=-1) q_value = critic(concatenated) optim.zero_grad() loss = self.loss_function(q_value, target_q) loss.backward() self.critics_losses[i] = loss.detach().cpu().numpy().item() optim.step() self.value_optim.zero_grad() self.loss_function(self.network.value_local(states), target_v).backward() self.value_optim.step() # optimize alpha alpha_loss = -self.network.log_alpha * (new_log_probs + self.TARGET_ENTROPY).detach() self.alpha_optim.zero_grad() alpha_loss.mean().backward() self.alpha_optim.step() # optimize the actor policy_kl_losses = -(min_current_q - alpha * new_log_probs) self.actor_optim.zero_grad() loss = policy_kl_losses.mean() loss.backward() self.policy_loss = loss.detach().cpu().numpy().item() self.actor_optim.step() self.update_target()
def train(self, epoch, data_train_loader, data_val_loader): optim = self.optim t = 0 LOSSES = 0 counter = 0 #for e in range(epoch): while self.checkpoint['e'] < epoch: for x in data_train_loader: optim.zero_grad() x = Variable(x[0]) if self.cuda: x = x.cuda() losses = self.maf.loss(x) loss = losses.mean() LOSSES += losses.sum().data.cpu().numpy() counter += losses.size(0) loss.backward() self.maf.clip_grad_norm() optim.step() t += 1 if self.checkpoint['e'] % 1 == 0: optim.swap() loss_val = self.evaluate(data_val_loader) print ('Epoch: [%4d/%4d] train <= %.2f ' \ 'valid: %.3f ' % \ (self.checkpoint['e']+1, epoch, LOSSES/float(counter), loss_val)) if loss_val < self.checkpoint['best_val']: print(' [^] Best validation loss [^] ... [saving]') self.save(self.save_dir + '/' + self.filename + '_best') self.checkpoint['best_val'] = loss_val self.checkpoint[ 'best_val_epoch'] = self.checkpoint['e'] + 1 LOSSES = 0 counter = 0 optim.swap() self.checkpoint['e'] += 1 if (self.checkpoint['e']) % 5 == 0: self.save(self.save_dir + '/' + self.filename + '_last') if self.impatient(): print('Terminating due to impatience ... \n') break # loading best valid model (early stopping) self.load(self.save_dir + '/' + self.filename + '_best')
def learn(self): states, actions, rewards, next_states, dones = self.memory.sample() alpha = self.network.log_alpha.exp().detach() # optimize the critic next_actions, next_log_probs = self.network.get_with_probabilities( next_states) concatenated = torch.cat((next_states, next_actions), dim=-1) next_q_targets = torch.stack( [critic(concatenated) for critic in self.network.critics_target]) next_min_q, _ = next_q_targets.min(dim=0) assert next_min_q.shape == next_log_probs.shape, " next_min_q {} != next_log_probs {}".format( next_min_q.shape, next_log_probs.shape) dones = dones.unsqueeze(-1) assert next_min_q.shape == dones.shape, " next_min_q {} != dones {}".format( next_min_q.shape, dones.shape) rewards = rewards.unsqueeze(-1) assert next_min_q.shape == rewards.shape, " next_min_q {} != rewards {}".format( next_min_q.shape, rewards.shape) next_value = next_min_q - alpha * next_log_probs target = (rewards + self.GAMMA * (1 - dones) * next_value).detach() for critic, optim, i in zip(self.network.critics_local, self.critic_optims, range(len(self.network.critics_local))): concatenated = torch.cat((states, actions), dim=-1) current = critic(concatenated) optim.zero_grad() loss = self.loss_function(current, target) loss.backward() self.critics_losses[i] = loss.detach().cpu().numpy().item() optim.step() new_actions, new_log_probs = self.network.get_with_probabilities( states) # optimize alpha alpha_loss = -self.network.log_alpha * (new_log_probs + self.TARGET_ENTROPY).detach() self.alpha_optim.zero_grad() alpha_loss.mean().backward() self.alpha_optim.step() # optimize the actor concatenated = torch.cat((states, new_actions), dim=-1) q_locals = torch.stack( [critic(concatenated) for critic in self.network.critics_local]) min_q_locals, _ = q_locals.min(dim=0) assert min_q_locals.shape == new_log_probs.shape, " min_q_locals {} != new_log_probs {}".format( min_q_locals.shape, new_log_probs.shape) self.estimation = min_q_locals.mean().detach().cpu().numpy().item() policy_kl_losses = alpha * new_log_probs - min_q_locals self.actor_optim.zero_grad() loss = policy_kl_losses.mean() loss.backward() self.policy_loss = loss.detach().cpu().numpy().item() self.actor_optim.step()
def train_VAE_1_step(model, other_VAE, optim, data): optim.zero_grad() recon_batch, mu, logsig = model(data) fake = other_VAE.decode(model.reparameterize(mu, logsig)) fake_batch, fake_mu, fake_logsig = other_VAE(fake) loss = loss_function(recon_batch, data, mu, logsig) + 0.5 * loss_function( fake_batch, fake, fake_mu, fake_logsig) loss.backward() optim.step() return loss.item()
def train(model,x_set,y_set,optim): all_loss = 0 for x,y in zip(x_set,y_set): optim.zero_grad() pred = model.forward(x) loss = (pred-y).pow(2).sum()/2 all_loss += loss loss.backward() optim.step() return all_loss.item()/len(x_set)
def train_single_layer(log, optim, cross_entropy, train_path_rep, train_label, batch_size): for _ in range(100): log.train() optimizer.zero_grad() logit = log(train_path_rep.view(batch_size, train_label.shape[0], -1)) logit = torch.squeeze(logit) loss = cross_entropy(logit, train_label) loss.backward() optim.step()
def train_with_gener(gener, cnt, optim, top_10_hit_gate): xy = next(gener) x = [autograd.Variable(file_matrix[i]) for i in xy[:2]] label = xy[2] output = net(x) target = autograd.Variable(label) loss = criterion(output, target) if cnt % 100 == 0: output_t = net(x_t) loss_t = criterion(output_t, target_t) val_analysis = validation(range(10)) short_report = val_analysis[8] top_10_hit = val_analysis[1] temple_report = '%05d: ' % (cnt) + analysis_result( output, xy, label, loss)[0] + '\t validation:\t' + short_report print(temple_report) f_log.write(temple_report + '\n') if top_10_hit >= top_10_hit_gate: val_report_data = validation(range(len(g.test_commits))) val_report = val_report_data[8] top_10_hit = val_report_data[1] print(val_report) cur_time = time.strftime('%Y-%m-%d-%H-%M', time.localtime(time.time())) torch.save( net, '/home/ub102/change_recommend_pytorch/models/model-%.4f-%s.pkl' % (top_10_hit, cur_time)) torch.save( net.state_dict(), '/home/ub102/change_recommend_pytorch/models/model-%.4f-pars-%s.pkl' % (top_10_hit, cur_time)) print('model_saved') return False if cnt % 5000 == 0 and cnt > 0: val_report_data = validation(range(len(g.test_commits))) val_report = val_report_data[8] top_10_hit = val_report_data[1] cur_time = time.strftime('%Y-%m-%d-%H-%M', time.localtime(time.time())) torch.save( net, '/home/ub102/change_recommend_pytorch/models/model-%.4f-%s.pkl' % (top_10_hit, cur_time)) torch.save( net.state_dict(), '/home/ub102/change_recommend_pytorch/models/model-%.4f-pars-%s.pkl' % (top_10_hit, cur_time)) f_log.write('model saved:\t%s\n' % cur_time) f_log.write(val_report) print(val_report) loss.backward() optim.step() return False
def train(feature_extractor, class_classifier, source_train_loader, optim, epoch, class_criterion): """ Train each epoch with default framework. """ loss = [] feature_extractor.train() class_classifier.train() for index, source_batch in enumerate(source_train_loader, 1): #------------------------------- # Prepare the images and labels #------------------------------- source_img, source_label, _ = source_batch source_img, source_label = source_img.to(DEVICE), source_label.view( -1).type(torch.long).to(DEVICE) batch_size = len(source_label) # print("Label.shape: \t{}".format(source_label.shape)) # print(source_label) #------------------------------- # Setup optimizer # Dynamic adjust the learning rate with parameter p #------------------------------- # optim = utils.set_optimizer_lr(optim, p) optim.zero_grad() #------------------------------- # Get features, class pred, domain pred: #------------------------------- source_feature = feature_extractor(source_img).view(batch_size, -1) class_predict = class_classifier(source_feature) #------------------------------- # Compute the accuracy, loss #------------------------------- # print(class_predict.type()) # print(source_label.type()) # print(class_predict.shape) # print(source_label.shape) loss = class_criterion(class_predict, source_label) loss.backward() optim.step() class_predict = class_predict.cpu().detach().numpy() source_label = source_label.cpu().detach().numpy() source_acc = np.mean(np.argmax(class_predict, axis=1) == source_label) if index % opt.log_interval == 0: print( "[Epoch %d] [ %d/%d ] [src_acc: %d%%] [loss_Y: %f] [loss_D: N/A]" % (epoch, index, len(source_train_loader), 100 * source_acc, loss.item())) return feature_extractor, class_classifier
def train(model): train_df = get_df_from_ds(train_ds, df) test_df = get_df_from_ds(test_ds, df) name = info[emb_str]['name'] ds = TensorDataset( torch.tensor(train_df[name].tolist()).to(device), torch.tensor(train_df["label"].tolist()).to(device)) train_dataloader = DataLoader(ds, batch_size=64) ds = TensorDataset( torch.tensor(test_df[name].tolist()).to(device), torch.tensor(test_df["label"].tolist()).to(device)) test_dataloader = DataLoader(ds, batch_size=64) dataloaders = {"train": train_dataloader, "test": test_dataloader} for epoch in range(EPOCH): probs = [] labels = [] for phase in ['train', 'test']: if phase == 'train': model.train() else: model.eval() for X, y in dataloaders[phase]: optim.zero_grad() with torch.set_grad_enabled(phase == 'train'): logits = model(X) loss = criterion(logits, y) if phase == 'train': loss.backward() optim.step() probs.extend(logits.softmax(-1).detach().cpu().numpy()) labels.extend(y.detach().cpu().numpy()) if epoch % 5 == 0: probs = np.array(probs) labels = np.array(labels) preds = probs.argmax(-1) assert phase == "test", probs.shape[0] == len(test_df) macro_auc = roc_auc_score(labels, probs, average="macro", multi_class="ovo") weight_auc = roc_auc_score(labels, probs, average="weighted", multi_class="ovo") precision, recall, f1, _ = precision_recall_fscore_support( labels, preds, average='macro') print(f"{epoch} test acc => {accuracy_score(preds, labels)}\n" f"\t f1 => {f1}\n" f"\t precision => {precision}\n" f"\t recall => {recall}\n" f"\t macro_auc => {macro_auc}\n" f"\t weighted auc => {weight_auc}\n")
def train(model, optim, criterion, datum, label): ''' Modify weights based off cost from one datapoint ''' optim.zero_grad() output = model(datum) output = output.view(1, num_classes) is_correct = accuracy(output, label) loss = criterion(output, label) loss.backward() optim.step() return loss.item(), is_correct
def train(data, model, optim, criterion, max_clip_norm=5): model.train() optim.zero_grad() data, labels = rebatchify(data) data, labels = data.to('cuda'), labels.to('cuda') logits = model(data) loss = criterion(logits, labels) torch.nn.utils.clip_grad_norm_(model.parameters(), max_clip_norm) loss.backward() optim.step() return loss.item()
def train(args): states, sender, action, value = [], [], [], [] with open( os.path.join(path('dataset'), f'supervised-{args.adversary_strategy}.pkl'), 'rb') as f: num_sim = 0 while True: try: states_x, sender_x, action_x, value_x = pickle.load(f) num_sim += 1 states.extend(states_x) sender.extend(sender_x) action.extend(action_x) value.extend(value_x) except EOFError: print("Number of simulations loaded:", num_sim) print("Dataset entries:", len(states)) break states = torch.Tensor(states) dataset = torch.utils.data.DataLoader(list( zip(states, sender, action, value)), batch_size=32, shuffle=True) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print("Device:", device) net = load_net(f'supervised-{args.adversary_strategy}') net.to(device) optim = torch.optim.Adam(net.parameters()) for epoch in range(args.num_epochs): for s, f, a, v in dataset: s = s.to(device) f = f.to(device) vp, ap = net(s, f) # value_loss = F.mse_loss(vp, v.unsqueeze(1)) a = a.to(device) action_loss = F.cross_entropy(ap, a) # loss = action_loss + value_loss optim.zero_grad() action_loss.backward() optim.step() print("Action loss:", action_loss.cpu().data.numpy()) # print(loss, value_loss, action_loss) save_net(net, f'supervised-{args.adversary_strategy}')
def finetune_model(pretrained_model, loss_func, optim, epochs=10): start = time.time() model_weights = copy.deepcopy(pretrained_model.state_dict()) accuracy = 0.0 for e in range(epochs): print(f'Epoch number {e}/{epochs - 1}') print('=' * 20) # for each epoch we run through the training and validation set for dset in ['train', 'val']: if dset == 'train': pretrained_model.train() # set model to train mode (i.e. trainbale weights) else: pretrained_model.eval() # set model to validation mode loss = 0.0 successes = 0 # iterate over the (training/validation) data. for imgs, tgts in dloaders[dset]: imgs = imgs.to(dvc) tgts = tgts.to(dvc) optim.zero_grad() with torch.set_grad_enabled(dset == 'train'): ops = pretrained_model(imgs) _, preds = torch.max(ops, 1) loss_curr = loss_func(ops, tgts) # backward pass only if in training mode if dset == 'train': loss_curr.backward() optim.step() loss += loss_curr.item() * imgs.size(0) successes += torch.sum(preds == tgts.data) loss_epoch = loss / dset_sizes[dset] accuracy_epoch = successes.double() / dset_sizes[dset] print(f'{dset} loss in this epoch: {loss_epoch}, accuracy in this epoch: {accuracy_epoch}') if dset == 'val' and accuracy_epoch > accuracy: accuracy = accuracy_epoch model_weights = copy.deepcopy(pretrained_model.state_dict()) print() time_delta = time.time() - start print(f'Training finished in {time_delta // 60}mins {time_delta % 60}secs') print(f'Best validation set accuracy: {accuracy}') # load the best model version (weights) pretrained_model.load_state_dict(model_weights) return pretrained_model
def test(): process = [] for idx, (data, ) in enumerate(test_loader): optimizer.zero_grad() pred = model(data) loss = criterion(pred, data) loss.backward() optim.step() process.append(loss.item()) print(f"[*] Test RMSE {sum(process) / len(process)} ") return torch.Tensor(sum(process) / len(process)).to(device)
def train(data, model, optim, criterion, max_clip_norm=0): input = data[:, :-1].to(device) label = data[:, -1].to(device) model.train() optim.zero_grad() logits = model(input) loss = criterion(logits, label) torch.nn.utils.clip_grad_norm_(model.parameters(), max_clip_norm) loss.backward() optim.step() return loss.item()
def train(model, iters, opt, criterion, optim): train_iter = iters['train'] valid_iter = iters['valid'] examples = train_iter.dataset.examples nsamples = len(examples) dist_is = np.array([1 / nsamples for _ in range(nsamples)]) bsz = train_iter.batch_size scores = np.zeros((nsamples, )) idx_score_filled = set() for epoch in range(opt.nepoch): for i in range(len(train_iter)): model.train() idx_sampled = np.random.choice(nsamples, bsz, p=dist_is) idx_sampled = sorted(idx_sampled, key=lambda i: -len(examples[i].txt)) examples_sampled = [examples[i] for i in idx_sampled] batch = torchtext.data.Batch(examples_sampled, train_iter.dataset, train_iter.device) txt, lbl = batch.txt, batch.lbl probs = model(txt) loss_batch = criterion(probs, lbl.squeeze(0)) for idx, loss in zip(idx_sampled, loss_batch): model.zero_grad() loss = loss / len(idx_sampled) loss.backward(retain_graph=True) clip_grad_norm_(model.parameters(), 5) scores[idx] = grad_norm(model.parameters()) idx_score_filled.add(idx) optim.step() utils.progress_bar(i / len(train_iter), (loss_batch.sum() / len(idx_sampled)).item(), epoch) # update the distribution val_smooth = min([scores[i] for i in idx_score_filled]) for i in range(len(dist_is)): if i not in idx_score_filled: dist_is[i] = scores[i] else: dist_is[i] = val_smooth dist_is /= dist_is.sum() print(valid(model, valid_iter)) if (epoch + 1) % opt.save_per == 0: basename = "{}-epoch-{}".format(opt.name, epoch) model_fname = basename + ".model" torch.save(model.state_dict(), model_fname)
def train(X): X = torch.FloatTensor(X) number = [X.shape[1], 100, 50] net = autoencoder(X, number) optimizer = torch.optim.SGD(net.parameters(), lr=0.152) for _ in range(100): Y = net.forward() loss = Loss(X, Y) optimizer.zero_grad() loss.backward() optimizer.step() return Y.detach()
def test_save_and_load(self): lin = pyro.module("mymodule", self.linear_module) pyro.module("mymodule2", self.linear_module2) x = torch.randn(1, 3) myparam = pyro.param("myparam", torch.tensor(1.234 * torch.ones(1), requires_grad=True)) cost = torch.sum(torch.pow(lin(x), 2.0)) * torch.pow(myparam, 4.0) cost.backward() params = list(self.linear_module.parameters()) + [myparam] optim = torch.optim.Adam(params, lr=.01) myparam_copy_stale = copy(pyro.param("myparam").detach().cpu().numpy()) optim.step() myparam_copy = copy(pyro.param("myparam").detach().cpu().numpy()) param_store_params = copy(pyro.get_param_store()._params) param_store_param_to_name = copy(pyro.get_param_store()._param_to_name) assert len(list(param_store_params.keys())) == 5 assert len(list(param_store_param_to_name.values())) == 5 pyro.get_param_store().save('paramstore.unittest.out') pyro.clear_param_store() assert len(list(pyro.get_param_store()._params)) == 0 assert len(list(pyro.get_param_store()._param_to_name)) == 0 pyro.get_param_store().load('paramstore.unittest.out') def modules_are_equal(): weights_equal = np.sum(np.fabs(self.linear_module3.weight.detach().cpu().numpy() - self.linear_module.weight.detach().cpu().numpy())) == 0.0 bias_equal = np.sum(np.fabs(self.linear_module3.bias.detach().cpu().numpy() - self.linear_module.bias.detach().cpu().numpy())) == 0.0 return (weights_equal and bias_equal) assert not modules_are_equal() pyro.module("mymodule", self.linear_module3, update_module_params=False) assert id(self.linear_module3.weight) != id(pyro.param('mymodule$$$weight')) assert not modules_are_equal() pyro.module("mymodule", self.linear_module3, update_module_params=True) assert id(self.linear_module3.weight) == id(pyro.param('mymodule$$$weight')) assert modules_are_equal() myparam = pyro.param("myparam") store = pyro.get_param_store() assert myparam_copy_stale != myparam.detach().cpu().numpy() assert myparam_copy == myparam.detach().cpu().numpy() assert sorted(param_store_params.keys()) == sorted(store._params.keys()) assert sorted(param_store_param_to_name.values()) == sorted(store._param_to_name.values()) assert sorted(store._params.keys()) == sorted(store._param_to_name.values())