def forward(self, arguments, outputs, keep_for_backward=None, device=None):
'''
Computes the values of speficied variables in ``outputs``, using values
provided in ``arguments`` that correspond to each input `Variable` of
the function whose ``is_input`` is `True`.
Example:
>>> v = C.input_variable(shape=(3,))
>>> f = C.reciprocal(v)
>>> _, fv = f.forward({v:[[1, 2, 4]]}, [f.output])
>>> list(fv.values())[0]
array([[[ 1. , 0.5 , 0.25]]], dtype=float32)
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.
* any other type: if node has an unique input, ``arguments`` is mapped to this input.
For nodes with more than one input, only dict is allowed.
In both cases, every 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.
keep_for_backward (set, default `None`): the subset of the
Function's output variables for which gradients shall be calculated
in a subsequent backward call. If `None`, the returned state will
be `None` and a subsequent call to :func:`backward` will not be
possible.
device (:class:`~cntk.device.DeviceDescriptor`, default `None`): the device
descriptor that contains the type and id of the device on which the
computation is. If `None`, the default device is used.
Returns:
A tuple (BackpropState, map of outputs to NumPy arrays). The
BackpropState is a handle taken by :func:`backward`.
'''
if device is None:
from cntk import DeviceDescriptor
device = DeviceDescriptor.use_default_device()
in_var_map = sanitize_var_map(self.arguments, arguments,
None, device)
output_map = {v: None for v in outputs}
keep_for_backward = set(keep_for_backward or {})
state = super(Function, self)._forward(in_var_map, output_map, device,
keep_for_backward)
for k in output_map:
output_map[k] = value_to_seq(output_map[k])
return state, output_map
def forward(self, arguments, outputs, keep_for_backward=None, device=None):
'''
Computes the values of speficied variables in ``outputs``, using values
provided in ``arguments`` that correspond to each input `Variable` of
the function whose ``is_input`` is `True`.
Example:
>>> v = C.input_variable(shape=(3,))
>>> f = C.reciprocal(v)
>>> _, fv = f.forward({v:[[1, 2, 4]]}, [f.output])
>>> list(fv.values())[0]
array([[[ 1. , 0.5 , 0.25]]], dtype=float32)
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.
* any other type: if node has an unique input, ``arguments`` is mapped to this input.
For nodes with more than one input, only dict is allowed.
In both cases, every 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.
keep_for_backward (set, default `None`): the subset of the
Function's output variables for which gradients shall be calculated
in a subsequent backward call. If `None`, the returned state will
be `None` and a subsequent call to :func:`backward` will not be
possible.
device (:class:`~cntk.device.DeviceDescriptor`, default `None`): the device
descriptor that contains the type and id of the device on which the
computation is. If `None`, the default device is used.
Returns:
A tuple (BackpropState, map of outputs to NumPy arrays). The
BackpropState is a handle taken by :func:`backward`.
'''
if device is None:
from cntk import DeviceDescriptor
device = DeviceDescriptor.use_default_device()
in_var_map = sanitize_var_map(self.arguments, arguments,
None, device)
output_map = {v: None for v in outputs}
keep_for_backward = set(keep_for_backward or {})
state = super(Function, self)._forward(in_var_map, output_map, device,
keep_for_backward)
for k in output_map:
output_map[k] = value_to_seq(output_map[k])
return state, output_map
def forward(self, arguments, outputs, keep_for_backward=None, device=None):
'''
Computes and stores the values of speficied variables in `outputs`,
using provided `arguments` values corresponding to each leaf `Variable`
of the function whose is_input() is true.
Args:
arguments (`dict` or `list` or `tuple`): 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.
* `list`: elements are input data in the order their respective variables have been defined in the network.
In both cases, every 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.
keep_for_backward (`set`, default `None): the subset of the
Function's output variables for which gradients shall be calculated
in a subsequent backward call. If `None`, the returned state will
be `None` and a subsequent call to `backward` will not be
possible.
for backpropagation.
device (:class:`cntk.DeviceDescriptor`, default `None): the device
descriptor that contains the type and id of the device on which the
computation is. If `None`, the default device is used.
Returns:
A tuple (`BackpropState`, `map` of outputs to NumPy arrays). The
BackpropState is a handle taken by :func:`backward`.
'''
if device is None:
from cntk import DeviceDescriptor
device = DeviceDescriptor.use_default_device()
in_var_map = sanitize_var_map(self.arguments(), arguments, None,
device)
output_map = {v: None for v in outputs}
keep_for_backward = set(keep_for_backward or {})
state = super(Function, self)._forward(in_var_map, output_map, device,
keep_for_backward)
for k in output_map:
output_map[k] = value_to_seq(output_map[k])
return state, output_map
def forward(self, arguments, outputs, keep_for_backward=None, device=None):
'''
Computes and stores the values of speficied variables in `outputs`,
using provided `arguments` values corresponding to each leaf `Variable`
of the function whose is_input() is true.
Args:
arguments (`dict` or `list` or `tuple`): 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.
* `list`: elements are input data in the order their respective variables have been defined in the network.
In both cases, every 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.
keep_for_backward (`set`, default `None): the subset of the
Function's output variables for which gradients shall be calculated
in a subsequent backward call. If `None`, the returned state will
be `None` and a subsequent call to `backward` will not be
possible.
for backpropagation.
device (:class:`cntk.DeviceDescriptor`, default `None): the device
descriptor that contains the type and id of the device on which the
computation is. If `None`, the default device is used.
Returns:
A tuple (`BackpropState`, `map` of outputs to NumPy arrays). The
BackpropState is a handle taken by :func:`backward`.
'''
if device is None:
from cntk import DeviceDescriptor
device = DeviceDescriptor.use_default_device()
in_var_map = sanitize_var_map(self.arguments(), arguments,
None, device)
output_map = {v: None for v in outputs}
keep_for_backward = set(keep_for_backward or {})
state = super(Function, self)._forward(in_var_map, output_map, device,
keep_for_backward)
for k in output_map:
output_map[k] = value_to_seq(output_map[k])
return state, output_map
