# Conv3DTranspose¶

class paddle.fluid.dygraph.nn. Conv3DTranspose ( num_channels, num_filters, filter_size, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, dtype='float32' ) [source]

Convlution3D transpose layer

The convolution3D transpose layer calculates the output based on the input, filter, and dilations, strides, paddings. Input(Input) and output(Output) are in NCDHW format. Where N is batch size, C is the number of channels, D is the depth of the feature, H is the height of the feature, and W is the width of the feature. Parameters(dilations, strides, paddings) are two elements. These two elements represent height and width, respectively. The details of convolution transpose layer, please refer to the following explanation and references therein. If bias attribution and activation type are provided, bias is added to the output of the convolution, and the corresponding activation function is applied to the final result.

For each input $$X$$, the equation is:

$\begin{split}Out = \sigma (W \\ast X + b)\end{split}$

In the above equation:

• $$X$$: Input value, a tensor with NCDHW format.

• $$W$$: Filter value, a tensor with MCDHW format.

• $$\\ast$$: Convolution operation.

• $$b$$: Bias value, a 2-D tensor with shape [M, 1].

• $$\\sigma$$: Activation function.

• $$Out$$: Output value, the shape of $$Out$$ and $$X$$ may be different.

Example

• Input:

Input shape: $$(N, C_{in}, D_{in}, H_{in}, W_{in})$$

Filter shape: $$(C_{in}, C_{out}, D_f, H_f, W_f)$$

• Output:

Output shape: $$(N, C_{out}, D_{out}, H_{out}, W_{out})$$

Where

$\begin{split}D^\prime_{out} &= (D_{in} - 1) * strides[0] - 2 * paddings[0] + dilations[0] * (D_f - 1) + 1 \\\\ H^\prime_{out} &= (H_{in} - 1) * strides[1] - 2 * paddings[1] + dilations[1] * (H_f - 1) + 1 \\\\ W^\prime_{out} &= (W_{in} - 1) * strides[2] - 2 * paddings[2] + dilations[2] * (W_f - 1) + 1 \\\\ D_{out} &\in [ D^\prime_{out}, D^\prime_{out} + strides[0] ] \\\\ H_{out} &\in [ H^\prime_{out}, H^\prime_{out} + strides[1] ] \\\\\end{split}$

Note:

The conv3d_transpose can be seen as the backward of the conv3d. For conv3d, when stride > 1, conv3d maps multiple input shape to the same output shape, so for conv3d_transpose, when stride > 1, input shape maps multiple output shape. If output_size is None, $$H_{out} = H^\prime_{out}, :math:$$; else, the $$D_{out}$$ of the output size must between $$D^\prime_{out}$$ and $$D^\prime_{out} + strides[0]$$, the $$H_{out}$$ of the output size must between $$H^\prime_{out}$$ and $$H^\prime_{out} + strides[1]$$, and the $$W_{out}$$ of the output size must between $$W^\prime_{out}$$ and $$W^\prime_{out} + strides[2]$$, conv3d_transpose can compute the kernel size automatically.

Parameters
• num_channels (int) – The number of channels in the input image.

• num_filters (int) – The number of the filter. It is as same as the output image channel.

• filter_size (int|tuple) – The filter size. If filter_size is a tuple, it must contain three integers, (filter_size_D, filter_size_H, filter_size_W). Otherwise, the filter will be a square.

adds dilation * (kernel - 1) amount of zero-padding on both sides of input. If padding is a string, either ‘VALID’ or ‘SAME’ supported, which is the padding algorithm. If padding is a tuple or list, it could be in three forms: [pad_depth, pad_height, pad_width] or

Definition list ends without a blank line; unexpected unindent.

• stride (int|tuple, optional) – The stride size. It means the stride in transposed convolution. If stride is a tuple, it must contain three integers, (stride_depth, stride_height, stride_width). Otherwise, stride_depth = stride_height = stride_width = stride. The default value is 1.

• dilation (int|tuple, optional) – The dilation size. If dilation is a tuple, it must contain three integers, (dilation_D, dilation_H, dilation_W). Otherwise, the dilation_D = dilation_H = dilation_W = dilation. The default value is 1.

• groups (int, optional) – The groups number of the Conv3D transpose layer. Inspired by grouped convolution in Alex Krizhevsky’s Deep CNN paper, in which when group=2, the first half of the filters is only connected to the first half of the input channels, while the second half of the filters is only connected to the second half of the input channels. The default value is 1.

