From ae28c0f7548046540683906f5a51e693d9f658b2 Mon Sep 17 00:00:00 2001 From: zhupengyang Date: Tue, 24 Dec 2019 09:39:44 +0800 Subject: [PATCH] [XPU] elementwise_add, softmax unit test (#2653) * [XPU] elementwise_add unit test * [XPU] softmax unit test test=develop --- lite/tests/kernels/CMakeLists.txt | 3 +- .../tests/kernels/elementwise_compute_test.cc | 12 ++ lite/tests/kernels/softmax_compute_test.cc | 122 ++++++++++++++++++ 3 files changed, 136 insertions(+), 1 deletion(-) create mode 100644 lite/tests/kernels/softmax_compute_test.cc diff --git a/lite/tests/kernels/CMakeLists.txt b/lite/tests/kernels/CMakeLists.txt index 0d7890b43c..9915aca51c 100644 --- a/lite/tests/kernels/CMakeLists.txt +++ b/lite/tests/kernels/CMakeLists.txt @@ -4,7 +4,7 @@ if((NOT LITE_WITH_OPENCL AND NOT LITE_WITH_FPGA) AND (LITE_WITH_X86 OR LITE_WITH lite_cc_test(test_kernel_shuffle_channel_compute SRCS shuffle_channel_compute_test.cc DEPS arena_framework ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) lite_cc_test(test_kernel_yolo_box_compute SRCS yolo_box_compute_test.cc DEPS arena_framework ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) lite_cc_test(test_fc SRCS fc_compute_test.cc DEPS arena_framework ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) - lite_cc_test(test_kernel_elementwise_compute SRCS elementwise_compute_test.cc DEPS arena_framework ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) + lite_cc_test(test_kernel_elementwise_compute SRCS elementwise_compute_test.cc DEPS arena_framework ${xpu_kernels} ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) lite_cc_test(test_kernel_lrn_compute SRCS lrn_compute_test.cc DEPS arena_framework ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) lite_cc_test(test_kernel_decode_bboxes_compute SRCS decode_bboxes_compute_test.cc DEPS arena_framework ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) lite_cc_test(test_kernel_box_coder_compute SRCS box_coder_compute_test.cc DEPS arena_framework ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) @@ -28,6 +28,7 @@ if((NOT LITE_WITH_OPENCL AND NOT LITE_WITH_FPGA) AND (LITE_WITH_X86 OR LITE_WITH lite_cc_test(test_kernel_transpose_compute SRCS transpose_compute_test.cc DEPS arena_framework ${xpu_kernels} ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) lite_cc_test(test_kernel_reshape_compute SRCS reshape_compute_test.cc DEPS arena_framework ${xpu_kernels} ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) lite_cc_test(test_kernel_layer_norm_compute SRCS layer_norm_compute_test.cc DEPS arena_framework ${xpu_kernels} ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) + lite_cc_test(test_kernel_softmax_compute SRCS softmax_compute_test.cc DEPS arena_framework ${xpu_kernels} ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) if(LITE_BUILD_EXTRA) lite_cc_test(test_gru_unit SRCS gru_unit_test.cc DEPS arena_framework ${x86_kernels} ${arm_kernels} ${lite_ops} ${host_kernels}) diff --git a/lite/tests/kernels/elementwise_compute_test.cc b/lite/tests/kernels/elementwise_compute_test.cc index 635f6e7c08..2c62929010 100644 --- a/lite/tests/kernels/elementwise_compute_test.cc +++ b/lite/tests/kernels/elementwise_compute_test.cc @@ -653,5 +653,17 @@ TEST(FusionElementwise, precision) { #endif } +#ifdef LITE_WITH_XPU +TEST(Elementwise_XPU, precision) { + Place place(TARGET(kXPU)); + for (int axis : {-1, 1}) { + std::unique_ptr tester( + new ElementwiseComputeTester(place, "def", axis)); + arena::Arena arena(std::move(tester), place, 2e-5); + arena.TestPrecision(); + } +} +#endif + } // namespace lite } // namespace paddle diff --git a/lite/tests/kernels/softmax_compute_test.cc b/lite/tests/kernels/softmax_compute_test.cc new file mode 100644 index 0000000000..94100da2b1 --- /dev/null +++ b/lite/tests/kernels/softmax_compute_test.cc @@ -0,0 +1,122 @@ +// Copyright (c) 2019 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 +#include "lite/api/paddle_use_kernels.h" +#include "lite/api/paddle_use_ops.h" +#include "lite/core/arena/framework.h" +#include "lite/tests/utils/fill_data.h" + +namespace paddle { +namespace lite { + +class SoftmaxComputeTest : public arena::TestCase { + protected: + // common attributes for this op. + std::string op_type_ = "softmax"; + std::string input_ = "x"; + std::string output_ = "out"; + DDim dims_{{1, 2, 3, 4}}; + int axis_ = 1; + + public: + SoftmaxComputeTest(const Place& place, + const std::string& alias, + DDim dims, + int axis) + : TestCase(place, alias), dims_(dims), axis_(axis) {} + + void RunBaseline(Scope* scope) override { + auto x = scope->FindTensor(input_); + auto out = scope->NewTensor(output_); + CHECK(out); + out->Resize(dims_); + + auto x_data = x->data(); + auto out_data = out->mutable_data(); + auto x_rank = dims_.size(); + if (axis_ < 0) { + axis_ += x_rank; + } + int axis_size = dims_[axis_]; + int outer_num = dims_.Slice(0, axis_).production(); + int inner_num = dims_.Slice(axis_ + 1, x_rank).production(); + int compute_size = outer_num * inner_num; + for (int i = 0; i < compute_size; i++) { + int idx_inner = i % inner_num; + int idx_outer = (i / inner_num) * axis_size; + int start = idx_outer * inner_num + idx_inner; + int offset; + + offset = start; + float max_data = std::numeric_limits::lowest(); + for (int j = 0; j < axis_size; j++) { + max_data = x_data[offset] > max_data ? x_data[offset] : max_data; + offset += inner_num; + } + + offset = start; + float sum_data = 0.f; + for (int j = 0; j < axis_size; j++) { + out_data[offset] = exp(x_data[offset] - max_data); + sum_data += out_data[offset]; + offset += inner_num; + } + + offset = start; + for (int j = 0; j < axis_size; j++) { + out_data[offset] /= sum_data; + offset += inner_num; + } + } + } + + void PrepareOpDesc(cpp::OpDesc* op_desc) { + op_desc->SetType(op_type_); + op_desc->SetInput("X", {input_}); + op_desc->SetOutput("Out", {output_}); + op_desc->SetAttr("axis", axis_); + } + + void PrepareData() override { + std::vector din(dims_.production()); + fill_data_rand(din.data(), -1.f, 1.f, dims_.production()); + SetCommonTensor(input_, dims_, din.data()); + } +}; + +TEST(Softmax, precision) { + LOG(INFO) << "test softmax op"; + float abs_error = 2e-5; + Place place; +#if defined(LITE_WITH_XPU) + place = TARGET(kXPU); +#else + return; +#endif + + std::vector> dims{{1, 2, 3, 4}, {2, 3, 4}, {3, 4}}; + for (auto dim_in : dims) { + for (auto axis : {-1, 0, 1, 2, 3}) { + if (axis >= dim_in.size()) continue; + std::unique_ptr tester( + new SoftmaxComputeTest(place, "def", DDim(dim_in), axis)); + arena::Arena arena(std::move(tester), place, abs_error); + arena.TestPrecision(); + } + } +} + +} // namespace lite +} // namespace paddle -- GitLab