def hybrid_forward(self, F, inputs, states=None, mask=None):
        # pylint: disable=arguments-differ
        # pylint: disable=unused-argument
        """Defines the forward computation for cache cell. Arguments can be either
        :py:class:`NDArray` or :py:class:`Symbol`.

        Parameters
        ----------
        inputs : NDArray
            The input data layout='TNC'.
        states : Tuple[List[List[NDArray]]]
            The states. including:
            states[0] indicates the states used in forward layer,
            Each layer has a list of two initial tensors with
            shape (batch_size, proj_size) and (batch_size, hidden_size).
            states[1] indicates the states used in backward layer,
            Each layer has a list of two initial tensors with
            shape (batch_size, proj_size) and (batch_size, hidden_size).

        Returns
        --------
        out: NDArray
            The output data with shape (num_layers, seq_len, batch_size, 2*input_size).
        [states_forward, states_backward] : List
            Including:
            states_forward: The out states from forward layer,
            which has the same structure with *states[0]*.
            states_backward: The out states from backward layer,
            which has the same structure with *states[1]*.
        """
        states_forward, states_backward = states
        if mask is not None:
            sequence_length = mask.sum(axis=1)

        outputs_forward = []
        outputs_backward = []

        for layer_index in range(self._num_layers):
            if layer_index == 0:
                layer_inputs = inputs
            else:
                layer_inputs = outputs_forward[layer_index-1]
            output, states_forward[layer_index] = F.contrib.foreach(
                self.forward_layers[layer_index],
                layer_inputs,
                states_forward[layer_index])
            outputs_forward.append(output)

            if layer_index == 0:
                layer_inputs = inputs
            else:
                layer_inputs = outputs_backward[layer_index-1]

            if mask is not None:
                layer_inputs = F.SequenceReverse(layer_inputs,
                                                 sequence_length=sequence_length,
                                                 use_sequence_length=True, axis=0)
            else:
                layer_inputs = F.SequenceReverse(layer_inputs, axis=0)
            output, states_backward[layer_index] = F.contrib.foreach(
                self.backward_layers[layer_index],
                layer_inputs,
                states_backward[layer_index])
            if mask is not None:
                backward_out = F.SequenceReverse(output,
                                                 sequence_length=sequence_length,
                                                 use_sequence_length=True, axis=0)
            else:
                backward_out = F.SequenceReverse(output, axis=0)
            outputs_backward.append(backward_out)
        out = F.concat(*[F.stack(*outputs_forward, axis=0),
                         F.stack(*outputs_backward, axis=0)], dim=-1)

        return out, [states_forward, states_backward]
def hybrid_forward ( self , F , inputs , states = None , mask = None ) : states_forward , states_backward = states if mask is not None : sequence_length = mask . sum ( axis = 1 ) outputs_forward = [ ] outputs_backward = [ ] for layer_index in range ( self . _num_layers ) : if layer_index == 0 : layer_inputs = inputs else : layer_inputs = outputs_forward [ layer_index - 1 ] output , states_forward [ layer_index ] = F . contrib . foreach ( self . forward_layers [ layer_index ] , layer_inputs , states_forward [ layer_index ] ) outputs_forward . append ( output ) if layer_index == 0 : layer_inputs = inputs else : layer_inputs = outputs_backward [ layer_index - 1 ] if mask is not None : layer_inputs = F . SequenceReverse ( layer_inputs , sequence_length = sequence_length , use_sequence_length = True , axis = 0 ) else : layer_inputs = F . SequenceReverse ( layer_inputs , axis = 0 ) output , states_backward [ layer_index ] = F . contrib . foreach ( self . backward_layers [ layer_index ] , layer_inputs , states_backward [ layer_index ] ) if mask is not None : backward_out = F . SequenceReverse ( output , sequence_length = sequence_length , use_sequence_length = True , axis = 0 ) else : backward_out = F . SequenceReverse ( output , axis = 0 ) outputs_backward . append ( backward_out ) out = F . concat ( * [ F . stack ( * outputs_forward , axis = 0 ) , F . stack ( * outputs_backward , axis = 0 ) ] , dim = - 1 ) return out , [ states_forward , states_backward ]
Defines the forward computation for cache cell. Arguments can be either
        :py:class:`NDArray` or :py:class:`Symbol`.

        Parameters
        ----------
        inputs : NDArray
            The input data layout='TNC'.
        states : Tuple[List[List[NDArray]]]
            The states. including:
            states[0] indicates the states used in forward layer,
            Each layer has a list of two initial tensors with
            shape (batch_size, proj_size) and (batch_size, hidden_size).
            states[1] indicates the states used in backward layer,
            Each layer has a list of two initial tensors with
            shape (batch_size, proj_size) and (batch_size, hidden_size).

        Returns
        --------
        out: NDArray
            The output data with shape (num_layers, seq_len, batch_size, 2*input_size).
        [states_forward, states_backward] : List
            Including:
            states_forward: The out states from forward layer,
            which has the same structure with *states[0]*.
            states_backward: The out states from backward layer,
            which has the same structure with *states[1]*.