• param_attr (ParamAttr, optional) – The parameter attribute for learnable parameters/weights of conv3d_transpose. If it is set to None or one attribute of ParamAttr, conv3d_transpose will create ParamAttr as param_attr. If the Initializer of the param_attr is not set, the parameter is initialized with Xavier. The default value is None.

• bias_attr (ParamAttr|bool, optional) – The parameter attribute for the bias of conv3d_transpose. If it is set to False, no bias will be added to the output units. If it is set to None or one attribute of ParamAttr, conv3d_transpose will create ParamAttr as bias_attr. If the Initializer of the bias_attr is not set, the bias is initialized zero. The default value is None.

• use_cudnn (bool, optional) – Use cudnn kernel or not, it is valid only when the cudnn library is installed. The default value is True.

• act (str, optional) – Activation type, if it is set to None, activation is not appended. The default value is None.

• name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.

Attribute:

weight (Parameter): the learnable weights of filters of this layer.

bias (Parameter): the learnable bias of this layer.

Returns

None.

Raises

ValueError – If the shapes of input, filter_size, stride, padding and groups mismatch.

Examples

import paddle.fluid as fluid
import numpy

with fluid.dygraph.guard():
data = numpy.random.random((5, 3, 12, 32, 32)).astype('float32')
conv3dTranspose = fluid.dygraph.nn.Conv3DTranspose(
num_channels=3,
num_filters=12,
filter_size=12,
use_cudnn=False)
ret = conv3dTranspose(fluid.dygraph.base.to_variable(data))

forward ( input )

Defines the computation performed at every call. Should be overridden by all subclasses.

Parameters
• *inputs (tuple) – unpacked tuple arguments

• **kwargs (dict) – unpacked dict arguments

Added parameter can be accessed by self.name

Parameters
• name (str) – name of this sublayer.

• parameter (Parameter) – an instance of Parameter.

Returns

the parameter passed in.

Return type

Parameter

Examples

import paddle

def __init__(self):
super(MyLayer, self).__init__()
w_tmp = self.create_parameter([1,1])

def forward(self, input):
return self._linear(input)

mylayer = MyLayer()
for name, param in mylayer.named_parameters():
print(name, param)      # will print w_tmp,_linear.weight,_linear.bias


Added sublayer can be accessed by self.name

Parameters
• name (str) – name of this sublayer.

• sublayer (Layer) – an instance of Layer.

Returns

the sublayer passed in.

Return type

Layer

Examples

import paddle

def __init__(self, *layers):
super(MySequential, self).__init__()
if len(layers) > 0 and isinstance(layers[0], tuple):
for name, layer in layers:
else:
for idx, layer in enumerate(layers):

def forward(self, input):
for layer in self._sub_layers.values():
input = layer(input)
return input

model = MySequential(fc1, fc2)
for prefix, layer in model.named_sublayers():
print(prefix, layer)

apply ( fn )

Applies fn recursively to every sublayer (as returned by .sublayers()) as well as self. Typical use includes initializing the parameters of a model.

Parameters

fn (function) – a function to be applied to each sublayer

Returns

self

Return type

Layer

Example::
import paddle

net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))

def init_weights(layer):
if type(layer) == nn.Linear:
print('before init weight:', layer.weight.numpy())
layer.weight.set_value(new_weight)
print('after init weight:', layer.weight.numpy())

net.apply(init_weights)

print(net.state_dict())

buffers ( include_sublayers=True )

Returns a list of all buffers from current layer and its sub-layers.

Parameters

include_sublayers (bool, optional) – Whether include the buffers of sublayers. If True, also include the buffers from sublayers. Default: True

Returns

a list of buffers.

Return type

list of Tensor

Examples

import numpy as np

value = np.array([0]).astype("float32")
linear.register_buffer("buf_name", buffer, persistable=True)

print(linear.buffers())     # == print([linear.buf_name])

children ( )

Returns an iterator over immediate children layers.

Yields

Layer – a child layer

Examples

import paddle

layer_list = list(model.children())



Clear the gradients of all parameters for this layer.

Returns

None

Examples

import paddle
import numpy as np

value = np.arange(26).reshape(2, 13).astype("float32")
parameters=linear.parameters())
out = linear(a)
out.backward()

create_parameter ( shape, attr=None, dtype=None, is_bias=False, default_initializer=None )

Create parameters for this layer.

Parameters
• shape (list) – Shape of the parameter.

• attr (ParamAttr, optional) – Parameter attribute of weight. Please refer to ParamAttr. Default: None.

• dtype (str, optional) – Data type of this parameter. If set str, it can be “bool”, “float16”, “float32”, “float64”, “int8”, “int16”, “int32”, “int64”, “uint8” or “uint16”. Default: “float32”.

