align reshape input param with pytorch

python/oneflow/nn/modules/batchnorm.py

@@ -129,12 +129,12 @@ def forward(self, x):
             if len(mean.shape) == 1:
                 nd_params_shape = [1] * len(x.shape)
                 nd_params_shape[axis] = params_shape[0]
-                mean = mean.reshape(shape=nd_params_shape)
-                variance = variance.reshape(shape=nd_params_shape)
+                mean = flow.reshape(mean, shape=nd_params_shape)
+                variance = flow.reshape(variance, shape=nd_params_shape)
                 if self.weight and params_shape[0] == self.weight.nelement():
-                    weight = self.weight.reshape(shape=nd_params_shape)
+                    weight = flow.reshape(self.weight, shape=nd_params_shape)
                 if self.bias and params_shape[0] == self.bias.nelement():
-                    bias = self.bias.reshape(shape=nd_params_shape)
+                    bias = flow.reshape(self.bias, shape=nd_params_shape)
             elif len(mean.shape) == len(x.shape):
                 pass
             else:

python/oneflow/nn/modules/instancenorm.py

@@ -39,9 +39,9 @@ def _forward(self, x):
         variance = x.var(2, keepdim=True)
         normalized = (x - mean) / flow.sqrt(variance + self.eps)
         if self.weight and params_shape[0] == self.weight.nelement():
-            weight = self.weight.reshape(shape=nd_params_shape)
+            weight = flow.reshape(self.weight, shape=nd_params_shape)
         if self.bias and params_shape[0] == self.bias.nelement():
-            bias = self.bias.reshape(shape=nd_params_shape)
+            bias = flow.reshape(self.bias, shape=nd_params_shape)
         if self.weight:
             normalized = normalized * weight
         if self.bias:
@@ -50,9 +50,9 @@ def _forward(self, x):
 
     def forward(self, x):
         self._check_input_dim(x)
-        reshape_to_1d = x.reshape([x.shape[0], x.shape[1], -1])
+        reshape_to_1d = flow.reshape(x, [x.shape[0], x.shape[1], -1])
         normalized_1d_out = self._forward(reshape_to_1d)
-        reshape_back_to_nd = normalized_1d_out.reshape(list(x.shape))
+        reshape_back_to_nd = flow.reshape(normalized_1d_out, list(x.shape))
         return reshape_back_to_nd
 
 

python/oneflow/nn/modules/loss.py

@@ -181,7 +181,7 @@ def forward(self, input, target):
         if input_shape_len == 3:
             (b, c, h) = (input.shape[0], input.shape[1], input.shape[2])
             input = flow.F.transpose(input, perm=(0, 2, 1))
-            input = input.reshape(shape=[-1, input.shape[2]])
+            input = flow.reshape(input, shape=[-1, input.shape[2]])
             target = target.flatten()
         elif input_shape_len == 4:
             (b, c, h, w) = (
@@ -191,7 +191,7 @@ def forward(self, input, target):
                 input.shape[3],
             )
             input = flow.F.transpose(input, perm=(0, 2, 3, 1))
-            input = input.reshape(shape=[-1, input.shape[3]])
+            input = flow.reshape(input, shape=[-1, input.shape[3]])
             target = target.flatten()
         elif input_shape_len >= 5:
             raise NotImplemented
@@ -423,10 +423,10 @@ def forward(self, input, target):
         elif len(input.shape) == 3:
             (b, c, h) = (input.shape[0], input.shape[1], input.shape[2])
             input = flow.F.transpose(input, perm=(0, 2, 1))
-            input = input.reshape(shape=[-1, input.shape[2]])
+            input = flow.reshape(input, shape=[-1, input.shape[2]])
             target = target.flatten()
             res = self.nllloss_1d(input, target)
-            res = res.reshape((b, h))
+            res = res.reshape(b, h)
         elif len(input.shape) == 4:
             (b, c, h, w) = (
                 input.shape[0],
@@ -435,10 +435,10 @@ def forward(self, input, target):
                 input.shape[3],
             )
             input = flow.F.transpose(input, perm=(0, 2, 3, 1))
-            input = input.reshape(shape=[-1, input.shape[3]])
+            input = input.reshape(-1, input.shape[3])
             target = target.flatten()
             res = self.nllloss_1d(input, target)
-            res = res.reshape((b, h, w))
+            res = res.reshape(b, h, w)
         else:
             raise NotImplemented
         if self.ignore_index is not None:
@@ -447,7 +447,7 @@ def forward(self, input, target):
             ones = flow.ones(
                 condition.shape, dtype=condition.dtype, device=condition.device
             )
