def predict_on_batch(self, *x):
"""
Returns the predictions of the network given a batch ``x``, where the
tensors are converted into Numpy arrays.
Args:
x: Batch for which to predict. Should contain ``(x_1, ..., x_n)``
where the ``x_i``'s are are ``n`` inputs. Should NOT contain the
ground truths ``y`` as the last element contrary to the other
methods.
Returns:
The predictions with tensors converted into Numpy arrays.
"""
self.model.eval()
with torch.no_grad():
x = self._process_input(x)
return torch_to_numpy(self.model(*x))
def _compute_loss_and_metrics(self,
x,
y,
return_loss_tensor=False,
return_pred=False):
x, y = self._process_input(x, y)
x = x if isinstance(x, (list, tuple)) else (x, )
pred_y = self.model(*x)
loss = self.loss_function(pred_y, y)
if not return_loss_tensor:
loss = float(loss)
with torch.no_grad():
metrics = self._compute_metrics(pred_y, y)
for epoch_metric in self.epoch_metrics:
epoch_metric(pred_y, y)
pred_y = torch_to_numpy(pred_y) if return_pred else None
return loss, metrics, pred_y
def _validate(self, step_iterator, return_pred=False, return_ground_truth=False):
pred_list = None
true_list = None
if return_pred:
pred_list = []
if return_ground_truth:
true_list = []
with self._set_training_mode(False):
for step, (x, y) in step_iterator:
step.loss, step.metrics, pred_y = self._compute_loss_and_metrics(x, y, return_pred=return_pred)
if return_pred:
pred_list.append(pred_y)
if return_ground_truth:
true_list.append(torch_to_numpy(y))
step.size = self._get_batch_size(x, y)
return step_iterator.loss, step_iterator.metrics, pred_list, true_list
def _test_checkpointer(self, checkpointer, lr_scheduler):
scheduler_states = {}
generator = some_data_generator(OptimizerCheckpointTest.batch_size)
checkpointer.set_params({'epochs': OptimizerCheckpointTest.epochs, 'steps': 1})
checkpointer.set_model(self.model)
checkpointer.on_train_begin({})
for epoch in range(1, OptimizerCheckpointTest.epochs + 1):
checkpointer.on_epoch_begin(epoch, {})
checkpointer.on_batch_begin(1, {})
loss = self._update_model(generator)
checkpointer.on_batch_end(1, {'batch': 1, 'size': OptimizerCheckpointTest.batch_size, 'loss': loss})
checkpointer.on_epoch_end(epoch, {'epoch': epoch, 'loss': loss, 'val_loss': 1})
filename = self.checkpoint_filename.format(epoch=epoch)
self.assertTrue(os.path.isfile(filename))
scheduler_states[epoch] = torch_to_numpy(lr_scheduler.scheduler.state_dict(), copy=True)
checkpointer.on_train_end({})
self._test_checkpoint(scheduler_states, lr_scheduler)
def predict(self, x):
r"""
Returns the predictions of the network given an input ``x``, where the output tensors
are converted into Numpy arrays.
Arguments
---------
x : Union[torch.Tensor, np.ndarray]
Input Dataset (should not contains output) for which the model should predict readout.
Returns
-------
Numpy arrays of the predictions.
"""
pred_y = []
self.model.eval()
with torch.no_grad():
x = self._process_input(x)
pred_y.append(torch_to_numpy(self.model(x)))
return np.concatenate(pred_y)
def _compute_loss_and_metrics(self,
x,
y,
*,
return_loss_tensor=False,
return_pred=False):
(adj, x, mask), *y = self._process_input(x, *y)
mols, y, *w = y
if len(w):
w = w[0]
else:
w = None
pred_y, side_loss = self.model(x, adj, mask)
loss = self.loss_function(pred_y, y, weights=w) + side_loss
if not return_loss_tensor:
loss = float(loss)
with torch.no_grad():
metrics = self._compute_metrics(pred_y, y)
pred_y = torch_to_numpy(pred_y) if return_pred else None
return loss, metrics, pred_y
def predict_generator(self, generator, *, steps=None):
"""
Returns the predictions of the network given batches of samples ``x``, where the tensors are
converted into Numpy arrays.
generator: Generator-like object for the dataset. The generator must yield a batch of
samples. See the :func:`fit_generator()` method for details on the types of generators
supported. This should only yield input data ``x`` and not the target ``y``.
steps (int, optional): Number of iterations done on ``generator``.
(Defaults the number of steps needed to see the entire dataset)
Returns:
List of the predictions of each batch with tensors converted into Numpy arrays.
"""
if steps is None and hasattr(generator, '__len__'):
steps = len(generator)
pred_y = []
with self._set_training_mode(False):
for _, x in _get_step_iterator(steps, generator):
x = self._process_input(x)
x = x if isinstance(x, (tuple, list)) else (x, )
pred_y.append(torch_to_numpy(self.model(*x)))
return pred_y