• is_bias (bool, optional) – if this is a bias parameter. Default: False.

• default_initializer (Initializer, optional) – the default initializer for this parameter. If set None, default initializer will be set to paddle.nn.initializer.Xavier and paddle.nn.initializer.Constant for non-bias and bias parameter, respectively. Default: None.

Returns

Tensor, created parameter.

Examples

import paddle

def __init__(self):
super(MyLayer, self).__init__()
w_tmp = self.create_parameter([1,1])

def forward(self, input):
return self._linear(input)

mylayer = MyLayer()
for name, param in mylayer.named_parameters():
print(name, param)      # will print w_tmp,_linear.weight,_linear.bias

create_tensor ( name=None, persistable=None, dtype=None )

Create Tensor for this layer.

Parameters
• name (str, optional) – name of the tensor. Please refer to Name . Default: None

• persistable (bool, optional) – if set this tensor persistable. Default: False

• dtype (str, optional) – data type of this parameter. If set str, it can be “bool”, “float16”, “float32”, “float64”, “int8”, “int16”, “int32”, “int64”, “uint8” or “uint16”. If set None, it will be “float32”. Default: None

Returns

Tensor, created Tensor.

Examples

import paddle

def __init__(self,
in_features,
out_features):
super(MyLinear, self).__init__()

self.back_var = self.create_tensor(name = "linear_tmp_0", dtype=self._dtype)

def forward(self, input):
out = self.linear(input)

return out

create_variable ( name=None, persistable=None, dtype=None )

Create Tensor for this layer.

Parameters
• name (str, optional) – name of the tensor. Please refer to Name . Default: None

• persistable (bool, optional) – if set this tensor persistable. Default: False

• dtype (str, optional) – data type of this parameter. If set str, it can be “bool”, “float16”, “float32”, “float64”,”int8”, “int16”, “int32”, “int64”, “uint8” or “uint16”. If set None, it will be “float32”. Default: None

Returns

Tensor, created Tensor.

Examples

import paddle

def __init__(self,
in_features,
out_features):
super(MyLinear, self).__init__()

self.back_var = self.create_variable(name = "linear_tmp_0", dtype=self._dtype)

def forward(self, input):
out = self.linear(input)

return out

eval ( )

Sets this Layer and all its sublayers to evaluation mode. This only effects certain modules like Dropout and BatchNorm.

Returns

None

Example::
import paddle

def __init__(self):
super(MyLayer, self).__init__()

def forward(self, input):
temp = self._linear(input)
temp = self._dropout(temp)
return temp

mylayer = MyLayer()
mylayer.eval()  # set mylayer._dropout to eval mode
out = mylayer(x)
print(out)

extra_repr ( )

Extra representation of this layer, you can have custom implementation of your own layer.

full_name ( )

Full name for this layer, composed by name_scope + “/” + MyLayer.__class__.__name__

Returns

full name of this layer.

Return type

str

Example::
import paddle

def __init__(self):
super(LinearNet, self).__init__(name_scope = "demo_linear_net")

def forward(self, x):
return self._linear(x)

linear_net = LinearNet()
print(linear_net.full_name())   # demo_linear_net_0


Set parameters and persistable buffers from state_dict. All the parameters and buffers will be reset by the tensor in the state_dict

Parameters
• state_dict (dict) – Dict contains all the parameters and persistable buffers.

• use_structured_name (bool, optional) – If true, use structured name as key, otherwise, use parameter or buffer name as key. Default: True

Returns

None

Examples

import paddle

state_dict = emb.state_dict()
emb.set_state_dict(para_state_dict)

named_buffers ( prefix='', include_sublayers=True )

Returns an iterator over all buffers in the Layer, yielding tuple of name and Tensor.

Parameters
• prefix (str, optional) – Prefix to prepend to all buffer names. Default: ‘’.

• include_sublayers (bool, optional) – Whether include the buffers of sublayers. If True, also include the named buffers from sublayers. Default: True.

Yields

(string, Tensor) – Tuple of name and tensor

Examples

import numpy as np

# register a tensor as buffer by specific persistable
fc1.register_buffer("buf_name_1", buffer1, persistable=True)

# register a buffer by assigning an attribute with Tensor.
# The persistable can only be False by this way.
fc2.buf_name_2 = buffer2

# get all named buffers
for name, buffer in model.named_buffers():
print(name, buffer)

named_children ( )

Returns an iterator over immediate children layers, yielding both the name of the layer as well as the layer itself.

Yields

(string, Layer) – Tuple containing a name and child layer

Examples

import paddle

