Merge pull request #4709 from chengduoZH/Add_conv3d_gemm_op
Add 3D Convolution operator implemented by GEMM.mobile_baidu
chengduo
7 years ago
committed by
GitHub
commit
f78731c837
@ -1,115 +0,0 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#include "paddle/operators/conv2d_op.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
void Conv2DOp::InferShape(framework::InferShapeContext* ctx) const {
|
||||
PADDLE_ENFORCE(ctx->HasInput("Input"),
|
||||
"Input(Input) of Conv2DOp should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasInput("Filter"),
|
||||
"Input(Filter) of Conv2DOp should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasOutput("Output"),
|
||||
"Output(Output) of Conv2DOp should not be null.");
|
||||
|
||||
auto in_dims = ctx->GetInputDim("Input");
|
||||
auto filter_dims = ctx->GetInputDim("Filter");
|
||||
std::vector<int> strides = ctx->Attrs().Get<std::vector<int>>("strides");
|
||||
std::vector<int> paddings = ctx->Attrs().Get<std::vector<int>>("paddings");
|
||||
int groups = ctx->Attrs().Get<int>("groups");
|
||||
int input_channels = in_dims[1];
|
||||
int output_channels = filter_dims[0];
|
||||
|
||||
PADDLE_ENFORCE_EQ(in_dims.size(), 4, "Conv2DOp input should be 4-D.");
|
||||
PADDLE_ENFORCE_EQ(filter_dims.size(), 4, "Conv2DOp filter should be 4-D.");
|
||||
PADDLE_ENFORCE_EQ(input_channels, filter_dims[1] * groups,
|
||||
"The number of input channels should be equal to filter "
|
||||
"channels * groups.");
|
||||
PADDLE_ENFORCE_EQ(
|
||||
output_channels % groups, 0,
|
||||
"The number of output channels should be divided by groups.");
|
||||
|
||||
auto output_height =
|
||||
OutputSize(in_dims[2], filter_dims[2], paddings[0], strides[0]);
|
||||
auto output_width =
|
||||
OutputSize(in_dims[3], filter_dims[3], paddings[1], strides[1]);
|
||||
ctx->SetOutputDim("Output",
|
||||
{in_dims[0], filter_dims[0], output_height, output_width});
|
||||
}
|
||||
|
||||
Conv2DOpMaker::Conv2DOpMaker(framework::OpProto* proto,
|
||||
framework::OpAttrChecker* op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput(
|
||||
"Input",
|
||||
"The input tensor of convolution operator. "
|
||||
"The format of input tensor is NCHW, where N is batch size, C is the "
|
||||
"number of channels, H is the height of the image, "
|
||||
"and W is the width of the image.");
|
||||
AddInput("Filter",
|
||||
"The filter tensor of convolution operator. "
|
||||
"The format of the filter tensor is MCHW, where M is the number of "
|
||||
"output image channels, C is the number of input image channels, "
|
||||
"H is the height of the filter, and W is the width of the filter. "
|
||||
"If the groups attribute is greater than 1, C equals the number of "
|
||||
"input image channels divided by the groups.");
|
||||
AddOutput("Output",
|
||||
"The output tensor of convolution operator. "
|
||||
"The format of output tensor is also NCHW.");
|
||||
AddAttr<std::vector<int>>("strides", "strides of convolution operator.")
|
||||
.SetDefault({1, 1});
|
||||
AddAttr<std::vector<int>>("paddings", "paddings of convolution operator.")
|
||||
.SetDefault({0, 0});
|
||||
AddAttr<int>(
|
||||
"groups",
|
||||
"Group size of convolution operator. "
|
||||
"According to grouped convolution in Alex Krizhevsky's Deep CNN paper: "
|
||||
"when group=2, the first half of the filters is only connected to the "
|
||||
"first half of the input channels, while the second half of the filters "
|
||||
"is only connected to the second half of the input channels.")
|
||||
.SetDefault(1);
|
||||
AddComment(R"DOC(
|
||||
Convolution Operator.
|
||||
|
||||
The convolution operation calculates the output based on the input, filter,
|
||||
strides, paddings, and groups parameters. The size of each dimension of the
|
||||
parameters is checked in the infer-shape method.
|
||||
|
||||
)DOC");
|
||||
}
|
||||
|
||||
void Conv2DOpGrad::InferShape(framework::InferShapeContext* ctx) const {
|
||||
auto in_dims = ctx->GetInputDim("Input");
|
||||
auto filter_dims = ctx->GetInputDim("Filter");
|
||||
if (ctx->HasOutput(framework::GradVarName("Input"))) {
|
||||
ctx->SetOutputDim(framework::GradVarName("Input"), in_dims);
|
||||
}
|
||||
if (ctx->HasOutput(framework::GradVarName("Filter"))) {
|
||||
ctx->SetOutputDim(framework::GradVarName("Filter"), filter_dims);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OP(conv2d, ops::Conv2DOp, ops::Conv2DOpMaker, conv2d_grad,
|
||||
ops::Conv2DOpGrad);
|
||||
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
conv2d, ops::GemmConv2DKernel<paddle::platform::CPUPlace, float>);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
conv2d_grad, ops::GemmConvGrad2DKernel<paddle::platform::CPUPlace, float>);
|
||||
@ -0,0 +1,209 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#include "paddle/operators/conv_op.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
void ConvOp::InferShape(framework::InferShapeContext* ctx) const {
|
||||
PADDLE_ENFORCE(ctx->HasInput("Input"),
|
||||
"Input(Input) of ConvOp should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasInput("Filter"),
|
||||
"Input(Filter) of ConvOp should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasOutput("Output"),
|
||||
"Output(Output) of ConvOp should not be null.");
|
||||
|
||||
auto in_dims = ctx->GetInputDim("Input");
|
||||
auto filter_dims = ctx->GetInputDim("Filter");
|
||||
std::vector<int> strides = ctx->Attrs().Get<std::vector<int>>("strides");
|
||||
std::vector<int> paddings = ctx->Attrs().Get<std::vector<int>>("paddings");
|
||||
int groups = ctx->Attrs().Get<int>("groups");
|
||||
int input_channels = in_dims[1];
|
||||
int output_channels = filter_dims[0];
|
||||
|
||||
PADDLE_ENFORCE(in_dims.size() == 4 || in_dims.size() == 5,
|
||||
"Conv intput should be 4-D or 5-D tensor.");
|
||||
PADDLE_ENFORCE_EQ(
|
||||
in_dims.size(), filter_dims.size(),
|
||||
"Conv input dimension and filter dimension should be the same.");
|
||||
PADDLE_ENFORCE(
|
||||
in_dims.size() - strides.size() == 2U,
|
||||
"Conv input dimension and strides dimension should be consistent.");
|
||||
PADDLE_ENFORCE_EQ(
|
||||
paddings.size(), strides.size(),
|
||||
"Conv paddings dimension and Conv strides dimension should be the same.");
|
||||
PADDLE_ENFORCE_EQ(input_channels, filter_dims[1] * groups,
|
||||
"The number of input channels should be equal to filter "
|
||||
"channels * groups.");
|
||||
PADDLE_ENFORCE_EQ(
|
||||
output_channels % groups, 0,
|
||||
"The number of output channels should be divided by groups.");
|
||||
|
||||
std::vector<int64_t> output_shape({in_dims[0], filter_dims[0]});
|
||||
for (size_t i = 0; i < paddings.size(); ++i) {
|
||||
output_shape.push_back(OutputSize(in_dims[i + 2], filter_dims[i + 2],
|
||||
paddings[i], strides[i]));
|
||||
}
|
||||
ctx->SetOutputDim("Output", framework::make_ddim(output_shape));
|
||||
}
|
||||
|
||||
Conv2DOpMaker::Conv2DOpMaker(framework::OpProto* proto,
|
||||
framework::OpAttrChecker* op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput(
|
||||
"Input",
|
||||
"(Tensor) The input tensor of convolution operator. "
|
||||
"The format of input tensor is NCHW, where N is batch size, C is the "
|
||||
"number of channels, H is the height of the feature, "
|
||||
"and W is the width of the feature.");
|
||||
AddInput("Filter",
|
||||
"(Tensor) The filter tensor of convolution operator. "
|
||||
"The format of the filter tensor is MCHW, where M is the number of "
|
||||
"output image channels, C is the number of input image channels, "
|
||||
"H is the height of the filter, and W is the width of the filter. "
|
||||
"If the groups attribute is greater than 1, C equals the number of "
|
||||
"input image channels divided by the groups.");
|
||||
AddOutput("Output",
|
||||
"(Tensor) The output tensor of convolution operator. "
|
||||
"The format of output tensor is also NCHW.");
|
||||
AddAttr<std::vector<int>>("strides", "strides of convolution operator.")
|
||||
.SetDefault({1, 1});
|
||||
AddAttr<std::vector<int>>("paddings", "paddings of convolution operator.")
|
||||
.SetDefault({0, 0});
|
||||
AddAttr<int>(
|
||||
"groups",
|
||||
"(int default:1), the group size of convolution operator. "
|
||||
"According to grouped convolution in Alex Krizhevsky's Deep CNN paper: "
|
||||
"when group=2, the first half of the filters is only connected to the "
|
||||
"first half of the input channels, while the second half of the filters "
|
||||
"is only connected to the second half of the input channels.")
|
||||
.SetDefault(1);
|
||||
AddComment(R"DOC(
|
||||
Convolution Operator.
|
||||
|
||||
The convolution operation calculates the output based on the input, filter
|
||||
and strides, paddings, groups parameters. The size of each dimension of the
|
||||
parameters is checked in the infer-shape.
|
||||
Input(Input, Filter) and output(Output) are in NCHW format. Where N is batch
|
||||
size, C is the number of channels, H is the height of the feature, and W is
|
||||
the width of the feature. Parameters(ksize, strides, paddings) are two elements.
|
||||
These two elements represent height and width, respectively.
|
||||
The input(X) size and output(Out) size may be different.
|
||||
|
||||
Example:
|
||||
Input:
|
||||
Input shape: (N, C_in, H_in, W_in)
|
||||
Filter shape: (C_out, C_in, H_f, W_f)
|
||||
Output:
|
||||
Output shape: (N, C_out, H_out, W_out)
|
||||
where
|
||||
H_out = (H_in - filter_size[0] + 2 * paddings[0]) / strides[0] + 1;
|
||||
W_out = (W_in - filter_size[1] + 2 * paddings[1]) / strides[1] + 1;
|
||||
)DOC");
|
||||
}
|
||||
|
||||
Conv3DOpMaker::Conv3DOpMaker(framework::OpProto* proto,
|
||||
framework::OpAttrChecker* op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput(
|
||||
"Input",
|
||||
"(Tensor) The input tensor of convolution operator. "
|
||||
"The format of input tensor is NCDHW. Where N is batch size, C is the "
|
||||
"number of channels, D is the depth of the feature, H is the height of "
|
||||
"the feature, "
|
||||
"and W is the width of the feature.");
|
||||
AddInput("Filter",
|
||||
"(Tensor) The filter tensor of convolution operator. "
|
||||
"The format of the filter tensor is MCDHW, where M is the number of "
|
||||
"output image channels, C is the number of input image channels, "
|
||||
"D is the depth of the filter, H is the height of the filter, and W "
|
||||
"is the width of the filter."
|
||||
"If the groups attribute is greater than 1, C equals the number of "
|
||||
"input image channels divided by the groups.");
|
||||
AddOutput("Output",
|
||||
"(Tensor) The output tensor of convolution operator."
|
||||
"The format of output tensor is also NCDHW.");
|
||||
AddAttr<std::vector<int>>(
|
||||
"strides",
|
||||
"(vector, default:{0, 0, 0}), the strides of convolution operator.")
|
||||
.SetDefault({1, 1, 1});
|
||||
AddAttr<std::vector<int>>(
|
||||
"paddings",
|
||||
"(vector, default:{0, 0, 0}), the paddings of convolution operator.")
|
||||
.SetDefault({0, 0, 0});
|
||||
AddAttr<int>(
|
||||
"groups",
|
||||
"(int default:1), the group size of convolution operator. "
|
||||
"According to grouped convolution in Alex Krizhevsky's Deep CNN paper: "
|
||||
"when group=2, the first half of the filters is only connected to the "
|
||||
"first half of the input channels, while the second half of the filters "
|
||||
"is only connected to the second half of the input channels.")
|
||||
.SetDefault(1);
|
||||
|
||||
AddComment(R"DOC(
|
||||
Convolution3D Operator.
|
||||
|
||||
The convolution operation calculates the output based on the input, filter
|
||||
and strides, paddings, groups parameters. The size of each dimension of the
|
||||
parameters is checked in the infer-shape.
|
||||
Input(Input, Filter) and output(Output) are in NCDHW format. Where N is batch
|
||||
size, C is the number of channels,D is the depth of the feature, H is the height of
|
||||
the feature, and W is the width of the feature. Parameters(ksize, strides, paddings)
|
||||
are three elements. These three elements represent depth, height and width, respectively.
|
||||
The input(X) size and output(Out) size may be different.
|
||||
|
||||
Example:
|
||||
Input:
|
||||
Input shape: (N, C_in, D_in, H_in, W_in)
|
||||
Filter shape: (C_out, C_in, D_f, H_f, W_f)
|
||||
Output:
|
||||
Output shape: (N, C_out, D_out, H_out, W_out)
|
||||
where
|
||||
D_out = (D_in - filter_size[0] + 2 * paddings[0]) / strides[0] + 1;
|
||||
H_out = (H_in - filter_size[1] + 2 * paddings[1]) / strides[1] + 1;
|
||||
W_out = (W_in - filter_size[2] + 2 * paddings[2]) / strides[2] + 1;
|
||||
)DOC");
|
||||
}
|
||||
|
||||
void ConvOpGrad::InferShape(framework::InferShapeContext* ctx) const {
|
||||
auto in_dims = ctx->GetInputDim("Input");
|
||||
auto filter_dims = ctx->GetInputDim("Filter");
|
||||
if (ctx->HasOutput(framework::GradVarName("Input"))) {
|
||||
ctx->SetOutputDim(framework::GradVarName("Input"), in_dims);
|
||||
}
|
||||
if (ctx->HasOutput(framework::GradVarName("Filter"))) {
|
||||
ctx->SetOutputDim(framework::GradVarName("Filter"), filter_dims);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OP(conv2d, ops::ConvOp, ops::Conv2DOpMaker, conv2d_grad,
|
||||
ops::ConvOpGrad);
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OP(conv3d, ops::ConvOp, ops::Conv3DOpMaker, conv3d_grad,
|
||||
ops::ConvOpGrad);
|
||||
|
||||
REGISTER_OP_CPU_KERNEL(conv2d,
|
||||
ops::GemmConvKernel<paddle::platform::CPUPlace, float>);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
conv2d_grad, ops::GemmConvGradKernel<paddle::platform::CPUPlace, float>);
|
||||
|
||||
REGISTER_OP_CPU_KERNEL(conv3d,
|
||||
ops::GemmConvKernel<paddle::platform::CPUPlace, float>);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
conv3d_grad, ops::GemmConvGradKernel<paddle::platform::CPUPlace, float>);
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,131 @@
|
||||
import unittest
|
||||
import numpy as np
|
||||
from op_test import OpTest
|
||||
|
||||
|
||||
def conv3d_forward_naive(input, filter, group, conv_param):
|
||||
in_n, in_c, in_d, in_h, in_w = input.shape
|
||||
out_c, f_c, f_d, f_h, f_w = filter.shape
|
||||
assert f_c * group == in_c
|
||||
assert np.mod(out_c, group) == 0
|
||||
sub_out_c = out_c / group
|
||||
|
||||
stride, pad = conv_param['stride'], conv_param['pad']
|
||||
out_d = 1 + (in_d + 2 * pad[0] - f_h) / stride[0]
|
||||
out_h = 1 + (in_h + 2 * pad[1] - f_h) / stride[1]
|
||||
out_w = 1 + (in_w + 2 * pad[2] - f_w) / stride[2]
|
||||
out = np.zeros((in_n, out_c, out_d, out_h, out_w))
|
||||
|
||||
input_pad = np.pad(input, ((0, ), (0, ), (pad[0], ), (pad[1], ),
|
||||
(pad[2], )),
|
||||
mode='constant',
|
||||
constant_values=0)
|
||||
for d in range(out_d):
|
||||
for i in range(out_h):
|
||||
for j in range(out_w):
|
||||
for g in range(group):
|
||||
input_pad_masked = \
|
||||
input_pad[:, g * f_c:(g + 1) * f_c,
|
||||
d * stride[0]:d * stride[0] + f_d,
|
||||
i * stride[1]:i * stride[1] + f_h,
|
||||
j * stride[2]:j * stride[2] + f_w]
|
||||
f_sub = filter[g * sub_out_c:(g + 1) *
|
||||
sub_out_c, :, :, :, :]
|
||||
for k in range(sub_out_c):
|
||||
out[:, g * sub_out_c + k, d, i, j] = \
|
||||
np.sum(input_pad_masked * f_sub[k, :, :, :, :],
|
||||
axis=(1, 2, 3, 4))
|
||||
|
||||
return out
|
||||
|
||||
|
||||
class TestConv3dOp(OpTest):
|
||||
def setUp(self):
|
||||
self.init_group()
|
||||
self.init_op_type()
|
||||
self.init_test_case()
|
||||
|
||||
conv3d_param = {'stride': self.stride, 'pad': self.pad}
|
||||
input = np.random.random(self.input_size).astype("float32")
|
||||
filter = np.random.random(self.filter_size).astype("float32")
|
||||
output = conv3d_forward_naive(input, filter, self.groups,
|
||||
conv3d_param).astype("float32")
|
||||
|
||||
self.inputs = {'Input': input, 'Filter': filter}
|
||||
self.attrs = {
|
||||
'strides': self.stride,
|
||||
'paddings': self.pad,
|
||||
'groups': self.groups
|
||||
}
|
||||
self.outputs = {'Output': output}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(
|
||||
set(['Input', 'Filter']), 'Output', max_relative_error=0.03)
|
||||
|
||||
def test_check_grad_no_filter(self):
|
||||
self.check_grad(
|
||||
['Input'],
|
||||
'Output',
|
||||
max_relative_error=0.03,
|
||||
no_grad_set=set(['Filter']))
|
||||
|
||||
def test_check_grad_no_input(self):
|
||||
self.check_grad(
|
||||
['Filter'],
|
||||
'Output',
|
||||
max_relative_error=0.03,
|
||||
no_grad_set=set(['Input']))
|
||||
|
||||
def init_test_case(self):
|
||||
self.pad = [0, 0, 0]
|
||||
self.stride = [1, 1, 1]
|
||||
self.input_size = [2, 3, 4, 4, 4] # NCDHW
|
||||
assert np.mod(self.input_size[1], self.groups) == 0
|
||||
f_c = self.input_size[1] / self.groups
|
||||
self.filter_size = [6, f_c, 3, 3, 3]
|
||||
|
||||
def init_group(self):
|
||||
self.groups = 1
|
||||
|
||||
def init_op_type(self):
|
||||
self.op_type = "conv3d"
|
||||
|
||||
|
||||
class TestCase1(TestConv3dOp):
|
||||
def init_test_case(self):
|
||||
self.pad = [1, 1, 1]
|
||||
self.stride = [1, 1, 1]
|
||||
self.input_size = [2, 3, 4, 4, 4] # NCDHW
|
||||
assert np.mod(self.input_size[1], self.groups) == 0
|
||||
f_c = self.input_size[1] / self.groups
|
||||
self.filter_size = [6, f_c, 3, 3, 3]
|
||||
|
||||
def init_group(self):
|
||||
self.groups = 1
|
||||
|
||||
def init_op_type(self):
|
||||
self.op_type = "conv3d"
|
||||
|
||||
|
||||
class TestWithGroup1(TestConv3dOp):
|
||||
def init_group(self):
|
||||
self.groups = 3
|
||||
|
||||
def init_op_type(self):
|
||||
self.op_type = "conv3d"
|
||||
|
||||
|
||||
class TestWithGroup2(TestCase1):
|
||||
def init_group(self):
|
||||
self.groups = 3
|
||||
|
||||
def init_op_type(self):
|
||||
self.op_type = "conv3d"
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Loading…
Reference in new issue