m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Polish and Optimize the print/repr information of Layer (#29998)

Browse Source 
* Polish and Optimize the print/repr message of all layer

* fix some code format
revert-31562-mean
Zhou Wei 4 years ago committed by GitHub
parent f3a2392662
commit 30888ca343
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 700 additions and 2 deletions
Show Stats Download Patch File Download Diff File

2
paddle/fluid/platform/dynload/dynamic_loader.cc
Unescape View File

@ -287,7 +287,7 @@ void* GetCUDNNDsoHandle() {
"For instance, download cudnn-10.0-windows10-x64-v7.6.5.32.zip from "
"NVIDIA's official website, \n"
"then, unzip it and copy it into C:\\Program Files\\NVIDIA GPU Computing "
"Toolkit\\CUDA/v10.0\n"
"Toolkit\\CUDA\\v10.0\n"
"You should do this according to your CUDA installation directory and "
"CUDNN version.");
return GetDsoHandleFromSearchPath(FLAGS_cudnn_dir, win_cudnn_lib, true,

40
python/paddle/fluid/dygraph/layers.py
Unescape View File

@ -46,6 +46,17 @@ def _convert_camel_to_snake(name):
return _all_cap_re.sub(r'\1_\2', s1).lower()
def _addindent(string, indent):
s1 = string.split('\n')
if len(s1) == 1:
return string
s2 = []
for idx, line in enumerate(s1):
if idx > 0:
s2.append(str((indent * ' ') + line))
return s1[0] + '\n' + '\n'.join(s2)
class HookRemoveHelper(object):
""" A HookRemoveHelper that can be used to remove hook. """
@ -1166,6 +1177,35 @@ class Layer(core.Layer):
return keys
def extra_repr(self):
"""
Extra representation of this layer, you can have custom implementation
of your own layer.
"""
return ''
def __repr__(self):
extra_lines = []
extra_repr = self.extra_repr()
extra_lines = extra_repr.split('\n')
sublayer_lines = []
for name, layer in self._sub_layers.items():
sublayer_str = repr(layer)
sublayer_str = _addindent(sublayer_str, 2)
sublayer_lines.append('(' + name + '): ' + sublayer_str)
final_str = self.__class__.__name__ + '('
if extra_lines:
if len(extra_lines) > 1:
final_str += '\n ' + '\n '.join(extra_lines) + '\n'
elif len(extra_lines) == 1:
final_str += extra_lines[0]
if sublayer_lines:
final_str += '\n ' + '\n '.join(sublayer_lines) + '\n'
final_str += ')'
return final_str
def state_dict(self,
destination=None,
include_sublayers=True,

347
python/paddle/fluid/tests/unittests/test_imperative_layers.py
View File

File diff suppressed because it is too large Load Diff

95
python/paddle/nn/layer/activation.py
Unescape View File

@ -86,6 +86,10 @@ class ELU(layers.Layer):
def forward(self, x):
return F.elu(x, self._alpha, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'alpha={}{}'.format(self._alpha, name_str)
class GELU(layers.Layer):
r"""
@ -135,6 +139,10 @@ class GELU(layers.Layer):
def forward(self, x):
return F.gelu(x, self._approximate, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'approximate={}{}'.format(self._approximate, name_str)
class Hardshrink(layers.Layer):
r"""
@ -179,6 +187,10 @@ class Hardshrink(layers.Layer):
def forward(self, x):
return F.hardshrink(x, self._threshold, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'threshold={}{}'.format(self._threshold, name_str)
class Hardswish(layers.Layer):
r"""
@ -225,6 +237,10 @@ class Hardswish(layers.Layer):
def forward(self, x):
return F.hardswish(x, self._name)
def extra_repr(self):
name_str = 'name={}'.format(self._name) if self._name else ''
return name_str
class Tanh(layers.Layer):
r"""
@ -262,6 +278,10 @@ class Tanh(layers.Layer):
def forward(self, x):
return F.tanh(x, self._name)
def extra_repr(self):
name_str = 'name={}'.format(self._name) if self._name else ''
return name_str
class Hardtanh(layers.Layer):
r"""
@ -304,6 +324,10 @@ class Hardtanh(layers.Layer):
def forward(self, x):
return F.hardtanh(x, self._min, self._max, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'min={}, max={}{}'.format(self._min, self._max, name_str)
class PReLU(layers.Layer):
"""
@ -371,6 +395,11 @@ class PReLU(layers.Layer):
def forward(self, x):
return F.prelu(x, self._weight)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'num_parameters={}, init={}, dtype={}{}'.format(
self._num_parameters, self._init, self._dtype, name_str)
class ReLU(layers.Layer):
"""
@ -405,6 +434,10 @@ class ReLU(layers.Layer):
def forward(self, x):
return F.relu(x, self._name)
def extra_repr(self):
name_str = 'name={}'.format(self._name) if self._name else ''
return name_str
class ReLU6(layers.Layer):
"""
@ -440,6 +473,10 @@ class ReLU6(layers.Layer):
def forward(self, x):
return F.relu6(x, self._name)
def extra_repr(self):
name_str = 'name={}'.format(self._name) if self._name else ''
return name_str
class SELU(layers.Layer):
r"""
@ -486,6 +523,11 @@ class SELU(layers.Layer):
def forward(self, x):
return F.selu(x, self._scale, self._alpha, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'scale={:.16f}, alpha={:.16f}{}'.format(self._scale, self._alpha,
name_str)
class LeakyReLU(layers.Layer):
r"""
@ -530,6 +572,10 @@ class LeakyReLU(layers.Layer):
def forward(self, x):
return F.leaky_relu(x, self._negative_slope, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'negative_slope={}{}'.format(self._negative_slope, name_str)
class Sigmoid(layers.Layer):
"""
@ -566,6 +612,10 @@ class Sigmoid(layers.Layer):
def forward(self, x):
return F.sigmoid(x, self.name)
def extra_repr(self):
name_str = 'name={}'.format(self.name) if self.name else ''
return name_str
class Hardsigmoid(layers.Layer):
r"""
@ -613,6 +663,10 @@ class Hardsigmoid(layers.Layer):
def forward(self, x):
return F.hardsigmoid(x, name=self.name)
def extra_repr(self):
name_str = 'name={}'.format(self.name) if self.name else ''
return name_str
class Softplus(layers.Layer):
r"""
@ -653,6 +707,11 @@ class Softplus(layers.Layer):
def forward(self, x):
return F.softplus(x, self._beta, self._threshold, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'beta={}, threshold={}{}'.format(self._beta, self._threshold,
name_str)
class Softshrink(layers.Layer):
r"""
@ -694,6 +753,10 @@ class Softshrink(layers.Layer):
def forward(self, x):
return F.softshrink(x, self._threshold, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'threshold={}{}'.format(self._threshold, name_str)
class Softsign(layers.Layer):
r"""
@ -729,6 +792,10 @@ class Softsign(layers.Layer):
def forward(self, x):
return F.softsign(x, self._name)
def extra_repr(self):
name_str = 'name={}'.format(self._name) if self._name else ''
return name_str
class Swish(layers.Layer):
r"""
@ -764,6 +831,10 @@ class Swish(layers.Layer):
def forward(self, x):
return F.swish(x, self._name)
def extra_repr(self):
name_str = 'name={}'.format(self._name) if self._name else ''
return name_str
class Tanhshrink(layers.Layer):
"""
@ -799,6 +870,10 @@ class Tanhshrink(layers.Layer):
def forward(self, x):
return F.tanhshrink(x, self._name)
def extra_repr(self):
name_str = 'name={}'.format(self._name) if self._name else ''
return name_str
class ThresholdedReLU(layers.Layer):
r"""
@ -839,6 +914,10 @@ class ThresholdedReLU(layers.Layer):
def forward(self, x):
return F.thresholded_relu(x, self._threshold, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'threshold={}{}'.format(self._threshold, name_str)
class LogSigmoid(layers.Layer):
r"""
@ -874,6 +953,10 @@ class LogSigmoid(layers.Layer):
def forward(self, x):
return F.log_sigmoid(x, self._name)
def extra_repr(self):
name_str = 'name={}'.format(self._name) if self._name else ''
return name_str
class Softmax(layers.Layer):
r"""
@ -997,6 +1080,10 @@ class Softmax(layers.Layer):
def forward(self, x):
return F.softmax(x, self._axis, self._dtype, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'axis={}{}'.format(self._axis, name_str)
class LogSoftmax(layers.Layer):
r"""
@ -1051,6 +1138,10 @@ class LogSoftmax(layers.Layer):
def forward(self, x):
return F.log_softmax(x, self._axis)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'axis={}{}'.format(self._axis, name_str)
class Maxout(layers.Layer):
r"""
@ -1111,3 +1202,7 @@ class Maxout(layers.Layer):
def forward(self, x):
return F.maxout(x, self._groups, self._axis, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'groups={}, axis={}{}'.format(self._groups, self._axis, name_str)

86
python/paddle/nn/layer/common.py
Unescape View File

@ -119,7 +119,6 @@ class Linear(layers.Layer):
self._dtype = self._helper.get_default_dtype()
self._weight_attr = weight_attr
self._bias_attr = bias_attr
self.name = name
self.weight = self.create_parameter(
shape=[in_features, out_features],
attr=self._weight_attr,
@ -137,6 +136,11 @@ class Linear(layers.Layer):
x=input, weight=self.weight, bias=self.bias, name=self.name)
return out
def extra_repr(self):
name_str = ', name={}'.format(self.name) if self.name else ''
return 'in_features={}, out_features={}, dtype={}{}'.format(
self.weight.shape[0], self.weight.shape[1], self._dtype, name_str)
class Upsample(layers.Layer):
"""
@ -377,6 +381,16 @@ class Upsample(layers.Layer):
return out
def extra_repr(self):
if self.scale_factor is not None:
main_str = 'scale_factor={}'.format(self.scale_factor)
else:
main_str = 'size={}'.format(self.size)
name_str = ', name={}'.format(self.name) if self.name else ''
return '{}, mode={}, align_corners={}, align_mode={}, data_format={}{}'.format(
main_str, self.mode, self.align_corners, self.align_mode,
self.data_format, name_str)
class UpsamplingNearest2D(layers.Layer):
"""
@ -453,6 +467,15 @@ class UpsamplingNearest2D(layers.Layer):
return out
def extra_repr(self):
if self.scale_factor is not None:
main_str = 'scale_factor={}'.format(self.scale_factor)
else:
main_str = 'size={}'.format(self.size)
name_str = ', name={}'.format(self.name) if self.name else ''
return '{}, data_format={}{}'.format(main_str, self.data_format,
name_str)
class UpsamplingBilinear2D(layers.Layer):
"""
@ -530,6 +553,15 @@ class UpsamplingBilinear2D(layers.Layer):
return out
def extra_repr(self):
if self.scale_factor is not None:
main_str = 'scale_factor={}'.format(self.scale_factor)
else:
main_str = 'size={}'.format(self.size)
name_str = ', name={}'.format(self.name) if self.name else ''
return '{}, data_format={}{}'.format(main_str, self.data_format,
name_str)
class Bilinear(layers.Layer):
r"""
@ -619,6 +651,12 @@ class Bilinear(layers.Layer):
def forward(self, x1, x2):
return F.bilinear(x1, x2, self.weight, self.bias, self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'in1_features={}, in2_features={}, out_features={}, dtype={}{}'.format(
self._in1_features, self._in2_features, self._out_features,
self._dtype, name_str)
class Dropout(layers.Layer):
"""
@ -688,6 +726,11 @@ class Dropout(layers.Layer):
name=self.name)
return out
def extra_repr(self):
name_str = ', name={}'.format(self.name) if self.name else ''
return 'p={}, axis={}, mode={}{}'.format(self.p, self.axis, self.mode,
name_str)
class Dropout2D(layers.Layer):
"""
@ -744,6 +787,11 @@ class Dropout2D(layers.Layer):
name=self.name)
return out
def extra_repr(self):
name_str = ', name={}'.format(self.name) if self.name else ''
return 'p={}, data_format={}{}'.format(self.p, self.data_format,
name_str)
class Dropout3D(layers.Layer):
"""
@ -800,6 +848,11 @@ class Dropout3D(layers.Layer):
name=self.name)
return out
def extra_repr(self):
name_str = ', name={}'.format(self.name) if self.name else ''
return 'p={}, data_format={}{}'.format(self.p, self.data_format,
name_str)
class AlphaDropout(layers.Layer):
"""
@ -849,6 +902,10 @@ class AlphaDropout(layers.Layer):
input, p=self.p, training=self.training, name=self.name)
return out
def extra_repr(self):
name_str = ', name={}'.format(self.name) if self.name else ''
return 'p={}{}'.format(self.p, name_str)
class Pad1D(layers.Layer):
"""
@ -924,6 +981,11 @@ class Pad1D(layers.Layer):
data_format=self._data_format,
name=self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'padding={}, mode={}, value={}, data_format={}{}'.format(
self._pad, self._mode, self._value, self._data_format, name_str)
class Pad2D(layers.Layer):
"""
@ -1002,6 +1064,11 @@ class Pad2D(layers.Layer):
data_format=self._data_format,
name=self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'padding={}, mode={}, value={}, data_format={}{}'.format(
self._pad, self._mode, self._value, self._data_format, name_str)
class Pad3D(layers.Layer):
"""
@ -1080,6 +1147,11 @@ class Pad3D(layers.Layer):
data_format=self._data_format,
name=self._name)
def extra_repr(self):
name_str = ', name={}'.format(self._name) if self._name else ''
return 'padding={}, mode={}, value={}, data_format={}{}'.format(
self._pad, self._mode, self._value, self._data_format, name_str)
class CosineSimilarity(layers.Layer):
"""
@ -1134,6 +1206,9 @@ class CosineSimilarity(layers.Layer):
def forward(self, x1, x2):
return F.cosine_similarity(x1, x2, axis=self._axis, eps=self._eps)
def extra_repr(self):
return 'axis={_axis}, eps={_eps}'.format(**self.__dict__)
class Embedding(layers.Layer):
r"""
@ -1284,3 +1359,12 @@ class Embedding(layers.Layer):
padding_idx=self._padding_idx,
sparse=self._sparse,
name=self._name)
def extra_repr(self):
main_str = '{_num_embeddings}, {_embedding_dim}'
if self._padding_idx is not None:
main_str += ', padding_idx={_padding_idx}'
main_str += ', sparse={_sparse}'
if self._name is not None:
main_str += ', name={_name}'
return main_str.format(**self.__dict__)

17
python/paddle/nn/layer/conv.py
Unescape View File

@ -148,6 +148,23 @@ class _ConvNd(layers.Layer):
self._op_type = 'depthwise_conv2d'
self._use_cudnn = False
def extra_repr(self):
main_str = '{_in_channels}, {_out_channels}, kernel_size={_kernel_size}'
if self._stride != [1] * len(self._stride):
main_str += ', stride={_stride}'
if self._padding != 0:
main_str += ', padding={_padding}'
if self._padding_mode is not 'zeros':
main_str += ', padding_mode={_padding_mode}'
if self.output_padding != 0:
main_str += ', output_padding={_output_padding}'
if self._dilation != [1] * len(self._dilation):
main_str += ', dilation={_dilation}'
if self._groups != 1:
main_str += ', groups={_groups}'
main_str += ', data_format={_data_format}'
return main_str.format(**self.__dict__)
class Conv1D(_ConvNd):
r"""

10
python/paddle/nn/layer/distance.py
Unescape View File

@ -100,3 +100,13 @@ class PairwiseDistance(layers.Layer):
type='p_norm', inputs={'X': sub}, outputs={'Out': out}, attrs=attrs)
return out
def extra_repr(self):
main_str = 'p={p}'
if self.epsilon != 1e-6:
main_str += ', epsilon={epsilon}'
if self.keepdim != False:
main_str += ', keepdim={keepdim}'
if self.name != None:
main_str += ', name={name}'
return main_str.format(**self.__dict__)

30
python/paddle/nn/layer/norm.py
Unescape View File

@ -107,6 +107,10 @@ class _InstanceNormBase(layers.Layer):
return instance_norm(
input, weight=self.scale, bias=self.bias, eps=self._epsilon)
def extra_repr(self):
return 'num_features={}, epsilon={}'.format(self.scale.shape[0],
self._epsilon)
class InstanceNorm1D(_InstanceNormBase):
r"""
@ -433,6 +437,10 @@ class GroupNorm(layers.Layer):
return self._helper.append_activation(group_norm_out, None)
def extra_repr(self):
return 'num_groups={}, num_channels={}, epsilon={}'.format(
self._num_groups, self._num_channels, self._epsilon)
class LayerNorm(layers.Layer):
r"""
@ -537,6 +545,10 @@ class LayerNorm(layers.Layer):
bias=self.bias,
epsilon=self._epsilon)
def extra_repr(self):
return 'normalized_shape={}, epsilon={}'.format(self._normalized_shape,
self._epsilon)
class _BatchNormBase(layers.Layer):
"""
@ -647,6 +659,15 @@ class _BatchNormBase(layers.Layer):
data_format=self._data_format,
use_global_stats=self._use_global_stats)
def extra_repr(self):
main_str = 'num_features={}, momentum={}, epsilon={}'.format(
self._num_features, self._momentum, self._epsilon)
if self._data_format is not 'NCHW':
main_str += ', data_format={}'.format(self._data_format)
if self._name is not None:
main_str += ', name={}'.format(self._name)
return main_str
class BatchNorm1D(_BatchNormBase):
r"""
@ -1186,3 +1207,12 @@ class LocalResponseNorm(layers.Layer):
out = F.local_response_norm(input, self.size, self.alpha, self.beta,
self.k, self.data_format, self.name)
return out
def extra_repr(self):
main_str = 'size={}, alpha={}, beta={}, k={}'.format(
self.size, self.alpha, self.beta, self.k)
if self.data_format is not 'NCHW':
main_str += ', data_format={}'.format(self.data_format)
if self.name is not None:
main_str += ', name={}'.format(self.name)
return main_str

45
python/paddle/nn/layer/pooling.py
Unescape View File

@ -119,6 +119,10 @@ class AvgPool1D(layers.Layer):
self.exclusive, self.ceil_mode, self.name)
return out
def extra_repr(self):
return 'kernel_size={kernel_size}, stride={stride}, padding={padding}'.format(
**self.__dict__)
class AvgPool2D(layers.Layer):
r"""
@ -222,6 +226,10 @@ class AvgPool2D(layers.Layer):
data_format=self.data_format,
name=self.name)
def extra_repr(self):
return 'kernel_size={ksize}, stride={stride}, padding={padding}'.format(
**self.__dict__)
class AvgPool3D(layers.Layer):
"""
@ -313,6 +321,10 @@ class AvgPool3D(layers.Layer):
data_format=self.data_format,
name=self.name)
def extra_repr(self):
return 'kernel_size={ksize}, stride={stride}, padding={padding}'.format(
**self.__dict__)
class MaxPool1D(layers.Layer):
"""
@ -401,6 +413,10 @@ class MaxPool1D(layers.Layer):
self.return_mask, self.ceil_mode, self.name)
return out
def extra_repr(self):
return 'kernel_size={kernel_size}, stride={stride}, padding={padding}'.format(
**self.__dict__)
class MaxPool2D(layers.Layer):
r"""
@ -504,6 +520,10 @@ class MaxPool2D(layers.Layer):
data_format=self.data_format,
name=self.name)
def extra_repr(self):
return 'kernel_size={ksize}, stride={stride}, padding={padding}'.format(
**self.__dict__)
class MaxPool3D(layers.Layer):
"""
@ -595,6 +615,10 @@ class MaxPool3D(layers.Layer):
data_format=self.data_format,
name=self.name)
def extra_repr(self):
return 'kernel_size={ksize}, stride={stride}, padding={padding}'.format(
**self.__dict__)
class AdaptiveAvgPool1D(layers.Layer):
r"""
@ -664,6 +688,9 @@ class AdaptiveAvgPool1D(layers.Layer):
def forward(self, input):
return F.adaptive_avg_pool1d(input, self.output_size, self.name)
def extra_repr(self):
return 'output_size={}'.format(self.output_size)
class AdaptiveAvgPool2D(layers.Layer):
r"""
@ -746,6 +773,9 @@ class AdaptiveAvgPool2D(layers.Layer):
data_format=self._data_format,
name=self._name)
def extra_repr(self):
return 'output_size={}'.format(self._output_size)
class AdaptiveAvgPool3D(layers.Layer):
r"""
@ -834,6 +864,9 @@ class AdaptiveAvgPool3D(layers.Layer):
data_format=self._data_format,
name=self._name)
def extra_repr(self):
return 'output_size={}'.format(self._output_size)
class AdaptiveMaxPool1D(layers.Layer):
"""
@ -913,6 +946,10 @@ class AdaptiveMaxPool1D(layers.Layer):
return F.adaptive_max_pool1d(input, self.output_size, self.return_mask,
self.name)
def extra_repr(self):
return 'output_size={}, return_mask={}'.format(self.output_size,
self.return_mask)
class AdaptiveMaxPool2D(layers.Layer):
"""
@ -985,6 +1022,10 @@ class AdaptiveMaxPool2D(layers.Layer):
return_mask=self._return_mask,
name=self._name)
def extra_repr(self):
return 'output_size={}, return_mask={}'.format(self._output_size,
self._return_mask)
class AdaptiveMaxPool3D(layers.Layer):
"""
@ -1067,3 +1108,7 @@ class AdaptiveMaxPool3D(layers.Layer):
output_size=self._output_size,
return_mask=self._return_mask,
name=self._name)
def extra_repr(self):
return 'output_size={}, return_mask={}'.format(self._output_size,
self._return_mask)

22
python/paddle/nn/layer/rnn.py
Unescape View File

@ -390,6 +390,12 @@ class SimpleRNNCell(RNNCellBase):
def state_shape(self):
return (self.hidden_size, )
def extra_repr(self):
s = '{input_size}, {hidden_size}'
if self.activation is not "tanh":
s += ', activation={activation}'
return s.format(**self.__dict__)
class LSTMCell(RNNCellBase):
r"""
@ -540,6 +546,9 @@ class LSTMCell(RNNCellBase):
"""
return ((self.hidden_size, ), (self.hidden_size, ))
def extra_repr(self):
return '{input_size}, {hidden_size}'.format(**self.__dict__)
class GRUCell(RNNCellBase):
r"""
@ -684,6 +693,9 @@ class GRUCell(RNNCellBase):
"""
return (self.hidden_size, )
def extra_repr(self):
return '{input_size}, {hidden_size}'.format(**self.__dict__)
class RNN(Layer):
r"""
@ -1053,6 +1065,16 @@ class RNNBase(LayerList):
self.state_components)
return outputs, final_states
def extra_repr(self):
main_str = '{input_size}, {hidden_size}'
if self.num_layers != 1:
main_str += ', num_layers={num_layers}'
if self.time_major != False:
main_str += ', time_major={time_major}'
if self.dropout != 0:
main_str += ', dropout={dropout}'
return main_str.format(**self.__dict__)
class SimpleRNN(RNNBase):
r"""

8
python/paddle/nn/layer/vision.py
Unescape View File

@ -79,3 +79,11 @@ class PixelShuffle(layers.Layer):
def forward(self, x):
return functional.pixel_shuffle(x, self._upscale_factor,
self._data_format, self._name)
def extra_repr(self):
main_str = 'upscale_factor={}'.format(self._upscale_factor)
if self._data_format is not 'NCHW':
main_str += ', data_format={}'.format(self._data_format)
if self._name is not None:
main_str += ', name={}'.format(self._name)
return main_str

Write Preview
Loading…
Cancel
Save