Add_Tensor.T_and_Tensor.t()_ops

docs/source/oneflow.rst

@@ -138,6 +138,7 @@ oneflow
             tile, 
             to, 
             transpose,
+            t,
             tril, 
             unsqueeze, 
             permute,

docs/source/tensor.rst

@@ -161,6 +161,8 @@ OneFlow Tensor Class
             tril, 
             triu, 
             type_as, 
+            t,
+            T,
             unfold, 
             uniform_, 
             unsqueeze, 

oneflow/api/python/framework/doc.cpp

@@ -50,6 +50,8 @@ py::object AddFunctionDoc(py::object f, const std::string& doc_string) {
       }
     }
     py::setattr(f, "__doc__", py::reinterpret_steal<py::object>(PyUnicode_FromString(doc_str)));
+  } else if (Py_TYPE(obj)->tp_name == PyProperty_Type.tp_name) {
+    py::setattr(f, "__doc__", py::reinterpret_steal<py::object>(PyUnicode_FromString(doc_str)));
   } else {
     THROW(RuntimeError) << "function is " << Py_TYPE(obj)->tp_name << ", not a valid function.";
   }

oneflow/core/functional/functional_api.yaml

@@ -299,6 +299,14 @@
   signature: "Tensor (Tensor input, Int32List dims) => Permute"
   bind_python: True
 
+- name: "T"
+  signature: "Tensor (Tensor input) => TransposeAllDimProperty"
+  bind_python: True
+
+- name: "t"
+  signature: "Tensor (Tensor input) => TransposeAllDimFunction"
+  bind_python: True 
+
 - name: "reciprocal"
   signature: "Tensor (Tensor x) => Reciprocal"
   bind_python: True

oneflow/core/functional/impl/array_functor.cpp

@@ -2523,6 +2523,35 @@ class GenTensorBufferFunctor {
   std::shared_ptr<OpExpr> op_;
 };
 
+class TransposeAllDimPropertyFunctor {
+ public:
+  TransposeAllDimPropertyFunctor() {}
+  Maybe<Tensor> operator()(const std::shared_ptr<one::Tensor>& x) const {
+    const int64_t ndim = x->shape()->NumAxes();
+    std::vector<int32_t> permute;
+    permute.resize(ndim);
+    std::iota(permute.begin(), permute.end(), 0);
+    std::reverse(permute.begin(), permute.end());
+    return Transpose(x, permute);
+  }
+};
+
+class TransposeAllDimFunctionFunctor {
+ public:
+  TransposeAllDimFunctionFunctor() {}
+  Maybe<Tensor> operator()(const std::shared_ptr<one::Tensor>& x) const {
+    const int64_t ndim = x->shape()->NumAxes();
+    CHECK_OR_RETURN(ndim <= 2)
+        << "RuntimeError: t() expects a tensor with <= 2 dimensions, but self is " 
+        << ndim << "D";
+    std::vector<int32_t> permute;
+    permute.resize(ndim);
+    std::iota(permute.begin(), permute.end(), 0);
+    std::reverse(permute.begin(), permute.end());
+    return Transpose(x, permute);
+  }
+};
+
 }  // namespace impl
 
 ONEFLOW_FUNCTION_LIBRARY(m) {
@@ -2626,6 +2655,8 @@ ONEFLOW_FUNCTION_LIBRARY(m) {
   m.add_functor<impl::TensorToTensorBufferFunctor>("TensorToTensorBuffer");
   m.add_functor<impl::TensorBufferToTensorFunctor>("TensorBufferToTensor");
   m.add_functor<impl::GenTensorBufferFunctor>("GenTensorBuffer");
+  m.add_functor<impl::TransposeAllDimPropertyFunctor>("TransposeAllDimProperty");
+  m.add_functor<impl::TransposeAllDimFunctionFunctor>("TransposeAllDimFunction");
 };
 
 }  // namespace functional

python/oneflow/__init__.py

@@ -174,7 +174,7 @@ def is_deprecated(func_or_class):
 from oneflow._C import erfinv, erfinv_
 from oneflow._C import cumsum
 from oneflow._C import swapaxes
-
+from oneflow._C import t
 
 from . import sbp
 import atexit

python/oneflow/framework/docstr/__init__.py

@@ -45,3 +45,4 @@
 from .clamp import *
 from .erfinv import *
 from .swapaxes import *
+from .tensor_t import *

python/oneflow/framework/docstr/tensor.py

