m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

deconv

Browse Source
revert-4814-Add_sequence_project_op
zchen0211 8 years ago
parent e59ca752fc
commit d97a732f4f
2 changed files with 24 additions and 16 deletions
Show Stats Download Patch File Download Diff File

4
paddle/operators/deconv2d_op.cc
Unescape View File

@ -30,7 +30,6 @@ void Deconv2DOp::InferShape(framework::InferShapeContext* ctx) const {
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");
for (int i = 0; i < paddings.size(); ++i) {
PADDLE_ENFORCE_EQ(paddings[i], 0, "No Padding allowed in deconv op.");
@ -41,9 +40,6 @@ void Deconv2DOp::InferShape(framework::InferShapeContext* ctx) const {
PADDLE_ENFORCE_EQ(in_dims[1], filter_dims[0],
"input and kernel input dimension should be equal.");
PADDLE_ENFORCE_EQ(groups, 1,
"The number of groups should be 1 in case of deconv op.");
auto output_height = (in_dims[2] - 1) * strides[0] + filter_dims[2];
auto output_width = (in_dims[3] - 1) * strides[1] + filter_dims[3];
ctx->SetOutputDim("Output",

36
paddle/operators/deconv2d_op.h
Unescape View File

@ -83,7 +83,7 @@ class GemmDeconv2DKernel : public framework::OpKernel<T> {
DDim col_shape = {C, K_H, K_W, H, W};
// use col_matrix_shape in the gemm calculation
DDim col_matrix_shape = {M * K_H * K_W, H * W};
DDim col_matrix_shape = {C * K_H * K_W, H * W};
Tensor col;
col.mutable_data<T>(col_shape, context.GetPlace());
@ -108,11 +108,11 @@ class GemmDeconv2DKernel : public framework::OpKernel<T> {
for (int i = 0; i < N; i++) {
// batch with size (M, H * W)
Tensor input_batch = input->Slice<T>(i, i + 1).Resize(input_matrix_shape);
// filter size: (M, C * K_H * K_W)
// output size: (C, O_H, O_W)
Tensor output_batch = output->Slice<T>(i, i + 1).Resize(output_shape);
// filter size: (Co, Ci * Hf * Wf)
// col_matrix = filter * input_batch
// of shape (C * K_H * K_W, H * W)
math::matmul<Place, T>(context.device_context(), filter, true,
@ -132,8 +132,8 @@ class GemmDeconvGrad2DKernel : public framework::OpKernel<T> {
const Tensor* output_grad =
context.Input<Tensor>(framework::GradVarName("Output"));
// For filter, we do not use const pointer
// but we should avoid
// For filter, we do not use const pointer b/c we will do reshape
// but we should avoid modifying its value
Tensor filter = *context.Input<Tensor>("Filter");
Tensor* input_grad =
@ -157,7 +157,7 @@ class GemmDeconvGrad2DKernel : public framework::OpKernel<T> {
int O_H = output_grad->dims()[2];
int O_W = output_grad->dims()[3];
// Two functors required to get to the right shape
// Only im2col functor required for bp to get to the right shape
paddle::operators::math::Im2ColFunctor<
paddle::operators::math::ColFormat::kCFO, Place, T>
im2col;
@ -166,15 +166,13 @@ class GemmDeconvGrad2DKernel : public framework::OpKernel<T> {
DDim col_shape = {C, K_H, K_W, H, W};
// use col_matrix_shape in the gemm calculation
DDim col_matrix_shape = {C * K_H * K_W, H * W};
DDim col_matrix_shape_f = {C * H * W, K_H * K_W};
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);
DDim output_shape = {C, O_H, O_W};
DDim input_matrix_shape = {M, H * W};
@ -186,6 +184,10 @@ class GemmDeconvGrad2DKernel : public framework::OpKernel<T> {
// im2col + gemm (similar to conv-forward)
// input need to compute gradient
if (input_grad) {
Tensor col_matrix = col;
DDim col_matrix_shape = {C * K_H * K_W, H * W};
col_matrix.Resize(col_matrix_shape);
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));
@ -194,14 +196,18 @@ class GemmDeconvGrad2DKernel : public framework::OpKernel<T> {
// batch with size (C, O_H * O_W)
Tensor output_grad_batch =
output_grad->Slice<T>(i, i + 1).Resize(output_shape);
// filter of size (M, C * K_H * K_W)
// batch with size (M, H, W)
Tensor input_grad_batch =
input_grad->Slice<T>(i, i + 1).Resize(input_matrix_shape);
// im2col: (C * K_H * K_W, H * W)
// im2col: dy from (C, O_H, O_W) -> (C * K_H * K_W, H * W)
im2col(context.device_context(), output_grad_batch, col_matrix,
strides[0], strides[1], paddings[0], paddings[1]);
// gemm: dx = filter * dy
// (M, C * K_H * K_W) * (C * K_H * K_W, H * W) -> (M, C, H)
math::matmul<Place, T>(context.device_context(), filter, false,
col_matrix, false, T(1.0), &input_grad_batch,
T(0.0));
@ -210,6 +216,10 @@ class GemmDeconvGrad2DKernel : public framework::OpKernel<T> {
// filter gradient required
if (filter_grad) {
Tensor col_matrix_f = col;
DDim col_matrix_shape_f = {C * H * W, K_H * K_W};
col_matrix_f.Resize(col_matrix_shape_f);
filter_grad->mutable_data<T>(context.GetPlace());
Tensor filter_grad_ = *filter_grad;
filter_grad_.Resize(filter_matrix_shape);
@ -223,10 +233,12 @@ class GemmDeconvGrad2DKernel : public framework::OpKernel<T> {
// input batch
Tensor in_batch = input->Slice<T>(i, i + 1).Resize(input_matrix_shape);
// im2col: (C * K_H * K_W, H * W)
im2col(context.device_context(), output_grad_batch, col_matrix,
// im2col: (C * H * W, K_H * K_W)
im2col(context.device_context(), output_grad_batch, col_matrix_f,
strides[0], strides[1], paddings[0], paddings[1]);
// gemm: d_filter = x * y_grad^T
// (M, C * H * W) * (K_H * K_W, C * H * W) -> (M, C, H)
math::matmul<Place, T>(context.device_context(), in_batch, false,
col_matrix, true, T(1.0), &filter_grad_, T(1.0));
}

Write Preview
Loading…
Cancel
Save