def get_loss(self, y_pred, y_true, X=None, train=False):
"""Return the loss for this batch.
Parameters
----------
y_pred : torch tensor
Predicted target values
y_true : torch tensor
True target values.
X : input data, compatible with skorch.dataset.Dataset
By default, you should be able to pass:
* numpy arrays
* torch tensors
* pandas DataFrame or Series
* a dictionary of the former three
* a list/tuple of the former three
If this doesn't work with your data, you have to pass a
``Dataset`` that can deal with the data.
train : bool (default=False)
Whether train mode should be used or not.
"""
y_true = to_var(y_true, use_cuda=self.use_cuda)
return self.criterion_(y_pred, y_true)
def get_loss(self, y_pred, y_true, X=None, train=False):
y_true = to_var(y_true, use_cuda=self.use_cuda)
y_pred_log = torch.log(y_pred)
return self.criterion_(
y_pred_log,
self._prepare_target_for_loss(y_true),
)
def get_loss(self, y_pred, y_true, X=None, training=False):
y_true = to_var(y_true, use_cuda=False)
loss_a = torch.abs(y_true.float() - y_pred[:, 1]).mean()
loss_b = ((y_true.float() - y_pred[:, 1])**2).mean()
if training:
self.history.record_batch('loss_a', to_numpy(loss_a)[0])
self.history.record_batch('loss_b', to_numpy(loss_b)[0])
return loss_a + loss_b
def infer(self, x, **fit_params):
"""Perform a single inference step on a batch of data.
Parameters
----------
x : input data
A batch of the input data.
**fit_params : dict
Additional parameters passed to the ``forward`` method of
the module and to the train_split call.
"""
x = to_var(x, use_cuda=self.use_cuda)
if isinstance(x, dict):
x_dict = self._merge_x_and_fit_params(x, fit_params)
return self.module_(**x_dict)
return self.module_(x, **fit_params)
def _scoring(self, net, X, y):
"""Resolve scoring and apply it to data."""
y = self.target_extractor(y)
if self.scoring is None:
score = net.score(X, y)
elif isinstance(self.scoring, str):
# scoring is a string
try:
scorer = getattr(metrics, self.scoring)
except AttributeError:
raise NameError("A metric called '{}' does not exist, "
"use a valid sklearn metric name."
"".format(self.scoring))
y_pred = self.pred_extractor(
net.infer(to_var(X, use_cuda=net.use_cuda)))
score = scorer(y, y_pred)
else:
# scoring is a function
score = self.scoring(net, X, y)
return score
def layer_data_viz(self, expe_params, viz_params):
expe_name = expe_params.get('expe_name', 'nan')
viz_tag = '{}_{}_'.format(viz_params.get('name', 'nan'),
viz_params.get('layer_name', 'nan'),
str(uuid.uuid4())[:3])
input_output = viz_params.get('input_output', None)
label = viz_params['data'].get('y', None)
if (input_output is None) or (label is None):
# do nothing if no data
return
layer_output = to_var(input_output['layer_output'], use_cuda=False)
label_list = to_numpy(label).tolist()
if self.tensorboard:
tensorboard_dir = os.path.join(expe_params.get('expe_dir', '.'),
self.tensorboard_dir_name)
tensorboard_expe_dir = os.path.join(tensorboard_dir, expe_name)
writer = self.get_tensorboard_writer_by_logdir(
tensorboard_expe_dir)
writer.add_embedding(layer_output.data,
metadata=label_list,
global_step=viz_params['epoch'],
tag=viz_tag)
def infer(self, x):
x = to_var(x, use_cuda=self.use_cuda)
if isinstance(x, dict):
return self.module_(**x)
return self.module_(x)
