chainer.links.NStepBiRNNTanh

class chainer.links.NStepBiRNNTanh(self, n_layers, in_size, out_size, dropout)

Stacked Bi-directional RNN for sequences.

This link is stacked version of Bi-directional RNN for sequences. Note that the activation function is tanh. It calculates hidden and cell states of all layer at end-of-string, and all hidden states of the last layer for each time.

Unlike chainer.functions.n_step_birnn(), this function automatically sort inputs in descending order by length, and transpose the sequence. Users just need to call the link with a list of chainer.Variable holding sequences.

Parameters

• n_layers (int) – Number of layers.

• in_size (int) – Dimensionality of input vectors.

• out_size (int) – Dimensionality of hidden states and output vectors.

• dropout (float) – Dropout ratio.

See also

chainer.functions.n_step_birnn()

Methods

__call__(*args: Any, **kwargs: Any) → Any

Call self as a function.

__getitem__(index)

Returns the child at given index.

Parameters

index (int) – Index of the child in the list.

Returns

The index-th child link.

Return type

Link

__setitem__(index: Union[int, slice], value: Union[chainer.link.Link, Iterable[chainer.link.Link]]) → None

__len__() → int

Returns the number of children.

__iter__() → Iterator[chainer.link.Link]

add_hook(hook: chainer.link_hook.LinkHook, name: Optional[str] = None) → chainer.link.Link

Registers a link hook.

Parameters

• hook (LinkHook) – Link hook to be registered.

• name (str) – Name of the link hook. The name must be unique among link hooks registered to this link. If None, the default name of the link hook is used.

Returns

self

add_link(link: chainer.link.Link) → None

Registers a child link and adds it to the tail of the list.

Parameters

link (Link) – The link object to be registered.

add_param(name: str, shape: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None, dtype: typing.Any = <class 'numpy.float32'>, initializer: typing.Optional[typing.Union[chainer.types.AbstractInitializer, numpy.generic, bytes, str, memoryview, numbers.Number, numpy.ndarray]] = None) → None

Registers a parameter to the link.

Parameters

• name (str) – Name of the parameter. This name is also used as the attribute name.

• shape (int or tuple of ints) – Shape of the parameter array. If it is omitted, the parameter variable is left uninitialized.

• dtype – Data type of the parameter array.

• initializer (initializer) – If it is not None, the data is initialized with the given initializer. If it is an array, the data is directly initialized by it. If it is callable, it is used as a weight initializer. Note that in these cases, dtype argument is ignored. It can also be a scalar, in which case the data array will be filled by this scalar. Note that float32 is used in this case.

add_persistent(name: str, value: Any) → None

Registers a persistent value to the link.

The registered value is saved and loaded on serialization and deserialization. The value is set to an attribute of the link.

Parameters

• name (str) – Name of the persistent value. This name is also used for the attribute name.

• value – Value to be registered.

addgrads(link: chainer.link.Link) → None

Accumulates gradient values from given link.

This method adds each gradient array of the given link to corresponding gradient array of this link. The accumulation is even done across host and different devices.

Parameters

link (Link) – Source link object.

append(value)

S.append(value) – append value to the end of the sequence

children() → Iterator[chainer.link.Link]

Returns a generator of all child links.

Returns

A generator object that generates all child links.

clear() → None -- remove all items from S

cleargrads() → None

Clears all gradient arrays.

This method should be called before the backward computation at every iteration of the optimization.

copy(mode='share')

Returns a deep copy of the chainlist.

copyparams(link: chainer.link.Link, copy_persistent: bool = True) → None

Copies all parameters from given link.

This method copies data arrays of all parameters in the hierarchy. The copy is even done across the host and devices. Note that this method does not copy the gradient arrays.

From v5.0.0: this method also copies the persistent values (e.g. the moving statistics of BatchNormalization). If the persistent value is an ndarray, the elements are copied. Otherwise, it is copied using copy.deepcopy(). The old behavior (not copying persistent values) can be reproduced with copy_persistent=False.

Parameters

• link (Link) – Source link object.

• copy_persistent (bool) – If True, persistent values are also copied. True by default.

count(value) → integer -- return number of occurrences of value

count_params() → int

Counts the total number of parameters.

This method counts the total number of scalar values included in all the Parameters held by this link and its descendants.

If the link containts uninitialized parameters, this method raises a warning.

Returns

The total size of parameters (int)

delete_hook(name: str) → None

Unregisters the link hook.

Parameters

name (str) – The name of the link hook to be unregistered.

device_resident_accept(visitor)