-            condition = ones.sub(condition).reshape(tuple(res.shape))
+            condition = flow.reshape(ones.sub(condition), tuple(res.shape))
             res = flow.where(condition, res, zeros)
             if self.reduction == "mean":
                 res = res.sum()

python/oneflow/nn/modules/meshgrid.py

@@ -42,7 +42,7 @@ def forward(self, inputs):
         for i in range(size):
             view_shape = [1] * size
             view_shape[i] = -1
-            outputs.append(inputs[i].reshape(view_shape).expand(*shape))
+            outputs.append(flow.reshape(inputs[i], view_shape).expand(*shape))
         return outputs
 
 

python/oneflow/nn/modules/norm.py

@@ -241,7 +241,7 @@ def norm_op(input, ord=None, dim=None, keepdim=False):
         >>> a = flow.tensor(np.arange(9, dtype=np.float32) - 4)
         >>> a
         tensor([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.], dtype=oneflow.float32)
-        >>> b = a.reshape((3, 3))
+        >>> b = a.reshape(3, 3)
         >>> b
         tensor([[-4., -3., -2.],
                 [-1.,  0.,  1.],
@@ -293,7 +293,7 @@ def norm_op(input, ord=None, dim=None, keepdim=False):
 
     Using the :attr:`dim` argument to compute matrix norms::
 
-        >>> m = flow.tensor(np.arange(8, dtype=np.float32)).reshape((2, 2, 2))
+        >>> m = flow.tensor(np.arange(8, dtype=np.float32)).reshape(2, 2, 2)
         >>> LA.norm(m, dim=(1,2))
         tensor([ 3.7417, 11.225 ], dtype=oneflow.float32)
     """
@@ -360,7 +360,7 @@ def vector_norm_tensor_op(input, ord=2, dim=None, keepdim=False):
         >>> a = flow.tensor(np.arange(9, dtype=np.float32) - 4)
         >>> a
         tensor([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.], dtype=oneflow.float32)
-        >>> b = a.reshape((3, 3))
+        >>> b = a.reshape(3, 3)
         >>> b
         tensor([[-4., -3., -2.],
                 [-1.,  0.,  1.],
@@ -419,7 +419,7 @@ def matrix_norm_tensor_op(input, ord="fro", dim=(-2, -1), keepdim=False):
         >>> import oneflow as flow
         >>> from oneflow import linalg as LA
         >>> import numpy as np
-        >>> a = flow.tensor(np.arange(9, dtype=np.float32)).reshape((3,3))
+        >>> a = flow.tensor(np.arange(9, dtype=np.float32)).reshape(3,3)
         >>> a
         tensor([[0., 1., 2.],
                 [3., 4., 5.],

python/oneflow/nn/modules/normalization.py

@@ -267,12 +267,12 @@ def forward(self, x):
             if len(mean.shape) == 1:
                 nd_params_shape = [1] * len(x.shape)
                 nd_params_shape[self.begin_norm_axis] = params_shape[0]
-                mean = mean.reshape(shape=nd_params_shape)
-                variance = variance.reshape(shape=nd_params_shape)
+                mean = flow.reshape(mean, shape=nd_params_shape)
+                variance = flow.reshape(variance, nd_params_shape)
                 if self.weight and params_shape[0] == self.weight.nelement():
-                    weight = self.weight.reshape(shape=nd_params_shape)
+                    weight = flow.reshape(self.weight, shape=nd_params_shape)
                 if self.bias and params_shape[0] == self.bias.nelement():
-                    bias = self.bias.reshape(shape=nd_params_shape)
+                    bias = flow.reshape(self.bias, shape=nd_params_shape)
             elif len(mean.shape) == len(x.shape):
                 pass
             else:

python/oneflow/nn/modules/pixelshuffle.py

@@ -115,32 +115,26 @@ def forward(self, input: Tensor) -> Tensor:
         ), "The channels of input tensor must be divisible by (upscale_factor * upscale_factor) or (h_upscale_factor * w_upscale_factor)"
         _new_c = int(_channel / (self.h_upscale_factor * self.w_upscale_factor))
         out = input.reshape(
-            [
-                _batch,
-                _new_c,
-                self.h_upscale_factor * self.w_upscale_factor,
-                _height,
-                _width,
-            ]
+            _batch,
+            _new_c,
+            self.h_upscale_factor * self.w_upscale_factor,
+            _height,
+            _width,
         )
         out = out.reshape(
-            [
-                _batch,
-                _new_c,
-                self.h_upscale_factor,
-                self.w_upscale_factor,
-                _height,
-                _width,
-            ]
+            _batch,
+            _new_c,
+            self.h_upscale_factor,
+            self.w_upscale_factor,
+            _height,
+            _width,
         )
         out = out.permute(0, 1, 4, 2, 5, 3)
         out = out.reshape(
-            [
-                _batch,
-                _new_c,
-                _height * self.h_upscale_factor,
-                _width * self.w_upscale_factor,
-            ]
+            _batch,
+            _new_c,
+            _height * self.h_upscale_factor,
+            _width * self.w_upscale_factor,
         )
         return out
 

python/oneflow/nn/modules/reshape.py

@@ -29,7 +29,6 @@ def _input_args_is_flow_size(args):
     return all((isinstance(x, flow.Size) for x in args)) and len(args) == 1
 
 
-@register_tensor_op("reshape")
 def reshape_op(input, shape: Sequence[int] = None):
     """This operator reshapes a Tensor.
 
@@ -60,6 +59,41 @@ def reshape_op(input, shape: Sequence[int] = None):
     return flow.F.reshape(input, shape)
 
 
+@register_tensor_op("reshape")
+def reshape_tensor_op(input, *shape):
+    """This operator reshapes a Tensor.
+
+    We can set one dimension in `shape` as `-1`, the operator will infer the complete shape.
+
+    Args:
+        x: A Tensor.
+        *shape: tuple of python::ints or int...
+    Returns:
+        A Tensor has the same type as `x`.
+
+    For example:
+
+    .. code-block:: python
+
+        >>> import numpy as np
+        >>> import oneflow as flow
+        >>> x = np.array(
+        ...    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+        ... ).astype(np.float32)
+        >>> input = flow.Tensor(x)
+
+        >>> y = input.reshape(2, 2, 2, -1).shape
+        >>> y
+        flow.Size([2, 2, 2, 2])
+
+    """
+    if _input_args_is_int(shape):
+        new_shape = _single(shape)
+    else:
+        raise ValueError("the input shape parameter of reshape is not illegal!")
+    return flow.F.reshape(input, new_shape)
+
+
 @register_tensor_op("view")
 def view_op(input, *shape):
     """

python/oneflow/test/dataloader/test_fashion_mnist_dataset.py

@@ -80,7 +80,7 @@ def __init__(self):
         super(FlattenLayer, self).__init__()
 
     def forward(self, x):  # x shape: (batch, *, *, ...)
-        res = x.reshape(shape=[x.shape[0], -1])
+        res = x.reshape(x.shape[0], -1)
         return res
 
 

python/oneflow/test/tensor/test_tensor.py

@@ -578,15 +578,15 @@ def _test_tensor_reshape(test_case):
             [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
         ).astype(np.float32)
         input = flow.Tensor(x)
-        of_shape = input.reshape(shape=[2, 2, 2, -1]).numpy().shape
+        of_shape = input.reshape(2, 2, 2, -1).numpy().shape
         np_shape = (2, 2, 2, 2)
         test_case.assertTrue(np.array_equal(of_shape, np_shape))
 
     @autotest()
     def test_reshape_tensor_with_random_data(test_case):
         device = random_device()
         x = random_pytorch_tensor(ndim=4).to(device)
-        y = x.reshape(shape=(-1,))
+        y = x.reshape(-1,)
         return y
 
     @autotest()

python/oneflow/utils/vision/datasets/mnist.py

@@ -290,7 +290,7 @@ def read_sn3_pascalvincent_tensor(path: str, strict: bool = True) -> Tensor:
     s = [get_int(data[4 * (i + 1) : 4 * (i + 2)]) for i in range(nd)]
     parsed = np.frombuffer(data, dtype=m[1], offset=(4 * (nd + 1)))
     assert parsed.shape[0] == np.prod(s) or not strict
-    return Tensor(parsed.astype(m[2]), dtype=m[0]).reshape(shape=s)
+    return flow.reshape(Tensor(parsed.astype(m[2]), dtype=m[0]), shape=s)
 
 
 def read_label_file(path: str) -> Tensor:

python/oneflow/utils/vision/transforms/functional.py

@@ -132,7 +132,7 @@ def to_tensor(pic):
     if pic.mode == "1":
         img = 255 * img
 
-    img = img.reshape(shape=(pic.size[1], pic.size[0], len(pic.getbands())))
+    img = flow.reshape(img, shape=(pic.size[1], pic.size[0], len(pic.getbands())))
     # put it from HWC to CHW format
     res = img.permute(2, 0, 1)
     if img.dtype == flow.int:
@@ -189,9 +189,9 @@ def normalize(
             )
         )
     if mean.ndim == 1:
-        mean = mean.reshape(shape=(-1, 1, 1))
+        mean = mean.reshape(-1, 1, 1)
     if std.ndim == 1:
-        std = std.reshape(shape=(-1, 1, 1))
+        std = std.reshape(-1, 1, 1)
     tensor = tensor.sub(mean).div(std)
     # tensor.sub_(mean).div_(std)
     return tensor