From 9a74c4489f350ad76e737e09ea177cca1cd9411e Mon Sep 17 00:00:00 2001 From: JiabinYang Date: Mon, 29 Oct 2018 05:26:40 +0000 Subject: [PATCH] test=develop --- paddle/fluid/operators/space_to_depth_op.cc | 34 +++++++++---------- paddle/fluid/operators/space_to_depth_op.h | 26 +++++++------- python/paddle/fluid/layers/nn.py | 22 ++++++------ .../tests/unittests/test_space_to_depth_op.py | 28 +++++++-------- 4 files changed, 55 insertions(+), 55 deletions(-) diff --git a/paddle/fluid/operators/space_to_depth_op.cc b/paddle/fluid/operators/space_to_depth_op.cc index 1cc169bf10..f109dd685c 100644 --- a/paddle/fluid/operators/space_to_depth_op.cc +++ b/paddle/fluid/operators/space_to_depth_op.cc @@ -31,31 +31,31 @@ class SpaceToDepthOp : public framework::OperatorWithKernel { auto x_dims = ctx->GetInputDim("X"); PADDLE_ENFORCE_EQ(x_dims.size(), 4, "input should be a 4D tensor"); - auto stride = ctx->Attrs().Get("stride"); + auto blocksize = ctx->Attrs().Get("blocksize"); - PADDLE_ENFORCE_GT(stride, 1, "The stride should be Greater than 1"); + PADDLE_ENFORCE_GT(blocksize, 1, "The blocksize should be Greater than 1"); PADDLE_ENFORCE_GT(x_dims[1], 0, "input channel should be Greater than 0"); PADDLE_ENFORCE_GT(x_dims[2], 0, "input Height should be Greater than 0"); PADDLE_ENFORCE_GT(x_dims[3], 0, "input Width should be Greater than 0"); - PADDLE_ENFORCE_EQ(x_dims[1] % (stride * stride), 0, + PADDLE_ENFORCE_EQ(x_dims[1] % (blocksize * blocksize), 0, "input channel should be divisible of the square of " - "SpaceToDepthOp stride"); - PADDLE_ENFORCE_EQ(x_dims[2] % (stride), 0, + "SpaceToDepthOp blocksize"); + PADDLE_ENFORCE_EQ(x_dims[2] % (blocksize), 0, "input Height should be divisible of the square of " - "SpaceToDepthOp stride"); - PADDLE_ENFORCE_EQ(x_dims[3] % (stride), 0, + "SpaceToDepthOp blocksize"); + PADDLE_ENFORCE_EQ(x_dims[3] % (blocksize), 0, "input Width should be divisible of the square of " - "SpaceToDepthOp stride"); + "SpaceToDepthOp blocksize"); VLOG(3) << "SpaceToDepthOp operator x.shape=" << x_dims - << "Attribute stride" << stride << std::endl; + << "Attribute blocksize" << blocksize << std::endl; std::vector output_shape(4, 0); // [B,C,H,W] output_shape[0] = x_dims[0]; - output_shape[1] = x_dims[1] * stride * stride; - output_shape[2] = x_dims[2] / stride; - output_shape[3] = x_dims[3] / stride; + output_shape[1] = x_dims[1] * blocksize * blocksize; + output_shape[2] = x_dims[2] / blocksize; + output_shape[3] = x_dims[3] / blocksize; auto out_dims = framework::make_ddim(output_shape); @@ -80,20 +80,20 @@ class SpaceToDepthOpMaker : public framework::OpProtoAndCheckerMaker { "(Tensor), The output should be a 4D tensor B * C2 * W2 * H2 of " "SpaceToDepthOp operator."); AddAttr( - "stride", - "(int64_t, default 2) stride used to do change Space To Depth.") + "blocksize", + "(int64_t, default 2) blocksize used to do change Space To Depth.") .SetDefault(2) .GreaterThan(1); AddComment(R"DOC( reorg operator used in Yolo v2. - The equation is: C2 = C1/stride * stride, W2 = W1 ∗ stride + offset % stride, H2 = H1 ∗ stride + offset / stride, + The equation is: C2 = C1/blocksize * blocksize, W2 = W1 ∗ blocksize + offset % blocksize, H2 = H1 ∗ blocksize + offset / blocksize, - Reshape Input(X) into the shape according to Attr(stride). The + Reshape Input(X) into the shape according to Attr(blocksize). The data in Input(X) are unchanged. Examples: - 1. Given a 4-D tensor Input(X) with a shape [128, 2048, 26, 26], and the stride is 2, the reorg operator will transform Input(X) + 1. Given a 4-D tensor Input(X) with a shape [128, 2048, 26, 26], and the blocksize is 2, the reorg operator will transform Input(X) into a 4-D tensor with shape [128, 2048, 13, 13] and leaving Input(X)'s data unchanged. )DOC"); diff --git a/paddle/fluid/operators/space_to_depth_op.h b/paddle/fluid/operators/space_to_depth_op.h index 4fc24138e6..a71662b481 100644 --- a/paddle/fluid/operators/space_to_depth_op.h +++ b/paddle/fluid/operators/space_to_depth_op.h @@ -25,19 +25,19 @@ template class space_to_depth_compute { public: HOSTDEVICE space_to_depth_compute(const T *x, int64_t w, int64_t h, int64_t c, - int64_t batch, int64_t stride, + int64_t batch, int64_t blocksize, int64_t forward, T *out) : x_(x), w_(w), h_(h), c_(c), batch_(batch), - stride_(stride), + blocksize_(blocksize), forward_(forward), out_(out) {} HOSTDEVICE void operator()(int64_t in_index) { - int64_t out_c = c_ / (stride_ * stride_); + int64_t out_c = c_ / (blocksize_ * blocksize_); // calculate each dim position with index of tensor int64_t b = in_index / (c_ * h_ * w_); int64_t k = (in_index % (c_ * h_ * w_)) / (h_ * w_); @@ -46,10 +46,10 @@ class space_to_depth_compute { int64_t c2 = k % out_c; int64_t offset = k / out_c; - int64_t w2 = i * stride_ + offset % stride_; - int64_t h2 = j * stride_ + offset / stride_; + int64_t w2 = i * blocksize_ + offset % blocksize_; + int64_t h2 = j * blocksize_ + offset / blocksize_; int64_t out_index = - w2 + w_ * stride_ * (h2 + h_ * stride_ * (c2 + out_c * b)); + w2 + w_ * blocksize_ * (h2 + h_ * blocksize_ * (c2 + out_c * b)); if (forward_) out_[out_index] = x_[in_index]; else @@ -58,7 +58,7 @@ class space_to_depth_compute { private: const T *x_; - int64_t w_, h_, c_, batch_, stride_, forward_; + int64_t w_, h_, c_, batch_, blocksize_, forward_; T *out_; }; @@ -68,7 +68,7 @@ class SpaceToDepthKernel : public framework::OpKernel { void Compute(const framework::ExecutionContext &context) const override { auto *out = context.Output("Out"); auto *x = context.Input("X"); - auto stride = context.Attr("stride"); + auto blocksize = context.Attr("blocksize"); auto in_dims = x->dims(); out->mutable_data(context.GetPlace(), x->type()); @@ -83,8 +83,8 @@ class SpaceToDepthKernel : public framework::OpKernel { auto *x_data = x->data(); auto *out_data = out->data(); - paddle::operators::space_to_depth_compute computer(x_data, W, H, C, B, - stride, 1, out_data); + paddle::operators::space_to_depth_compute computer( + x_data, W, H, C, B, blocksize, 1, out_data); for_range(computer); out->Resize(out_dims); @@ -99,7 +99,7 @@ class SpaceToDepthGradKernel : public framework::OpKernel { context.Input(framework::GradVarName("Out")); auto *d_x = context.Output(framework::GradVarName("X")); - auto stride = context.Attr("stride"); + auto blocksize = context.Attr("blocksize"); auto in_dims = d_x->dims(); d_x->mutable_data(context.GetPlace(), d_out->type()); @@ -115,8 +115,8 @@ class SpaceToDepthGradKernel : public framework::OpKernel { auto *dx_data = d_x->data(); auto *dout_data = d_out->data(); - paddle::operators::space_to_depth_compute computer(dout_data, W, H, C, B, - stride, 0, dx_data); + paddle::operators::space_to_depth_compute computer( + dout_data, W, H, C, B, blocksize, 0, dx_data); for_range(computer); d_x->Resize(in_dims); diff --git a/python/paddle/fluid/layers/nn.py b/python/paddle/fluid/layers/nn.py index c762633c60..5659eafd04 100644 --- a/python/paddle/fluid/layers/nn.py +++ b/python/paddle/fluid/layers/nn.py @@ -7485,29 +7485,29 @@ def maxout(x, groups, name=None): return out -def space_to_depth(x, stride, name=None): +def space_to_depth(x, blocksize, name=None): """ - Gives a stride to space_to_depth the input LoDtensor + Gives a blocksize to space_to_depth the input LoDtensor with Layout: [batch, channel, height, width] - Rearranges blocks of spatial data, into depth. More specifically, this op outputs a copy of the + This op rearranges blocks of spatial data, into depth. More specifically, this op outputs a copy of the input LoDtensor where values from the height and width dimensions are moved to the channel dimension. - The attr stride indicates the input block size. + The attr blocksize indicates the input block size. space_to_depth will reorgnize the elements of input with shape[batch, channel, height, width] according - to stride to construct output with shape [batch, channel * stride * stride, height/stride, width/stride]: + to blocksize to construct output with shape [batch, channel * blocksize * blocksize, height/blocksize, width/blocksize]: space_to_depth is used to This operation is useful for resizing the activations between convolutions (but keeping all data) Args: x(variable): The input LoDtensor. - stride(variable): The stride to select the element on each feature map + blocksize(variable): The blocksize to select the element on each feature map Returns: Variable: The output LoDtensor. Raises: - TypeError: stride type must be a long. + TypeError: blocksize type must be a long. Examples: .. code-block:: python @@ -7515,13 +7515,13 @@ def space_to_depth(x, stride, name=None): data = fluid.layers.data( name='data', shape=[1, 4, 2, 2], dtype='float32') space_to_depthed = fluid.layers.space_to_depth( - x=data, stride=2) + x=data, blocksize=2) """ helper = LayerHelper("space_to_depth", **locals()) - if not (isinstance(stride, int)): - raise ValueError("stride must be a python Int") + if not (isinstance(blocksize, int)): + raise ValueError("blocksize must be a python Int") if name is None: out = helper.create_variable_for_type_inference( @@ -7533,7 +7533,7 @@ def space_to_depth(x, stride, name=None): helper.append_op( type="space_to_depth", inputs={"X": x}, - attrs={"stride": stride}, + attrs={"blocksize": blocksize}, outputs={"Out": out}) return out diff --git a/python/paddle/fluid/tests/unittests/test_space_to_depth_op.py b/python/paddle/fluid/tests/unittests/test_space_to_depth_op.py index 36c8cd1119..5fdad44f12 100644 --- a/python/paddle/fluid/tests/unittests/test_space_to_depth_op.py +++ b/python/paddle/fluid/tests/unittests/test_space_to_depth_op.py @@ -21,8 +21,8 @@ from op_test import OpTest class TestSpaceToDepthOp(OpTest): @staticmethod - def helper(in_, width, height, channel, batch, stride, forward, out_): - channel_out = channel // (stride * stride) + def helper(in_, width, height, channel, batch, blocksize, forward, out_): + channel_out = channel // (blocksize * blocksize) for b in range(batch): for k in range(channel): for j in range(height): @@ -30,10 +30,10 @@ class TestSpaceToDepthOp(OpTest): in_index = i + width * (j + height * (k + channel * b)) channel2 = k % channel_out offset = k // channel_out - width2 = i * stride + offset % stride - height2 = j * stride + offset // stride - out_index = width2 + width * stride * ( - height2 + height * stride * + width2 = i * blocksize + offset % blocksize + height2 = j * blocksize + offset // blocksize + out_index = width2 + width * blocksize * ( + height2 + height * blocksize * (channel2 + channel_out * b)) if forward: out_[out_index] = in_[in_index] @@ -46,10 +46,10 @@ class TestSpaceToDepthOp(OpTest): self.op_type = "space_to_depth" self.inputs = {"X": self.x} self.helper(self.x_1d, self.x.shape[3], self.x.shape[2], - self.x.shape[1], self.x.shape[0], self.stride, self.forward, - self.out_1d) + self.x.shape[1], self.x.shape[0], self.blocksize, + self.forward, self.out_1d) self.out = np.reshape(self.out_1d, self.infered_shape) - self.attrs = {"stride": self.stride} + self.attrs = {"blocksize": self.blocksize} self.outputs = {"Out": self.out} def init_data(self): @@ -57,7 +57,7 @@ class TestSpaceToDepthOp(OpTest): self.infered_shape = (32, 48, 3, 3) self.one_d_len = 32 * 48 * 3 * 3 - self.stride = 2 + self.blocksize = 2 self.x = np.random.random(self.ori_shape).astype('float32') self.x_1d = np.reshape(self.x, self.one_d_len) self.out = np.zeros(self.infered_shape).astype('float32') @@ -81,7 +81,7 @@ class TestSpaceToDepthOpBasic(TestSpaceToDepthOp): self.infered_shape = (32, 32, 3, 3) self.one_d_len = 32 * 32 * 3 * 3 - self.stride = 2 + self.blocksize = 2 self.x = np.random.random(self.ori_shape).astype('float32') self.x_1d = np.reshape(self.x, self.one_d_len) self.out = np.zeros(self.infered_shape).astype('float32') @@ -95,7 +95,7 @@ class TestSpaceToDepthOpDoubleBasic(TestSpaceToDepthOp): self.infered_shape = (32, 32, 3, 3) self.one_d_len = 32 * 32 * 3 * 3 - self.stride = 2 + self.blocksize = 2 self.x = np.random.random(self.ori_shape).astype('float64') self.x_1d = np.reshape(self.x, self.one_d_len) self.out = np.zeros(self.infered_shape).astype('float64') @@ -109,7 +109,7 @@ class TestSpaceToDepthOpWithStride3(TestSpaceToDepthOp): self.infered_shape = (32, 81, 2, 2) self.one_d_len = 32 * 81 * 2 * 2 - self.stride = 3 + self.blocksize = 3 self.x = np.random.random(self.ori_shape).astype('float32') self.x_1d = np.reshape(self.x, self.one_d_len) self.out = np.zeros(self.infered_shape).astype('float32') @@ -123,7 +123,7 @@ class TestSpaceToDepthOpWithNotSquare(TestSpaceToDepthOp): self.infered_shape = (32, 81, 3, 2) self.one_d_len = 32 * 81 * 3 * 2 - self.stride = 3 + self.blocksize = 3 self.x = np.random.random(self.ori_shape).astype('float32') self.x_1d = np.reshape(self.x, self.one_d_len) self.out = np.zeros(self.infered_shape).astype('float32') -- GitLab