kunlun add op (#27890)
* add stack pool2d roi_align xpu op,test=kunlun * error message opt, test=kunlun * add xpu unittest,test=kunlun * skip check grad,test=kunlun * fix boostget , test=kunlunmy_2.0rc
Double_V
4 years ago
committed by
GitHub
parent
82eb486edd
commit
b0edda4d99
@ -0,0 +1,165 @@
|
|||||||
|
/* Copyright (c) 2016 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/pool_op.h"
|
||||||
|
#include <unordered_map>
|
||||||
|
|
||||||
|
#ifdef PADDLE_WITH_XPU
|
||||||
|
namespace paddle {
|
||||||
|
namespace operators {
|
||||||
|
|
||||||
|
xpu::Pooling_t XPUPoolingType(const std::string& pooltype, bool exclusive,
|
||||||
|
bool is_test) {
|
||||||
|
if (pooltype == "max") {
|
||||||
|
return xpu::Pooling_t::MAX_WITHOUT_INDEX;
|
||||||
|
} else if (pooltype == "avg") {
|
||||||
|
if (exclusive) {
|
||||||
|
return xpu::Pooling_t::AVG_WITHOUT_PAD;
|
||||||
|
} else {
|
||||||
|
return xpu::Pooling_t::AVG_WITH_PAD;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
PADDLE_THROW(platform::errors::InvalidArgument(
|
||||||
|
"Pool op only supports 2D and 3D input."));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
template <typename DeviceContext, typename T>
|
||||||
|
class PoolXPUKernel : public framework::OpKernel<T> {
|
||||||
|
public:
|
||||||
|
void Compute(const framework::ExecutionContext& context) const override {
|
||||||
|
const Tensor* in_x = context.Input<Tensor>("X");
|
||||||
|
Tensor* out = context.Output<Tensor>("Out");
|
||||||
|
std::string pooling_type = context.Attr<std::string>("pooling_type");
|
||||||
|
std::vector<int> ksize = context.Attr<std::vector<int>>("ksize");
|
||||||
|
std::vector<int> strides = context.Attr<std::vector<int>>("strides");
|
||||||
|
std::vector<int> paddings = context.Attr<std::vector<int>>("paddings");
|
||||||
|
bool exclusive = context.Attr<bool>("exclusive");
|
||||||
|
bool is_test = context.Attr<bool>("is_test");
|
||||||
|
bool adaptive = context.Attr<bool>("adaptive");
|
||||||
|
PADDLE_ENFORCE_EQ(!adaptive, true,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"XPU does not support adaptive == true!"));
|
||||||
|
PADDLE_ENFORCE_EQ(ksize.size(), 2,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"XPU only support 2 dimension pooling!"));
|
||||||
|
int* index_data = nullptr;
|
||||||
|
if (context.Attr<bool>("global_pooling")) {
|
||||||
|
for (size_t i = 0; i < ksize.size(); ++i) {
|
||||||
|
paddings[i] = 0;
|
||||||
|
ksize[i] = static_cast<int>(in_x->dims()[i + 2]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
const int c = in_x->dims()[0] * in_x->dims()[1];
|
||||||
|
const int in_h = in_x->dims()[2];
|
||||||
|
const int in_w = in_x->dims()[3];
|
||||||
|
const int out_h = out->dims()[2];
|
||||||
|
const int out_w = out->dims()[3];
|
||||||
|
const int win_h = ksize[0];
|
||||||
|
const int win_w = ksize[1];
|
||||||
|
const int stride_h = strides[0];
|
||||||
|
const int stride_w = strides[1];
|
||||||
|
const int pad_up = paddings[0];
|
||||||
|
const int pad_down = paddings[0];
|
||||||
|
const int pad_left = paddings[1];
|
||||||
|
const int pad_right = paddings[1];
|
||||||
|
const float* input = in_x->data<float>();
|
||||||
|
out->mutable_data<T>(context.GetPlace());
|
||||||
|
float* output = out->data<float>();
|
||||||
|
xpu::Pooling_t pool_type = XPUPoolingType(pooling_type, exclusive, is_test);
|
||||||
|
auto& dev_ctx = context.template device_context<DeviceContext>();
|
||||||
|
int r = xpu::pooling_forward<float, float>(
|
||||||
|
dev_ctx.x_context(), input, output, index_data, pool_type, c, in_h,
|
||||||
|
in_w, pad_left, pad_right, pad_up, pad_down, win_h, win_w, stride_h,
|
||||||
|
stride_w, out_h, out_w);
|
||||||
|
PADDLE_ENFORCE_EQ(
|
||||||
|
r, xpu::Error_t::SUCCESS,
|
||||||
|
platform::errors::InvalidArgument("pool2d XPU kernel error!"));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
template <typename DeviceContext, typename T>
|
||||||
|
class PoolGradXPUKernel : public framework::OpKernel<T> {
|
||||||
|
public:
|
||||||
|
void Compute(const framework::ExecutionContext& context) const override {
|
||||||
|
const Tensor* in_x = context.Input<Tensor>("X");
|
||||||
|
const Tensor* out = context.Input<Tensor>("Out");
|
||||||
|
const Tensor* out_grad =
|
||||||
|
context.Input<Tensor>(framework::GradVarName("Out"));
|
||||||
|
Tensor* in_x_grad = context.Output<Tensor>(framework::GradVarName("X"));
|
||||||
|
std::string pooling_type = context.Attr<std::string>("pooling_type");
|
||||||
|
std::vector<int> ksize = context.Attr<std::vector<int>>("ksize");
|
||||||
|
std::vector<int> strides = context.Attr<std::vector<int>>("strides");
|
||||||
|
std::vector<int> paddings = context.Attr<std::vector<int>>("paddings");
|
||||||
|
bool exclusive = context.Attr<bool>("exclusive");
|
||||||
|
bool adaptive = context.Attr<bool>("adaptive");
|
||||||
|
const int* index_data = nullptr;
|
||||||
|
PADDLE_ENFORCE_EQ(!adaptive, true,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"XPU does not support adaptive == true!"));
|
||||||
|
PADDLE_ENFORCE_EQ(ksize.size(), 2,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"XPU only support 2 dimension pooling!"));
|
||||||
|
if (context.Attr<bool>("global_pooling")) {
|
||||||
|
for (size_t i = 0; i < ksize.size(); ++i) {
|
||||||
|
paddings[i] = 0;
|
||||||
|
ksize[i] = static_cast<int>(in_x->dims()[i + 2]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (!in_x_grad) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
const int c = in_x->dims()[0] * in_x->dims()[1];
|
||||||
|
const int in_h = in_x->dims()[2];
|
||||||
|
const int in_w = in_x->dims()[3];
|
||||||
|
const int out_h = out->dims()[2];
|
||||||
|
const int out_w = out->dims()[3];
|
||||||
|
const int win_h = ksize[0];
|
||||||
|
const int win_w = ksize[1];
|
||||||
|
const int stride_h = strides[0];
|
||||||
|
const int stride_w = strides[1];
|
||||||
|
const int pad_up = paddings[0];
|
||||||
|
const int pad_down = paddings[0];
|
||||||
|
const int pad_left = paddings[1];
|
||||||
|
const int pad_right = paddings[1];
|
||||||
|
const float* input = in_x->data<float>();
|
||||||
|
const float* output = out->data<float>();
|
||||||
|
const float* output_grad = out_grad->data<float>();
|
||||||
|
in_x_grad->mutable_data<T>(context.GetPlace());
|
||||||
|
float* input_grad = in_x_grad->data<float>();
|
||||||
|
xpu::Pooling_t pool_type = XPUPoolingType(pooling_type, exclusive, false);
|
||||||
|
auto& dev_ctx = context.template device_context<DeviceContext>();
|
||||||
|
// Need to init memory in the first place
|
||||||
|
const int zero = 0;
|
||||||
|
int r =
|
||||||
|
xpu::memset(dev_ctx.x_context(), reinterpret_cast<void**>(input_grad),
|
||||||
|
zero, in_x_grad->numel() * sizeof(float));
|
||||||
|
PADDLE_ENFORCE_EQ(r, xpu::Error_t::SUCCESS,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"There are pool2d grad XPU kernel error raised!"));
|
||||||
|
r = xpu::pooling_backward(dev_ctx.x_context(), input, output, index_data,
|
||||||
|
output_grad, input_grad, pool_type, c, in_h, in_w,
|
||||||
|
pad_left, pad_right, pad_up, pad_down, win_h,
|
||||||
|
win_w, stride_h, stride_w, out_h, out_w);
|
||||||
|
PADDLE_ENFORCE_EQ(r, xpu::Error_t::SUCCESS,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"There are pool2d grad XPU kernel error raised!"));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace operators
|
||||||
|
} // namespace paddle
|
||||||
|
|
||||||
|
namespace ops = paddle::operators;
|
||||||
|
REGISTER_OP_XPU_KERNEL(
|
||||||
|
pool2d, ops::PoolXPUKernel<paddle::platform::XPUDeviceContext, float>);
|
||||||
|
REGISTER_OP_XPU_KERNEL(
|
||||||
|
pool2d_grad,
|
||||||
|
ops::PoolGradXPUKernel<paddle::platform::XPUDeviceContext, float>);
|
||||||
|
|
||||||
|
#endif
|
||||||
@ -0,0 +1,78 @@
|
|||||||
|
/* Copyright (c) 2016 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. */
|
||||||
|
|
||||||
|
#ifdef PADDLE_WITH_XPU
|
||||||
|
#include "paddle/fluid/operators/roi_align_op.h"
|
||||||
|
#include <memory>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
namespace operators {
|
||||||
|
|
||||||
|
template <typename DeviceContext, typename T>
|
||||||
|
class XPUROIAlignOpKernel : public framework::OpKernel<T> {
|
||||||
|
public:
|
||||||
|
void Compute(const framework::ExecutionContext& ctx) const override {
|
||||||
|
auto* in = ctx.Input<framework::Tensor>("X");
|
||||||
|
auto* rois = ctx.Input<framework::LoDTensor>("ROIs");
|
||||||
|
auto* out = ctx.Output<framework::Tensor>("Out");
|
||||||
|
auto pooled_height = ctx.Attr<int>("pooled_height");
|
||||||
|
auto pooled_width = ctx.Attr<int>("pooled_width");
|
||||||
|
auto spatial_scale = ctx.Attr<float>("spatial_scale");
|
||||||
|
auto sampling_ratio = ctx.Attr<int>("sampling_ratio");
|
||||||
|
auto& dev_ctx = ctx.template device_context<DeviceContext>();
|
||||||
|
auto in_dims = in->dims();
|
||||||
|
int batch_size = in_dims[0];
|
||||||
|
int channels = in_dims[1];
|
||||||
|
int height = in_dims[2];
|
||||||
|
int width = in_dims[3];
|
||||||
|
int rois_num = rois->dims()[0];
|
||||||
|
const T* input_data = in->data<T>();
|
||||||
|
auto rois_lod = rois->lod().back();
|
||||||
|
int rois_batch_size = rois_lod.size() - 1;
|
||||||
|
PADDLE_ENFORCE_EQ(
|
||||||
|
rois_batch_size, batch_size,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"The rois_batch_size and imgs batch_size must be the same."));
|
||||||
|
int rois_num_with_lod = rois_lod[rois_batch_size];
|
||||||
|
PADDLE_ENFORCE_EQ(rois_num, rois_num_with_lod,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"The rois_num from input and lod must be the same."));
|
||||||
|
T* output_data = out->mutable_data<T>(ctx.GetPlace());
|
||||||
|
const T* rois_data = rois->data<T>();
|
||||||
|
for (int n = 0; n < rois_batch_size; n++) {
|
||||||
|
int cur_batch_rois_num = rois_lod[n + 1] - rois_lod[n];
|
||||||
|
if (cur_batch_rois_num != 0) {
|
||||||
|
int r = xpu::roi_align(
|
||||||
|
dev_ctx.x_context(), input_data + n * channels * height * width,
|
||||||
|
rois_data + rois_lod[n] * 4, cur_batch_rois_num, channels, height,
|
||||||
|
width, pooled_height, pooled_width, sampling_ratio, spatial_scale,
|
||||||
|
output_data +
|
||||||
|
rois_lod[n] * channels * pooled_height * pooled_width);
|
||||||
|
PADDLE_ENFORCE_EQ(
|
||||||
|
r, xpu::Error_t::SUCCESS,
|
||||||
|
platform::errors::InvalidArgument("roi_align XPU kernel error!"));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace operators
|
||||||
|
} // namespace paddle
|
||||||
|
namespace ops = paddle::operators;
|
||||||
|
REGISTER_OP_XPU_KERNEL(
|
||||||
|
roi_align,
|
||||||
|
ops::XPUROIAlignOpKernel<paddle::platform::XPUDeviceContext, float>);
|
||||||
|
|
||||||
|
#endif
|
||||||
@ -0,0 +1,75 @@
|
|||||||
|
// Copyright (c) 2018 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/stack_op.h"
|
||||||
|
#ifdef PADDLE_WITH_XPU
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
namespace operators {
|
||||||
|
|
||||||
|
using framework::Tensor;
|
||||||
|
template <typename DeviceContext, typename T>
|
||||||
|
class StackXPUKernel : public framework::OpKernel<T> {
|
||||||
|
public:
|
||||||
|
void Compute(const framework::ExecutionContext& ctx) const override {
|
||||||
|
auto x = ctx.MultiInput<Tensor>("X");
|
||||||
|
auto* y = ctx.Output<Tensor>("Y");
|
||||||
|
int axis = ctx.Attr<int>("axis");
|
||||||
|
if (axis < 0) {
|
||||||
|
axis += (x[0]->dims().size() + 1);
|
||||||
|
}
|
||||||
|
int n = static_cast<int>(x.size());
|
||||||
|
PADDLE_ENFORCE_LE(n, 24,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"XPU only surpport at most 24 tensors for now"));
|
||||||
|
auto* y_data = y->mutable_data<T>(ctx.GetPlace());
|
||||||
|
int pre = 1, post = 1;
|
||||||
|
auto& dim = x[0]->dims();
|
||||||
|
for (auto i = 0; i < axis; ++i) {
|
||||||
|
pre *= dim[i];
|
||||||
|
}
|
||||||
|
for (auto i = axis; i < dim.size(); ++i) {
|
||||||
|
post *= dim[i];
|
||||||
|
}
|
||||||
|
auto& dev_ctx = ctx.template device_context<DeviceContext>();
|
||||||
|
void* x_datas_host = std::malloc(n * sizeof(void*));
|
||||||
|
void* x_datas_device = nullptr;
|
||||||
|
PADDLE_ENFORCE(xpu_malloc(reinterpret_cast<void**>(&x_datas_device),
|
||||||
|
n * sizeof(void*)) == XPU_SUCCESS);
|
||||||
|
for (auto i = 0; i < n; ++i) {
|
||||||
|
((const void**)x_datas_host)[i] = x[i]->data<T>();
|
||||||
|
}
|
||||||
|
memory::Copy(BOOST_GET_CONST(platform::XPUPlace, ctx.GetPlace()),
|
||||||
|
x_datas_device, platform::CPUPlace(), x_datas_host,
|
||||||
|
n * sizeof(void*));
|
||||||
|
int r = xpu::stack_forward<float>(dev_ctx.x_context(), pre, post, n,
|
||||||
|
x_datas_device, y_data);
|
||||||
|
PADDLE_ENFORCE_EQ(r, xpu::Error_t::SUCCESS,
|
||||||
|
platform::errors::InvalidArgument(
|
||||||
|
"There are stack XPU kernel error raised!"));
|
||||||
|
dev_ctx.Wait();
|
||||||
|
std::free(x_datas_host);
|
||||||
|
xpu_free(x_datas_device);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace operators
|
||||||
|
} // namespace paddle
|
||||||
|
|
||||||
|
namespace plat = paddle::platform;
|
||||||
|
namespace ops = paddle::operators;
|
||||||
|
|
||||||
|
REGISTER_OP_XPU_KERNEL(stack,
|
||||||
|
ops::StackXPUKernel<plat::XPUDeviceContext, float>);
|
||||||
|
#endif
|
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,183 @@
|
|||||||
|
# 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 sys
|
||||||
|
sys.path.append("..")
|
||||||
|
import unittest
|
||||||
|
import math
|
||||||
|
import numpy as np
|
||||||
|
import paddle.fluid.core as core
|
||||||
|
from op_test import OpTest, skip_check_grad_ci
|
||||||
|
import paddle
|
||||||
|
import paddle.fluid as fluid
|
||||||
|
from paddle.fluid import Program, program_guard
|
||||||
|
|
||||||
|
|
||||||
|
@skip_check_grad_ci(reason="There is no grad kernel for roi_align_xpu kernel.")
|
||||||
|
class TestROIAlignOp(OpTest):
|
||||||
|
def set_data(self):
|
||||||
|
self.init_test_case()
|
||||||
|
self.make_rois()
|
||||||
|
self.calc_roi_align()
|
||||||
|
|
||||||
|
self.inputs = {
|
||||||
|
'X': self.x,
|
||||||
|
'ROIs': (self.rois[:, 1:5], self.rois_lod),
|
||||||
|
}
|
||||||
|
self.attrs = {
|
||||||
|
'spatial_scale': self.spatial_scale,
|
||||||
|
'pooled_height': self.pooled_height,
|
||||||
|
'pooled_width': self.pooled_width,
|
||||||
|
'sampling_ratio': self.sampling_ratio
|
||||||
|
}
|
||||||
|
|
||||||
|
self.outputs = {'Out': self.out_data}
|
||||||
|
|
||||||
|
def init_test_case(self):
|
||||||
|
self.batch_size = 3
|
||||||
|
self.channels = 3
|
||||||
|
self.height = 8
|
||||||
|
self.width = 6
|
||||||
|
|
||||||
|
# n, c, h, w
|
||||||
|
self.x_dim = (self.batch_size, self.channels, self.height, self.width)
|
||||||
|
|
||||||
|
self.spatial_scale = 1.0 / 2.0
|
||||||
|
self.pooled_height = 2
|
||||||
|
self.pooled_width = 2
|
||||||
|
self.sampling_ratio = -1
|
||||||
|
|
||||||
|
self.x = np.random.random(self.x_dim).astype('float64')
|
||||||
|
|
||||||
|
def pre_calc(self, x_i, roi_xmin, roi_ymin, roi_bin_grid_h, roi_bin_grid_w,
|
||||||
|
bin_size_h, bin_size_w):
|
||||||
|
count = roi_bin_grid_h * roi_bin_grid_w
|
||||||
|
bilinear_pos = np.zeros(
|
||||||
|
[self.channels, self.pooled_height, self.pooled_width, count, 4],
|
||||||
|
np.float64)
|
||||||
|
bilinear_w = np.zeros(
|
||||||
|
[self.pooled_height, self.pooled_width, count, 4], np.float64)
|
||||||
|
for ph in range(self.pooled_width):
|
||||||
|
for pw in range(self.pooled_height):
|
||||||
|
c = 0
|
||||||
|
for iy in range(roi_bin_grid_h):
|
||||||
|
y = roi_ymin + ph * bin_size_h + (iy + 0.5) * \
|
||||||
|
bin_size_h / roi_bin_grid_h
|
||||||
|
for ix in range(roi_bin_grid_w):
|
||||||
|
x = roi_xmin + pw * bin_size_w + (ix + 0.5) * \
|
||||||
|
bin_size_w / roi_bin_grid_w
|
||||||
|
if y < -1.0 or y > self.height or \
|
||||||
|
x < -1.0 or x > self.width:
|
||||||
|
continue
|
||||||
|
if y <= 0:
|
||||||
|
y = 0
|
||||||
|
if x <= 0:
|
||||||
|
x = 0
|
||||||
|
y_low = int(y)
|
||||||
|
x_low = int(x)
|
||||||
|
if y_low >= self.height - 1:
|
||||||
|
y = y_high = y_low = self.height - 1
|
||||||
|
else:
|
||||||
|
y_high = y_low + 1
|
||||||
|
if x_low >= self.width - 1:
|
||||||
|
x = x_high = x_low = self.width - 1
|
||||||
|
else:
|
||||||
|
x_high = x_low + 1
|
||||||
|
ly = y - y_low
|
||||||
|
lx = x - x_low
|
||||||
|
hy = 1 - ly
|
||||||
|
hx = 1 - lx
|
||||||
|
for ch in range(self.channels):
|
||||||
|
bilinear_pos[ch, ph, pw, c, 0] = x_i[ch, y_low,
|
||||||
|
x_low]
|
||||||
|
bilinear_pos[ch, ph, pw, c, 1] = x_i[ch, y_low,
|
||||||
|
x_high]
|
||||||
|
bilinear_pos[ch, ph, pw, c, 2] = x_i[ch, y_high,
|
||||||
|
x_low]
|
||||||
|
bilinear_pos[ch, ph, pw, c, 3] = x_i[ch, y_high,
|
||||||
|
x_high]
|
||||||
|
bilinear_w[ph, pw, c, 0] = hy * hx
|
||||||
|
bilinear_w[ph, pw, c, 1] = hy * lx
|
||||||
|
bilinear_w[ph, pw, c, 2] = ly * hx
|
||||||
|
bilinear_w[ph, pw, c, 3] = ly * lx
|
||||||
|
c = c + 1
|
||||||
|
return bilinear_pos, bilinear_w
|
||||||
|
|
||||||
|
def calc_roi_align(self):
|
||||||
|
self.out_data = np.zeros(
|
||||||
|
(self.rois_num, self.channels, self.pooled_height,
|
||||||
|
self.pooled_width)).astype('float64')
|
||||||
|
|
||||||
|
for i in range(self.rois_num):
|
||||||
|
roi = self.rois[i]
|
||||||
|
roi_batch_id = int(roi[0])
|
||||||
|
x_i = self.x[roi_batch_id]
|
||||||
|
roi_xmin = roi[1] * self.spatial_scale
|
||||||
|
roi_ymin = roi[2] * self.spatial_scale
|
||||||
|
roi_xmax = roi[3] * self.spatial_scale
|
||||||
|
roi_ymax = roi[4] * self.spatial_scale
|
||||||
|
roi_width = max(roi_xmax - roi_xmin, 1)
|
||||||
|
roi_height = max(roi_ymax - roi_ymin, 1)
|
||||||
|
bin_size_h = float(roi_height) / float(self.pooled_height)
|
||||||
|
bin_size_w = float(roi_width) / float(self.pooled_width)
|
||||||
|
roi_bin_grid_h = self.sampling_ratio if self.sampling_ratio > 0 else \
|
||||||
|
math.ceil(roi_height / self.pooled_height)
|
||||||
|
roi_bin_grid_w = self.sampling_ratio if self.sampling_ratio > 0 else \
|
||||||
|
math.ceil(roi_width / self.pooled_width)
|
||||||
|
count = int(roi_bin_grid_h * roi_bin_grid_w)
|
||||||
|
pre_size = count * self.pooled_width * self.pooled_height
|
||||||
|
bilinear_pos, bilinear_w = self.pre_calc(x_i, roi_xmin, roi_ymin,
|
||||||
|
int(roi_bin_grid_h),
|
||||||
|
int(roi_bin_grid_w),
|
||||||
|
bin_size_h, bin_size_w)
|
||||||
|
for ch in range(self.channels):
|
||||||
|
align_per_bin = (bilinear_pos[ch] * bilinear_w).sum(axis=-1)
|
||||||
|
output_val = align_per_bin.mean(axis=-1)
|
||||||
|
self.out_data[i, ch, :, :] = output_val
|
||||||
|
|
||||||
|
def make_rois(self):
|
||||||
|
rois = []
|
||||||
|
self.rois_lod = [[]]
|
||||||
|
for bno in range(self.batch_size):
|
||||||
|
self.rois_lod[0].append(bno + 1)
|
||||||
|
for i in range(bno + 1):
|
||||||
|
x1 = np.random.random_integers(
|
||||||
|
0, self.width // self.spatial_scale - self.pooled_width)
|
||||||
|
y1 = np.random.random_integers(
|
||||||
|
0, self.height // self.spatial_scale - self.pooled_height)
|
||||||
|
|
||||||
|
x2 = np.random.random_integers(x1 + self.pooled_width,
|
||||||
|
self.width // self.spatial_scale)
|
||||||
|
y2 = np.random.random_integers(
|
||||||
|
y1 + self.pooled_height, self.height // self.spatial_scale)
|
||||||
|
|
||||||
|
roi = [bno, x1, y1, x2, y2]
|
||||||
|
rois.append(roi)
|
||||||
|
self.rois_num = len(rois)
|
||||||
|
self.rois = np.array(rois).astype("float64")
|
||||||
|
|
||||||
|
def setUp(self):
|
||||||
|
self.op_type = "roi_align"
|
||||||
|
self.set_data()
|
||||||
|
|
||||||
|
def test_check_output(self):
|
||||||
|
if paddle.is_compiled_with_xpu():
|
||||||
|
paddle.enable_static()
|
||||||
|
place = paddle.XPUPlace(0)
|
||||||
|
self.check_output_with_place(place)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
unittest.main()
|
||||||
@ -0,0 +1,100 @@
|
|||||||
|
# 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 sys
|
||||||
|
sys.path.append("..")
|
||||||
|
import unittest
|
||||||
|
import numpy as np
|
||||||
|
import paddle.fluid.core as core
|
||||||
|
from op_test import OpTest, skip_check_grad_ci
|
||||||
|
import paddle
|
||||||
|
import paddle.fluid as fluid
|
||||||
|
from paddle.fluid import Program, program_guard
|
||||||
|
|
||||||
|
|
||||||
|
@skip_check_grad_ci(reason="There is no grad kernel for stack_xpu op.")
|
||||||
|
class TestStackOpBase(OpTest):
|
||||||
|
def initDefaultParameters(self):
|
||||||
|
self.num_inputs = 4
|
||||||
|
self.input_dim = (5, 6, 7)
|
||||||
|
self.axis = 0
|
||||||
|
self.dtype = 'float64'
|
||||||
|
|
||||||
|
def initParameters(self):
|
||||||
|
pass
|
||||||
|
|
||||||
|
def get_x_names(self):
|
||||||
|
x_names = []
|
||||||
|
for i in range(self.num_inputs):
|
||||||
|
x_names.append('x{}'.format(i))
|
||||||
|
return x_names
|
||||||
|
|
||||||
|
def setUp(self):
|
||||||
|
self.initDefaultParameters()
|
||||||
|
self.initParameters()
|
||||||
|
self.op_type = 'stack'
|
||||||
|
self.x = []
|
||||||
|
for i in range(self.num_inputs):
|
||||||
|
self.x.append(
|
||||||
|
np.random.random(size=self.input_dim).astype(self.dtype))
|
||||||
|
|
||||||
|
tmp = []
|
||||||
|
x_names = self.get_x_names()
|
||||||
|
for i in range(self.num_inputs):
|
||||||
|
tmp.append((x_names[i], self.x[i]))
|
||||||
|
|
||||||
|
self.inputs = {'X': tmp}
|
||||||
|
self.outputs = {'Y': np.stack(self.x, axis=self.axis)}
|
||||||
|
self.attrs = {'axis': self.axis}
|
||||||
|
|
||||||
|
def test_check_output(self):
|
||||||
|
if paddle.is_compiled_with_xpu():
|
||||||
|
paddle.enable_static()
|
||||||
|
place = paddle.XPUPlace(0)
|
||||||
|
self.check_output_with_place(place)
|
||||||
|
|
||||||
|
|
||||||
|
class TestStackOp1(TestStackOpBase):
|
||||||
|
def initParameters(self):
|
||||||
|
self.num_inputs = 16
|
||||||
|
|
||||||
|
|
||||||
|
class TestStackOp2(TestStackOpBase):
|
||||||
|
def initParameters(self):
|
||||||
|
self.num_inputs = 20
|
||||||
|
|
||||||
|
|
||||||
|
class TestStackOp3(TestStackOpBase):
|
||||||
|
def initParameters(self):
|
||||||
|
self.axis = -1
|
||||||
|
|
||||||
|
|
||||||
|
class TestStackOp4(TestStackOpBase):
|
||||||
|
def initParameters(self):
|
||||||
|
self.axis = -4
|
||||||
|
|
||||||
|
|
||||||
|
class TestStackOp5(TestStackOpBase):
|
||||||
|
def initParameters(self):
|
||||||
|
self.axis = 1
|
||||||
|
|
||||||
|
|
||||||
|
class TestStackOp6(TestStackOpBase):
|
||||||
|
def initParameters(self):
|
||||||
|
self.axis = 3
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
unittest.main()
|
||||||
Loading…
Reference in new issue