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())
