Block¶

class mxnet.gluon.nn.Block(prefix=None, params=None)[source]¶

Base class for all neural network layers and models. Your models should subclass this class.

Block can be nested recursively in a tree structure. You can create and assign child Block as regular attributes:

from mxnet.gluon import Block, nn
from mxnet import ndarray as F

class Model(Block):
    def __init__(self, **kwargs):
        super(Model, self).__init__(**kwargs)
        # use name_scope to give child Blocks appropriate names.
        with self.name_scope():
            self.dense0 = nn.Dense(20)
            self.dense1 = nn.Dense(20)

    def forward(self, x):
        x = F.relu(self.dense0(x))
        return F.relu(self.dense1(x))

model = Model()
model.initialize(ctx=mx.cpu(0))
model(F.zeros((10, 10), ctx=mx.cpu(0)))

Child Block assigned this way will be registered and collect_params() will collect their Parameters recursively. You can also manually register child blocks with register_child().

Parameters

prefix (str) – Prefix acts like a name space. All children blocks created in parent block’s name_scope() will have parent block’s prefix in their name. Please refer to naming tutorial for more info on prefix and naming.
params (ParameterDict or None) –
ParameterDict for sharing weights with the new Block. For example, if you want dense1 to share dense0’s weights, you can do:
```
dense0 = nn.Dense(20)
dense1 = nn.Dense(20, params=dense0.collect_params())
```

Handle model parameters:

`Block.initialize`([init, ctx, verbose, …])	Initializes `Parameter` s of this `Block` and its children.
`Block.save_parameters`(filename)	Save parameters to file.
`Block.load_parameters`(filename[, ctx, …])	Load parameters from file previously saved by save_parameters.
`Block.collect_params`([select])	Returns a `ParameterDict` containing this `Block` and all of its children’s Parameters(default), also can returns the select `ParameterDict` which match some given regular expressions.
`Block.cast`(dtype)	Cast this Block to use another data type.
`Block.apply`(fn)	Applies `fn` recursively to every child block as well as self.

Run computation

Block.forward(*args)

Overrides to implement forward computation using NDArray.

Debugging

Block.summary(*inputs)

Print the summary of the model’s output and parameters.

Advanced API for customization

`Block.name_scope`()	Returns a name space object managing a child `Block` and parameter names.
`Block.register_child`(block[, name])	Registers block as a child of self.
`Block.register_forward_hook`(hook)	Registers a forward hook on the block.
`Block.register_forward_pre_hook`(hook)	Registers a forward pre-hook on the block.

Attributes

`Block.name`	Name of this `Block`, without ‘_’ in the end.
`Block.params`	Returns this `Block`’s parameter dictionary (does not include its children’s parameters).
`Block.prefix`	Prefix of this `Block`.

Warning

The following two APIs are deprecated since v1.2.1.

`Block.save_params`(filename)	[Deprecated] Please use save_parameters.
`Block.load_params`(filename[, ctx, …])	[Deprecated] Please use load_parameters.

prefix¶: Prefix of this Block.

name¶: Name of this Block, without ‘_’ in the end.

name_scope()[source]¶

Returns a name space object managing a child Block and parameter names. Should be used within a with statement:

with self.name_scope():
    self.dense = nn.Dense(20)

Please refer to naming tutorial for more info on prefix and naming.

params¶: Returns this Block’s parameter dictionary (does not include its children’s parameters).

collect_params(select=None)[source]¶

Returns a ParameterDict containing this Block and all of its children’s Parameters(default), also can returns the select ParameterDict which match some given regular expressions.

For example, collect the specified parameters in [‘conv1_weight’, ‘conv1_bias’, ‘fc_weight’, ‘fc_bias’]:

model.collect_params('conv1_weight|conv1_bias|fc_weight|fc_bias')

or collect all parameters whose names end with ‘weight’ or ‘bias’, this can be done using regular expressions:

model.collect_params('.*weight|.*bias')

