def update_core(self):
if not self.contain_discriminator():
return super().update_core()
iterator = self._iterators["main"]
batch = iterator.next()
in_arrays = convert._call_converter(self.converter, batch, self.device)
optimizer = self._optimizers["main"]
model = self._models["main"]
discriminator_optimizer = self._optimizers["discriminator"]
discriminator_model = self._models["discriminator"]
for m in self._models.values():
m.train()
# discriminator
discriminator_optimizer.zero_grad()
discriminator_model(**in_arrays).backward()
discriminator_optimizer.step()
# predictor
optimizer.zero_grad()
model(**in_arrays).backward()
optimizer.step()
def update_core(self):
iterator = self._iterators["main"]
batch = iterator.next()
in_arrays = convert._call_converter(self.converter, batch, self.device)
style_transfer_optimizer = self._optimizers["style_transfer"]
mapping_network_optimizer = self._optimizers["mapping_network"]
style_encoder_optimizer = self._optimizers["style_encoder"]
discriminator_optimizer = self._optimizers["discriminator"]
generator_model = self._models["generator"]
discriminator_model = self._models["discriminator"]
for m in self._models.values():
m.train()
# discriminator
loss = discriminator_model.forward_with_latent(**in_arrays)
discriminator_optimizer.zero_grad()
loss.backward()
discriminator_optimizer.step()
loss = discriminator_model.forward_with_reference(**in_arrays)
discriminator_optimizer.zero_grad()
loss.backward()
discriminator_optimizer.step()
# predictor
loss = generator_model.forward_with_latent(**in_arrays)
style_transfer_optimizer.zero_grad()
mapping_network_optimizer.zero_grad()
style_encoder_optimizer.zero_grad()
loss.backward()
style_transfer_optimizer.step()
mapping_network_optimizer.step()
style_encoder_optimizer.step()
loss = generator_model.forward_with_reference(**in_arrays)
style_transfer_optimizer.zero_grad()
loss.backward()
style_transfer_optimizer.step()
# moving average
moving_generator_model = self._models["moving_generator"]
for param1, param2 in zip(
generator_model.parameters(), moving_generator_model.parameters()
):
param2.data = torch.lerp(param1.data, param2.data, self.moving_average_rate)
def update_core(self):
iterator = self._iterators['main']
batch = iterator.next()
in_arrays = convert._call_converter(self.converter, batch, self.device)
opt_dis = self._optimizers['dis']
opt_gen = self._optimizers['gen']
for model in self._models.values():
model.train()
x_real, y_real = in_arrays
# generative
self.discriminator.requires_grad_(False)
y_fake = self.generator(x_real)
xy_fake = torch.cat((x_real, y_fake), dim=1)
p_fake = self.discriminator(xy_fake)
loss_gen = self.generative_lossfun(p_fake) \
+ self.alpha * self.conditional_lossfun(y_fake, y_real)
opt_gen.zero_grad()
loss_gen.backward()
opt_gen.step()
# discriminative
# NOTE: deallocate intermediate variable nodes related to the generator
# with `detach` method
self.discriminator.requires_grad_(True)
y_fake_old = self._buffer(y_fake.detach())
xy_fake = torch.cat((x_real, y_fake_old), dim=1)
p_fake = self.discriminator(xy_fake)
xy_real = torch.cat((x_real, y_real), dim=1)
p_real = self.discriminator(xy_real)
loss_dis = self.discriminative_lossfun(p_real, p_fake)
opt_dis.zero_grad()
loss_dis.backward()
opt_dis.step()
def update_core(self):
iterator = self._iterators["main"]
batch = iterator.next()
in_arrays = convert._call_converter(self.converter, batch, self.device)
optimizer = self._optimizers["main"]
model = self._models["main"]
loss_func = self.loss_func or model
for model in self._models.values():
model.train()
optimizer.zero_grad()
if isinstance(in_arrays, tuple):
loss = loss_func(*in_arrays)
elif isinstance(in_arrays, dict):
loss = loss_func(**in_arrays)
else:
loss = loss_func(in_arrays)
loss.backward()
optimizer.step()
def evaluate(self):
"""Evaluates the model and returns a result dictionary.
This method runs the evaluation loop over the validation dataset. It
accumulates the reported values to :class:`~pytorch_trainer.DictSummary` and
returns a dictionary whose values are means computed by the summary.
Note that this function assumes that the main iterator raises
``StopIteration`` or code in the evaluation loop raises an exception.
So, if this assumption is not held, the function could be caught in
an infinite loop.
Users can override this method to customize the evaluation routine.
.. note::
This method encloses :attr:`eval_func` calls with
:func:`function.no_backprop_mode` context, so all calculations
using :class:`~pytorch_trainer.FunctionNode`\\s inside
:attr:`eval_func` do not make computational graphs. It is for
reducing the memory consumption.
Returns:
dict: Result dictionary. This dictionary is further reported via
:func:`~pytorch_trainer.report` without specifying any observer.
"""
iterator = self._iterators['main']
eval_func = self.eval_func or self._targets['main']
for target in self._targets.values():
target.eval()
if self.eval_hook:
self.eval_hook(self)
if hasattr(iterator, 'reset'):
iterator.reset()
it = iterator
else:
warnings.warn(
'This iterator does not have the reset method. Evaluator '
'copies the iterator instead of resetting. This behavior is '
'deprecated. Please implement the reset method.',
DeprecationWarning)
it = copy.copy(iterator)
summary = reporter_module.DictSummary()
if self._progress_bar:
pbar = _IteratorProgressBar(iterator=it)
for batch in it:
observation = {}
with reporter_module.report_scope(observation):
in_arrays = convert._call_converter(self.converter, batch,
self.device)
if isinstance(in_arrays, tuple):
eval_func(*in_arrays)
elif isinstance(in_arrays, dict):
eval_func(**in_arrays)
else:
eval_func(in_arrays)
summary.add(observation)
if self._progress_bar:
pbar.update()
if self._progress_bar:
pbar.close()
return summary.compute_mean()
