add roll and logsoftmax

Author: hanjr92

docs/index.rst

@@ -25,7 +25,7 @@ User Guide
 ------------
 
 The TensorLayerX user guide explains how to install TensorFlow, CUDA and cuDNN,
-how to build and train neural networks using TensorLayer3, and how to contribute
+how to build and train neural networks using TensorLayerX, and how to contribute
 to the library as a developer.
 
 .. toctree::

docs/modules/activation.rst

@@ -47,6 +47,7 @@ activation list
    Sigmoid
    Softmax
    Mish
+   LogSoftmax
 
 TensorLayerX Activations
 --------------------------------
@@ -119,6 +120,9 @@ Softmax
 ---------
 .. autoclass:: Softmax
 
+LogSoftmax
+---------
+.. autoclass:: LogSoftmax
 
 Parametric activation
 ------------------------------

docs/modules/ops.rst

@@ -121,6 +121,8 @@ API - Operations
    set_device
    get_device
    to_device
+   roll
+   logsoftmax
 
 TensorLayerX Tensor Operations
 --------------------------------
@@ -583,4 +585,12 @@ get_device
 
 to_device
 ^^^^^^^^^^^^^^^^^^^^^^^
-.. autofunction:: to_device
+.. autofunction:: to_device
+
+roll
+^^^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: roll
+
+logsoftmax
+^^^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: logsoftmax

tensorlayerx/backend/__init__.py

@@ -152,6 +152,8 @@
 from .ops import get_device
 from .ops import scatter_update
 from .ops import to_device
+from .ops import logsoftmax
+from .ops import roll
 # dtype
 from .ops import (
     DType, float16, float32, float64, int8, int16, int32, int64, uint8, uint16, uint32, uint64, bool, complex64,

tensorlayerx/backend/ops/__init__.py

@@ -204,6 +204,8 @@
 from .load_backend import get_device
 from .load_backend import scatter_update
 from .load_backend import to_device
+from .load_backend import roll
+from .load_backend import logsoftmax
 # dtype
 from .load_backend import (
     DType, float16, float32, float64, int8, int16, int32, int64, uint8, uint16, uint32, uint64, bool, complex64,

tensorlayerx/backend/ops/mindspore_backend.py

@@ -1880,3 +1880,13 @@ def get_device():
 def to_device(tensor, device = 'GPU', id = 0):
 
     return tensor
+
+def roll(input, shifts, dims=None):
+
+    return msnp.roll(input, shifts, dims)
+
+def logsoftmax(input, dim = None):
+    if dim is None:
+        dim = -1
+    log_softmax = P.LogSoftmax(dim)
+    return log_softmax(input)

tensorlayerx/backend/ops/paddle_backend.py

@@ -1909,4 +1909,13 @@ def to_device(tensor, device = 'GPU', id = 0):
     if device == 'GPU':
         return paddle.to_tensor(tensor, place=paddle.CUDAPlace(id))
     if device == 'CPU':
-        return paddle.to_tensor(tensor, place=paddle.CPUPlace())
+        return paddle.to_tensor(tensor, place=paddle.CPUPlace())
+
+def roll(input, shifts, dims=None):
+
+    return paddle.roll(input, shifts, dims)
+
+def logsoftmax(input, dim = None):
+    if dim is None:
+        dim = -1
+    return F.log_softmax(input, dim)

tensorlayerx/backend/ops/tensorflow_backend.py

@@ -3980,3 +3980,58 @@ def to_device(tensor, device = 'GPU', id = 0):
         return tensor
     with tf.device("/" + device.upper()+':'+str(id)):
         return tf.identity(tensor)
+
+def roll(input, shifts, dims=None):
+    """Roll the tensor input along the given dimension(s).
+    Elements that are shifted beyond the last position are re-introduced at the first position.
+    If dims is None, the tensor will be flattened before rolling and then restored to the original shape.
+
+    Parameters
+    ----------
+    input : tensor
+        the input tensor.
+    shifts : int or tuple
+        The number of places by which the elements of the tensor are shifted.
+        If shifts is a tuple, dims must be a tuple of the same size, and each dimension will be rolled by the corresponding value
+    dims : int or tuple
+        Axis along which to roll
+
+    Examples
+    ---------
+    >>> import tensorlayerx as tlx
+    >>> x = tlx.ops.ones((5,6))
+    >>> x = tlx.ops.roll(x, shifts=2)
+
+    """
+    if dims is None:
+        raw_shape = input.shape
+        shape = 1
+        for d in input.shape:
+            shape *= d
+        input = tf.reshape(input, [1, shape])
+        output = tf.roll(input, shifts, 1)
+        output = tf.reshape(output, raw_shape)
+        return output
+    return tf.roll(input, shifts, dims)
+
+def logsoftmax(input, dim = None):
+    """Applies a softmax followed by a logarithm.
+
+    Parameters
+    ----------
+    input : Tensor
+        the input tensor.
+    dim : int
+        A dimension along which LogSoftmax will be computed.
+
+
+    Examples
+    ---------
+    >>> import tensorlayerx as tlx
+    >>> import numpy as np
+    >>> x = tlx.ops.convert_to_tensor(np.random.random((3,4)))
+    >>> x = tlx.ops.logsoftmax(x, dim=1)
+
+    """
+
+    return tf.nn.log_softmax(input, dim)

tensorlayerx/backend/ops/torch_backend.py

@@ -1726,4 +1726,13 @@ def to_device(tensor, device='GPU', id=0):
     if device == 'gpu':
         device = 'cuda' + ':' + str(id)
     tensor = tensor.detach().to(device)
-    return tensor
+    return tensor
+
+def roll(input, shifts, dims=None):
+
+    return torch.roll(input, shifts, dims)
+
+
+def logsoftmax(input, dim=None):
+
+    return F.log_softmax(input, dim)

tensorlayerx/nn/layers/activation.py

@@ -7,7 +7,7 @@
 
 __all__ = [
     'ELU', 'PRelu', 'PRelu6', 'PTRelu6', 'ReLU', 'ReLU6', 'Softplus', 'LeakyReLU', 'LeakyReLU6', 'LeakyTwiceRelu6',
-    'Ramp', 'Swish', 'HardTanh', 'Mish', 'Tanh', 'Sigmoid', 'Softmax'
+    'Ramp', 'Swish', 'HardTanh', 'Mish', 'Tanh', 'Sigmoid', 'Softmax', 'LogSoftmax'
 ]
 
 
@@ -914,3 +914,42 @@ def forward(self, x):
             self._add_node(x, outputs)
             self._nodes_fixed = True
         return outputs
+
+class LogSoftmax(Module):
+    r"""Applies a softmax followed by a logarithm.
+
+        .. math::
+        \text{LogSoftmax}(x_{i}) = \log\left(\frac{\exp(x_i) }{ \sum_j \exp(x_j)} \right)
+
+
+        Parameters
+        ----------
+        x : Tensor
+            input.
+        dim : int
+            A dimension along which LogSoftmax will be computed.
+
+        Examples
+        --------
+        >>> net = tlx.nn.Input([10, 200])
+        >>> net = tlx.nn.LogSoftmax()(net)
+
+        Returns
+        -------
+        Tensor
+            A ``Tensor`` in the same type as ``x``.
+
+    """
+
+    def __init__(self, dim = None):
+        super(LogSoftmax, self).__init__()
+        self.dim = dim
+        self._built = True
+
+    def forward(self, x):
+        outputs = tlx.ops.logsoftmax(x, self.dim)
+
+        if not self._nodes_fixed and self._build_graph:
+            self._add_node(x, outputs)
+            self._nodes_fixed = True
+        return outputs