text stringlengths 1 93.6k |
|---|
self.model.train()
|
loss = None
|
oom = 0
|
batch_score = 0
|
if sample is not None:
|
try:
|
with torch.no_grad() if eval else contextlib.ExitStack():
|
answers = sample[2]
|
img_data = sample[0][1]
|
# MEVF loss computation
|
if self.args.autoencoder:
|
features, decoder = self.model(sample[0], sample[1])
|
else:
|
features = self.model(sample[0], sample[1])
|
preds = self.model.classifier(features)
|
loss = self.criterion(preds.float(), answers)
|
if self.args.autoencoder:
|
loss_ae = self.ae_criterion(img_data, decoder)
|
loss = loss + (loss_ae*self.args.ae_alpha)
|
loss /= answers.size()[0]
|
final_preds = preds
|
batch_score = compute_score_with_logits(final_preds, sample[2].data).sum()
|
except RuntimeError as e:
|
if not eval and 'out of memory' in str(e):
|
print('| WARNING: ran out of memory, skipping batch')
|
oom = 1
|
loss = None
|
else:
|
raise e
|
return loss, len(sample[0]), oom, batch_score # TODO: Not sure about sample size, need to recheck
|
def _backward(self, loss):
|
oom = 0
|
if loss is not None:
|
try:
|
# backward pass
|
loss.backward()
|
except RuntimeError as e:
|
if 'out of memory' in str(e):
|
print('| WARNING: ran out of memory, skipping batch')
|
oom = 1
|
self.zero_grad()
|
else:
|
raise e
|
return oom
|
def _all_reduce_and_rescale(self, grad_denom):
|
# flatten grads into a single buffer and all-reduce
|
flat_grads = self._flat_grads = self._get_flat_grads(self._flat_grads)
|
# rescale and clip gradients
|
flat_grads.div_(grad_denom)
|
grad_norm = utils.clip_grad_norm_(flat_grads, self.args.clip_norm)
|
# copy grads back into model parameters
|
self._set_flat_grads(flat_grads)
|
return grad_norm
|
def _get_grads(self):
|
grads = []
|
for name, p in self.model.named_parameters():
|
if not p.requires_grad:
|
continue
|
if p.grad is None:
|
raise RuntimeError('Model parameter did not receive gradient: ' + name + '. '
|
'Use the param in the forward pass or set requires_grad=False')
|
grads.append(p.grad.data)
|
return grads
|
def _get_flat_grads(self, out=None):
|
grads = self._get_grads()
|
if out is None:
|
grads_size = sum(g.numel() for g in grads)
|
out = grads[0].new(grads_size).zero_()
|
offset = 0
|
for g in grads:
|
numel = g.numel()
|
out[offset:offset+numel].copy_(g.view(-1))
|
offset += numel
|
return out[:offset]
|
def _set_flat_grads(self, new_grads):
|
grads = self._get_grads()
|
offset = 0
|
for g in grads:
|
numel = g.numel()
|
g.copy_(new_grads[offset:offset+numel].view_as(g))
|
offset += numel
|
def _opt(self):
|
# take an optimization step
|
self.optimizer.step()
|
self.zero_grad()
|
self._num_updates += 1
|
# update learning rate
|
# self.lr_scheduler.step_update(self._num_updates)
|
def zero_grad(self):
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.