@@ -782,3 +782,21 @@
     Alias for :func:`oneflow.Tensor.clamp_`. 
     """,
 )
+
+add_docstr(
+    oneflow.Tensor.t,
+    """
+    Tensor.t() → Tensor
+
+    See :func:`oneflow.t`
+    """,
+)
+
+add_docstr(
+    oneflow.Tensor.T,
+    """
+    Is this Tensor with its dimensions reversed.
+
+    If `n` is the number of dimensions in `x`, `x.T` is equivalent to `x.permute(n-1, n-2, ..., 0)`.
+    """,
+)

python/oneflow/framework/docstr/tensor_t.py

@@ -0,0 +1,61 @@
+"""
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+import oneflow
+from oneflow.framework.docstr.utils import add_docstr
+
+add_docstr(
+    oneflow.t,
+    """
+    oneflow.t(input) → Tensor.
+
+        Expects `input` to be <= 2-D tensor and transposes dimensions 0 and 1. 
+
+        0-D and 1-D tensors are returned as is. When input is a 2-D tensor this is equivalent to `transpose(input, 0, 1)`.
+
+    Args:
+        input (oneflow.Tensor): An input tensor.   
+
+    For example:
+
+    .. code-block:: python
+
+        >>> import oneflow as flow
+        >>> import numpy as np
+
+        >>> x = flow.randn()
+        >>> x
+        tensor(-0.2048, dtype=oneflow.float32)
+        >>> flow.t(x)
+        tensor(-0.2048, dtype=oneflow.float32)
+        >>> x = flow.randn(3)
+        >>> x
+        tensor([ 0.5034, -0.4999,  0.2721], dtype=oneflow.float32)
+        >>> flow.t(x)
+        tensor([ 0.5034, -0.4999,  0.2721], dtype=oneflow.float32)
+        >>> x = flow.randn(2,3)
+        >>> x
+        tensor([[ 0.1939,  0.6988,  1.0040],
+                [-0.2530, -1.5002,  0.1415]], dtype=oneflow.float32)
+        >>> y = flow.t(x)
+        >>> y
+        tensor([[ 0.1939, -0.2530],
+                [ 0.6988, -1.5002],
+                [ 1.0040,  0.1415]], dtype=oneflow.float32)
+        >>> y.shape
+        oneflow.Size([3, 2])
+
+    """,
+)

python/oneflow/framework/tensor.py

@@ -745,6 +745,14 @@ def _gather(self, dim, index):
     return flow._C.dim_gather(self, dim, index, False)
 
 
+def _T(self):
+    return flow._C.T(self)
+
+
+def _t(self):
+    return flow._C.t(self)
+
+
 def _numpy(self):
     assert (
         not self.is_lazy
@@ -915,6 +923,8 @@ def RegisterMethods():
     Tensor.gather = _gather
     Tensor.all = _all
     Tensor.any = _any
+    Tensor.T = property(_T)
+    Tensor.t = _t
 
 
 def register_tensor_op(op_name):

python/oneflow/test/modules/test_t.py

@@ -0,0 +1,40 @@
+"""
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import unittest
+from collections import OrderedDict
+
+import numpy as np
+
+from oneflow.test_utils.automated_test_util import *
+from test_util import GenArgList
+
+import oneflow as flow
+import oneflow.unittest
+
+
+@flow.unittest.skip_unless_1n1d()
+class TestTransposeAllDimFunction(flow.unittest.TestCase):
+    @autotest(check_graph=True)
+    def test_t_flow_with_random_data(test_case):
+        device = random_device()
+        x = random_pytorch_tensor(ndim=random(1, 2)).to(device)
+        y = torch.t(x)
+        return y
+
+
+if __name__ == "__main__":
+    unittest.main()

python/oneflow/test/tensor/test_tensor.py

@@ -899,6 +899,20 @@ def test_transpose_tensor_with_random_data(test_case):
         x = random_pytorch_tensor(ndim=4).to(device)
         y = x.transpose(dim0=random(1, 3).to(int), dim1=random(1, 3).to(int))
         return y
+
+    @autotest(check_graph=True)
+    def test_t_tensor_with_random_data(test_case):
+        device = random_device()
+        x = random_pytorch_tensor(ndim=random(1, 2)).to(device)
+        y = x.t()
+        return y
+
+    @autotest(check_graph=True)
+    def test_T_tensor_with_random_data(test_case):
+        device = random_device()
+        x = random_pytorch_tensor(ndim=random(1, 4)).to(device)
+        y = x.T
+        return y
 
     @flow.unittest.skip_unless_1n1d()
     def test_tensor_where(test_case):