Parameters: select (str) – regular expressions
Returns
Return type: The selected ParameterDict

save_parameters(filename)[source]¶

Save parameters to file.

Saved parameters can only be loaded with load_parameters. Note that this method only saves parameters, not model structure. If you want to save model structures, please use HybridBlock.export().

Parameters: filename (str) – Path to file.

References

Saving and Loading Gluon Models

save_params(filename)[source]¶

[Deprecated] Please use save_parameters. Note that if you want load from SymbolBlock later, please use export instead.

Save parameters to file.

filenamestr: Path to file.

load_parameters(filename, ctx=None, allow_missing=False, ignore_extra=False)[source]¶

Load parameters from file previously saved by save_parameters.

Parameters

filename (str) – Path to parameter file.
ctx (Context or list of Context, default cpu()) – Context(s) to initialize loaded parameters on.
allow_missing (bool, default False) – Whether to silently skip loading parameters not represents in the file.
ignore_extra (bool, default False) – Whether to silently ignore parameters from the file that are not present in this Block.

References

Saving and Loading Gluon Models

load_params(filename, ctx=None, allow_missing=False, ignore_extra=False)[source]¶

[Deprecated] Please use load_parameters.

Load parameters from file.

filenamestr: Path to parameter file.
ctxContext or list of Context, default cpu(): Context(s) to initialize loaded parameters on.
allow_missingbool, default False: Whether to silently skip loading parameters not represents in the file.
ignore_extrabool, default False: Whether to silently ignore parameters from the file that are not present in this Block.

register_child(block, name=None)[source]¶: Registers block as a child of self. Block s assigned to self as attributes will be registered automatically.

register_forward_pre_hook(hook)[source]¶

Registers a forward pre-hook on the block.

The hook function is called immediately before forward(). It should not modify the input or output.

Parameters: hook (callable) – The forward hook function of form hook(block, input) -> None.
Returns
Return type: mxnet.gluon.utils.HookHandle

register_forward_hook(hook)[source]¶

Registers a forward hook on the block.

The hook function is called immediately after forward(). It should not modify the input or output.

Parameters: hook (callable) – The forward hook function of form hook(block, input, output) -> None.
Returns
Return type: mxnet.gluon.utils.HookHandle

apply(fn)[source]¶

Applies fn recursively to every child block as well as self.

Parameters: fn (callable) – Function to be applied to each submodule, of form fn(block).
Returns
Return type: this block

initialize(init=<mxnet.initializer.Uniform object>, ctx=None, verbose=False, force_reinit=False)[source]¶

Initializes Parameter s of this Block and its children. Equivalent to block.collect_params().initialize(...)

Parameters

init (Initializer) – Global default Initializer to be used when Parameter.init() is None. Otherwise, Parameter.init() takes precedence.
ctx (Context or list of Context) – Keeps a copy of Parameters on one or many context(s).
verbose (bool, default False) – Whether to verbosely print out details on initialization.
force_reinit (bool, default False) – Whether to force re-initialization if parameter is already initialized.

hybridize(active=True, **kwargs)[source]¶

Activates or deactivates HybridBlock s recursively. Has no effect on non-hybrid children.

Parameters

active (bool, default True) – Whether to turn hybrid on or off.
static_alloc (bool, default False) – Statically allocate memory to improve speed. Memory usage may increase.
static_shape (bool, default False) – Optimize for invariant input shapes between iterations. Must also set static_alloc to True. Change of input shapes is still allowed but slower.

cast(dtype)[source]¶

Cast this Block to use another data type.

Parameters: dtype (str or numpy.dtype) – The new data type.

forward(*args)[source]¶

Overrides to implement forward computation using NDArray. Only accepts positional arguments.

Parameters: *args (list of NDArray) – Input tensors.

summary(*inputs)[source]¶

Print the summary of the model’s output and parameters.

The network must have been initialized, and must not have been hybridized.

Parameters: inputs (object) – Any input that the model supports. For any tensor in the input, only mxnet.ndarray.NDArray is supported.