Applies the visitor to all the device objects in this instance.

Parameters

visitor (DeviceResidentsVisitor) – Visitor.

This method should be overridden if the concrete class has custom sub-hierarchy of device resident objects.

disable_update() → None

Disables update rules of all parameters under the link hierarchy.

This method sets the enabled flag of the update rule of each parameter variable to False.

enable_update() → None

Enables update rules of all parameters under the link hierarchy.

This method sets the enabled flag of the update rule of each parameter variable to True.

extend(values)

S.extend(iterable) – extend sequence by appending elements from the iterable

forward(self, hx, xs)

Calculates all of the hidden states and the cell states.

Parameters

• hx (Variable or None) – Initial hidden states. If None is specified zero-vector is used. Its shape is (S, B, N) for uni-directional RNN and (2S, B, N) for bi-directional RNN where S is the number of layers and is equal to n_layers, B is the mini-batch size, and N is the dimension of the hidden units.

• xs (list of Variable) – List of input sequences. Each element xs[i] is a chainer.Variable holding a sequence. Its shape is (L_i, I), where L_i is the length of a sequence for batch i, and I is the size of the input and is equal to in_size.

Returns

This function returns a tuple containing two elements, hy and ys.

• hy is an updated hidden states whose shape is same as hx.

• ys is a list of Variable . Each element ys[i] holds hidden states of the last layer corresponding to an input xs[i]. Its shape is (L_i, N) for uni-directional RNN and (L_i, 2N) for bi-directional RNN where L_i is the length of a sequence for batch i, and N is size of hidden units.

Return type

tuple

from_chx()

Converts parameter variables and persistent values from ChainerX to NumPy/CuPy devices without any copy.

classmethod from_params(*args, **kwargs)

Initialize link with given parameters.

This method initializes the link with given N-dimensional arrays. Arguments includes

• some parameters for a specific link.

• constants such as stride width of a convolutional layer.

index(value[, start[, stop]]) → integer -- return first index of value.

Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but recommended.

init_hx(xs)

init_scope() → Iterator[None]

Creates an initialization scope.

This method returns a context manager object that enables registration of parameters (and links for Chain) by an assignment. A Parameter object can be automatically registered by assigning it to an attribute under this context manager.

Example

In most cases, the parameter registration is done in the initializer method. Using the init_scope method, we can simply assign a Parameter object to register it to the link.

class MyLink(chainer.Link):
    def __init__(self):
        super().__init__()
        with self.init_scope():
            self.W = chainer.Parameter(0, (10, 5))
            self.b = chainer.Parameter(0, (5,))

insert(index: int, link: chainer.link.Link) → None

Insert a child link at the given index.

Parameters

• index (int) – The position of the list where the new

• inserted. (link is) –

• link (Link) – The link to be inserted.

links(skipself: bool = False) → Iterator[chainer.link.Link]

Returns a generator of all links under the hierarchy.

Parameters

skipself (bool) – If True, then the generator skips this link and starts with the first child link.

Returns

A generator object that generates all links.

namedlinks(skipself: bool = False) → Iterator[Tuple[str, chainer.link.Link]]

Returns a generator of all (path, link) pairs under the hierarchy.

Parameters

skipself (bool) – If True, then the generator skips this link and starts with the first child link.

Returns

A generator object that generates all (path, link) pairs.

namedparams(include_uninit: bool = True) → Iterator[Tuple[str, chainer.variable.Parameter]]

Returns a generator of all (path, param) pairs under the hierarchy.

Parameters

include_uninit (bool) – If True, it also generates uninitialized parameters.

Returns

A generator object that generates all (path, parameter) pairs. The paths are relative from this link.

params(include_uninit: bool = True) → Iterator[chainer.variable.Parameter]

Returns a generator of all parameters under the link hierarchy.

Parameters

include_uninit (bool) – If True, it also generates uninitialized parameters.

Returns

A generator object that generates all parameters.

pop([index]) → item -- remove and return item at index (default last).

Raise IndexError if list is empty or index is out of range.

register_persistent(name: str) → None

Registers an attribute of a given name as a persistent value.

This is a convenient method to register an existing attribute as a persistent value. If name has been already registered as a parameter, this method removes it from the list of parameter names and re-registers it as a persistent value.

Parameters

name (str) – Name of the attribute to be registered.

remove(value)

S.remove(value) – remove first occurrence of value. Raise ValueError if the value is not present.

repeat(n_repeat: int, mode: str = 'init') → chainer.sequential.Sequential

Repeats this link multiple times to make a Sequential.

