def test_minibatch(self, arguments, device=None):
'''
Test the model on the specified batch of samples using the evaluation
Function specified during construction of the Trainer.
Args:
arguments: maps variables to their
input data. The interpretation depends on the input type:
* `dict`: keys are input variable or names, and values are the input data.
See :meth:`~cntk.ops.functions.Function.forward` for details on passing input data.
* any other type: if node has a unique input, ``arguments`` is mapped to this input.
For nodes with more than one input, only `dict` is allowed.
In both cases, every sample in the data will be interpreted
as a new sequence. To mark samples as continuations of the
previous sequence, specify ``arguments`` as `tuple`: the
first element will be used as ``arguments``, and the second one will
be used as a list of bools, denoting whether a sequence is a new
one (`True`) or a continuation of the previous one (`False`).
Data should be either NumPy arrays or a
:class:`~cntk.io.MinibatchData` instance.
device (:class:`~cntk.device.DeviceDescriptor`): the device descriptor that
contains the type and id of the device on which the computation is
to be performed.
Note:
See :meth:`~cntk.ops.functions.Function.forward` for examples on
passing input data.
Returns:
`float`: the average evaluation criterion value per sample for the
tested minibatch.
'''
if not device:
device = use_default_device()
# pass all args of all parts (model, loss, eval)
all_args = set(self.loss_function.arguments)
if self.model:
all_args |= set(self.model.arguments)
if self.evaluation_function:
all_args |= set(self.evaluation_function.arguments)
arguments = sanitize_var_map(tuple(all_args), arguments)
return super(Trainer, self).test_minibatch(arguments, device)
def test_minibatch(self, arguments, device=None):
'''
Test the model on the specified batch of samples using the evaluation
Function specified during construction of the Trainer.
Args:
arguments: maps variables to their
input data. The interpretation depends on the input type:
* `dict`: keys are input variable or names, and values are the input data.
See :meth:`~cntk.ops.functions.Function.forward` for details on passing input data.
* any other type: if node has a unique input, ``arguments`` is mapped to this input.
For nodes with more than one input, only `dict` is allowed.
In both cases, every sample in the data will be interpreted
as a new sequence. To mark samples as continuations of the
previous sequence, specify ``arguments`` as `tuple`: the
first element will be used as ``arguments``, and the second one will
be used as a list of bools, denoting whether a sequence is a new
one (`True`) or a continuation of the previous one (`False`).
Data should be either NumPy arrays or a
:class:`~cntk.io.MinibatchData` instance.
device (:class:`~cntk.device.DeviceDescriptor`): the device descriptor that
contains the type and id of the device on which the computation is
to be performed.
Note:
See :meth:`~cntk.ops.functions.Function.forward` for examples on
passing input data.
Returns:
`float`: the average evaluation criterion value per sample for the
tested minibatch.
'''
if not device:
device = use_default_device()
# pass all args of all parts (model, loss, eval)
all_args = set(self.loss_function.arguments)
if self.model:
all_args |= set(self.model.arguments)
if self.evaluation_function:
all_args |= set(self.evaluation_function.arguments)
arguments = sanitize_var_map(tuple(all_args), arguments)
return super(Trainer, self).test_minibatch(arguments, device)
def train_minibatch(self, arguments, outputs=None, device=None, is_sweep_end=None):
'''
Optimize model parameters using the specified 'arguments' minibatch of training samples.
Args:
arguments: maps variables to their input data. Empty map signifies
end of local training data.
The interpretation depends on the input type:
* `dict`: keys are input variable or names, and values are the input data.
* any other type: if node has a unique input, ``arguments`` is mapped to this input.
For nodes with more than one input, only `dict` is allowed.
In both cases, every sample in the data will be interpreted
as a new sequence. To mark samples as continuations of the
previous sequence, specify ``arguments`` as `tuple`: the
first element will be used as ``arguments``, and the second one will
be used as a list of bools, denoting whether a sequence is a new
one (`True`) or a continuation of the previous one (`False`).
Data should be either NumPy arrays or a
:class:`~cntk.io.MinibatchData` instance.
outputs (iterable): outputs to fetch values for.
device (:class:`~cntk.device.DeviceDescriptor`): the device descriptor that
contains the type and id of the device on which the computation is
to be performed.
is_sweep_end (bool): indicate whether this minibatch is at the end of a sweep (of an eopoch), default to None.
This is used in combination with `arguments` being fed with numpy arrays data; when the data is from
:class:`~cntk.io.MinibatchData`, `is_sweep_end` is provided by :class:`~cntk.io.MinibatchData` so there is
no need to specify it manually.
Note:
See :meth:`~cntk.ops.functions.Function.forward` for examples on
passing input data.
Returns:
`bool` or `tuple`:
If ``outputs`` have not been provided, the returned value is `True`
if updates have been performed, `False` if all parameter learners
indicate end of learning (through their update). Otherwise, the
return value is a tuple of the that `bool` and a dictionary that
maps the variables in `outputs` to their respective NumPy arrays.
'''
if not device:
device = use_default_device()
if arguments: # arguments must feed all inputs (model, loss, eval)
all_args = set(self.loss_function.arguments)
if self.model:
all_args |= set(self.model.arguments)
if self.evaluation_function:
all_args |= set(self.evaluation_function.arguments)
arguments = sanitize_var_map(tuple(all_args), arguments,
extract_values_from_minibatch_data = False, device=device)
contains_minibatch_data = False
if (len(arguments) > 0):
value = next(iter(arguments.values()))
contains_minibatch_data = isinstance(value, MinibatchData)
if contains_minibatch_data and is_sweep_end is not None:
raise ValueError("is_sweep_end is ignored by Trainer::train_minibatch when it is fed with MinibatchData!")
if not contains_minibatch_data and is_sweep_end is None:
#for legacy code when is_sweep_end is not specified.
is_sweep_end = False
if outputs:
output_map = {v: None for v in outputs}
if contains_minibatch_data:
updated = super(Trainer, self).train_minibatch_overload_for_minibatchdata(
arguments, output_map, device)
else:
updated = super(Trainer, self).train_minibatch(arguments, is_sweep_end,
output_map, device)
for k, v in output_map.items():
output_map[k] = _value_as_sequence_or_array(v, k)
return updated, output_map
else:
if contains_minibatch_data:
updated = super(Trainer, self).train_minibatch_overload_for_minibatchdata(
arguments, device)
else:
updated = super(Trainer, self).train_minibatch(arguments, is_sweep_end,
device)
return updated
def train_minibatch(self, arguments, outputs=None, device=None):
'''
Optimize model parameters using the specified 'arguments' minibatch of training samples.
Args:
arguments: maps variables to their input data. Empty map signifies
end of local training data.
The interpretation depends on the input type:
* `dict`: keys are input variable or names, and values are the input data.
* any other type: if node has a unique input, ``arguments`` is mapped to this input.
For nodes with more than one input, only `dict` is allowed.
In both cases, every sample in the data will be interpreted
as a new sequence. To mark samples as continuations of the
previous sequence, specify ``arguments`` as `tuple`: the
first element will be used as ``arguments``, and the second one will
be used as a list of bools, denoting whether a sequence is a new
one (`True`) or a continuation of the previous one (`False`).
Data should be either NumPy arrays or a
:class:`~cntk.io.MinibatchData` instance.
outputs (iterable): outputs to fetch values for.
device (:class:`~cntk.device.DeviceDescriptor`): the device descriptor that
contains the type and id of the device on which the computation is
to be performed.
Note:
See :meth:`~cntk.ops.functions.Function.forward` for examples on
passing input data.
Returns:
`bool` or `tuple`:
If ``outputs`` have not been provided, the returned value is `True`
if updates have been performed, `False` if all parameter learners
indicate end of learning (through their update). Otherwise, the
return value is a tuple of the that `bool` and a dictionary that
maps the variables in `outputs` to their respective NumPy arrays.
'''
if not device:
device = use_default_device()
if arguments: # arguments must feed all inputs (model, loss, eval)
all_args = set(self.loss_function.arguments)
if self.model:
all_args |= set(self.model.arguments)
if self.evaluation_function:
all_args |= set(self.evaluation_function.arguments)
arguments = sanitize_var_map(
tuple(all_args),
arguments,
extract_values_from_minibatch_data=False,
device=device)
contains_minibatch_data = False
if (len(arguments) > 0):
value = next(iter(arguments.values()))
contains_minibatch_data = isinstance(value, MinibatchData)
if outputs:
output_map = {v: None for v in outputs}
if contains_minibatch_data:
updated = super(
Trainer, self).train_minibatch_overload_for_minibatchdata(
arguments, output_map, device)
else:
updated = super(Trainer,
self).train_minibatch(arguments, output_map,
device)
for k, v in output_map.items():
output_map[k] = _value_as_sequence_or_array(v, k)
return updated, output_map
else:
if contains_minibatch_data:
updated = super(
Trainer, self).train_minibatch_overload_for_minibatchdata(
arguments, device)
else:
updated = super(Trainer,
self).train_minibatch(arguments, device)
return updated