for prefix, layer in model.named_children():
print(prefix, layer)
# ('0', <paddle.nn.layer.common.Linear object at 0x7fb61ed85830>)
# ('1', <paddle.nn.layer.common.Linear object at 0x7fb61ed85950>)

named_parameters ( prefix='', include_sublayers=True )

Returns an iterator over all parameters in the Layer, yielding tuple of name and parameter.

Parameters
• prefix (str, optional) – Prefix to prepend to all parameter names. Default: ‘’.

• include_sublayers (bool, optional) – Whether include the parameters of sublayers. If True, also include the named parameters from sublayers. Default: True.

Yields

(string, Parameter) – Tuple of name and Parameter

Examples

import paddle

for name, param in model.named_parameters():
print(name, param)

named_sublayers ( prefix='', include_self=False, layers_set=None )

Returns an iterator over all sublayers in the Layer, yielding tuple of name and sublayer. The duplicate sublayer will only be yielded once.

Parameters
• prefix (str, optional) – Prefix to prepend to all parameter names. Default: ‘’.

• include_self (bool, optional) – Whether include the Layer itself. Default: False.

• layers_set (set, optional) – The set to record duplicate sublayers. Default: None.

Yields

(string, Layer) – Tuple of name and Layer

Examples

import paddle

for prefix, layer in model.named_sublayers():
print(prefix, layer)

parameters ( include_sublayers=True )

Returns a list of all Parameters from current layer and its sub-layers.

Returns

a list of Parameters.

Return type

list of Tensor

Examples




linear = paddle.nn.Linear(1,1) print(linear.parameters()) # print linear_0.w_0 and linear_0.b_0

register_buffer ( name, tensor, persistable=True )

Registers a tensor as buffer into the layer.

buffer is a non-trainable tensor and will not be updated by optimizer, but is necessary for evaluation and inference. For example, the mean and variance in BatchNorm layers. The registered buffer is persistable by default, and will be saved into state_dict alongside parameters. If set persistable=False, it registers a non-persistable buffer, so that it will not be a part of state_dict .

Buffers can be accessed as attributes using given names.

Parameters
• name (string) – name of the buffer. The buffer can be accessed from this layer using the given name

• tensor (Tensor) – the tensor to be registered as buffer.

• persistable (bool) – whether the buffer is part of this layer’s state_dict.

Returns

None

Examples

import numpy as np

value = np.array([0]).astype("float32")
linear.register_buffer("buf_name", buffer, persistable=True)

# get the buffer by attribute.
print(linear.buf_name)

register_forward_post_hook ( hook )

Register a forward post-hook for Layer. The hook will be called after forward function has been computed.

It should have the following form, input and output of the hook is input and output of the Layer respectively. User can use forward post-hook to change the output of the Layer or perform information statistics tasks on the Layer.

hook(Layer, input, output) -> None or modified output

Parameters

hook (function) – a function registered as a forward post-hook

Returns

a HookRemoveHelper object that can be used to remove the added hook by calling hook_remove_helper.remove() .

Return type

HookRemoveHelper

Examples

import paddle
import numpy as np

# the forward_post_hook change the output of the layer: output = output * 2
def forward_post_hook(layer, input, output):
# user can use layer, input and output for information statistis tasks

# change the output
return output * 2

# register the hook
forward_post_hook_handle = linear.register_forward_post_hook(forward_post_hook)

value1 = np.arange(26).reshape(2, 13).astype("float32")

out0 = linear(in1)

# remove the hook
forward_post_hook_handle.remove()

out1 = linear(in1)

# hook change the linear's output to output * 2, so out0 is equal to out1 * 2.
assert (out0.numpy() == (out1.numpy()) * 2).any()

register_forward_pre_hook ( hook )

Register a forward pre-hook for Layer. The hook will be called before forward function has been computed.

It should have the following form, input of the hook is input of the Layer, hook can either return a tuple or a single modified value in the hook. We will wrap the value into a tuple if a single value is returned(unless that value is already a tuple). User can use forward pre-hook to change the input of the Layer or perform information statistics tasks on the Layer.

hook(Layer, input) -> None or modified input

Parameters

hook (function) – a function registered as a forward pre-hook

Returns

a HookRemoveHelper object that can be used to remove the added hook by calling hook_remove_helper.remove() .

Return type

HookRemoveHelper

Examples

import paddle
import numpy as np

# the forward_pre_hook change the input of the layer: input = input * 2
def forward_pre_hook(layer, input):
# user can use layer and input for information statistis tasks

# change the input
input_return = (input[0] * 2)
return input_return

