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