Fix autotest inplace bug, hardsigmod

docs/source/oneflow.rst

@@ -147,6 +147,7 @@ oneflow
             zeros, 
             zeros_like,
             is_nonzero,
+            is_tensor,
             no_grad,
             grad_enable,
             inference_mode,

python/oneflow/__init__.py

@@ -296,6 +296,7 @@ def atexit_hook(hook):
     adaptive_avg_pool2d,
     adaptive_avg_pool3d,
 )
+from oneflow.nn.modules.is_tensor import is_tensor_op as is_tensor
 from oneflow.nn.modules.arange import arange_op as arange
 from oneflow.nn.modules.linspace import linspace_op as linspace
 from oneflow.nn.modules.argsort import argsort_op as argsort

python/oneflow/nn/modules/is_tensor.py

@@ -0,0 +1,43 @@
+"""
+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 as flow
+
+
+def is_tensor_op(obj):
+    r"""
+    is_tensor(input) -> (bool)
+
+    Note that this function is simply doing ``isinstance(obj, Tensor)``.
+    Using that ``isinstance`` check is better for typechecking with mypy,
+    and more explicit - so it's recommended to use that instead of
+    ``is_tensor``.
+
+    Args:
+        obj (Object): Object to test
+
+    For example:
+
+    .. code-block:: python
+
+        >>> import oneflow as flow
+
+        >>> x=flow.tensor([1,2,3])
+        >>> flow.is_tensor(x)
+        True
+
+    """
+    return isinstance(obj, flow.Tensor)

python/oneflow/test/modules/test_activation.py

@@ -256,7 +256,7 @@ def test_hardsigmoid_module_with_random_data(test_case):
         y = m(x)
         return y
 
-    @autotest(check_graph=False)
+    @autotest(check_graph=True)
     def test_functional_hardsigmoid_with_random_data(test_case):
         device = random_device()
         x = random_pytorch_tensor().to(device)

python/oneflow/test_utils/automated_test_util/torch_flow_dual_object.py

@@ -18,6 +18,7 @@
 import inspect
 import os
 import warnings
+import copy
 
 import numpy as np
 import oneflow as flow
@@ -317,6 +318,19 @@ def dual_method(self, *args, **kwargs):
                         if name in postulate:
                             oneflow_res = torch_tensor_to_flow(pytorch_res)
                         else:
+                            graph_args = []
+                            for arg in oneflow_args:
+                                if flow.is_tensor(arg):
+                                    copy_arg = arg.clone().detach()
+                                else:
+                                    copy_arg = copy.deepcopy(arg)
+                                graph_args.append(copy_arg)
+                            graph_kwargs = {}
+                            for key, value in oneflow_kwargs.items():
+                                if flow.is_tensor(value):
+                                    graph_kwargs[key] = value.clone().detach()
+                                else:
+                                    graph_kwargs[key] = copy.deepcopy(value)
                             oneflow_res = oneflow(*oneflow_args, **oneflow_kwargs)
                             if testing_graph:
                                 find_check_module_func = True
@@ -336,7 +350,8 @@ def build(self, *args):
                                     if verbose:
                                         print("Run graph of module: ", repr(oneflow))
                                         test_g.debug(3)
-                                    test_g_res = test_g(*oneflow_args)
+                                    # When testing module methods, kwargs are not considered.
+                                    test_g_res = test_g(*graph_args)
                                 elif oneflow.__name__ in ignore_apis_list:
                                     find_check_module_func = False
                                 # 1. "oneflow.nn.modules" not in oneflow.__module__: For avoid run nn.Module branch graph test, like fold op call Fold Module actually.
@@ -356,9 +371,7 @@ def __init__(self):
                                             super().__init__()
 
                                         def build(self):
-                                            return oneflow(
-                                                *oneflow_args, **oneflow_kwargs
-                                            )
+                                            return oneflow(*graph_args, **graph_kwargs)
 
                                     try:
                                         # When the tensor on the cpu executes to to the cpu in nn.Graph, a check error will be reported.
@@ -446,6 +459,19 @@ def dual_method(self, *args, **kwargs):
                                     "PyTorch has an error but OneFlow is ok, maybe you should check your implementation to align with PyTorch."
                                 )
                             raise PyTorchDoesNotSupportError(e)
+                        tensor_graph_args = []
+                        for arg in oneflow_args:
+                            if flow.is_tensor(arg):
+                                copy_arg = arg.clone().detach()
+                            else:
+                                copy_arg = copy.deepcopy(arg)
+                            tensor_graph_args.append(copy_arg)
+                        tensor_graph_kwargs = {}
+                        for key, value in oneflow_kwargs.items():
+                            if flow.is_tensor(value):
+                                tensor_graph_kwargs[key] = value.clone().detach()
+                            else:
+                                tensor_graph_kwargs[key] = copy.deepcopy(value)
                         oneflow_res = oneflow_method(*oneflow_args, **oneflow_kwargs)
                         if testing_graph:
 
@@ -455,7 +481,7 @@ def __init__(self):
 
                                 def build(self):
                                     return oneflow_method(
-                                        *oneflow_args, **oneflow_kwargs
+                                        *tensor_graph_args, **tensor_graph_kwargs
                                     )
 
                             try: