Wilber
6 years ago
committed by
GitHub
parent
d8a21ef6f3
commit
9676ac1c5c
@ -0,0 +1,149 @@
|
|||||||
|
/* Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||||
|
|
||||||
|
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/fluid/operators/flip_op.h"
|
||||||
|
|
||||||
|
#include <string>
|
||||||
|
#include <unordered_map>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
namespace operators {
|
||||||
|
|
||||||
|
using framework::OpKernelType;
|
||||||
|
using framework::Tensor;
|
||||||
|
|
||||||
|
class FlipOp : public framework::OperatorWithKernel {
|
||||||
|
public:
|
||||||
|
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||||
|
|
||||||
|
void InferShape(framework::InferShapeContext* ctx) const override {
|
||||||
|
PADDLE_ENFORCE_EQ(
|
||||||
|
ctx->HasInput("X"), true,
|
||||||
|
platform::errors::NotFound("Input(X) of FlipOp should not be null."));
|
||||||
|
PADDLE_ENFORCE_EQ(ctx->HasOutput("Out"), true,
|
||||||
|
platform::errors::NotFound(
|
||||||
|
"Output(Out) of FlipOp should not be null."));
|
||||||
|
auto x_dims = ctx->GetInputDim("X");
|
||||||
|
auto flip_dims = ctx->Attrs().Get<std::vector<int>>("dims");
|
||||||
|
size_t flip_dims_size = flip_dims.size();
|
||||||
|
|
||||||
|
// check if dims axis within range
|
||||||
|
auto min_max_d = std::minmax_element(flip_dims.begin(), flip_dims.end());
|
||||||
|
PADDLE_ENFORCE_LT(*min_max_d.first, x_dims.size(),
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"min(dims) should be less than the input tensor X's "
|
||||||
|
"dimensions of FlipOp. But received min(dims) = %d, "
|
||||||
|
"X's dimensions = %d, X's shape = [%s]",
|
||||||
|
*min_max_d.first, x_dims.size(), x_dims));
|
||||||
|
PADDLE_ENFORCE_GE(
|
||||||
|
*min_max_d.first, x_dims.size() * -1,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"min(dims) should be greater than or equal to the input tensor X's "
|
||||||
|
"dimensions of FlipOp times -1. But received min(dims) = %d, X's "
|
||||||
|
"dimensions = %d, X's shape = [%s]",
|
||||||
|
*min_max_d.first, x_dims.size() * -1, x_dims));
|
||||||
|
PADDLE_ENFORCE_LT(*min_max_d.second, x_dims.size(),
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"max(dims) should be less than the input tensor X's "
|
||||||
|
"dimensions of FlipOp. But received max(dims) = %d, "
|
||||||
|
"X's dimensions = %d, X's shape = [%s]",
|
||||||
|
*min_max_d.second, x_dims.size(), x_dims));
|
||||||
|
PADDLE_ENFORCE_GE(
|
||||||
|
*min_max_d.second, x_dims.size() * -1,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"max(dims) should be greater than or equal to the input tensor X's "
|
||||||
|
"dimensions of FlipOp times -1. But received max(dims) = %d, X's "
|
||||||
|
"dimensions = %d, X's shape = [%s]",
|
||||||
|
*min_max_d.second, x_dims.size() * -1, x_dims));
|
||||||
|
|
||||||
|
// check duplicates in dims
|
||||||
|
flip_dims.erase(std::unique(flip_dims.begin(), flip_dims.end()),
|
||||||
|
flip_dims.end());
|
||||||
|
PADDLE_ENFORCE_EQ(flip_dims.size(), flip_dims_size,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"dims has duplicates, original flip dims size=%d, "
|
||||||
|
"but unique flip dims size=%d.)",
|
||||||
|
flip_dims_size, flip_dims.size()));
|
||||||
|
|
||||||
|
VLOG(3) << "flip operator x.shape=" << x_dims;
|
||||||
|
|
||||||
|
std::vector<int64_t> output_dims(x_dims.size());
|
||||||
|
for (int i = 0; i < x_dims.size(); ++i) {
|
||||||
|
output_dims[i] = x_dims[i];
|
||||||
|
}
|
||||||
|
ctx->SetOutputDim("Out", framework::make_ddim(output_dims));
|
||||||
|
ctx->ShareLoD("X", "Out");
|
||||||
|
}
|
||||||
|
|
||||||
|
framework::OpKernelType GetExpectedKernelType(
|
||||||
|
const framework::ExecutionContext& ctx) const {
|
||||||
|
framework::LibraryType library = framework::LibraryType::kPlain;
|
||||||
|
framework::DataLayout layout = framework::DataLayout::kAnyLayout;
|
||||||
|
int customized_type_value =
|
||||||
|
framework::OpKernelType::kDefaultCustomizedTypeValue;
|
||||||
|
auto input_data_type = OperatorWithKernel::IndicateVarDataType(ctx, "X");
|
||||||
|
return framework::OpKernelType(input_data_type, ctx.GetPlace(), layout,
|
||||||
|
library, customized_type_value);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class FlipOpMaker : public framework::OpProtoAndCheckerMaker {
|
||||||
|
public:
|
||||||
|
void Make() override {
|
||||||
|
AddInput("X", "(Tensor), The input tensor of flip op.");
|
||||||
|
AddOutput("Out", "(Tensor), The output tensor of flip op.");
|
||||||
|
AddAttr<std::vector<int>>("dims", "The axes to flip on.");
|
||||||
|
AddComment(R"DOC(
|
||||||
|
Flip Operator.
|
||||||
|
Reverse the order of a n-D tensor along given axis in dims.
|
||||||
|
)DOC");
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class FlipOpInferVarType : public framework::PassInDtypeAndVarTypeToOutput {
|
||||||
|
protected:
|
||||||
|
std::unordered_map<std::string, std::string> GetInputOutputWithSameType()
|
||||||
|
const override {
|
||||||
|
return std::unordered_map<std::string, std::string>{{"X", /*->*/ "Out"}};
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class FlipOpGradMaker : public framework::SingleGradOpMaker<T> {
|
||||||
|
public:
|
||||||
|
using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
void Apply(GradOpPtr<T> retv) const override {
|
||||||
|
retv->SetType("flip");
|
||||||
|
retv->SetInput("X", this->OutputGrad("Out"));
|
||||||
|
retv->SetOutput("Out", this->InputGrad("X"));
|
||||||
|
retv->SetAttrMap(this->Attrs());
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace operators
|
||||||
|
} // namespace paddle
|
||||||
|
|
||||||
|
namespace ops = paddle::operators;
|
||||||
|
REGISTER_OPERATOR(flip, ops::FlipOp, ops::FlipOpMaker, ops::FlipOpInferVarType,
|
||||||
|
ops::FlipOpGradMaker<paddle::framework::OpDesc>,
|
||||||
|
ops::FlipOpGradMaker<paddle::imperative::OpBase>);
|
||||||
|
REGISTER_OP_CPU_KERNEL(
|
||||||
|
flip, ops::FlipKernel<paddle::platform::CPUDeviceContext, float>,
|
||||||
|
ops::FlipKernel<paddle::platform::CPUDeviceContext, double>,
|
||||||
|
ops::FlipKernel<paddle::platform::CPUDeviceContext, int32_t>,
|
||||||
|
ops::FlipKernel<paddle::platform::CPUDeviceContext, int64_t>,
|
||||||
|
ops::FlipKernel<paddle::platform::CPUDeviceContext, bool>);
|
||||||
@ -0,0 +1,166 @@
|
|||||||
|
/* Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||||
|
|
||||||
|
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/fluid/operators/flip_op.h"
|
||||||
|
|
||||||
|
#include <vector>
|
||||||
|
#include "paddle/fluid/memory/malloc.h"
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
namespace operators {
|
||||||
|
|
||||||
|
using Tensor = framework::Tensor;
|
||||||
|
using CUDADeviceContext = paddle::platform::CUDADeviceContext;
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
__global__ void kernel_pointwise_flip_apply(const int N, const T* in_data,
|
||||||
|
T* out_data, int dim0, int stride0,
|
||||||
|
int dim1, int flip_dim) {
|
||||||
|
for (int idx = blockIdx.x * blockDim.x + threadIdx.x; idx < N;
|
||||||
|
idx += gridDim.x * blockDim.x) {
|
||||||
|
int dst_offset = 0;
|
||||||
|
if (flip_dim == 0) {
|
||||||
|
// flip 1st dim
|
||||||
|
dst_offset = (dim0 - 1 - idx / stride0) * stride0 + idx % stride0;
|
||||||
|
} else {
|
||||||
|
// flip last dim
|
||||||
|
dst_offset = idx / stride0 * stride0 + (dim1 - 1 - idx % stride0);
|
||||||
|
}
|
||||||
|
out_data[dst_offset] = in_data[idx];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
__global__ void flip_cuda_kernel(const int N, const T* in_data, T* out_data,
|
||||||
|
int64_t* x_shape, int64_t* x_stride,
|
||||||
|
int* flip_dims, int flip_dims_size,
|
||||||
|
int total_dims) {
|
||||||
|
int idx = blockIdx.x * blockDim.x + threadIdx.x;
|
||||||
|
if (idx >= N) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
int cur_indices = idx, rem = 0, dst_offset = 0;
|
||||||
|
for (int i = 0; i < total_dims; ++i) {
|
||||||
|
int64_t temp = cur_indices;
|
||||||
|
cur_indices = cur_indices / x_stride[i];
|
||||||
|
rem = temp - cur_indices * x_stride[i];
|
||||||
|
// flip the indices if it is in flip_dims
|
||||||
|
for (int j = 0; j < flip_dims_size; ++j) {
|
||||||
|
if (i == flip_dims[j]) {
|
||||||
|
cur_indices = x_shape[i] - 1 - cur_indices;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
dst_offset += cur_indices * x_stride[i];
|
||||||
|
cur_indices = rem;
|
||||||
|
}
|
||||||
|
out_data[idx] = in_data[dst_offset];
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class FlipKernel<platform::CUDADeviceContext, T>
|
||||||
|
: public framework::OpKernel<T> {
|
||||||
|
public:
|
||||||
|
void Compute(const framework::ExecutionContext& ctx) const override {
|
||||||
|
const auto gplace = boost::get<platform::CUDAPlace>(ctx.GetPlace());
|
||||||
|
auto cplace = platform::CPUPlace();
|
||||||
|
auto& dev_ctx = ctx.template device_context<CUDADeviceContext>();
|
||||||
|
|
||||||
|
const Tensor* x = ctx.Input<Tensor>("X");
|
||||||
|
Tensor* out = ctx.Output<Tensor>("Out");
|
||||||
|
auto* in_data = x->data<T>();
|
||||||
|
auto* out_data = out->mutable_data<T>(ctx.GetPlace());
|
||||||
|
auto flip_dims = ctx.template Attr<std::vector<int>>("dims");
|
||||||
|
|
||||||
|
const int flip_dims_size = static_cast<int>(flip_dims.size());
|
||||||
|
auto x_dims = x->dims();
|
||||||
|
const int total_dims = x_dims.size();
|
||||||
|
const int N = x->numel();
|
||||||
|
|
||||||
|
int block_size = 512;
|
||||||
|
dim3 dim_block(block_size);
|
||||||
|
dim3 dim_grid((N + block_size - 1) / block_size);
|
||||||
|
|
||||||
|
for (size_t i = 0; i < flip_dims.size(); ++i) {
|
||||||
|
if (flip_dims[i] < 0) {
|
||||||
|
flip_dims[i] += total_dims;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
auto x_stride = framework::stride(x_dims);
|
||||||
|
std::vector<int64_t> x_dims_v = framework::vectorize(x_dims);
|
||||||
|
std::vector<int64_t> x_stride_v = framework::vectorize(x_stride);
|
||||||
|
|
||||||
|
// wrap high-dims to 2-dims
|
||||||
|
if (flip_dims_size == 1 &&
|
||||||
|
(flip_dims[0] == 0 || flip_dims[0] == total_dims - 1)) {
|
||||||
|
int dim0 = 1, dim1 = 1;
|
||||||
|
int stride0 = 1;
|
||||||
|
if (flip_dims[0] == 0) {
|
||||||
|
dim0 = x_dims_v[0];
|
||||||
|
stride0 = x_stride_v[0];
|
||||||
|
for (size_t i = 1; i < total_dims; ++i) {
|
||||||
|
dim1 *= x_dims_v[i];
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
dim1 = x_dims_v[total_dims - 1];
|
||||||
|
for (size_t i = 0; i < total_dims - 1; ++i) {
|
||||||
|
dim0 *= x_dims_v[i];
|
||||||
|
}
|
||||||
|
stride0 *= x_dims_v[total_dims - 1];
|
||||||
|
}
|
||||||
|
kernel_pointwise_flip_apply<
|
||||||
|
T><<<dim_grid, dim_block, 0, ctx.cuda_device_context().stream()>>>(
|
||||||
|
N, in_data, out_data, dim0, stride0, dim1, flip_dims[0]);
|
||||||
|
}
|
||||||
|
|
||||||
|
int bytes = total_dims * sizeof(int64_t);
|
||||||
|
auto x_strides_array_tmp = memory::Alloc(dev_ctx, bytes);
|
||||||
|
int64_t* x_strides_array_gpu =
|
||||||
|
reinterpret_cast<int64_t*>(x_strides_array_tmp->ptr());
|
||||||
|
memory::Copy(gplace, x_strides_array_gpu, cplace, x_stride_v.data(), bytes,
|
||||||
|
dev_ctx.stream());
|
||||||
|
|
||||||
|
auto x_shape_array_tmp = memory::Alloc(dev_ctx, bytes);
|
||||||
|
int64_t* x_shape_array_gpu =
|
||||||
|
reinterpret_cast<int64_t*>(x_shape_array_tmp->ptr());
|
||||||
|
memory::Copy(gplace, x_shape_array_gpu, cplace, x_dims_v.data(), bytes,
|
||||||
|
dev_ctx.stream());
|
||||||
|
|
||||||
|
bytes = flip_dims_size * sizeof(int);
|
||||||
|
auto flip_dims_array_tmp = memory::Alloc(dev_ctx, bytes);
|
||||||
|
int* flip_dims_array_gpu =
|
||||||
|
reinterpret_cast<int*>(flip_dims_array_tmp->ptr());
|
||||||
|
memory::Copy(gplace, flip_dims_array_gpu, cplace, flip_dims.data(), bytes,
|
||||||
|
dev_ctx.stream());
|
||||||
|
|
||||||
|
flip_cuda_kernel<
|
||||||
|
T><<<dim_grid, dim_block, 0, ctx.cuda_device_context().stream()>>>(
|
||||||
|
N, in_data, out_data, x_shape_array_gpu, x_strides_array_gpu,
|
||||||
|
flip_dims_array_gpu, flip_dims_size, total_dims);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace operators
|
||||||
|
} // namespace paddle
|
||||||
|
|
||||||
|
namespace ops = paddle::operators;
|
||||||
|
namespace plat = paddle::platform;
|
||||||
|
REGISTER_OP_CUDA_KERNEL(
|
||||||
|
flip, ops::FlipKernel<paddle::platform::CUDADeviceContext, float>,
|
||||||
|
ops::FlipKernel<paddle::platform::CUDADeviceContext, double>,
|
||||||
|
ops::FlipKernel<paddle::platform::CUDADeviceContext, plat::float16>,
|
||||||
|
ops::FlipKernel<paddle::platform::CUDADeviceContext, int>,
|
||||||
|
ops::FlipKernel<paddle::platform::CUDADeviceContext, int64_t>,
|
||||||
|
ops::FlipKernel<paddle::platform::CUDADeviceContext, bool>);
|
||||||
@ -0,0 +1,83 @@
|
|||||||
|
/* Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||||
|
|
||||||
|
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 <algorithm>
|
||||||
|
#include <bitset>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include "paddle/fluid/framework/op_registry.h"
|
||||||
|
#include "paddle/fluid/framework/operator.h"
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
namespace operators {
|
||||||
|
|
||||||
|
using Tensor = framework::Tensor;
|
||||||
|
|
||||||
|
constexpr size_t dim_bitset_size = 64;
|
||||||
|
|
||||||
|
template <typename DeviceContext, typename T>
|
||||||
|
class FlipKernel : public framework::OpKernel<T> {
|
||||||
|
public:
|
||||||
|
void Compute(const framework::ExecutionContext& ctx) const override;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class FlipKernel<platform::CPUDeviceContext, T>
|
||||||
|
: public framework::OpKernel<T> {
|
||||||
|
public:
|
||||||
|
void Compute(const framework::ExecutionContext& ctx) const override {
|
||||||
|
const Tensor* x = ctx.Input<Tensor>("X");
|
||||||
|
Tensor* out = ctx.Output<Tensor>("Out");
|
||||||
|
auto flip_dims = ctx.template Attr<std::vector<int>>("dims");
|
||||||
|
|
||||||
|
auto x_dims = x->dims();
|
||||||
|
const int total_dims = x_dims.size();
|
||||||
|
std::bitset<dim_bitset_size> dim_bitset;
|
||||||
|
for (size_t i = 0; i < flip_dims.size(); ++i) {
|
||||||
|
int dim = flip_dims[i];
|
||||||
|
if (flip_dims[i] < 0) {
|
||||||
|
dim += total_dims;
|
||||||
|
}
|
||||||
|
dim_bitset[dim] = true;
|
||||||
|
}
|
||||||
|
auto x_strides = framework::stride(x_dims);
|
||||||
|
auto numel = x->numel();
|
||||||
|
const T* x_data = x->data<T>();
|
||||||
|
T* out_data = out->mutable_data<T>(ctx.GetPlace());
|
||||||
|
#ifdef PADDLE_WITH_MKLML
|
||||||
|
#pragma omp parallel for
|
||||||
|
#endif
|
||||||
|
for (int64_t i = 0; i < numel; ++i) {
|
||||||
|
int64_t cur_indices = i;
|
||||||
|
int64_t rem = 0;
|
||||||
|
int64_t dst_offset = 0;
|
||||||
|
|
||||||
|
for (int d = 0; d < total_dims; ++d) {
|
||||||
|
int64_t temp = cur_indices;
|
||||||
|
cur_indices = cur_indices / x_strides[d];
|
||||||
|
rem = temp - cur_indices * x_strides[d];
|
||||||
|
dst_offset += dim_bitset[d]
|
||||||
|
? (x_dims[d] - 1 - cur_indices) * x_strides[d]
|
||||||
|
: cur_indices * x_strides[d];
|
||||||
|
cur_indices = rem;
|
||||||
|
}
|
||||||
|
out_data[i] = x_data[dst_offset];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace operators
|
||||||
|
} // namespace paddle
|
||||||
@ -0,0 +1,115 @@
|
|||||||
|
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||||
|
#
|
||||||
|
# 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.
|
||||||
|
|
||||||
|
from __future__ import print_function
|
||||||
|
|
||||||
|
import unittest
|
||||||
|
import numpy as np
|
||||||
|
import paddle
|
||||||
|
import paddle.fluid as fluid
|
||||||
|
import paddle.fluid.core as core
|
||||||
|
from paddle.fluid import Program, program_guard
|
||||||
|
from op_test import OpTest
|
||||||
|
|
||||||
|
|
||||||
|
class TestFlipOp_API(unittest.TestCase):
|
||||||
|
"""Test flip api."""
|
||||||
|
|
||||||
|
def test_static_graph(self):
|
||||||
|
startup_program = fluid.Program()
|
||||||
|
train_program = fluid.Program()
|
||||||
|
with fluid.program_guard(train_program, startup_program):
|
||||||
|
dims = [0]
|
||||||
|
input = fluid.data(name='input', dtype='float32', shape=[2, 3])
|
||||||
|
output = paddle.flip(input, dims)
|
||||||
|
place = fluid.CPUPlace()
|
||||||
|
if fluid.core.is_compiled_with_cuda():
|
||||||
|
place = fluid.CUDAPlace(0)
|
||||||
|
exe = fluid.Executor(place)
|
||||||
|
exe.run(startup_program)
|
||||||
|
img = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
|
||||||
|
res = exe.run(train_program,
|
||||||
|
feed={'input': img},
|
||||||
|
fetch_list=[output])
|
||||||
|
out_np = np.array(res[0])
|
||||||
|
out_ref = np.array([[4, 5, 6], [1, 2, 3]]).astype(np.float32)
|
||||||
|
self.assertTrue(
|
||||||
|
(out_np == out_ref).all(),
|
||||||
|
msg='flip output is wrong, out =' + str(out_np))
|
||||||
|
|
||||||
|
def test_dygraph(self):
|
||||||
|
img = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
|
||||||
|
with fluid.dygraph.guard():
|
||||||
|
inputs = fluid.dygraph.to_variable(img)
|
||||||
|
ret = paddle.flip(inputs, [0])
|
||||||
|
out_ref = np.array([[4, 5, 6], [1, 2, 3]]).astype(np.float32)
|
||||||
|
self.assertTrue(
|
||||||
|
(ret.numpy() == out_ref).all(),
|
||||||
|
msg='flip output is wrong, out =' + str(ret.numpy()))
|
||||||
|
|
||||||
|
|
||||||
|
class TestFlipOp(OpTest):
|
||||||
|
def setUp(self):
|
||||||
|
self.op_type = 'flip'
|
||||||
|
self.init_test_case()
|
||||||
|
self.inputs = {'X': np.random.random(self.in_shape).astype('float64')}
|
||||||
|
self.init_attrs()
|
||||||
|
self.outputs = {'Out': self.calc_ref_res()}
|
||||||
|
|
||||||
|
def init_attrs(self):
|
||||||
|
self.attrs = {"dims": self.dims}
|
||||||
|
|
||||||
|
def test_check_output(self):
|
||||||
|
self.check_output()
|
||||||
|
|
||||||
|
def test_check_grad(self):
|
||||||
|
self.check_grad(["X"], "Out")
|
||||||
|
|
||||||
|
def init_test_case(self):
|
||||||
|
self.in_shape = (6, 4, 2, 3)
|
||||||
|
self.dims = [0, 1]
|
||||||
|
|
||||||
|
def calc_ref_res(self):
|
||||||
|
res = self.inputs['X']
|
||||||
|
for axis in self.dims:
|
||||||
|
res = np.flip(res, axis)
|
||||||
|
return res
|
||||||
|
|
||||||
|
|
||||||
|
class TestFlipOpAxis1(TestFlipOp):
|
||||||
|
def init_test_case(self):
|
||||||
|
self.in_shape = (2, 4, 4)
|
||||||
|
self.dims = [0]
|
||||||
|
|
||||||
|
|
||||||
|
class TestFlipOpAxis2(TestFlipOp):
|
||||||
|
def init_test_case(self):
|
||||||
|
self.in_shape = (4, 4, 6, 3)
|
||||||
|
self.dims = [0, 2]
|
||||||
|
|
||||||
|
|
||||||
|
class TestFlipOpAxis3(TestFlipOp):
|
||||||
|
def init_test_case(self):
|
||||||
|
self.in_shape = (4, 3, 1)
|
||||||
|
self.dims = [0, 1, 2]
|
||||||
|
|
||||||
|
|
||||||
|
class TestFlipOpAxis4(TestFlipOp):
|
||||||
|
def init_test_case(self):
|
||||||
|
self.in_shape = (6, 4, 2, 2)
|
||||||
|
self.dims = [0, 1, 2, 3]
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
unittest.main()
|
||||||
Loading…
Reference in new issue