Fix torch backend manual naming and added layer names cannot repeated.

Author: Laicheng0830

tensorlayerx/backend/ops/tensorflow_nn.py

@@ -40,6 +40,37 @@ def padding_format(padding):
         raise Exception("Unsupported padding: " + str(padding))
     return padding
 
+def channel_format(data_format, dim='2d'):
+    if dim == '1d':
+        if data_format in ["channels_last", "NWC", 'NLC']:
+            data_format = "NWC"
+        elif data_format in ["channels_first", "NCW", 'NCL']:
+            data_format = "NCW"
+        elif data_format == None:
+            data_format = None
+        else:
+            raise Exception("Unsupported data format: " + str(data_format))
+    elif dim == '2d':
+        if data_format in ["channels_last", "NHWC"]:
+            data_format = "NHWC"
+        elif data_format in ["channels_first", "NCHW"]:
+            data_format = "NCHW"
+        elif data_format == None:
+            data_format = None
+        else:
+            raise Exception("Unsupported data format: " + str(data_format))
+    elif dim == '3d':
+        if data_format in ['channels_last', 'NDHWC']:
+            data_format = 'NDHWC'
+        elif data_format in ['channels_first', 'NCDHW']:
+            data_format = 'NCDHW'
+        elif data_format == None:
+            data_format = None
+        else:
+            raise Exception("Unsupported data format: " + str(data_format))
+    else:
+        raise Exception("dim must be '1d', '2d', '3d'.")
+    return data_format
 
 def preprocess_padding(padding, dim='2d', data_format='NHWC'):
     # When explicit padding is used and data_format is "NHWC",
@@ -88,8 +119,6 @@ def check_padding(padding, dim='2d'):
         raise RuntimeError("expected padding to be a single integer value or a list of 3 values to match the convolution dimensions.")
 
 
-
-
 def preprocess_1d_format(data_format, padding):
     """
     Checks that the 1-D dataformat format correspond format.
@@ -105,14 +134,7 @@ def preprocess_1d_format(data_format, padding):
     -------
         str "NWC" or "NCW" and "SAME" or "VALID"
     """
-    if data_format in ["channels_last", "NWC", 'NLC']:
-        data_format = "NWC"
-    elif data_format in ["channels_first", "NCW", 'NCL']:
-        data_format = "NCW"
-    elif data_format == None:
-        data_format = None
-    else:
-        raise Exception("Unsupported data format: " + str(data_format))
+    data_format = channel_format(data_format, dim='1d')
     padding = padding_format(padding)
     return data_format, padding
 
@@ -133,14 +155,7 @@ def preprocess_2d_format(data_format, padding):
         str "NHWC" or "NCHW" and "SAME" or "VALID"
     """
 
-    if data_format in ["channels_last", "NHWC"]:
-        data_format = "NHWC"
-    elif data_format in ["channels_first", "NCHW"]:
-        data_format = "NCHW"
-    elif data_format == None:
-        data_format = None
-    else:
-        raise Exception("Unsupported data format: " + str(data_format))
+    data_format = channel_format(data_format, dim='2d')
     padding = padding_format(padding)
     return data_format, padding
 
@@ -161,14 +176,7 @@ def preprocess_3d_format(data_format, padding):
         str "NDHWC" or "NCDHW" and "SAME" or "VALID"
     """
 
-    if data_format in ['channels_last', 'NDHWC']:
-        data_format = 'NDHWC'
-    elif data_format in ['channels_first', 'NCDHW']:
-        data_format = 'NCDHW'
-    elif data_format == None:
-        data_format = None
-    else:
-        raise Exception("Unsupported data format: " + str(data_format))
+    data_format = channel_format(data_format, dim='3d')
     padding = padding_format(padding)
     return data_format, padding
 
@@ -868,10 +876,11 @@ def __init__(self, ksize, strides, padding, data_format=None):
             self.padding = "VALID"
 
     def __call__(self, inputs):
+        data_format = channel_format(self.data_format, str(len(inputs.shape) - 2) + 'd')
         if self.padding_value is not None:
             inputs = tf.pad(inputs, self.padding_value)
         outputs = tf.nn.avg_pool(
-            input=inputs, ksize=self.ksize, strides=self.strides, padding=self.padding, data_format=self.data_format
+            input=inputs, ksize=self.ksize, strides=self.strides, padding=self.padding, data_format=data_format
         )
         return outputs
 

tensorlayerx/nn/core/core_tensorflow.py

@@ -102,6 +102,9 @@ def __init__(self, name=None, act=None, *args, **kwargs):
         # Layer training state
         self.is_train = True
 
