update-doc-pybind
superjom
8 years ago
commit
0da8133224
@ -0,0 +1,133 @@
|
||||
/* 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/gemm_conv2d_op.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
int outputSize(int input_size, int filter_size, int padding, int stride) {
|
||||
int output_size = (input_size - filter_size + 2 * padding) / stride + 1;
|
||||
return output_size;
|
||||
}
|
||||
|
||||
class Conv2DOp : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(const framework::InferShapeContext &ctx) const override {
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Input"),
|
||||
"Input(Input) of Conv2DOp should not be null.");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Filter"),
|
||||
"Input(Filter) of Conv2DOp should not be null.");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.OutputVar("Output"),
|
||||
"Output(Output) of Conv2DOp should not be null.");
|
||||
|
||||
auto in = ctx.Input<Tensor>("Input");
|
||||
auto filter = ctx.Input<Tensor>("Filter");
|
||||
auto out = ctx.Output<framework::LoDTensor>("Output");
|
||||
std::vector<int> strides = Attr<std::vector<int>>("strides");
|
||||
std::vector<int> paddings = Attr<std::vector<int>>("paddings");
|
||||
int groups = Attr<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]);
|
||||
out->Resize(
|
||||
{in->dims()[0], filter->dims()[0], output_height, output_width});
|
||||
}
|
||||
};
|
||||
|
||||
class Conv2DOpMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
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 and W is the height and width of 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 and W is height and width of filter. "
|
||||
"If the groups attribute is greater than 1, C equal 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. "
|
||||
"Refer to grouped convolution in Alex Krizhevsky's paper: "
|
||||
"when group=2, the first half of the filters are only connected to the "
|
||||
"first half of the input channels, and the second half only connected "
|
||||
"to the second half.")
|
||||
.SetDefault(1);
|
||||
AddComment(R"DOC(
|
||||
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.
|
||||
)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class Conv2DOpGrad : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(const framework::InferShapeContext &ctx) const override {
|
||||
auto in = ctx.Input<Tensor>("Input");
|
||||
auto filter = ctx.Input<Tensor>("Filter");
|
||||
auto d_in =
|
||||
ctx.Output<framework::LoDTensor>(framework::GradVarName("Input"));
|
||||
auto d_filter =
|
||||
ctx.Output<framework::LoDTensor>(framework::GradVarName("Filter"));
|
||||
if (d_in) d_in->Resize(in->dims());
|
||||
if (d_filter) d_filter->Resize(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,22 @@
|
||||
/* 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/gemm_conv2d_op.h"
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
conv2d, ops::GemmConv2DKernel<paddle::platform::GPUPlace, float>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
conv2d_grad, ops::GemmConvGrad2DKernel<paddle::platform::GPUPlace, float>);
|
||||
@ -0,0 +1,231 @@
|
||||
/* 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. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "paddle/framework/eigen.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
#include "paddle/operators/math/im2col.h"
|
||||
#include "paddle/operators/math/math_function.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
using Tensor = framework::Tensor;
|
||||
|
||||
template <typename Place, typename T>
|
||||
class GemmConv2DKernel : public framework::OpKernel {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& context) const override {
|
||||
const Tensor* input = context.Input<Tensor>("Input");
|
||||
// The filter will be reshaped in the calculations,
|
||||
// so here use an assignment operation,
|
||||
// that avoids modifying the variable in the Scope.
|
||||
Tensor filter = *context.Input<Tensor>("Filter");
|
||||
Tensor* output = context.Output<Tensor>("Output");
|
||||
output->mutable_data<T>(context.GetPlace());
|
||||
|
||||
std::vector<int> strides = context.Attr<std::vector<int>>("strides");
|
||||
std::vector<int> paddings = context.Attr<std::vector<int>>("paddings");
|
||||
int groups = context.Attr<int>("groups");
|
||||
|
||||
int batch_size = input->dims()[0];
|
||||
int input_channels = input->dims()[1];
|
||||
int filter_height = filter.dims()[filter.dims().size() - 2];
|
||||
int filter_width = filter.dims()[filter.dims().size() - 1];
|
||||
int output_channels = output->dims()[1];
|
||||
int output_height = output->dims()[2];
|
||||
int output_width = output->dims()[3];
|
||||
|
||||
paddle::operators::math::Im2ColFunctor<
|
||||
paddle::operators::math::ColFormat::kCFO, Place, T>
|
||||
im2col;
|
||||
// use col_shape in the im2col calculation
|
||||
framework::DDim col_shape = {input_channels / groups, filter_height,
|
||||
filter_width, output_height, output_width};
|
||||
// use col_matrix_shape in the gemm calculation
|
||||
framework::DDim col_matrix_shape = {
|
||||
input_channels / groups * filter_height * filter_width,
|
||||
output_height * output_width};
|
||||
Tensor col;
|
||||
col.mutable_data<T>(col_shape, context.GetPlace());
|
||||
// col_matrix shares the same piece of data with col,
|
||||
// but will be reshaped into a two-dimensional matrix shape
|
||||
// to call the matrix multiplication interface.
|
||||
Tensor col_matrix = col;
|
||||
col_matrix.Resize(col_matrix_shape);
|
||||
|
||||
framework::DDim input_shape = {input->dims()[1], input->dims()[2],
|
||||
input->dims()[3]};
|
||||
framework::DDim filter_matrix_shape = {filter.dims()[0],
|
||||
filter.numel() / filter.dims()[0]};
|
||||
filter.Resize(filter_matrix_shape);
|
||||
|
||||
framework::DDim output_matrix_shape = {output_channels,
|
||||
output_height * output_width};
|
||||
|
||||
auto* device_context =
|
||||
const_cast<platform::DeviceContext*>(context.device_context_);
|
||||
|
||||
// convolution operator: im2col + gemm
|
||||
int in_step = input_channels / groups;
|
||||
int out_step = output_channels / groups;
|
||||
for (int i = 0; i < batch_size; i++) {
|
||||
Tensor in_batch = input->Slice<T>(i, i + 1).Resize(input_shape);
|
||||
Tensor out_batch = output->Slice<T>(i, i + 1).Resize(output_matrix_shape);
|
||||
for (int g = 0; g < groups; g++) {
|
||||
// im2col
|
||||
Tensor in_slice = in_batch.Slice<T>(g * in_step, (g + 1) * in_step);
|
||||
im2col(in_slice, col, strides[0], strides[1], paddings[0], paddings[1],
|
||||
device_context);
|
||||
|
||||
// gemm
|
||||
Tensor out_slice = out_batch.Slice<T>(g * out_step, (g + 1) * out_step);
|
||||
Tensor filter_slice = filter.Slice<T>(g * out_step, (g + 1) * out_step);
|
||||
math::matmul<Place, T>(filter_slice, false, col_matrix, false, T(1.0),
|
||||
&out_slice, T(0.0), device_context);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Place, typename T>
|
||||
class GemmConvGrad2DKernel : public framework::OpKernel {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& context) const override {
|
||||
const Tensor* input = context.Input<Tensor>("Input");
|
||||
const Tensor* output_grad =
|
||||
context.Input<Tensor>(framework::GradVarName("Output"));
|
||||
Tensor* input_grad =
|
||||
context.Output<Tensor>(framework::GradVarName("Input"));
|
||||
Tensor* filter_grad =
|
||||
context.Output<Tensor>(framework::GradVarName("Filter"));
|
||||
|
||||
// The filter and filter_grad will be reshaped in the calculations,
|
||||
// so here use an assignment operation,
|
||||
// that avoids modifying the variable in the Scope.
|
||||
Tensor filter = *context.Input<Tensor>("Filter");
|
||||
|
||||
std::vector<int> strides = context.Attr<std::vector<int>>("strides");
|
||||
std::vector<int> paddings = context.Attr<std::vector<int>>("paddings");
|
||||
int groups = context.Attr<int>("groups");
|
||||
|
||||
int batch_size = input->dims()[0];
|
||||
int input_channels = input->dims()[1];
|
||||
int filter_height = filter.dims()[filter.dims().size() - 2];
|
||||
int filter_width = filter.dims()[filter.dims().size() - 1];
|
||||
int output_channels = output_grad->dims()[1];
|
||||
int output_height = output_grad->dims()[2];
|
||||
int output_width = output_grad->dims()[3];
|
||||
|
||||
paddle::operators::math::Col2ImFunctor<
|
||||
paddle::operators::math::ColFormat::kCFO, Place, T>
|
||||
col2im;
|
||||
paddle::operators::math::Im2ColFunctor<
|
||||
paddle::operators::math::ColFormat::kCFO, Place, T>
|
||||
im2col;
|
||||
// use col_shape in the im2col and col2im calculation
|
||||
framework::DDim col_shape = {input_channels / groups, filter_height,
|
||||
filter_width, output_height, output_width};
|
||||
// use col_matrix_shape in the gemm calculation
|
||||
framework::DDim col_matrix_shape = {
|
||||
input_channels / groups * filter_height * filter_width,
|
||||
output_height * output_width};
|
||||
Tensor col;
|
||||
col.mutable_data<T>(col_shape, context.GetPlace());
|
||||
// col_matrix shares the same piece of data with col,
|
||||
// but will be reshaped into a two-dimensional matrix shape
|
||||
// to call the matrix multiplication interface.
|
||||
Tensor col_matrix = col;
|
||||
col_matrix.Resize(col_matrix_shape);
|
||||
|
||||
framework::DDim input_shape = {input->dims()[1], input->dims()[2],
|
||||
input->dims()[3]};
|
||||
framework::DDim output_matrix_shape = {
|
||||
output_grad->dims()[1],
|
||||
output_grad->dims()[2] * output_grad->dims()[3]};
|
||||
|
||||
framework::DDim filter_matrix_shape = {filter.dims()[0],
|
||||
filter.numel() / filter.dims()[0]};
|
||||
filter.Resize(filter_matrix_shape);
|
||||
|
||||
auto* device_context =
|
||||
const_cast<platform::DeviceContext*>(context.device_context_);
|
||||
|
||||
// convolution backward input operator: gemm + col2im
|
||||
// convolution backward weight operator: im2col + gemm
|
||||
int in_step = input_channels / groups;
|
||||
int out_step = output_channels / groups;
|
||||
|
||||
if (input_grad) {
|
||||
input_grad->mutable_data<T>(context.GetPlace());
|
||||
auto t = framework::EigenVector<T>::Flatten(*input_grad);
|
||||
t.device(context.GetEigenDevice<Place>()) = t.constant(static_cast<T>(0));
|
||||
|
||||
for (int i = 0; i < batch_size; i++) {
|
||||
Tensor out_grad_batch =
|
||||
output_grad->Slice<T>(i, i + 1).Resize(output_matrix_shape);
|
||||
Tensor in_grad_batch =
|
||||
input_grad->Slice<T>(i, i + 1).Resize(input_shape);
|
||||
for (int g = 0; g < groups; g++) {
|
||||
// gemm
|
||||
Tensor out_grad_slice =
|
||||
out_grad_batch.Slice<T>(g * out_step, (g + 1) * out_step);
|
||||
Tensor filter_slice =
|
||||
filter.Slice<T>(g * out_step, (g + 1) * out_step);
|
||||
math::matmul<Place, T>(filter_slice, true, out_grad_slice, false,
|
||||
T(1.0), &col_matrix, T(0.0), device_context);
|
||||
|
||||
// col2im
|
||||
Tensor in_grad_slice =
|
||||
in_grad_batch.Slice<T>(g * in_step, (g + 1) * in_step);
|
||||
col2im(in_grad_slice, col, strides[0], strides[1], paddings[0],
|
||||
paddings[1], device_context);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (filter_grad) {
|
||||
filter_grad->mutable_data<T>(context.GetPlace());
|
||||
Tensor filter_grad_ = *filter_grad;
|
||||
filter_grad_.Resize(filter_matrix_shape);
|
||||
auto t = framework::EigenVector<T>::Flatten(filter_grad_);
|
||||
t.device(context.GetEigenDevice<Place>()) = t.constant(static_cast<T>(0));
|
||||
|
||||
for (int i = 0; i < batch_size; i++) {
|
||||
Tensor out_grad_batch =
|
||||
output_grad->Slice<T>(i, i + 1).Resize(output_matrix_shape);
|
||||
Tensor in_batch = input->Slice<T>(i, i + 1).Resize(input_shape);
|
||||
for (int g = 0; g < groups; g++) {
|
||||
// im2col
|
||||
Tensor out_grad_slice =
|
||||
out_grad_batch.Slice<T>(g * out_step, (g + 1) * out_step);
|
||||
Tensor in_slice = in_batch.Slice<T>(g * in_step, (g + 1) * in_step);
|
||||
im2col(in_slice, col, strides[0], strides[1], paddings[0],
|
||||
paddings[1], device_context);
|
||||
|
||||
// gemm
|
||||
Tensor filter_grad_slice =
|
||||
filter_grad_.Slice<T>(g * out_step, (g + 1) * out_step);
|
||||
math::matmul<Place, T>(out_grad_slice, false, col_matrix, true,
|
||||
T(1.0), &filter_grad_slice, T(1.0),
|
||||
device_context);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,94 @@
|
||||
import unittest
|
||||
import numpy as np
|
||||
from op_test import OpTest
|
||||
|
||||
|
||||
class TestConv2dOp(OpTest):
|
||||
def setUp(self):
|
||||
self.init_groups()
|
||||
self.op_type = "conv2d"
|
||||
batch_size = 2
|
||||
input_channels = 3
|
||||
input_height = 5
|
||||
input_width = 5
|
||||
output_channels = 6
|
||||
filter_height = 3
|
||||
filter_width = 3
|
||||
stride = 1
|
||||
padding = 0
|
||||
output_height = (input_height - filter_height + 2 * padding
|
||||
) / stride + 1
|
||||
output_width = (input_width - filter_width + 2 * padding) / stride + 1
|
||||
input = np.random.random((batch_size, input_channels, input_height,
|
||||
input_width)).astype("float32")
|
||||
|
||||
filter = np.random.random(
|
||||
(output_channels, input_channels / self.groups, filter_height,
|
||||
filter_width)).astype("float32")
|
||||
output = np.ndarray(
|
||||
(batch_size, output_channels, output_height, output_width))
|
||||
|
||||
self.inputs = {'Input': input, 'Filter': filter}
|
||||
self.attrs = {
|
||||
'strides': [1, 1],
|
||||
'paddings': [0, 0],
|
||||
'groups': self.groups
|
||||
}
|
||||
|
||||
output_group_channels = output_channels / self.groups
|
||||
input_group_channels = input_channels / self.groups
|
||||
for batchid in xrange(batch_size):
|
||||
for group in xrange(self.groups):
|
||||
for outchannelid in range(group * output_group_channels,
|
||||
(group + 1) * output_group_channels):
|
||||
for rowid in xrange(output_height):
|
||||
for colid in xrange(output_width):
|
||||
start_h = (rowid * stride) - padding
|
||||
start_w = (colid * stride) - padding
|
||||
output_value = 0.0
|
||||
for inchannelid in range(
|
||||
group * input_group_channels,
|
||||
(group + 1) * input_group_channels):
|
||||
for frowid in xrange(filter_height):
|
||||
for fcolid in xrange(filter_width):
|
||||
input_value = 0.0
|
||||
inrowid = start_h + frowid
|
||||
incolid = start_w + fcolid
|
||||
if ((inrowid >= 0 and
|
||||
inrowid < input_height) and
|
||||
(incolid >= 0 and
|
||||
incolid < input_width)):
|
||||
input_value = input[batchid][
|
||||
inchannelid][inrowid][incolid]
|
||||
filter_value = filter[outchannelid][
|
||||
inchannelid % input_group_channels][
|
||||
frowid][fcolid]
|
||||
output_value += input_value * filter_value
|
||||
output[batchid][outchannelid][rowid][
|
||||
colid] = output_value
|
||||
|
||||
self.outputs = {'Output': output}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(set(['Input', 'Filter']), 'Output')
|
||||
|
||||
def test_check_grad_no_filter(self):
|
||||
self.check_grad(['Input'], 'Output', no_grad_set=set(['Filter']))
|
||||
|
||||
def test_check_grad_no_input(self):
|
||||
self.check_grad(['Filter'], 'Output', no_grad_set=set(['Input']))
|
||||
|
||||
def init_groups(self):
|
||||
self.groups = 1
|
||||
|
||||
|
||||
class TestWithGroup(TestConv2dOp):
|
||||
def init_groups(self):
|
||||
self.groups = 3
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Loading…
Reference in new issue