This method returns a Sequential object which has the same Link multiple times repeatedly. The mode argument means how to copy this link to repeat.

Example

You can repeat the same link multiple times to create a longer Sequential block like this:

class ConvBNReLU(chainer.Chain):

    def __init__(self):
        super(ConvBNReLU, self).__init__()
        with self.init_scope():
            self.conv = L.Convolution2D(
                None, 64, 3, 1, 1, nobias=True)
            self.bn = L.BatchNormalization(64)

    def forward(self, x):
        return F.relu(self.bn(self.conv(x)))

net = ConvBNReLU().repeat(16, mode='init')

The net object contains 16 blocks, each of which is ConvBNReLU. And the mode was init, so each block is re-initialized with different parameters. If you give copy to this argument, each block has same values for its parameters but its object ID is different from others. If it is share, each block is same to others in terms of not only parameters but also the object IDs because they are shallow-copied, so that when the parameter of one block is changed, all the parameters in the others also change.

Parameters

• n_repeat (int) – Number of times to repeat.

• mode (str) – It should be either init, copy, or share. init means parameters of each repeated element in the returned Sequential will be re-initialized, so that all elements have different initial parameters. copy means that the parameters will not be re-initialized but object itself will be deep-copied, so that all elements have same initial parameters but can be changed independently. share means all the elements which consist the resulting Sequential object are same object because they are shallow-copied, so that all parameters of elements are shared with each other.

reverse()

S.reverse() – reverse IN PLACE

rnn(*args)

Calls RNN function.

This function must be implemented in a child class.

serialize(serializer: chainer.serializer.AbstractSerializer) → None

Serializes the link object.

Parameters

serializer (AbstractSerializer) – Serializer object.

to_chx()

Converts parameter variables and persistent values to ChainerX without any copy.

This method does not handle non-registered attributes. If some of such attributes must be copied to ChainerX, the link implementation must override this method to do so.

Returns: self

to_cpu() → chainer.device_resident.DeviceResident

Copies parameter variables and persistent values to CPU.

Deprecated since version v7.0.0: Use to_device() instead.

This method does not handle non-registered attributes. If some of such attributes must be copied to CPU, the link implementation should override device_resident_accept() to do so.

Returns: self

to_device(device: Union[backend.Device, chainerx.Device, cuda.Device, str, Tuple[str, int], ModuleType, Tuple[ModuleType, int]]) → DeviceResident

Copies parameter variables and persistent values to the specified device.

This method does not handle non-registered attributes. If some of such attributes must be copied to the device, the link implementation must override this method to do so.

Parameters

device – Target device specifier. See get_device() for available values.

Returns: self

to_gpu(device: Optional[Union[chainer.backends.cuda.Device, int, numpy.integer]] = None) → chainer.device_resident.DeviceResident

Copies parameter variables and persistent values to GPU.

Deprecated since version v7.0.0: Use to_device() instead.

This method does not handle non-registered attributes. If some of such attributes must be copied to GPU, the link implementation must override device_resident_accept() to do so.

Warning

This method does not transfer the parameters if they are already on GPU. Use to_device to perform inter-GPU transfer.

Parameters

device – Target device specifier. If omitted, the current device is used.

Returns: self

to_intel64() → chainer.device_resident.DeviceResident

Copies parameter variables and persistent values to CPU.

Deprecated since version v7.0.0: Use to_device() instead.

zerograds() → None

Initializes all gradient arrays by zero.

Deprecated since version v1.15: Use the more efficient cleargrads() instead.

__eq__(value, /)

Return self==value.

__ne__(value, /)

Return self!=value.

__lt__(value, /)

Return self<value.

__le__(value, /)

Return self<=value.

__gt__(value, /)

Return self>value.

__ge__(value, /)

Return self>=value.

Attributes

device

Device instance.

local_link_hooks

Ordered dictionary of registered link hooks.

Contrary to chainer.thread_local.link_hooks, which registers its elements to all functions, link hooks in this property are specific to this link.

n_cells

n_weights = 2

printable_specs

Generator of printable specs of this link.

Yields

specs (tuple of str and object) – Basically, it returns the arguments (pair of keyword and value) that are passed to the __init__(). This pair of key and value is used for representing this class or subclass with __str__().

update_enabled

True if at least one parameter has an update rule enabled.

use_bi_direction = True

within_init_scope

True if the current code is inside of an initialization scope.

See init_scope() for the details of the initialization scope.

xp

Array module corresponding to the device.

Depending on the device in which this object resides, this property returns numpy, cupy or chainerx.