+        # weights check state
+        self._check = False
+
     def extend_repr(self):
         """
         Sets the extended representation of the Module.
@@ -160,11 +163,23 @@ def __setattr__(self, name, value):
             object.__setattr__(self, name, value)
 
     def __call__(self, inputs, *args, **kwargs):
+        if self._check == False:
+            self.train_weights_check()
+            self._check = True
 
         output = self.forward(inputs, *args, **kwargs)
-
         return output
 
+    def train_weights_check(self):
+        _param_name = []
+        for w in self.trainable_weights:
+            if w.name not in _param_name:
+                _param_name.append(w.name)
+            else:
+                raise Exception("parameter name [{}] have be been used. "
+                "In training, the name of layer can't be same."
+                "Please check the layers name".format(w.name))
+
     def forward(self, *inputs, **kwargs):
         raise Exception("The forward method must be implemented by inherited class")
 

tensorlayerx/nn/core/core_torch.py

@@ -5,7 +5,7 @@
 from .common import check_parameter, processing_act, str2init, tolist, construct_graph, ModuleNode, select_attrs
 from .common import _save_weights, _load_weights, _save_standard_weights_dict, _load_standard_weights_dict
 from torch.nn.parameter import Parameter
-from torch._C import _disabled_torch_function_impl
+from typing import Any, Callable
 import torch
 import operator
 from itertools import islice
@@ -67,6 +67,10 @@ def __init__(self, name=None, act=None, *args, **kwargs):
         # layer forward  state
         self._forward_state = False
 
+        # weights check state
+        self._check = False
+
+
     def set_train(self, mode=True):
         if not isinstance(mode, bool):
             raise ValueError("training mode is expected to be boolean")
@@ -85,8 +89,6 @@ def forward(self, *inputs, **kwargs):
         raise Exception("The forward method must be implemented by inherited class")
 
     def _get_weights(self, var_name, shape, init=None, trainable=True, transposed=None, order=False):
-        var_name = self.name + "/" + var_name
-
         if order:
             w_tmp = Parameter(init(shape), requires_grad=trainable)
             return w_tmp
@@ -103,8 +105,39 @@ def _get_weights(self, var_name, shape, init=None, trainable=True, transposed=No
         # TODO paramters name should be add
         _param = init(shape)
         param = Parameter(_param, requires_grad=trainable)
+        self.var_name = var_name
         return param
 
+    def _call_impl_tlx(self, *input, **kwargs):
+        if self._check == False:
+            _param_name = []
+            for name, param in self.named_parameters(recurse=True):
+                if name not in _param_name:
+                    _param_name.append(name)
+                else:
+                    raise Exception("parameter name [{}] have be been used. "
+                                    "In training, the name of layer can't be same."
+                                    "Please check the layers name".format(name))
+            self._check = True
+
+        result = self._call_impl(*input, **kwargs)
+        return result
+
+    __call__: Callable[..., Any] = _call_impl_tlx
+
+    def _named_members(self, get_members_fn, prefix='', recurse=True):
+        r"""Helper method for yielding various names + members of modules."""
+        memo = set()
+        modules = self.named_modules(prefix=prefix) if recurse else [(prefix, self)]
+        for module_prefix, module in modules:
+            members = get_members_fn(module)
+            for k, v in members:
+                if v is None or v in memo:
+                    continue
+                memo.add(v)
+                name = module.name + '/' + k
+                yield name, v
+
     @property
     def all_weights(self):
         if self._all_weights is not None and len(self._all_weights) > 0:

tensorlayerx/nn/layers/Transformer.py

@@ -103,16 +103,16 @@ def __repr__(self):
     def build(self, inputs_shape):
         bias_init = tlx.nn.initializers.zeros()
         weight_init = tlx.nn.initializers.XavierNormal()
-        self.q_proj_weight = self._get_weights(
+        self.q_weight = self._get_weights(
             'q_weight', shape=(self.embed_dim, self.embed_dim), init=weight_init, order=True
         )
-        self.k_proj_weight = self._get_weights(
+        self.k_weight = self._get_weights(
             'k_weight', shape=(self.embed_dim, self.kdim), init=weight_init, order=True
         )
-        self.v_proj_weight = self._get_weights(
+        self.v_weight = self._get_weights(
             'v_weight', shape=(self.embed_dim, self.vdim), init=weight_init, order=True
         )
-        self.out_proj_weight = self._get_weights(
+        self.out_weight = self._get_weights(
             'out_weight', shape=(self.embed_dim, self.embed_dim), init=weight_init, order=True
         )
         self.q_bias = None
@@ -127,8 +127,8 @@ def build(self, inputs_shape):
 
         self.multiheadattention = tlx.ops.multiheadattention(
             embed_dim=self.embed_dim, num_heads=self.num_heads, dropout=self.dropout, batch_first=self.batch_first,
-            need_weights=self.need_weights, q_weight=self.q_proj_weight, k_weight=self.k_proj_weight,
-            v_weight=self.v_proj_weight, out_weight=self.out_proj_weight, q_bias=self.q_bias, k_bias=self.k_bias,
+            need_weights=self.need_weights, q_weight=self.q_weight, k_weight=self.k_weight,
+            v_weight=self.v_weight, out_weight=self.out_weight, q_bias=self.q_bias, k_bias=self.k_bias,
             v_bias=self.v_bias, out_bias=self.out_bias, train=self.is_train
         )
 

tensorlayerx/nn/layers/activation.py

@@ -73,7 +73,7 @@ def build(self, inputs_shape):
             elif dim < 3:
                 w_shape = (self.num_parameters, )
 
-        self.alpha_var = self._get_weights("alpha", shape=w_shape, init=tlx.initializers.constant(value=self.init))
+        self.alpha = self._get_weights("alpha", shape=w_shape, init=tlx.initializers.constant(value=self.init))
         self.prelu = tlx.ops.PReLU(data_format = self.data_format)
 
     def forward(self, inputs):
@@ -83,7 +83,7 @@ def forward(self, inputs):
                 self._built = True
             self._forward_state = True
 
-        output = self.prelu(inputs, self.alpha_var)
+        output = self.prelu(inputs, self.alpha)
 
         if not self._nodes_fixed and self._build_graph:
             self._add_node(inputs, output)
@@ -186,7 +186,7 @@ def build(self, inputs_shape):
                 w_shape = (1, self.in_channels, 1, 1, 1)
             else:
                 raise Exception("Dim should be equal to 1, 2 or 3")
-        self.alpha_var = self._get_weights("alpha", shape=w_shape, init=self.a_init)
+        self.alpha = self._get_weights("alpha", shape=w_shape, init=self.a_init)
         self.sigmoid = tlx.ops.Sigmoid()
         self.relu = tlx.ops.ReLU()
 
@@ -197,7 +197,7 @@ def forward(self, inputs):
                 self._built = True
             self._forward_state = True
 
-        alpha_var_constrained = self.sigmoid(self.alpha_var)
+        alpha_var_constrained = self.sigmoid(self.alpha)
         pos = self.relu(inputs)
         pos_6 = -self.relu(inputs - 6)
         neg = -alpha_var_constrained * self.relu(-inputs)

tensorlayerx/nn/layers/convolution/binary_conv.py

@@ -114,11 +114,11 @@ def build(self, inputs_shape):
 
         self.filter_shape = (self.kernel_size[0], self.kernel_size[1], self.in_channels, self.out_channels)
 
-        self.W = self._get_weights("filters", shape=self.filter_shape, init=self.W_init)
+        self.filters = self._get_weights("filters", shape=self.filter_shape, init=self.W_init)
 
         self.b_init_flag = False
         if self.b_init:
-            self.b = self._get_weights("biases", shape=(self.out_channels, ), init=self.b_init)
+            self.biases = self._get_weights("biases", shape=(self.out_channels, ), init=self.b_init)
             self.bias_add = tlx.ops.BiasAdd(self.data_format)
             self.b_init_flag = True
 
@@ -143,10 +143,10 @@ def forward(self, inputs):
                 self._built = True
             self._forward_state = True
 
-        outputs = self.binaryconv2d(inputs, self.W)
+        outputs = self.binaryconv2d(inputs, self.filters)
 
         if self.b_init_flag:
-            outputs = self.bias_add(outputs, self.b)
+            outputs = self.bias_add(outputs, self.biases)
         if self.act_init_flag:
             outputs = self.act(outputs)
 

tensorlayerx/nn/layers/convolution/deformable_conv.py

@@ -146,10 +146,10 @@ def build(self, inputs_shape):
 
         self.filter_shape = (1, 1, self.kernel_n, self.in_channels, self.out_channels)
 
-        self.W = self._get_weights("W_deformableconv2d", shape=self.filter_shape, init=self.W_init)
+        self.W_deformableconv2d = self._get_weights("W_deformableconv2d", shape=self.filter_shape, init=self.W_init)
 
         if self.b_init:
-            self.b = self._get_weights("b_deformableconv2d", shape=(self.out_channels, ), init=self.b_init)
+            self.b_deformableconv2d = self._get_weights("b_deformableconv2d", shape=(self.out_channels, ), init=self.b_init)
 
         self.conv3d = tlx.ops.Conv3D(strides=[1, 1, 1, 1, 1], padding='VALID')
         self.bias_add = tlx.ops.BiasAdd()
@@ -166,12 +166,12 @@ def forward(self, inputs):
         grid_offset = self.grid_offset
 
         input_deform = self._tf_batch_map_offsets(inputs, offset, grid_offset)
-        outputs = self.conv3d(input=input_deform, filters=self.W)
+        outputs = self.conv3d(input=input_deform, filters=self.W_deformableconv2d)
         outputs = tlx.ops.reshape(
             tensor=outputs, shape=[outputs.get_shape()[0], self.input_h, self.input_w, self.out_channels]
         )
         if self.b_init:
-            outputs = self.bias_add(outputs, self.b)
+            outputs = self.bias_add(outputs, self.b_deformableconv2d)
         if self.act:
             outputs = self.act(outputs)
         return outputs

tensorlayerx/nn/layers/convolution/depthwise_conv.py

@@ -137,15 +137,15 @@ def build(self, inputs_shape):
             self.filter_shape = (self.kernel_size[0], self.kernel_size[1], self.in_channels, 1)
 
         if BACKEND in ['tensorflow', 'mindspore']:
-            self.W = self._get_weights("filters", shape=self.filter_shape, init=self.W_init, transposed=True)
-            self.point_W = None
+            self.filters = self._get_weights("filters", shape=self.filter_shape, init=self.W_init, transposed=True)
+            self.point_filter = None
         # TODO The number of parameters on multiple backends is not equal.
         # TODO It might be better to use deepwise convolution and pointwise convolution for other backends as well.
         if BACKEND in ['paddle', 'torch']:
             self.filter_depthwise = (self.in_channels, 1, self.kernel_size[0], self.kernel_size[1])
             self.filter_pointwise = (self.in_channels * self.depth_multiplier, self.in_channels, 1, 1)
-            self.W = self._get_weights("filters", shape=self.filter_depthwise, init=self.W_init, order=True)
-            self.point_W = self._get_weights("point_filter", shape=self.filter_pointwise, init=self.W_init, order=True)
+            self.filters = self._get_weights("filters", shape=self.filter_depthwise, init=self.W_init, order=True)
+            self.point_filter = self._get_weights("point_filter", shape=self.filter_pointwise, init=self.W_init, order=True)
 
         self.depthwise_conv2d = tlx.ops.DepthwiseConv2d(
             strides=self._strides, padding=self.padding, data_format=self.data_format, dilations=self._dilation,
@@ -169,7 +169,7 @@ def forward(self, inputs):
                 self._built = True
             self._forward_state = True
 
-        outputs = self.depthwise_conv2d(input=inputs, filter=self.W, point_filter=self.point_W)
+        outputs = self.depthwise_conv2d(input=inputs, filter=self.filters, point_filter=self.point_filter)
         if self.b_init_flag:
             outputs = self.bias_add(outputs, self.b)
         if self.act_init_flag:

tensorlayerx/nn/layers/convolution/dorefa_conv.py

@@ -133,11 +133,11 @@ def build(self, inputs_shape):
 
         self.filter_shape = (self.kernel_size[0], self.kernel_size[1], self.in_channels, self.out_channels)
 
-        self.W = self._get_weights("filters", shape=self.filter_shape, init=self.W_init)
+        self.filters = self._get_weights("filters", shape=self.filter_shape, init=self.W_init)
 
         self.b_init_flag = False
         if self.b_init:
-            self.b = self._get_weights("biases", shape=(self.out_channels, ), init=self.b_init)
+            self.biases = self._get_weights("biases", shape=(self.out_channels, ), init=self.b_init)
             self.bias_add = tlx.ops.BiasAdd(self.data_format)
             self.b_init_flag = True
 
@@ -159,10 +159,10 @@ def forward(self, inputs):
                 self._built = True
             self._forward_state = True
 
-        outputs = self.dorefaconv2d(inputs, self.W)
+        outputs = self.dorefaconv2d(inputs, self.filters)
 
         if self.b_init_flag:
-            outputs = self.bias_add(outputs, self.b)
+            outputs = self.bias_add(outputs, self.biases)
         if self.act_init_flag:
             outputs = self.act(outputs)