Merge branch 'main' of github.com:tensorlayer/TensorLayerX into main

Author: Laicheng0830

README.md

@@ -38,12 +38,12 @@ Compare to TensorLayer version:
 
 # Resources
 
-- [Examples](https://github.com/tensorlayer/TensorLayerX/tree/main/examples) for tutorials
-- OpenIVA an easy-to-use product-level deployment framework
-- [TLXZoo](https://github.com/tensorlayer/TLXZoo) pretrained models/backbones
-- TLXCV a bunch of Computer Vision applications
-- TLXNLP a bunch of Natural Language Processing applications
-- TLXRL a bunch of Reinforcement Learning applications, check [RLZoo](https://github.com/tensorlayer/RLzoo) for the old version
+- [Examples](https://github.com/tensorlayer/TensorLayerX/tree/main/examples) for tutorials✅
+- OpenIVA an easy-to-use product-level deployment framework✅
+- [TLXZoo](https://github.com/tensorlayer/TLXZoo) pretrained models/backbones🚧
+- TLXCV a bunch of Computer Vision applications🚧
+- TLXNLP a bunch of Natural Language Processing applications🚧
+- TLXRL a bunch of Reinforcement Learning applications, check [RLZoo](https://github.com/tensorlayer/RLzoo) for the old version✅
 
 More resources can be found [here](https://github.com/tensorlayer)
 
@@ -70,8 +70,10 @@ For more installation instructions, please refer to [Installtion](https://tensor
 You can immediately use tensorlayerx to define a model, using your favourite framework in the background, like so:
 ```python
 import os
-os.environ['TL_BACKEND'] = 'tensorflow' # change to any framework!
-
+os.environ['TL_BACKEND'] = 'tensorflow' # Just modify this line, easily change to any framework!
+#os.environ['TL_BACKEND'] = 'mindspore'
+#os.environ['TL_BACKEND'] = 'paddle'
+#os.environ['TL_BACKEND'] = 'torch'
 import tensorlayerx as tlx
 from tensorlayerx.nn import Module
 from tensorlayerx.nn import Linear
@@ -80,14 +82,14 @@ class CustomModel(Module):
   def __init__(self):
       super(CustomModel, self).__init__()
 
-      self.dense1 = Linear(out_features=800, act=tlx.ReLU, in_features=784)
-      self.dense2 = Linear(out_features=800, act=tlx.ReLU, in_features=800)
-      self.dense3 = Linear(out_features=10, act=None, in_features=800)
+      self.linear1 = Linear(out_features=800, act=tlx.ReLU, in_features=784)
+      self.linear2 = Linear(out_features=800, act=tlx.ReLU, in_features=800)
+      self.linear3 = Linear(out_features=10, act=None, in_features=800)
 
   def forward(self, x, foo=False):
-      z = self.dense1(x)
-      z = self.dense2(z)
-      out = self.dense3(z)
+      z = self.linear1(x)
+      z = self.linear2(z)
+      out = self.linear3(z)
       if foo:
           out = tlx.softmax(out)
       return out
@@ -102,6 +104,9 @@ TensorLayerX has extensive documentation for both beginners and professionals.
 [![English Documentation](https://img.shields.io/badge/documentation-english-blue.svg)](https://tensorlayerx.readthedocs.io/en/latest/)
 
 
+# Contributing
+Join our community as a code contributor, find out more in our [Contributing](https://tensorlayerx.readthedocs.io/en/latest/user/contributing.html) guide!
+
 # Contact
  - [email protected]
  - [email protected]

docs/user/get_start_advance.rst

@@ -18,36 +18,47 @@ The fully-connected layer is `a = f(x*W+b)`, the most simple implementation is a
   import tensorlayerx as tlx
   from tensorlayerx.nn import Module
 
-  class Dense(Module):
-    """The :class:`Dense` class is a fully connected layer.
+  class Linear(Module):
+    """The :class:`Linear` class is a fully connected layer.
     
     Parameters
     ----------
-    n_units : int
+    out_features : int
         The number of units of this layer.
     act : activation function
         The activation function of this layer.
+    W_init : initializer or str
+        The initializer for the weight matrix.
+    b_init : initializer or None or str
+        The initializer for the bias vector. If None, skip biases.
+    in_features: int
+        The number of channels of the previous layer.
+        If None, it will be automatically detected when the layer is forwarded for the first time.
     name : None or str
         A unique layer name. If None, a unique name will be automatically generated.
     """
     
     def __init__(
-            self,
-            n_units,   # the number of units/channels of this layer
-            act=None,  # None: no activation, tlx.relu or 'relu': ReLU ...
-            name=None, # the name of this layer (optional)
-            in_channels = None
+        self,
+        out_features,
+        act=None,
+        W_init='truncated_normal',
+        b_init='constant',
+        in_features=None,
+        name=None,  # 'linear',
     ):
-        super(Dense, self).__init__(name, act=act) # auto naming, dense_1, dense_2 ...
-        self.n_units = n_units
-        self.in_channels = in_channels
+        super(Linear, self).__init__(name, act=act) # auto naming, linear_1, linear_2 ...
+        self.out_features = out_features
+        self.in_features = in_features
+        self.W_init = self.str_to_init(W_init)
+        self.b_init = self.str_to_init(b_init)
         self.build()
         self._built = True
         
     def build(self): # initialize the model weights here
-        shape = [self.in_channels, self.n_units]
+        shape = [self.in_features, self.out_features]
         self.W = self._get_weights("weights", shape=tuple(shape), init=self.W_init)
-        self.b = self._get_weights("biases", shape=(self.n_units, ), init=self.b_init)
+        self.b = self._get_weights("biases", shape=(self.out_features, ), init=self.b_init)
 
     def forward(self, inputs): # call function
         z = tlx.matmul(inputs, self.W) + self.b
@@ -60,36 +71,32 @@ The full implementation is as follow, which supports both automatic inference in
 .. code-block:: python
 
 
-  class Dense(Module):
-    """The :class:`Dense` class is a fully connected layer.
+  class Linear(Module):
+    """The :class:`Linear` class is a fully connected layer.
 
     Parameters
     ----------
-    n_units : int
+    out_features : int
         The number of units of this layer.
     act : activation function
         The activation function of this layer.
-    W_init : initializer
+    W_init : initializer or str
         The initializer for the weight matrix.
-    b_init : initializer or None
+    b_init : initializer or None or str
         The initializer for the bias vector. If None, skip biases.
-    in_channels: int
+    in_features: int
         The number of channels of the previous layer.
         If None, it will be automatically detected when the layer is forwarded for the first time.
     name : None or str
         A unique layer name. If None, a unique name will be automatically generated.
 
     Examples
     --------
-    With TensorLayerX
+    With TensorLayerx
 
     >>> net = tlx.nn.Input([100, 50], name='input')
-    >>> dense = tlx.nn.Dense(n_units=800, act=tlx.ReLU, in_channels=50, name='dense_1')
-    >>> print(dense)
-    Dense(n_units=800, relu, in_channels='50', name='dense_1')
-    >>> tensor = tl.layers.Dense(n_units=800, act=tlx.ReLU, name='dense_2')(net)
-    >>> print(tensor)
-    Tensor([...], shape=(100, 800), dtype=float32)
+    >>> linear = tlx.nn.Linear(out_features=800, act=tlx.ReLU, in_features=50, name='linear_1')
+    >>> tensor = tlx.nn.Linear(out_features=800, act=tlx.ReLU, name='linear_2')(net)
 
     Notes
     -----
@@ -99,67 +106,67 @@ The full implementation is as follow, which supports both automatic inference in
 
     def __init__(
         self,
-        n_units,
+        out_features,
         act=None,
-        W_init=tlx.nn.initializers.truncated_normal(stddev=0.05),
-        b_init=tlx.nn.initializers.constant(value=0.0),
-        in_channels=None,
-        name=None,  # 'dense',
+        W_init='truncated_normal',
+        b_init='constant',
+        in_features=None,
+        name=None,  # 'linear',
     ):
 
-        super(Dense, self).__init__(name, act=act)
+        super(Linear, self).__init__(name, act=act)
 
-        self.n_units = n_units
-        self.W_init = W_init
-        self.b_init = b_init
-        self.in_channels = in_channels
+        self.out_features = out_features
+        self.W_init = self.str_to_init(W_init)
+        self.b_init = self.str_to_init(b_init)
+        self.in_features = in_features
 
-        if self.in_channels is not None:
-            self.build(self.in_channels)
+        if self.in_features is not None:
+            self.build(self.in_features)
             self._built = True
 
         logging.info(
-            "Dense  %s: %d %s" %
-            (self.name, self.n_units, self.act.__class__.__name__ if self.act is not None else 'No Activation')
+            "Linear  %s: %d %s" %
+            (self.name, self.out_features, self.act.__class__.__name__ if self.act is not None else 'No Activation')
         )
 
     def __repr__(self):
         actstr = self.act.__class__.__name__ if self.act is not None else 'No Activation'
-        s = ('{classname}(n_units={n_units}, ' + actstr)
-        if self.in_channels is not None:
-            s += ', in_channels=\'{in_channels}\''
+        s = ('{classname}(out_features={out_features}, ' + actstr)
+        if self.in_features is not None:
+            s += ', in_features=\'{in_features}\''
         if self.name is not None:
             s += ', name=\'{name}\''
         s += ')'
         return s.format(classname=self.__class__.__name__, **self.__dict__)
 
     def build(self, inputs_shape):
-        if self.in_channels is None and len(inputs_shape) != 2:
-            raise AssertionError("The input dimension must be rank 2, please reshape or flatten it")
-        if self.in_channels:
-            shape = [self.in_channels, self.n_units]
+        if self.in_features is None and len(inputs_shape) < 2:
+            raise AssertionError("The dimension of input should not be less than 2")
+        if self.in_features:
+            shape = [self.in_features, self.out_features]
         else:
-            self.in_channels = inputs_shape[1]
-            shape = [inputs_shape[1], self.n_units]
+            self.in_features = inputs_shape[-1]
+            shape = [self.in_features, self.out_features]
 
         self.W = self._get_weights("weights", shape=tuple(shape), init=self.W_init)
 
         self.b_init_flag = False
         if self.b_init:
-            self.b = self._get_weights("biases", shape=(self.n_units, ), init=self.b_init)
+            self.b = self._get_weights("biases", shape=(self.out_features, ), init=self.b_init)
             self.b_init_flag = True
-            self.bias_add = tlx.BiasAdd()
+            self.bias_add = tlx.ops.BiasAdd(data_format='NHWC')
 
         self.act_init_flag = False
         if self.act:
             self.act_init_flag = True
 
-        self.matmul = tlx.MatMul()
+        self.matmul = tlx.ops.MatMul()
 
     def forward(self, inputs):
         if self._forward_state == False:
             if self._built == False:
-                self.build(tl.get_tensor_shape(inputs))
+                self.build(tlx.get_tensor_shape(inputs))
                 self._built = True
             self._forward_state = True
 
@@ -171,6 +178,7 @@ The full implementation is as follow, which supports both automatic inference in
         return z
 
 
+
 Layers with train/test modes
 ------------------------------
 
@@ -181,13 +189,12 @@ We use Dropout as an example here:
   class Dropout(Module):
     """
     The :class:`Dropout` class is a noise layer which randomly set some
-    activations to zero according to a keeping probability.
+    activations to zero according to a probability.
 
     Parameters
     ----------
-    keep : float
-        The keeping probability.
-        The lower the probability it is, the more activations are set to zero.
+    p : float
+        probability of an element to be zeroed. Default: 0.5
     seed : int or None
         The seed for random dropout.
     name : None or str
@@ -196,29 +203,29 @@ We use Dropout as an example here:
     Examples
     --------
     >>> net = tlx.nn.Input([10, 200])
-    >>> net = tlx.nn.Dropout(keep=0.2)(net)
+    >>> net = tlx.nn.Dropout(p=0.2)(net)
 
     """
 
-    def __init__(self, keep, seed=0, name=None):  #"dropout"):
+    def __init__(self, p=0.5, seed=0, name=None):  #"dropout"):
         super(Dropout, self).__init__(name)
-        self.keep = keep
+        self.p = p
         self.seed = seed
 
         self.build()
         self._built = True
 
-        logging.info("Dropout %s: keep: %f " % (self.name, self.keep))
+        logging.info("Dropout %s: p: %f " % (self.name, self.p))
 
     def __repr__(self):
-        s = ('{classname}(keep={keep}')
+        s = ('{classname}(p={p}')
         if self.name is not None:
             s += ', name=\'{name}\''
         s += ')'
         return s.format(classname=self.__class__.__name__, **self.__dict__)
 
     def build(self, inputs_shape=None):
-        self.dropout = tlx.ops.Dropout(keep=self.keep, seed=self.seed)
+        self.dropout = tlx.ops.Dropout(p=self.p, seed=self.seed)
 
     def forward(self, inputs):
         if self.is_train:
@@ -242,7 +249,8 @@ Get entire CNN
   from examples.model_zoo import vgg16
 
   vgg = vgg16(pretrained=True)
-  img = tlx.utils.visualize.read_image('data/tiger.jpeg')
-  img = tlx.utils.prepro.imresize(img, (224, 224)).astype(tlx.float32) / 255
+  img = tlx.vision.load_image('data/tiger.jpeg')
+  img = tlx.utils.functional.resize(img, (224, 224), method='bilinear')
+  img = tlx.ops.convert_to_tensor(img, dtype = 'float32') / 255.
   output = vgg(img, is_train=False)