# register the hook
forward_pre_hook_handle = linear.register_forward_pre_hook(forward_pre_hook)

value0 = np.arange(26).reshape(2, 13).astype("float32")
out0 = linear(in0)

# remove the hook
forward_pre_hook_handle.remove()

value1 = value0 * 2
out1 = linear(in1)

# hook change the linear's input to input * 2, so out0 is equal to out1.
assert (out0.numpy() == out1.numpy()).any()

set_dict ( state_dict, use_structured_name=True )

Set parameters and persistable buffers from state_dict. All the parameters and buffers will be reset by the tensor in the state_dict

Parameters
• state_dict (dict) – Dict contains all the parameters and persistable buffers.

• use_structured_name (bool, optional) – If true, use structured name as key, otherwise, use parameter or buffer name as key. Default: True

Returns

None

Examples

import paddle

state_dict = emb.state_dict()
emb.set_state_dict(para_state_dict)

set_state_dict ( state_dict, use_structured_name=True )

Set parameters and persistable buffers from state_dict. All the parameters and buffers will be reset by the tensor in the state_dict

Parameters
• state_dict (dict) – Dict contains all the parameters and persistable buffers.

• use_structured_name (bool, optional) – If true, use structured name as key, otherwise, use parameter or buffer name as key. Default: True

Returns

None

Examples

import paddle

state_dict = emb.state_dict()
emb.set_state_dict(para_state_dict)

state_dict ( destination=None, include_sublayers=True, structured_name_prefix='', use_hook=True )

Get all parameters and persistable buffers of current layer and its sub-layers. And set them into a dict

Parameters
• destination (dict, optional) – If provide, all the parameters and persistable buffers will be set to this dict . Default: None

• include_sublayers (bool, optional) – If true, also include the parameters and persistable buffers from sublayers. Default: True

• use_hook (bool, optional) – If true, the operations contained in _state_dict_hooks will be appended to the destination. Default: True

Retruns:

dict: a dict contains all the parameters and persistable buffers.

Examples

import paddle

state_dict = emb.state_dict()

sublayers ( include_self=False )

Returns a list of sub layers.

Parameters

include_self (bool, optional) – Whether return self as sublayers. Default: False

Returns

a list of sub layers.

Return type

list of Layer

Examples

import paddle

def __init__(self):
super(MyLayer, self).__init__()

def forward(self, input):
temp = self._linear(input)
temp = self._dropout(temp)
return temp

mylayer = MyLayer()

to ( device=None, dtype=None, blocking=None )

Cast the parameters and buffers of Layer by the give device, dtype and blocking.

Parameters

• None (If) –

• string (the device is the same with the original Tensor. If device is) –

• cpu (it can be) –

• xpu:x (gpu:x and) –

• the (where x is) –

• Default (index of the GPUs or XPUs.) – None.

• dtype (str|numpy.dtype|paddle.dtype|None, optional) – The type of the data. If None, the dtype is the same with the original Tensor. Default: None.

• blocking (bool|None, optional) – If False and the source is in pinned memory, the copy will be asynchronous with respect to the host. Otherwise, the argument has no effect. If None, the blocking is set True. Default: None.

Returns

self

Examples

# required: skip

linear.weight
#Parameter containing:
#       [[-0.32770029,  0.38653070],
#        [ 0.46030545,  0.08158520]])

linear.to(dtype='float64')
linear.weight
#       [[-0.32770029,  0.38653070],
#        [ 0.46030545,  0.08158520]])

linear.to(device='cpu')
linear.weight
#       [[-0.32770029,  0.38653070],
#        [ 0.46030545,  0.08158520]])
linear.weight
#       [[-0.04989364, -0.56889004],
#        [ 0.33960250,  0.96878713]])

to_static_state_dict ( destination=None, include_sublayers=True, structured_name_prefix='', use_hook=True )

Get all parameters and buffers of current layer and its sub-layers. And set them into a dict

Parameters
• destination (dict, optional) – If provide, all the parameters and persistable buffers will be set to this dict . Default: None

• include_sublayers (bool, optional) – If true, also include the parameters and persistable buffers from sublayers. Default: True

• use_hook (bool, optional) – If true, the operations contained in _state_dict_hooks will be appended to the destination. Default: True

Retruns:

dict: a dict contains all the parameters and persistable buffers.

Examples

import paddle

state_dict = emb.to_static_state_dict()

train ( )

Sets this Layer and all its sublayers to training mode. This only effects certain modules like Dropout and BatchNorm.

Returns

None

Example::
import paddle

def __init__(self):
super(MyLayer, self).__init__()