You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
347 lines
14 KiB
347 lines
14 KiB
/* 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 <iostream>
|
|
#include <string>
|
|
#include <vector>
|
|
#include "gtest/gtest.h"
|
|
#include "paddle/fluid/framework/op_registry.h"
|
|
#include "paddle/fluid/platform/float16.h"
|
|
|
|
USE_CPU_ONLY_OP(save_combine);
|
|
USE_CPU_ONLY_OP(load_combine);
|
|
|
|
template <typename T, typename U>
|
|
T* CreateForSaveCombineOp(int x, int y, const std::vector<int>& lod_info,
|
|
std::string var_name,
|
|
const paddle::platform::CPUPlace& place,
|
|
paddle::framework::Scope* scope,
|
|
paddle::framework::LoD* expect_lod) {
|
|
auto var = scope->Var(var_name);
|
|
auto tensor = var->GetMutable<paddle::framework::LoDTensor>();
|
|
tensor->Resize({x, y});
|
|
expect_lod->resize(1);
|
|
for (size_t i = 0; i < lod_info.size(); i++) {
|
|
(*expect_lod)[0].push_back(lod_info[i]);
|
|
}
|
|
tensor->set_lod(*expect_lod);
|
|
T* expect = tensor->mutable_data<T>(place);
|
|
for (int64_t i = 0; i < tensor->numel(); ++i) {
|
|
expect[i] = static_cast<T>(
|
|
static_cast<U>(i)); // For FP16, we intend to do float(float16(i))
|
|
}
|
|
return expect;
|
|
}
|
|
|
|
paddle::framework::LoDTensor* GeneratePlaceholderBeforeLoad(
|
|
const std::string out_var_name, paddle::framework::Scope* scope) {
|
|
auto load_var = scope->Var(out_var_name);
|
|
auto target = load_var->GetMutable<paddle::framework::LoDTensor>();
|
|
return target;
|
|
}
|
|
|
|
template <typename T>
|
|
T* GetValuesAfterLoadCombineOp(paddle::framework::LoDTensor* target,
|
|
const paddle::framework::Scope& scope,
|
|
paddle::framework::LoD* actual_lod) {
|
|
T* actual = target->data<T>();
|
|
*actual_lod = target->lod();
|
|
return actual;
|
|
}
|
|
|
|
template <typename T, typename U>
|
|
void CheckValues(T* expect, U* actual, const paddle::framework::LoD& expect_lod,
|
|
const paddle::framework::LoD& actual_lod, const int& numel) {
|
|
for (int i = 0; i < numel; ++i) {
|
|
EXPECT_EQ(expect[i], static_cast<T>(actual[i]));
|
|
}
|
|
EXPECT_EQ(expect_lod.size(), actual_lod.size());
|
|
for (size_t i = 0; i < expect_lod.size(); ++i) {
|
|
for (size_t j = 0; j < expect_lod[i].size(); ++j) {
|
|
EXPECT_EQ(expect_lod[i][j], actual_lod[i][j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Here, we create 4 LoDTensors and use save_combine_op to first save these
|
|
// in a single file. Then, we use load_combine_op to load these sequentially
|
|
TEST(SaveLoadCombineOp, CPU) {
|
|
paddle::framework::Scope scope;
|
|
paddle::platform::CPUPlace place;
|
|
|
|
std::vector<int> lod1 = {0, 1, 2, 3, 10};
|
|
int numel1 = 100;
|
|
paddle::framework::LoD expect_lod1;
|
|
int* expect1 = CreateForSaveCombineOp<int, int>(10, 10, lod1, "test_var1",
|
|
place, &scope, &expect_lod1);
|
|
|
|
std::vector<int> lod2 = {0, 2, 5, 10};
|
|
int numel2 = 200;
|
|
paddle::framework::LoD expect_lod2;
|
|
int* expect2 = CreateForSaveCombineOp<int, int>(10, 20, lod2, "test_var2",
|
|
place, &scope, &expect_lod2);
|
|
|
|
std::vector<int> lod3 = {0, 2, 3, 20};
|
|
int numel3 = 4000;
|
|
paddle::framework::LoD expect_lod3;
|
|
int* expect3 = CreateForSaveCombineOp<int, int>(20, 200, lod3, "test_var3",
|
|
place, &scope, &expect_lod3);
|
|
|
|
std::vector<int> lod4 = {0, 1, 20};
|
|
int numel4 = 1000;
|
|
paddle::framework::LoD expect_lod4;
|
|
int* expect4 = CreateForSaveCombineOp<int, int>(20, 50, lod4, "test_var4",
|
|
place, &scope, &expect_lod4);
|
|
|
|
// Set attributes
|
|
std::string filename = "check_tensor.ls";
|
|
paddle::framework::AttributeMap attrs;
|
|
attrs.insert({"file_path", std::string(filename)});
|
|
|
|
// Run the save_combine_op
|
|
auto save_combine_op = paddle::framework::OpRegistry::CreateOp(
|
|
"save_combine",
|
|
{{"X", {"test_var1", "test_var2", "test_var3", "test_var4"}}}, {}, attrs);
|
|
save_combine_op->Run(scope, place);
|
|
|
|
// Set up output vars
|
|
auto target1 = GeneratePlaceholderBeforeLoad("out_var1", &scope);
|
|
auto target2 = GeneratePlaceholderBeforeLoad("out_var2", &scope);
|
|
auto target3 = GeneratePlaceholderBeforeLoad("out_var3", &scope);
|
|
auto target4 = GeneratePlaceholderBeforeLoad("out_var4", &scope);
|
|
|
|
// Run the load_combine_op
|
|
auto load_combine_op = paddle::framework::OpRegistry::CreateOp(
|
|
"load_combine", {},
|
|
{{"Out", {"out_var1", "out_var2", "out_var3", "out_var4"}}}, attrs);
|
|
load_combine_op->Run(scope, place);
|
|
|
|
paddle::framework::LoD actual_lod1, actual_lod2, actual_lod3, actual_lod4;
|
|
int* actual1 = GetValuesAfterLoadCombineOp<int>(target1, scope, &actual_lod1);
|
|
int* actual2 = GetValuesAfterLoadCombineOp<int>(target2, scope, &actual_lod2);
|
|
int* actual3 = GetValuesAfterLoadCombineOp<int>(target3, scope, &actual_lod3);
|
|
int* actual4 = GetValuesAfterLoadCombineOp<int>(target4, scope, &actual_lod4);
|
|
|
|
CheckValues<int, int>(expect1, actual1, expect_lod1, actual_lod1, numel1);
|
|
CheckValues<int, int>(expect2, actual2, expect_lod2, actual_lod2, numel2);
|
|
CheckValues<int, int>(expect3, actual3, expect_lod3, actual_lod3, numel3);
|
|
CheckValues<int, int>(expect4, actual4, expect_lod4, actual_lod4, numel4);
|
|
}
|
|
|
|
// FP16 version of SaveLoadCombineOp Test, only altering the saving aspect
|
|
// to save as FP16.
|
|
TEST(SaveCombineFP16Op, CPU) {
|
|
paddle::framework::Scope scope;
|
|
paddle::platform::CPUPlace place;
|
|
|
|
std::vector<int> lod1 = {0, 1, 2, 3, 10};
|
|
int numel1 = 100;
|
|
paddle::framework::LoD expect_lod1;
|
|
float* expect1 = CreateForSaveCombineOp<float, paddle::platform::float16>(
|
|
10, 10, lod1, "test_var1", place, &scope, &expect_lod1);
|
|
|
|
std::vector<int> lod2 = {0, 2, 5, 10};
|
|
int numel2 = 200;
|
|
paddle::framework::LoD expect_lod2;
|
|
float* expect2 = CreateForSaveCombineOp<float, paddle::platform::float16>(
|
|
10, 20, lod2, "test_var2", place, &scope, &expect_lod2);
|
|
|
|
std::vector<int> lod3 = {0, 20};
|
|
int numel3 = 4000;
|
|
paddle::framework::LoD expect_lod3;
|
|
float* expect3 = CreateForSaveCombineOp<float, paddle::platform::float16>(
|
|
20, 200, lod3, "test_var3", place, &scope, &expect_lod3);
|
|
|
|
std::vector<int> lod4 = {0, 1, 20};
|
|
int numel4 = 1000;
|
|
paddle::framework::LoD expect_lod4;
|
|
float* expect4 = CreateForSaveCombineOp<float, paddle::platform::float16>(
|
|
20, 50, lod4, "test_var4", place, &scope, &expect_lod4);
|
|
|
|
// Set attributes
|
|
std::string filename = "check_tensor_fp16_save.ls";
|
|
paddle::framework::AttributeMap attrs;
|
|
attrs.insert({"file_path", std::string(filename)});
|
|
attrs.insert({"save_as_fp16", true});
|
|
|
|
// Run the save_combine_op
|
|
auto save_combine_op = paddle::framework::OpRegistry::CreateOp(
|
|
"save_combine",
|
|
{{"X", {"test_var1", "test_var2", "test_var3", "test_var4"}}}, {}, attrs);
|
|
save_combine_op->Run(scope, place);
|
|
|
|
// Set up output vars
|
|
auto target1 = GeneratePlaceholderBeforeLoad("out_var1", &scope);
|
|
auto target2 = GeneratePlaceholderBeforeLoad("out_var2", &scope);
|
|
auto target3 = GeneratePlaceholderBeforeLoad("out_var3", &scope);
|
|
auto target4 = GeneratePlaceholderBeforeLoad("out_var4", &scope);
|
|
|
|
// Run the load_combine_op
|
|
auto load_combine_op = paddle::framework::OpRegistry::CreateOp(
|
|
"load_combine", {},
|
|
{{"Out", {"out_var1", "out_var2", "out_var3", "out_var4"}}}, attrs);
|
|
load_combine_op->Run(scope, place);
|
|
|
|
paddle::framework::LoD actual_lod1, actual_lod2, actual_lod3, actual_lod4;
|
|
paddle::platform::float16* actual1 =
|
|
GetValuesAfterLoadCombineOp<paddle::platform::float16>(target1, scope,
|
|
&actual_lod1);
|
|
paddle::platform::float16* actual2 =
|
|
GetValuesAfterLoadCombineOp<paddle::platform::float16>(target2, scope,
|
|
&actual_lod2);
|
|
paddle::platform::float16* actual3 =
|
|
GetValuesAfterLoadCombineOp<paddle::platform::float16>(target3, scope,
|
|
&actual_lod3);
|
|
paddle::platform::float16* actual4 =
|
|
GetValuesAfterLoadCombineOp<paddle::platform::float16>(target4, scope,
|
|
&actual_lod4);
|
|
|
|
CheckValues<float, paddle::platform::float16>(expect1, actual1, expect_lod1,
|
|
actual_lod1, numel1);
|
|
CheckValues<float, paddle::platform::float16>(expect2, actual2, expect_lod2,
|
|
actual_lod2, numel2);
|
|
CheckValues<float, paddle::platform::float16>(expect3, actual3, expect_lod3,
|
|
actual_lod3, numel3);
|
|
CheckValues<float, paddle::platform::float16>(expect4, actual4, expect_lod4,
|
|
actual_lod4, numel4);
|
|
}
|
|
|
|
// FP16 version of SaveLoadCombineOp Test, only altering the loading aspect
|
|
// to load tensors with FP16 precision.
|
|
TEST(LoadCombineFP16Op, CPU) {
|
|
paddle::framework::Scope scope;
|
|
paddle::platform::CPUPlace place;
|
|
|
|
std::vector<int> lod1 = {0, 1, 2, 3, 10};
|
|
int numel1 = 100;
|
|
paddle::framework::LoD expect_lod1;
|
|
float* expect1 = CreateForSaveCombineOp<float, paddle::platform::float16>(
|
|
10, 10, lod1, "test_var1", place, &scope, &expect_lod1);
|
|
|
|
std::vector<int> lod2 = {0, 2, 5, 10};
|
|
int numel2 = 200;
|
|
paddle::framework::LoD expect_lod2;
|
|
float* expect2 = CreateForSaveCombineOp<float, paddle::platform::float16>(
|
|
10, 20, lod2, "test_var2", place, &scope, &expect_lod2);
|
|
|
|
std::vector<int> lod3 = {0, 20};
|
|
int numel3 = 4000;
|
|
paddle::framework::LoD expect_lod3;
|
|
float* expect3 = CreateForSaveCombineOp<float, paddle::platform::float16>(
|
|
20, 200, lod3, "test_var3", place, &scope, &expect_lod3);
|
|
|
|
std::vector<int> lod4 = {0, 1, 20};
|
|
int numel4 = 1000;
|
|
paddle::framework::LoD expect_lod4;
|
|
float* expect4 = CreateForSaveCombineOp<float, paddle::platform::float16>(
|
|
20, 50, lod4, "test_var4", place, &scope, &expect_lod4);
|
|
|
|
// Set attributes
|
|
std::string filename = "check_tensor_fp16_load.ls";
|
|
paddle::framework::AttributeMap attrs;
|
|
attrs.insert({"file_path", std::string(filename)});
|
|
|
|
// Run the save_combine_op
|
|
auto save_combine_op = paddle::framework::OpRegistry::CreateOp(
|
|
"save_combine",
|
|
{{"X", {"test_var1", "test_var2", "test_var3", "test_var4"}}}, {}, attrs);
|
|
save_combine_op->Run(scope, place);
|
|
|
|
// Set up output vars
|
|
auto load_var1 = scope.Var("out_var1");
|
|
auto load_var2 = scope.Var("out_var2");
|
|
auto load_var3 = scope.Var("out_var3");
|
|
auto load_var4 = scope.Var("out_var4");
|
|
|
|
attrs.insert({"load_as_fp16", true});
|
|
// Run the load_combine_op
|
|
auto load_combine_op = paddle::framework::OpRegistry::CreateOp(
|
|
"load_combine", {},
|
|
{{"Out", {"out_var1", "out_var2", "out_var3", "out_var4"}}}, attrs);
|
|
load_combine_op->Run(scope, place);
|
|
|
|
auto* target1 = load_var1->GetMutable<paddle::framework::LoDTensor>();
|
|
auto* target2 = load_var2->GetMutable<paddle::framework::LoDTensor>();
|
|
auto* target3 = load_var3->GetMutable<paddle::framework::LoDTensor>();
|
|
auto* target4 = load_var4->GetMutable<paddle::framework::LoDTensor>();
|
|
|
|
paddle::framework::LoD actual_lod1, actual_lod2, actual_lod3, actual_lod4;
|
|
paddle::platform::float16* actual1 =
|
|
GetValuesAfterLoadCombineOp<paddle::platform::float16>(target1, scope,
|
|
&actual_lod1);
|
|
paddle::platform::float16* actual2 =
|
|
GetValuesAfterLoadCombineOp<paddle::platform::float16>(target2, scope,
|
|
&actual_lod2);
|
|
paddle::platform::float16* actual3 =
|
|
GetValuesAfterLoadCombineOp<paddle::platform::float16>(target3, scope,
|
|
&actual_lod3);
|
|
paddle::platform::float16* actual4 =
|
|
GetValuesAfterLoadCombineOp<paddle::platform::float16>(target4, scope,
|
|
&actual_lod4);
|
|
|
|
CheckValues<float, paddle::platform::float16>(expect1, actual1, expect_lod1,
|
|
actual_lod1, numel1);
|
|
CheckValues<float, paddle::platform::float16>(expect2, actual2, expect_lod2,
|
|
actual_lod2, numel2);
|
|
CheckValues<float, paddle::platform::float16>(expect3, actual3, expect_lod3,
|
|
actual_lod3, numel3);
|
|
CheckValues<float, paddle::platform::float16>(expect4, actual4, expect_lod4,
|
|
actual_lod4, numel4);
|
|
}
|
|
|
|
// Test with original SaveLoadTest
|
|
TEST(SaveLoadTestWithCombineOp, CPU) {
|
|
paddle::framework::Scope scope;
|
|
paddle::platform::CPUPlace place;
|
|
|
|
auto var = scope.Var("test_var");
|
|
auto tensor = var->GetMutable<paddle::framework::LoDTensor>();
|
|
tensor->Resize({3, 4000});
|
|
paddle::framework::LoD expect_lod;
|
|
expect_lod.resize(1);
|
|
expect_lod[0].push_back(0);
|
|
expect_lod[0].push_back(1);
|
|
expect_lod[0].push_back(2);
|
|
expect_lod[0].push_back(3);
|
|
|
|
tensor->set_lod(expect_lod);
|
|
int* expect = tensor->mutable_data<int>(place);
|
|
for (int64_t i = 0; i < tensor->numel(); ++i) {
|
|
expect[i] = static_cast<int>(i);
|
|
}
|
|
paddle::framework::AttributeMap attrs;
|
|
attrs.insert({"file_path", std::string("check_t.save")});
|
|
|
|
auto save_op = paddle::framework::OpRegistry::CreateOp(
|
|
"save_combine", {{"X", {"test_var"}}}, {}, attrs);
|
|
save_op->Run(scope, place);
|
|
|
|
auto load_var = scope.Var("out_var");
|
|
auto target = load_var->GetMutable<paddle::framework::LoDTensor>();
|
|
auto load_op = paddle::framework::OpRegistry::CreateOp(
|
|
"load_combine", {}, {{"Out", {"out_var"}}}, attrs);
|
|
load_op->Run(scope, place);
|
|
int* actual = target->data<int>();
|
|
for (int64_t i = 0; i < tensor->numel(); ++i) {
|
|
EXPECT_EQ(expect[i], actual[i]);
|
|
}
|
|
auto& actual_lod = target->lod();
|
|
EXPECT_EQ(expect_lod.size(), actual_lod.size());
|
|
for (size_t i = 0; i < expect_lod.size(); ++i) {
|
|
for (size_t j = 0; j < expect_lod[i].size(); ++j) {
|
|
EXPECT_EQ(expect_lod[i][j], actual_lod[i][j]);
|
|
}
|
|
}
|
|
}
|