Feature/copytensor (#5455)
* "make global tensor function independently" * "replace functor" * "fix inline template error" * "fix tensor array with CopyFrom" * "fix other case use CopyFrom" * "move the op interface hardly" * "fix operators" * "fix typo" * "delete dynamic recurrent rnn and fix gru_unit in debugmode" * "fix unique_ptr copy" * "fix cuda copy" * "fix namespace error" * "removed nccl python test" * "fix include error" * "fix typo" * fix copy util testrelease/0.11.0
dzhwinter
7 years ago
committed by
GitHub
parent
748fdbbec5
commit
45062fe5d7
File diff suppressed because it is too large
Load Diff
@ -1,132 +0,0 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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 <vector>
|
||||
|
||||
#include "paddle/framework/lod_tensor.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace framework {
|
||||
|
||||
/*
|
||||
* DyBatchSeqPosition stores indices of the basic element in tensor. It is used
|
||||
* after lod-tensor's re-assembling, its info can be used to recover the order
|
||||
* in original lod-tensor.
|
||||
*/
|
||||
struct DySeqMeta {
|
||||
DySeqMeta(size_t begin, size_t end, size_t ori_idx)
|
||||
: begin(begin), end(end), ori_idx(ori_idx) {}
|
||||
|
||||
size_t begin;
|
||||
size_t end; // not included
|
||||
size_t ori_idx;
|
||||
};
|
||||
|
||||
using DySeqMetaBatch = std::vector<DySeqMeta>;
|
||||
|
||||
/*
|
||||
* Extract the indices of instances.
|
||||
*/
|
||||
std::vector<size_t> GenDyBatchIndice(const DySeqMetaBatch &metas, int batch_id);
|
||||
|
||||
/*
|
||||
* TensorArray is a C-array-like array of tensors, it is meant to be used with
|
||||
* dynamic iteration primitives such as while_loop. It is used to segment inputs
|
||||
* and store states in all time steps.
|
||||
*
|
||||
* By providing some methods similar to a C++ array, the difinition of some
|
||||
* state-based dynamic models such as RNN cound be more natural and highly
|
||||
* flexible.
|
||||
*/
|
||||
class TensorArray {
|
||||
public:
|
||||
using value_type = float;
|
||||
|
||||
// max number of values allowed to store.
|
||||
const size_t MAX_SIZE{100000};
|
||||
|
||||
/*
|
||||
* Read the value at location `index` in the `TensorArray`.
|
||||
*/
|
||||
const LoDTensor &Read(size_t index) const;
|
||||
|
||||
/*
|
||||
* Write value into the index of the TensorArray.
|
||||
*/
|
||||
void Write(size_t index, const LoDTensor &value);
|
||||
|
||||
/*
|
||||
* Write value into the index of the TensorArray, with memory shared.
|
||||
*/
|
||||
void WriteShared(size_t index, const LoDTensor &value);
|
||||
|
||||
/*
|
||||
* Recover the original LoD-arranged LoDTensor with the `values`, `level` and
|
||||
* `indice_map`.
|
||||
*/
|
||||
LoDTensor Pack(size_t level, const DySeqMetaBatch &meta,
|
||||
const LoD &lod) const;
|
||||
|
||||
/*
|
||||
* Split LoDTensor in some `level` and write the generated batches to
|
||||
* `values`, if set `desend`, will sort by length in descending order else in
|
||||
* ascending order.
|
||||
*/
|
||||
DySeqMetaBatch Unpack(const LoDTensor &source, int level, bool length_desend);
|
||||
|
||||
/*
|
||||
* Pack an array of LoDTensors to a LoDTensor.
|
||||
*/
|
||||
LoDTensor LodPack(size_t level) const;
|
||||
|
||||
/*
|
||||
* Unpack a LoDTensor to an array of LoDTensors.
|
||||
*/
|
||||
void LodUnpack(const LoDTensor &source, size_t level);
|
||||
|
||||
/*
|
||||
* Pack the values into a tensor with rank one higher than each tensor in
|
||||
* values.
|
||||
*/
|
||||
LoDTensor Stack() const;
|
||||
|
||||
/*
|
||||
* Unstacks the given division of a rank-`R` tensor into rank-`(R-1)` tensors.
|
||||
*/
|
||||
void Unstack(const LoDTensor &source) const;
|
||||
|
||||
/*
|
||||
* Unstacks the given division of a rank-`R` tensor into rank-`(R-1)` tensors,
|
||||
* with memory of tensors shared.
|
||||
*/
|
||||
void UnstackShared(const LoDTensor &source) const;
|
||||
|
||||
/*
|
||||
* Return the number of values.
|
||||
*/
|
||||
size_t size() const;
|
||||
|
||||
protected:
|
||||
void Unstack(const LoDTensor &source, bool data_shared) const;
|
||||
|
||||
LoDTensor LodPackTwo(const LoDTensor &pre, const LoDTensor &cur,
|
||||
size_t level) const;
|
||||
|
||||
private:
|
||||
mutable std::vector<LoDTensor> values_;
|
||||
}; // class TensorArray
|
||||
|
||||
} // namespace framework
|
||||
} // namespace paddle
|
||||
@ -1,182 +0,0 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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/framework/tensor_array.h"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
namespace paddle {
|
||||
namespace framework {
|
||||
|
||||
class TensorArrayTester : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
LoDTensor source;
|
||||
source.Resize(make_ddim({batch_size, dim}));
|
||||
int* data = source.mutable_data<int>(platform::CPUPlace());
|
||||
for (int i = 0; i < 16 * 32; i++) {
|
||||
data[i] = i;
|
||||
}
|
||||
ta.Unstack(source);
|
||||
}
|
||||
|
||||
TensorArray ta;
|
||||
const int batch_size = 16;
|
||||
const int dim = 32;
|
||||
};
|
||||
|
||||
TEST_F(TensorArrayTester, Read) {
|
||||
for (int i = 0; i < batch_size; i++) {
|
||||
const auto& tensor = ta.Read(i);
|
||||
ASSERT_EQ(tensor.dims()[0], 1);
|
||||
ASSERT_EQ(tensor.dims()[1], dim);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(TensorArrayTester, Write) {
|
||||
LoDTensor source;
|
||||
source.Resize(make_ddim({1, dim}));
|
||||
for (int i = 0; i < dim; i++) {
|
||||
*(source.mutable_data<int>(platform::CPUPlace()) + i) = i;
|
||||
}
|
||||
|
||||
ta.Write(2, source);
|
||||
|
||||
const auto& tensor = ta.Read(2);
|
||||
for (int i = 0; i < dim; i++) {
|
||||
EXPECT_EQ(*(tensor.data<int>() + i), *(source.data<int>() + i));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(TensorArrayTester, WriteShared) {
|
||||
LoDTensor source;
|
||||
source.Resize(make_ddim({1, dim}));
|
||||
for (int i = 0; i < dim; i++) {
|
||||
*(source.mutable_data<int>(platform::CPUPlace()) + i) = i;
|
||||
}
|
||||
|
||||
ta.WriteShared(2, source);
|
||||
|
||||
const auto& tensor = ta.Read(2);
|
||||
for (int i = 0; i < dim; i++) {
|
||||
EXPECT_EQ(*(tensor.data<int>() + i), *(source.data<int>() + i));
|
||||
}
|
||||
|
||||
EXPECT_EQ(source.data<int>(), tensor.data<int>());
|
||||
}
|
||||
|
||||
class TensorArrayPackTester : public ::testing::Test {
|
||||
protected:
|
||||
virtual void SetUp() override {
|
||||
lod.push_back(std::vector<size_t>{0, 2, 9, 13});
|
||||
|
||||
source.set_lod(lod);
|
||||
source.Resize(make_ddim({13, 128}));
|
||||
source.mutable_data<int>(platform::CPUPlace());
|
||||
|
||||
// content of each setence: 0 1 2 3 4
|
||||
const auto& level = lod.front();
|
||||
for (size_t i = 0; i < level.size() - 1; i++) {
|
||||
size_t begin = level[i];
|
||||
size_t end = level[i + 1];
|
||||
for (size_t j = begin; j < end; j++) {
|
||||
auto record = source.Slice(j, j + 1);
|
||||
for (int dim = 0; dim < 128; dim++) {
|
||||
record.mutable_data<int>(platform::CPUPlace())[dim] = j - begin;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// unpack
|
||||
meta = ta.Unpack(source, 0, true);
|
||||
}
|
||||
|
||||
LoD lod;
|
||||
TensorArray ta;
|
||||
LoDTensor source;
|
||||
std::vector<DySeqMeta> meta;
|
||||
};
|
||||
|
||||
TEST_F(TensorArrayPackTester, Unpack) {
|
||||
ASSERT_EQ(ta.size(), 7UL);
|
||||
|
||||
const auto& t0 = ta.Read(0);
|
||||
const auto& t1 = ta.Read(1);
|
||||
|
||||
ASSERT_EQ(t0.data<int>()[0], int(0));
|
||||
ASSERT_EQ(t1.data<int>()[0], int(1));
|
||||
}
|
||||
|
||||
TEST_F(TensorArrayPackTester, Pack) {
|
||||
LoDTensor packed = ta.Pack(0, meta, lod);
|
||||
}
|
||||
|
||||
TEST_F(TensorArrayTester, size) {
|
||||
ASSERT_EQ(ta.size(), static_cast<size_t>(batch_size));
|
||||
}
|
||||
|
||||
TEST(TensorArray, LodPack) {
|
||||
// three time steps, each step stores a LoDTensors
|
||||
// - [0] [1]
|
||||
// - [2 3], [4 5]
|
||||
// - [6 7] [] [8], [9, 10]
|
||||
// try to get a LoDTensor with content:
|
||||
// - [0 2 6]
|
||||
// - [0 2 7]
|
||||
// - [0 3]
|
||||
// - [1 4 8]
|
||||
// - [1 5 9]
|
||||
// - [1 5 10]
|
||||
std::array<LoDTensor, 3> tensors;
|
||||
tensors[0].Resize(make_ddim({2, 1}));
|
||||
tensors[1].Resize(make_ddim({4, 1}));
|
||||
tensors[2].Resize(make_ddim({5, 1}));
|
||||
int index = 0;
|
||||
for (auto& t : tensors) {
|
||||
t.mutable_data<int>(platform::CPUPlace());
|
||||
for (int i = 0; i < t.dims()[0]; i++) {
|
||||
t.data<int>()[i] = index;
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
std::array<LoD, 3> lods;
|
||||
std::vector<std::vector<size_t>> levels{
|
||||
{0, 1, 2}, {0, 2, 4}, {0, 2, 2, 3, 5}};
|
||||
for (int i = 0; i < 3; i++) {
|
||||
lods[i].emplace_back(levels[i].begin(), levels[i].end());
|
||||
}
|
||||
|
||||
TensorArray ta;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
tensors[i].set_lod(lods[i]);
|
||||
ta.Write(i, tensors[i]);
|
||||
}
|
||||
|
||||
auto merged = ta.LodPack(0);
|
||||
|
||||
std::vector<int> target_tensor_data{{0, 2, 6, // 0
|
||||
0, 2, 7, // 1
|
||||
0, 3, // 2
|
||||
1, 4, 8, // 3
|
||||
1, 5, 9, // 5
|
||||
1, 5, 10}};
|
||||
EXPECT_EQ(merged.dims()[0], (int)target_tensor_data.size());
|
||||
for (size_t i = 0; i < target_tensor_data.size(); i++) {
|
||||
EXPECT_EQ(target_tensor_data[i], merged.data<int>()[i]);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace framework
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,153 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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 "paddle/framework/tensor.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace framework {
|
||||
|
||||
/**
|
||||
* @brief Copy the content of external tensor to a new place.
|
||||
*
|
||||
* @param[in] src The external tensor.
|
||||
* @param[in] dst_place The dst place.
|
||||
* @param[in] ctx The device context contains device resources.
|
||||
*
|
||||
* @note CopyFrom supports CPU <-> GPU, GPU <-> GPU.
|
||||
*/
|
||||
|
||||
inline void CopyFrom(const Tensor& src, const platform::Place& dst_place,
|
||||
const platform::DeviceContext& ctx, Tensor* dst) {
|
||||
src.check_memory_size();
|
||||
|
||||
dst->Resize(src.dims());
|
||||
auto src_place = src.place();
|
||||
auto src_ptr = src.data<void>();
|
||||
|
||||
auto dst_ptr = dst->mutable_data(dst_place, src.type());
|
||||
|
||||
auto size = src.numel() * SizeOfType(src.type());
|
||||
|
||||
if (platform::is_cpu_place(src_place) && platform::is_cpu_place(dst_place)) {
|
||||
memory::Copy(boost::get<platform::CPUPlace>(dst_place), dst_ptr,
|
||||
boost::get<platform::CPUPlace>(src_place), src_ptr, size);
|
||||
}
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
else if (platform::is_gpu_place(src_place) && // NOLINT
|
||||
platform::is_cpu_place(dst_place)) {
|
||||
auto src_gpu_place = boost::get<platform::GPUPlace>(src_place);
|
||||
auto dst_cpu_place = boost::get<platform::CPUPlace>(dst_place);
|
||||
auto ctx_place = ctx.GetPlace();
|
||||
PADDLE_ENFORCE(platform::is_gpu_place(ctx_place));
|
||||
auto ctx_gpu_place = boost::get<platform::GPUPlace>(ctx_place);
|
||||
PADDLE_ENFORCE_EQ(src_gpu_place, ctx_gpu_place);
|
||||
memory::Copy(
|
||||
dst_cpu_place, dst_ptr, src_gpu_place, src_ptr, size,
|
||||
reinterpret_cast<const platform::CUDADeviceContext&>(ctx).stream());
|
||||
} else if (platform::is_cpu_place(src_place) &&
|
||||
platform::is_gpu_place(dst_place)) {
|
||||
auto src_cpu_place = boost::get<platform::CPUPlace>(src_place);
|
||||
auto dst_gpu_place = boost::get<platform::GPUPlace>(dst_place);
|
||||
auto ctx_place = ctx.GetPlace();
|
||||
PADDLE_ENFORCE(platform::is_gpu_place(ctx_place));
|
||||
auto ctx_gpu_place = boost::get<platform::GPUPlace>(ctx_place);
|
||||
PADDLE_ENFORCE_EQ(dst_gpu_place, ctx_gpu_place);
|
||||
memory::Copy(
|
||||
dst_gpu_place, dst_ptr, src_cpu_place, src_ptr, size,
|
||||
reinterpret_cast<const platform::CUDADeviceContext&>(ctx).stream());
|
||||
} else if (platform::is_gpu_place(src_place) &&
|
||||
platform::is_gpu_place(dst_place)) {
|
||||
auto src_gpu_place = boost::get<platform::GPUPlace>(src_place);
|
||||
auto dst_gpu_place = boost::get<platform::GPUPlace>(dst_place);
|
||||
auto ctx_place = ctx.GetPlace();
|
||||
PADDLE_ENFORCE(platform::is_gpu_place(ctx_place));
|
||||
auto ctx_gpu_place = boost::get<platform::GPUPlace>(ctx_place);
|
||||
PADDLE_ENFORCE_EQ(src_gpu_place, ctx_gpu_place);
|
||||
memory::Copy(
|
||||
dst_gpu_place, dst_ptr, src_gpu_place, src_ptr, size,
|
||||
reinterpret_cast<const platform::CUDADeviceContext&>(ctx).stream());
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Copy the content of an external vector to a tensor.
|
||||
*
|
||||
* @param[in] src The external tensor.
|
||||
* @param[in] ctx The device context contains device resources.
|
||||
*
|
||||
* * @note CopyFromVector assumes that the tensor has been resized
|
||||
* before invoking.
|
||||
*/
|
||||
template <typename T>
|
||||
inline void CopyFromVector(const std::vector<T>& src,
|
||||
const platform::DeviceContext& ctx, Tensor* dst) {
|
||||
auto dst_place = ctx.GetPlace();
|
||||
auto src_ptr = static_cast<const void*>(src.data());
|
||||
platform::CPUPlace src_place;
|
||||
dst->Resize({static_cast<int64_t>(src.size())});
|
||||
auto dst_ptr = static_cast<void*>(dst->mutable_data<T>(dst_place));
|
||||
auto size = src.size() * sizeof(T);
|
||||
|
||||
if (platform::is_cpu_place(dst_place)) {
|
||||
memory::Copy(boost::get<platform::CPUPlace>(dst_place), dst_ptr, src_place,
|
||||
src_ptr, size);
|
||||
}
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
else if (platform::is_gpu_place(dst_place)) { // NOLINT
|
||||
memory::Copy(
|
||||
boost::get<platform::GPUPlace>(dst_place), dst_ptr, src_place, src_ptr,
|
||||
size,
|
||||
reinterpret_cast<const platform::CUDADeviceContext&>(ctx).stream());
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Copy the content of a tensor to a vector
|
||||
*
|
||||
* @param[in] src The external tensor.
|
||||
* @param[in] ctx The device context contains device resources.
|
||||
*
|
||||
* * @note CopyFromVector assumes that the tensor has been resized
|
||||
* before invoking.
|
||||
*/
|
||||
template <typename T>
|
||||
inline void CopyToVector(const Tensor& src, const platform::DeviceContext& ctx,
|
||||
std::vector<T>* dst) {
|
||||
auto src_ptr = static_cast<const void*>(src.data<T>());
|
||||
auto size = src.numel() * sizeof(T);
|
||||
|
||||
platform::CPUPlace dst_place;
|
||||
dst->resize(src.numel());
|
||||
auto dst_ptr = static_cast<void*>(dst->data());
|
||||
|
||||
if (platform::is_cpu_place(src.place())) {
|
||||
memory::Copy(dst_place, dst_ptr, boost::get<platform::CPUPlace>(src.place()),
|
||||
src_ptr, size);
|
||||
}
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
else if (platform::is_gpu_place(src.place())) { // NOLINT
|
||||
memory::Copy(
|
||||
dst_place, dst_ptr, boost::get<platform::GPUPlace>(src.place()), src_ptr,
|
||||
size,
|
||||
reinterpret_cast<const platform::CUDADeviceContext&>(ctx).stream());
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
} // namespace framework
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,228 @@
|
||||
/*
|
||||
Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
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/framework/tensor_util.h"
|
||||
#include <gtest/gtest.h>
|
||||
#include <string>
|
||||
|
||||
namespace paddle {
|
||||
namespace framework {
|
||||
TEST(CopyFrom, Tensor) {
|
||||
Tensor src_tensor;
|
||||
Tensor dst_tensor;
|
||||
platform::CPUDeviceContext cpu_ctx((platform::CPUPlace()));
|
||||
|
||||
int* src_ptr =
|
||||
src_tensor.mutable_data<int>(make_ddim({3, 3}), platform::CPUPlace());
|
||||
|
||||
int arr[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
memcpy(src_ptr, arr, 9 * sizeof(int));
|
||||
|
||||
auto cpu_place = new platform::CPUPlace();
|
||||
CopyFrom(src_tensor, *cpu_place, cpu_ctx, &dst_tensor);
|
||||
|
||||
const int* dst_ptr = dst_tensor.data<int>();
|
||||
ASSERT_NE(src_ptr, dst_ptr);
|
||||
for (size_t i = 0; i < 9; ++i) {
|
||||
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
||||
}
|
||||
|
||||
Tensor slice_tensor = src_tensor.Slice(1, 2);
|
||||
CopyFrom(slice_tensor, *cpu_place, cpu_ctx, &dst_tensor);
|
||||
const int* slice_ptr = slice_tensor.data<int>();
|
||||
dst_ptr = dst_tensor.data<int>();
|
||||
ASSERT_NE(dst_ptr, slice_ptr);
|
||||
for (size_t i = 0; i < 3; ++i) {
|
||||
EXPECT_EQ(dst_ptr[i], slice_ptr[i]);
|
||||
}
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
{
|
||||
Tensor src_tensor;
|
||||
Tensor gpu_tensor;
|
||||
Tensor dst_tensor;
|
||||
|
||||
int* src_ptr =
|
||||
src_tensor.mutable_data<int>(make_ddim({3, 3}), platform::CPUPlace());
|
||||
|
||||
int arr[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
memcpy(src_ptr, arr, 9 * sizeof(int));
|
||||
|
||||
// CPU Tensor to GPU Tensor
|
||||
auto gpu_place = new platform::GPUPlace(0);
|
||||
platform::CUDADeviceContext gpu_ctx(*gpu_place);
|
||||
CopyFrom(src_tensor, *gpu_place, gpu_ctx, &gpu_tensor);
|
||||
|
||||
// GPU Tensor to CPU Tensor
|
||||
auto cpu_place = new platform::CPUPlace();
|
||||
CopyFrom(gpu_tensor, *cpu_place, gpu_ctx, &dst_tensor);
|
||||
|
||||
// Sync before Compare Tensors
|
||||
gpu_ctx.Wait();
|
||||
const int* dst_ptr = dst_tensor.data<int>();
|
||||
ASSERT_NE(src_ptr, dst_ptr);
|
||||
for (size_t i = 0; i < 9; ++i) {
|
||||
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
||||
}
|
||||
|
||||
Tensor slice_tensor = src_tensor.Slice(1, 2);
|
||||
|
||||
// CPU Slice Tensor to GPU Tensor
|
||||
CopyFrom(slice_tensor, *gpu_place, gpu_ctx, &gpu_tensor);
|
||||
|
||||
// GPU Tensor to CPU Tensor
|
||||
CopyFrom(gpu_tensor, *cpu_place, gpu_ctx, &dst_tensor);
|
||||
|
||||
// Sync before Compare Slice Tensors
|
||||
gpu_ctx.Wait();
|
||||
const int* slice_ptr = slice_tensor.data<int>();
|
||||
dst_ptr = dst_tensor.data<int>();
|
||||
ASSERT_NE(dst_ptr, slice_ptr);
|
||||
for (size_t i = 0; i < 3; ++i) {
|
||||
EXPECT_EQ(dst_ptr[i], slice_ptr[i]);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST(CopyFromVector, Tensor) {
|
||||
using namespace paddle::framework;
|
||||
using namespace paddle::platform;
|
||||
{
|
||||
std::vector<int> src_vec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
Tensor cpu_tensor;
|
||||
|
||||
// Copy to CPU Tensor
|
||||
cpu_tensor.Resize(make_ddim({3, 3}));
|
||||
auto cpu_place = new paddle::platform::CPUPlace();
|
||||
CPUDeviceContext cpu_ctx(*cpu_place);
|
||||
CopyFromVector<int>(src_vec, cpu_ctx, &cpu_tensor);
|
||||
|
||||
// Compare Tensors
|
||||
const int* cpu_ptr = cpu_tensor.data<int>();
|
||||
const int* src_ptr = src_vec.data();
|
||||
ASSERT_NE(src_ptr, cpu_ptr);
|
||||
for (size_t i = 0; i < 9; ++i) {
|
||||
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
||||
}
|
||||
|
||||
src_vec.erase(src_vec.begin(), src_vec.begin() + 5);
|
||||
cpu_tensor.Resize(make_ddim({2, 2}));
|
||||
CopyFromVector<int>(src_vec, cpu_ctx, &cpu_tensor);
|
||||
cpu_ptr = cpu_tensor.data<int>();
|
||||
src_ptr = src_vec.data();
|
||||
ASSERT_NE(src_ptr, cpu_ptr);
|
||||
for (size_t i = 0; i < 5; ++i) {
|
||||
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
||||
}
|
||||
|
||||
delete cpu_place;
|
||||
}
|
||||
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
{
|
||||
std::vector<int> src_vec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
Tensor cpu_tensor;
|
||||
Tensor gpu_tensor;
|
||||
Tensor dst_tensor;
|
||||
|
||||
// Copy to CPU Tensor
|
||||
cpu_tensor.Resize(make_ddim({3, 3}));
|
||||
auto cpu_place = new paddle::platform::CPUPlace();
|
||||
CPUDeviceContext cpu_ctx(*cpu_place);
|
||||
CopyFromVector<int>(src_vec, cpu_ctx, &cpu_tensor);
|
||||
|
||||
// Copy to GPUTensor
|
||||
gpu_tensor.Resize(make_ddim({3, 3}));
|
||||
auto gpu_place = new paddle::platform::GPUPlace();
|
||||
CUDADeviceContext gpu_ctx(*gpu_place);
|
||||
CopyFromVector<int>(src_vec, gpu_ctx, &gpu_tensor);
|
||||
// Copy from GPU to CPU tensor for comparison
|
||||
CopyFrom(gpu_tensor, *cpu_place, gpu_ctx, &dst_tensor);
|
||||
|
||||
// Sync before Compare Tensors
|
||||
gpu_ctx.Wait();
|
||||
const int* src_ptr = src_vec.data();
|
||||
const int* cpu_ptr = cpu_tensor.data<int>();
|
||||
const int* dst_ptr = dst_tensor.data<int>();
|
||||
ASSERT_NE(src_ptr, cpu_ptr);
|
||||
ASSERT_NE(src_ptr, dst_ptr);
|
||||
for (size_t i = 0; i < 9; ++i) {
|
||||
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
||||
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
||||
}
|
||||
|
||||
src_vec.erase(src_vec.begin(), src_vec.begin() + 5);
|
||||
|
||||
cpu_tensor.Resize(make_ddim({2, 2}));
|
||||
CopyFromVector<int>(src_vec, cpu_ctx, &cpu_tensor);
|
||||
gpu_tensor.Resize(make_ddim({2, 2}));
|
||||
CopyFromVector<int>(src_vec, gpu_ctx, &gpu_tensor);
|
||||
CopyFrom(gpu_tensor, *cpu_place, gpu_ctx, &dst_tensor);
|
||||
|
||||
// Sync before Compare Tensors
|
||||
gpu_ctx.Wait();
|
||||
src_ptr = src_vec.data();
|
||||
cpu_ptr = cpu_tensor.data<int>();
|
||||
dst_ptr = dst_tensor.data<int>();
|
||||
ASSERT_NE(src_ptr, cpu_ptr);
|
||||
ASSERT_NE(src_ptr, dst_ptr);
|
||||
for (size_t i = 0; i < 5; ++i) {
|
||||
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
||||
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
||||
}
|
||||
|
||||
delete cpu_place;
|
||||
delete gpu_place;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST(CopyToVector, Tensor) {
|
||||
using namespace paddle::framework;
|
||||
using namespace paddle::platform;
|
||||
{
|
||||
Tensor src;
|
||||
int* src_ptr = src.mutable_data<int>({3, 3}, CPUPlace());
|
||||
for (int i = 0; i < 3 * 3; ++i) {
|
||||
src_ptr[i] = i;
|
||||
}
|
||||
|
||||
CPUPlace place;
|
||||
CPUDeviceContext cpu_ctx(place);
|
||||
std::vector<int> dst;
|
||||
CopyToVector<int>(src, cpu_ctx, &dst);
|
||||
|
||||
for (int i = 0; i < 3 * 3; ++i) {
|
||||
EXPECT_EQ(src_ptr[i], dst[i]);
|
||||
}
|
||||
}
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
{
|
||||
std::vector<int> src_vec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
Tensor gpu_tensor;
|
||||
GPUPlace place;
|
||||
CUDADeviceContext gpu_ctx(place);
|
||||
CopyFromVector<int>(src_vec, gpu_ctx, &gpu_tensor);
|
||||
|
||||
std::vector<int> dst;
|
||||
CopyToVector<int>(gpu_tensor, gpu_ctx, &dst);
|
||||
|
||||
for (int i = 0; i < 3 * 3; ++i) {
|
||||
EXPECT_EQ(src_vec[i], dst[i]);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace framework
|
||||
} // namespace paddle
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,233 +0,0 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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
|
||||
|
||||
#ifdef PADDLE_WITH_TESTING
|
||||
#include "gtest/gtest.h"
|
||||
#endif
|
||||
|
||||
#include "paddle/framework/lod_tensor.h"
|
||||
#include "paddle/framework/operator.h"
|
||||
#include "paddle/framework/tensor_array.h"
|
||||
#include "paddle/framework/variable.h"
|
||||
#include "paddle/operators/rnn/recurrent_op_utils.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
class RNNAlgorithm {
|
||||
public:
|
||||
enum ComputeMode { kForward = 0, kBackward = 1 };
|
||||
static const std::array<rnn::ArgumentName, 2> kArgNames;
|
||||
using value_type = float;
|
||||
|
||||
/*
|
||||
* Different `Run` method for forward and backward, `_` is just for template
|
||||
* specifialization.
|
||||
*/
|
||||
template <ComputeMode _>
|
||||
void Run(const framework::Scope& scope, const framework::OperatorBase& op,
|
||||
const platform::DeviceContext& dev_ctx);
|
||||
/*
|
||||
* Split the inputs(LoDTensors) to segments for each time step.
|
||||
*/
|
||||
void SplitInputs();
|
||||
|
||||
/*
|
||||
* Create step-scopes to store temporary outputs in each time steps.
|
||||
*/
|
||||
void CreateScopes();
|
||||
|
||||
/*
|
||||
* Link TensorArray steps to the corresponding variables located in
|
||||
* step-scopes.
|
||||
*/
|
||||
void WriteStepInputs();
|
||||
|
||||
/*
|
||||
* Write output of each step to the corresponding TensorArray.
|
||||
*/
|
||||
void WriteStepOutputs();
|
||||
|
||||
/*
|
||||
* Initialize the states, each state will have a corresponding pre-state,
|
||||
* which share the memory with the state in the previous time state. The
|
||||
* pre-state in the first time step will be initialized with an zero tensor or
|
||||
* a tensor in parent scope if is provided.
|
||||
*/
|
||||
void InitStates();
|
||||
|
||||
/*
|
||||
* Create state variables for each time step.
|
||||
*/
|
||||
void CreateState(const rnn::StateAttr& state, size_t step);
|
||||
|
||||
/*
|
||||
* Link pre-state variable in current scope to the state variable in the
|
||||
* previous time step (scope) by reference.
|
||||
*/
|
||||
void LinkState(const rnn::StateAttr& state, size_t step);
|
||||
|
||||
/*
|
||||
* Link the pre-state of the first time step to the `boot-state` in parent's
|
||||
* scope.
|
||||
*/
|
||||
void LinkInitialState(const rnn::StateAttr& state);
|
||||
|
||||
/*
|
||||
* Copy the gradient from `pre-state` in the first step-scope to the
|
||||
* `boot-state` in parent's scope.
|
||||
*/
|
||||
void ExportInitialStateGradient(const rnn::StateAttr& state);
|
||||
|
||||
/*
|
||||
* Calculate time steps.
|
||||
*/
|
||||
void RunSteps();
|
||||
|
||||
/*
|
||||
* Concatenate outputs in each time step and generate a LoDTensor.
|
||||
*/
|
||||
void ConcatOutputs();
|
||||
|
||||
void SetComputeMode(ComputeMode mode) { mode_ = mode; }
|
||||
bool IsForward() const { return mode_ == ComputeMode::kForward; }
|
||||
bool IsBackward() const { return mode_ == ComputeMode::kBackward; }
|
||||
|
||||
/*
|
||||
* set a step unit that is created according to a RecurrentOp's step unit.
|
||||
*/
|
||||
void SetStepUnit(std::unique_ptr<framework::OperatorBase> step_unit) {
|
||||
PADDLE_ENFORCE_NOT_NULL(step_unit);
|
||||
step_unit_ = std::move(step_unit);
|
||||
}
|
||||
const framework::OperatorBase& GetStepUnit() const { return *step_unit_; }
|
||||
|
||||
const framework::TensorArray& state(const std::string& name) const {
|
||||
auto it = states_.find(name);
|
||||
PADDLE_ENFORCE(it != states_.end());
|
||||
return it->second;
|
||||
}
|
||||
const framework::TensorArray& step_input(const std::string& name) const {
|
||||
auto it = step_inputs_.find(name);
|
||||
PADDLE_ENFORCE(it != step_inputs_.end());
|
||||
return it->second;
|
||||
}
|
||||
const framework::TensorArray& step_output(const std::string& name) const {
|
||||
auto it = step_outputs_.find(name);
|
||||
PADDLE_ENFORCE(it != step_outputs_.end());
|
||||
return it->second;
|
||||
}
|
||||
|
||||
protected:
|
||||
struct ArgCache {
|
||||
framework::Scope const* scope;
|
||||
std::vector<framework::Scope*>* scopes;
|
||||
std::map<std::string, framework::Variable*> inputs;
|
||||
std::map<std::string, framework::Variable*> outputs;
|
||||
platform::DeviceContext const* dev_ctx;
|
||||
|
||||
size_t num_steps{0};
|
||||
|
||||
void Init(const rnn::ArgumentName& name, const framework::OperatorBase& op,
|
||||
const framework::Scope& scope,
|
||||
platform::DeviceContext const* dev_ctx, rnn::Argument* arg);
|
||||
|
||||
framework::Scope& GetScope(size_t index) {
|
||||
PADDLE_ENFORCE_LT(index, num_steps);
|
||||
return *scopes->at(index);
|
||||
}
|
||||
|
||||
framework::LoDTensor* GetTensor(const framework::Scope& scope,
|
||||
const std::string& name);
|
||||
|
||||
private:
|
||||
void InitArgument(const rnn::ArgumentName& name,
|
||||
const framework::OperatorBase& op, rnn::Argument* arg);
|
||||
void CacheScopes(const framework::Scope& scope, const rnn::Argument& arg);
|
||||
void CacheInlinks(const framework::Scope& scope,
|
||||
const std::vector<std::string>& names);
|
||||
void CacheOutlinks(const framework::Scope& scope,
|
||||
const std::vector<std::string>& names);
|
||||
framework::Variable* GetVariable(const framework::Scope& scope,
|
||||
const std::string& name);
|
||||
};
|
||||
|
||||
private:
|
||||
std::unique_ptr<framework::OperatorBase> step_unit_;
|
||||
std::map<std::string, framework::TensorArray> states_;
|
||||
std::map<std::string, framework::TensorArray> step_inputs_;
|
||||
std::map<std::string, framework::TensorArray> step_outputs_;
|
||||
std::map<std::string, std::vector<framework::DySeqMeta>> dy_seq_metas_;
|
||||
rnn::Argument arg_;
|
||||
ArgCache cache_;
|
||||
ComputeMode mode_{ComputeMode::kForward};
|
||||
|
||||
#ifdef PADDLE_WITH_TESTING
|
||||
// test forward
|
||||
friend class RNNAlgorithmTestHelper;
|
||||
FRIEND_TEST(RNNAlgorithmTestHelper, SplitInputs);
|
||||
FRIEND_TEST(RNNAlgorithmTestHelper, CreateCache);
|
||||
FRIEND_TEST(RNNAlgorithmTestHelper, CreateScopes);
|
||||
FRIEND_TEST(RNNAlgorithmTestHelper, WriteStepInputs);
|
||||
FRIEND_TEST(RNNAlgorithmTestHelper, WriteStepOutputs);
|
||||
FRIEND_TEST(RNNAlgorithmTestHelper, InitStates);
|
||||
FRIEND_TEST(RNNAlgorithmTestHelper, ConcatOutputs);
|
||||
// TODO(superjom) test backward
|
||||
#endif
|
||||
};
|
||||
|
||||
class DynamicRecurrentOp : public framework::OperatorBase {
|
||||
public:
|
||||
DynamicRecurrentOp(const std::string& type,
|
||||
const framework::VariableNameMap& inputs,
|
||||
const framework::VariableNameMap& outputs,
|
||||
const framework::AttributeMap& attrs)
|
||||
: OperatorBase(type, inputs, outputs, attrs) {}
|
||||
|
||||
DynamicRecurrentOp(const DynamicRecurrentOp& o)
|
||||
: framework::OperatorBase(
|
||||
static_cast<const framework::OperatorBase&>(o)) {
|
||||
PADDLE_THROW("Not implemented");
|
||||
}
|
||||
|
||||
void Run(const framework::Scope& scope,
|
||||
const platform::DeviceContext& dev_ctx) const override;
|
||||
|
||||
mutable RNNAlgorithm rnn;
|
||||
};
|
||||
|
||||
class DynamicRecurrentGradientOp : public framework::OperatorBase {
|
||||
public:
|
||||
DynamicRecurrentGradientOp(const std::string& type,
|
||||
const framework::VariableNameMap& inputs,
|
||||
const framework::VariableNameMap& outputs,
|
||||
const framework::AttributeMap& attrs)
|
||||
: OperatorBase(type, inputs, outputs, attrs) {}
|
||||
|
||||
DynamicRecurrentGradientOp(const DynamicRecurrentGradientOp& o)
|
||||
: framework::OperatorBase(
|
||||
static_cast<const framework::OperatorBase&>(o)) {
|
||||
PADDLE_THROW("Not implemented");
|
||||
}
|
||||
|
||||
void Run(const framework::Scope& scope,
|
||||
const platform::DeviceContext& dev_ctx) const override;
|
||||
|
||||
mutable RNNAlgorithm rnn;
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
@ -1,217 +0,0 @@
|
||||
#include "paddle/operators/dynamic_recurrent_op.h"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "paddle/framework/ddim.h"
|
||||
#include "paddle/framework/lod_tensor.h"
|
||||
#include "paddle/framework/op_desc.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
#include "paddle/operators/net_op.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
using framework::Scope;
|
||||
using framework::TensorArray;
|
||||
using framework::LoDTensor;
|
||||
using framework::Variable;
|
||||
|
||||
class TestOp : public framework::OperatorBase {
|
||||
public:
|
||||
using framework::OperatorBase::OperatorBase;
|
||||
DEFINE_OP_CLONE_METHOD(TestOp);
|
||||
void Run(const Scope& scope,
|
||||
const platform::DeviceContext& dev_ctx) const override {}
|
||||
};
|
||||
|
||||
void OpDescNewVar(const std::string& param_name,
|
||||
std::initializer_list<const char*> arguments,
|
||||
paddle::framework::OpDesc::Var* var) {
|
||||
var->set_parameter(param_name);
|
||||
for (auto& arg_name : arguments) {
|
||||
var->add_arguments(arg_name);
|
||||
}
|
||||
}
|
||||
|
||||
// create a LoD tensor in scope with specific dims
|
||||
LoDTensor* CreateVar(Scope& scope, std::string name, framework::DDim dims,
|
||||
const platform::Place& place) {
|
||||
auto* var = scope.Var(name);
|
||||
auto* tensor = var->GetMutable<LoDTensor>();
|
||||
tensor->Resize(dims);
|
||||
tensor->mutable_data<float>(place);
|
||||
return tensor;
|
||||
}
|
||||
|
||||
class RNNAlgorithmTestHelper : public ::testing::Test {
|
||||
protected:
|
||||
const rnn::ArgumentName argname = RNNAlgorithm::kArgNames[0];
|
||||
|
||||
virtual void SetUp() override {
|
||||
CreateGlobalVariables();
|
||||
|
||||
auto op_desc = CreateOpDesc();
|
||||
op = paddle::framework::OpRegistry::CreateOp(op_desc);
|
||||
dop = &(dynamic_cast<DynamicRecurrentOp*>(op.get())->rnn);
|
||||
InitCacheManually();
|
||||
InitStepNet();
|
||||
}
|
||||
|
||||
framework::OpDesc CreateOpDesc() {
|
||||
// create op
|
||||
paddle::framework::OpDesc op_desc;
|
||||
op_desc.set_type("dynamic_recurrent");
|
||||
|
||||
OpDescNewVar(argname.inlinks, {"in0"}, op_desc.add_inputs());
|
||||
OpDescNewVar(argname.initial_states, {"boot_mem"}, op_desc.add_inputs());
|
||||
OpDescNewVar(argname.step_scopes, {"step_scopes"}, op_desc.add_outputs());
|
||||
OpDescNewVar(argname.outlinks, {"out0"}, op_desc.add_outputs());
|
||||
|
||||
// set pre-states
|
||||
auto pre_memories = op_desc.mutable_attrs()->Add();
|
||||
pre_memories->set_name(argname.ex_states);
|
||||
pre_memories->set_type(paddle::framework::AttrType::STRINGS);
|
||||
auto pre_memories_item = pre_memories->add_strings();
|
||||
*pre_memories_item = "mem@pre";
|
||||
|
||||
// set states
|
||||
auto memories = op_desc.mutable_attrs()->Add();
|
||||
memories->set_name(argname.states);
|
||||
memories->set_type(paddle::framework::AttrType::STRINGS);
|
||||
auto memories_item = memories->add_strings();
|
||||
*memories_item = "mem";
|
||||
return op_desc;
|
||||
}
|
||||
|
||||
void CreateGlobalVariables() {
|
||||
platform::CPUPlace place;
|
||||
scope.Var("step_scopes");
|
||||
CreateVar(scope, "boot_mem", framework::make_ddim({10, 20}), place);
|
||||
CreateVar(scope, "out0", framework::make_ddim({10, 20}), place);
|
||||
auto* in0 = CreateVar(scope, "in0", framework::make_ddim({10, 8}), place);
|
||||
// 10 instanes with 4 sentences, length is 4, 3, 2, 1 respectively.
|
||||
framework::LoD in0_lod(1);
|
||||
for (int x : std::vector<int>{0, 4, 7, 9, 10}) {
|
||||
in0_lod[0].push_back(x);
|
||||
}
|
||||
in0->set_lod(in0_lod);
|
||||
in0->Resize(framework::make_ddim({10, 8}));
|
||||
// set the content, each sentence content is seqid.batchid
|
||||
// the seqid starts from 0
|
||||
int start = 0;
|
||||
for (size_t seqid = 0; seqid < in0_lod.size() - 1; seqid++) {
|
||||
for (size_t batchid = 0;
|
||||
batchid < in0_lod[0][seqid + 1] - in0_lod[0][seqid]; batchid++) {
|
||||
float v = seqid + batchid * 0.1;
|
||||
|
||||
for (size_t dim = 0; dim < 8; dim++) {
|
||||
in0->data<float>()[start * 8 + dim] = v;
|
||||
}
|
||||
start++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void InitCacheManually() {
|
||||
dop->cache_.Init(RNNAlgorithm::kArgNames[0], *op, scope, &device_context,
|
||||
&dop->arg_);
|
||||
}
|
||||
|
||||
void InitStepNet() {
|
||||
std::unique_ptr<framework::OperatorBase> stepnet{new NetOp};
|
||||
dynamic_cast<NetOp*>(stepnet.get())
|
||||
->AppendOp(std::unique_ptr<TestOp>(new TestOp(
|
||||
"test", {{"inputs", {"in0"}}, {"initial_states", {"boot_mem"}}},
|
||||
{{"outputs", {"out0"}}, {"step_scopes", {"step_scopes"}}}, {})));
|
||||
dop->SetStepUnit(std::move(stepnet));
|
||||
}
|
||||
|
||||
protected:
|
||||
RNNAlgorithm* dop;
|
||||
std::unique_ptr<framework::OperatorBase> op;
|
||||
paddle::platform::CPUDeviceContext device_context;
|
||||
paddle::framework::Scope scope;
|
||||
};
|
||||
|
||||
TEST_F(RNNAlgorithmTestHelper, CreateCache) {
|
||||
const rnn::Argument& arg = dop->arg_;
|
||||
ASSERT_EQ(arg.inlinks.size(), 1UL);
|
||||
ASSERT_EQ(arg.outlinks.size(), 1UL);
|
||||
}
|
||||
|
||||
TEST_F(RNNAlgorithmTestHelper, SplitInputs) {
|
||||
dop->SplitInputs();
|
||||
auto& in0_ta = dop->step_inputs_["in0"];
|
||||
ASSERT_EQ(in0_ta.size(), 4UL);
|
||||
|
||||
const auto& batch0 = in0_ta.Read(0);
|
||||
const auto& batch1 = in0_ta.Read(1);
|
||||
const auto& batch2 = in0_ta.Read(2);
|
||||
const auto& batch3 = in0_ta.Read(3);
|
||||
EXPECT_EQ(batch0.dims()[0], 4);
|
||||
EXPECT_EQ(batch1.dims()[0], 3);
|
||||
EXPECT_EQ(batch2.dims()[0], 2);
|
||||
EXPECT_EQ(batch3.dims()[0], 1);
|
||||
}
|
||||
|
||||
TEST_F(RNNAlgorithmTestHelper, CreateScopes) {
|
||||
dop->SplitInputs();
|
||||
dop->CreateScopes();
|
||||
ASSERT_EQ(dop->cache_.num_steps, 4UL);
|
||||
ASSERT_EQ(dop->cache_.scopes->size(), 4UL);
|
||||
}
|
||||
|
||||
TEST_F(RNNAlgorithmTestHelper, WriteStepInputs) {
|
||||
dop->SplitInputs();
|
||||
dop->CreateScopes();
|
||||
dop->WriteStepInputs();
|
||||
|
||||
for (size_t step = 0; step < dop->cache_.num_steps; step++) {
|
||||
auto& scope = dop->cache_.GetScope(step);
|
||||
for (auto name : std::vector<std::string>({"in0"})) {
|
||||
ASSERT_TRUE(scope.FindVar(name) != nullptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(RNNAlgorithmTestHelper, WriteStepOutputs) {
|
||||
dop->SplitInputs();
|
||||
dop->CreateScopes();
|
||||
dop->WriteStepInputs();
|
||||
dop->WriteStepOutputs();
|
||||
|
||||
for (size_t step = 0; step < dop->cache_.num_steps; step++) {
|
||||
auto& scope = dop->cache_.GetScope(step);
|
||||
for (auto name : std::vector<std::string>({"out0"})) {
|
||||
ASSERT_TRUE(scope.FindVar(name));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(RNNAlgorithmTestHelper, ConcatOutputs) {
|
||||
// Let's leave this test to python unittest.
|
||||
}
|
||||
|
||||
TEST_F(RNNAlgorithmTestHelper, InitStates) {
|
||||
dop->SetComputeMode(RNNAlgorithm::ComputeMode::kForward);
|
||||
dop->SplitInputs();
|
||||
dop->CreateScopes();
|
||||
dop->WriteStepInputs();
|
||||
dop->WriteStepOutputs();
|
||||
dop->InitStates();
|
||||
|
||||
for (size_t step = 0; step < dop->cache_.num_steps; step++) {
|
||||
auto& scope = dop->cache_.GetScope(step);
|
||||
auto state = scope.FindVar("mem");
|
||||
ASSERT_TRUE(state != nullptr);
|
||||
|
||||
auto* pre_state = scope.FindVar("mem@pre");
|
||||
ASSERT_TRUE(pre_state != nullptr);
|
||||
|
||||
auto* boot_state = scope.FindVar("boot_mem");
|
||||
ASSERT_TRUE(boot_state != nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
} // operators
|
||||
} // namespace paddle
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue