wehub-resource-sync
246 lines
7.9 KiB
C++
246 lines
7.9 KiB
C++
/* 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/phi/kernels/funcs/math/beam_search.h"
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "paddle/fluid/framework/operator.h"
|
|
#include "paddle/phi/common/place.h"
|
|
#include "paddle/phi/core/platform/device_context.h"
|
|
|
|
void PrepareCPUTensors(phi::DenseTensor* ids,
|
|
phi::DenseTensor* scores,
|
|
phi::DenseTensor* pre_ids,
|
|
phi::DenseTensor* pre_scores) {
|
|
// lod
|
|
phi::LegacyLoD lod;
|
|
std::vector<size_t> level0({0, 2, 4});
|
|
std::vector<size_t> level1({0, 1, 2, 3, 4});
|
|
lod.push_back(level0);
|
|
lod.push_back(level1);
|
|
ids->set_lod(lod);
|
|
scores->set_lod(lod);
|
|
|
|
auto dims = common::make_ddim({4, 3});
|
|
ids->Resize(dims);
|
|
scores->Resize(dims);
|
|
|
|
phi::CPUPlace place;
|
|
auto* ids_data = ids->mutable_data<int64_t>(place);
|
|
auto* scores_data = scores->mutable_data<float>(place);
|
|
std::vector<int64_t> ids_vec_data({4, 2, 5, 2, 1, 3, 3, 5, 2, 8, 2, 1});
|
|
std::vector<float> scores_vec_data(
|
|
{0.6f, 0.3f, 0.5f, 0.2f, 0.3f, 0.1f, 0.9f, 0.5f, 0.1f, 0.7f, 0.5f, 0.1f});
|
|
|
|
PADDLE_ENFORCE_EQ(
|
|
static_cast<size_t>(ids->numel()),
|
|
ids_vec_data.size(),
|
|
common::errors::InvalidArgument(
|
|
"Required ids->numel() should be equal to ids_vec_data.size(). "));
|
|
PADDLE_ENFORCE_EQ(
|
|
static_cast<size_t>(ids->numel()),
|
|
scores_vec_data.size(),
|
|
common::errors::InvalidArgument(
|
|
"Required ids->numel() should be equal to scores_vec_data.size(). "));
|
|
|
|
for (int i = 0; i < ids->numel(); i++) {
|
|
ids_data[i] = ids_vec_data[i];
|
|
scores_data[i] = scores_vec_data[i];
|
|
}
|
|
|
|
// pre_ids
|
|
pre_ids->Resize(common::make_ddim({4, 1}));
|
|
for (int i = 0; i < 4; i++) {
|
|
pre_ids->mutable_data<int64_t>(place)[i] = i + 1;
|
|
}
|
|
|
|
// pre_scores
|
|
pre_scores->Resize(common::make_ddim({4, 1}));
|
|
for (int i = 0; i < 4; i++) {
|
|
pre_scores->mutable_data<float>(place)[i] = 0.1 * (i + 1); // NOLINT
|
|
}
|
|
}
|
|
|
|
template <typename DeviceContext, typename Place>
|
|
void TestBeamSearch() {
|
|
phi::DenseTensor ids;
|
|
phi::DenseTensor scores;
|
|
phi::DenseTensor pre_ids;
|
|
phi::DenseTensor pre_scores;
|
|
|
|
auto* place = new Place();
|
|
DeviceContext* context = new DeviceContext(*place);
|
|
context->SetAllocator(paddle::memory::allocation::AllocatorFacade::Instance()
|
|
.GetAllocator(phi::CPUPlace())
|
|
.get());
|
|
if (phi::is_cpu_place(*place)) {
|
|
PrepareCPUTensors(&ids, &scores, &pre_ids, &pre_scores);
|
|
} else {
|
|
phi::DenseTensor cpu_ids;
|
|
phi::DenseTensor cpu_scores;
|
|
phi::DenseTensor cpu_pre_ids;
|
|
phi::DenseTensor cpu_pre_scores;
|
|
|
|
PrepareCPUTensors(&cpu_ids, &cpu_scores, &cpu_pre_ids, &cpu_pre_scores);
|
|
|
|
paddle::framework::TensorCopySync(cpu_ids, *place, &ids);
|
|
paddle::framework::TensorCopySync(cpu_scores, *place, &scores);
|
|
paddle::framework::TensorCopySync(cpu_pre_ids, *place, &pre_ids);
|
|
paddle::framework::TensorCopySync(cpu_pre_scores, *place, &pre_scores);
|
|
|
|
ids.set_lod(cpu_ids.lod());
|
|
scores.set_lod(cpu_scores.lod());
|
|
pre_ids.set_lod(cpu_pre_ids.lod());
|
|
pre_scores.set_lod(cpu_pre_scores.lod());
|
|
}
|
|
|
|
phi::DenseTensor selected_ids;
|
|
phi::DenseTensor selected_scores;
|
|
phi::DenseTensor parent_idx;
|
|
|
|
size_t level = 0;
|
|
size_t beam_size = 2;
|
|
int end_id = 0;
|
|
phi::math::BeamSearchFunctor<DeviceContext, float> beamsearch;
|
|
beamsearch(*context,
|
|
&pre_ids,
|
|
&pre_scores,
|
|
&ids,
|
|
&scores,
|
|
&selected_ids,
|
|
&selected_scores,
|
|
&parent_idx,
|
|
level,
|
|
beam_size,
|
|
end_id,
|
|
true);
|
|
|
|
ASSERT_EQ(selected_ids.lod(), selected_scores.lod());
|
|
|
|
phi::DenseTensor cpu_selected_ids;
|
|
phi::DenseTensor cpu_selected_scores;
|
|
if (phi::is_cpu_place(*place)) {
|
|
cpu_selected_ids = selected_ids;
|
|
cpu_selected_scores = selected_scores;
|
|
} else {
|
|
paddle::framework::TensorCopySync(
|
|
selected_ids, phi::CPUPlace(), &cpu_selected_ids);
|
|
paddle::framework::TensorCopySync(
|
|
selected_scores, phi::CPUPlace(), &cpu_selected_scores);
|
|
cpu_selected_ids.set_lod(selected_ids.lod());
|
|
cpu_selected_scores.set_lod(selected_scores.lod());
|
|
}
|
|
|
|
std::vector<int64_t> expected_ids({4, 5, 3, 8});
|
|
std::vector<float> expected_scores({0.6f, 0.5f, 0.9f, 0.7f});
|
|
for (int i = 0; i < 4; i++) {
|
|
ASSERT_EQ(expected_ids[i], cpu_selected_ids.data<int64_t>()[i]);
|
|
ASSERT_EQ(expected_scores[i], cpu_selected_scores.data<float>()[i]);
|
|
}
|
|
|
|
delete place;
|
|
delete context;
|
|
}
|
|
|
|
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
|
|
template <>
|
|
void TestBeamSearch<phi::GPUContext, phi::GPUPlace>() {
|
|
phi::DenseTensor ids;
|
|
phi::DenseTensor scores;
|
|
phi::DenseTensor pre_ids;
|
|
phi::DenseTensor pre_scores;
|
|
|
|
auto* place = new phi::GPUPlace();
|
|
auto* context = new phi::GPUContext(*place);
|
|
context->SetAllocator(paddle::memory::allocation::AllocatorFacade::Instance()
|
|
.GetAllocator(*place, context->stream())
|
|
.get());
|
|
context->PartialInitWithAllocator();
|
|
if (phi::is_cpu_place(*place)) {
|
|
PrepareCPUTensors(&ids, &scores, &pre_ids, &pre_scores);
|
|
} else {
|
|
phi::DenseTensor cpu_ids;
|
|
phi::DenseTensor cpu_scores;
|
|
phi::DenseTensor cpu_pre_ids;
|
|
phi::DenseTensor cpu_pre_scores;
|
|
|
|
PrepareCPUTensors(&cpu_ids, &cpu_scores, &cpu_pre_ids, &cpu_pre_scores);
|
|
|
|
paddle::framework::TensorCopySync(cpu_ids, *place, &ids);
|
|
paddle::framework::TensorCopySync(cpu_scores, *place, &scores);
|
|
paddle::framework::TensorCopySync(cpu_pre_ids, *place, &pre_ids);
|
|
paddle::framework::TensorCopySync(cpu_pre_scores, *place, &pre_scores);
|
|
|
|
ids.set_lod(cpu_ids.lod());
|
|
scores.set_lod(cpu_scores.lod());
|
|
pre_ids.set_lod(cpu_pre_ids.lod());
|
|
pre_scores.set_lod(cpu_pre_scores.lod());
|
|
}
|
|
|
|
phi::DenseTensor selected_ids;
|
|
phi::DenseTensor selected_scores;
|
|
phi::DenseTensor parent_idx;
|
|
|
|
size_t level = 0;
|
|
size_t beam_size = 2;
|
|
int end_id = 0;
|
|
phi::math::BeamSearchFunctor<phi::GPUContext, float> beamsearch;
|
|
beamsearch(*context,
|
|
&pre_ids,
|
|
&pre_scores,
|
|
&ids,
|
|
&scores,
|
|
&selected_ids,
|
|
&selected_scores,
|
|
&parent_idx,
|
|
level,
|
|
beam_size,
|
|
end_id,
|
|
true);
|
|
|
|
ASSERT_EQ(selected_ids.lod(), selected_scores.lod());
|
|
|
|
phi::DenseTensor cpu_selected_ids;
|
|
phi::DenseTensor cpu_selected_scores;
|
|
if (phi::is_cpu_place(*place)) {
|
|
cpu_selected_ids = selected_ids;
|
|
cpu_selected_scores = selected_scores;
|
|
} else {
|
|
paddle::framework::TensorCopySync(
|
|
selected_ids, phi::CPUPlace(), &cpu_selected_ids);
|
|
paddle::framework::TensorCopySync(
|
|
selected_scores, phi::CPUPlace(), &cpu_selected_scores);
|
|
cpu_selected_ids.set_lod(selected_ids.lod());
|
|
cpu_selected_scores.set_lod(selected_scores.lod());
|
|
}
|
|
|
|
std::vector<int64_t> expected_ids({4, 5, 3, 8});
|
|
std::vector<float> expected_scores({0.6f, 0.5f, 0.9f, 0.7f});
|
|
for (int i = 0; i < 4; i++) {
|
|
ASSERT_EQ(expected_ids[i], cpu_selected_ids.data<int64_t>()[i]);
|
|
ASSERT_EQ(expected_scores[i], cpu_selected_scores.data<float>()[i]);
|
|
}
|
|
|
|
delete place;
|
|
delete context;
|
|
}
|
|
#endif
|
|
|
|
TEST(BeamSearch, CPU) { TestBeamSearch<phi::CPUContext, phi::CPUPlace>(); }
|
|
|
|
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
|
|
TEST(BeamSearch, GPU) { TestBeamSearch<phi::GPUContext, phi::GPUPlace>(); }
|
|
#endif
|