chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,348 @@
|
||||
// Copyright (c) 2021 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 "test/cpp/eager/performance_tests/benchmark_utils.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <memory>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
// Eager
|
||||
#include "paddle/fluid/eager/api/all.h"
|
||||
#include "paddle/fluid/eager/autograd_meta.h"
|
||||
#include "paddle/fluid/eager/backward.h"
|
||||
#include "paddle/fluid/eager/utils.h"
|
||||
#include "test/cpp/eager/test_utils.h"
|
||||
|
||||
// Eager Generated
|
||||
#include "paddle/fluid/eager/api/generated/eager_generated/forwards/dygraph_functions.h"
|
||||
#include "paddle/fluid/eager/api/generated/fluid_generated/dygraph_forward_api.h"
|
||||
|
||||
// Fluid
|
||||
#include "paddle/fluid/framework/op_registry.h"
|
||||
#include "paddle/fluid/imperative/basic_engine.h"
|
||||
#include "paddle/fluid/imperative/tracer.h"
|
||||
#include "paddle/phi/core/memory/memcpy.h"
|
||||
|
||||
static size_t max_num_benchmark_runs = 4000;
|
||||
|
||||
namespace egr {
|
||||
|
||||
/* --------------------- */
|
||||
/* ---- Eager Scale ---- */
|
||||
/* --------------------- */
|
||||
void benchmark_eager_scale(const paddle::Tensor& tensor, bool accuracy_check) {
|
||||
paddle::Tensor input_tensor = tensor;
|
||||
float scale = 2.0;
|
||||
float bias = 3.0;
|
||||
|
||||
size_t max_num_runs = accuracy_check ? 10 : max_num_benchmark_runs;
|
||||
for (size_t i = 0; i < max_num_runs; i++) {
|
||||
input_tensor = egr::scale(input_tensor,
|
||||
scale,
|
||||
bias,
|
||||
true /*bias_after_scale*/,
|
||||
true /*trace_backward*/);
|
||||
}
|
||||
|
||||
std::vector<paddle::Tensor> target_tensors = {input_tensor};
|
||||
Backward(target_tensors, {});
|
||||
|
||||
if (accuracy_check) {
|
||||
// Examine Forward Grad (w.r.t max_num_runs = 10)
|
||||
eager_test::CompareTensorWithValue<float>(input_tensor, 8189.0);
|
||||
// Examine Backward Grad (w.r.t max_num_runs = 10)
|
||||
eager_test::CompareGradTensorWithValue<float>(tensor, 1024.0);
|
||||
}
|
||||
}
|
||||
|
||||
void benchmark_eager_matmul(const paddle::Tensor& X,
|
||||
const paddle::Tensor& Y,
|
||||
bool accuracy_check) {
|
||||
paddle::Tensor input_tensor0 = X;
|
||||
|
||||
size_t max_num_runs = accuracy_check ? 2 : max_num_benchmark_runs;
|
||||
for (size_t i = 0; i < max_num_runs; i++) {
|
||||
input_tensor0 = matmul_ad_func(input_tensor0, Y, false, false);
|
||||
}
|
||||
|
||||
std::vector<paddle::Tensor> target_tensors = {input_tensor0};
|
||||
Backward(target_tensors, {});
|
||||
|
||||
if (accuracy_check) {
|
||||
// Examine Forward Grad (w.r.t max_num_runs = 2)
|
||||
eager_test::CompareTensorWithValue<float>(input_tensor0, 16);
|
||||
// Examine Backward Grad (w.r.t max_num_runs = 2)
|
||||
eager_test::CompareGradTensorWithValue<float>(X, 16);
|
||||
eager_test::CompareGradTensorWithValue<float>(Y, 16);
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------- */
|
||||
/* ---- Eager Intermediate Matmul ---- */
|
||||
/* ----------------------------------- */
|
||||
void benchmark_eager_intermediate_matmul(const paddle::Tensor& X,
|
||||
const paddle::Tensor& Y,
|
||||
bool accuracy_check) {
|
||||
paddle::Tensor input_tensor0 = X;
|
||||
|
||||
size_t max_num_runs = accuracy_check ? 2 : max_num_benchmark_runs;
|
||||
for (size_t i = 0; i < max_num_runs; i++) {
|
||||
input_tensor0 = matmul_v2_dygraph_function(
|
||||
input_tensor0, Y, {{"trans_x", false}, {"trans_y", false}});
|
||||
}
|
||||
|
||||
std::vector<paddle::Tensor> target_tensors = {input_tensor0};
|
||||
Backward(target_tensors, {});
|
||||
|
||||
if (accuracy_check) {
|
||||
// Examine Forward Grad (w.r.t max_num_runs = 2)
|
||||
eager_test::CompareTensorWithValue<float>(input_tensor0, 16);
|
||||
// Examine Backward Grad (w.r.t max_num_runs = 2)
|
||||
eager_test::CompareGradTensorWithValue<float>(X, 16);
|
||||
eager_test::CompareGradTensorWithValue<float>(Y, 16);
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------- */
|
||||
/* ---- Eager Intermediate MLP ---- */
|
||||
/* -------------------------------- */
|
||||
void benchmark_eager_intermediate_mlp(const paddle::Tensor& X,
|
||||
const std::vector<paddle::Tensor>& Ws,
|
||||
const std::vector<paddle::Tensor>& Bs,
|
||||
bool accuracy_check) {
|
||||
paddle::Tensor input0 = X;
|
||||
|
||||
for (size_t i = 0; i < MLP_NUM_LINEAR; i++) {
|
||||
paddle::Tensor Out = matmul_v2_dygraph_function(
|
||||
input0, Ws[i], {{"trans_x", false}, {"trans_y", false}});
|
||||
|
||||
input0 = elementwise_add_dygraph_function(Out, Bs[i], {});
|
||||
}
|
||||
|
||||
paddle::Tensor Out =
|
||||
reduce_sum_dygraph_function(input0, {{"reduce_all", true}});
|
||||
|
||||
std::vector<paddle::Tensor> target_tensors = {Out};
|
||||
Backward(target_tensors, {});
|
||||
|
||||
if (accuracy_check) {
|
||||
std::unordered_map<std::string, float> result =
|
||||
compute_mlp_expected_results();
|
||||
|
||||
// Examine Forward Grad (w.r.t max_num_runs = 2)
|
||||
eager_test::CompareTensorWithValue<float>(Out, result["Out"]);
|
||||
|
||||
// Examine Backward Grad (w.r.t max_num_runs = 2)
|
||||
eager_test::CompareGradTensorWithValue<float>(X, result["GradX"]);
|
||||
eager_test::CompareGradTensorWithValue<float>(Ws[0], result["GradW"]);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace egr
|
||||
|
||||
namespace paddle {
|
||||
namespace imperative {
|
||||
|
||||
static void FluidCheckTensorValue(const std::shared_ptr<imperative::VarBase>& X,
|
||||
const phi::Place& place,
|
||||
float value) {
|
||||
auto* tensor = X->MutableVar()->GetMutable<phi::DenseTensor>();
|
||||
float* t_ptr = tensor->mutable_data<float>(place);
|
||||
std::vector<float> host_data(tensor->numel());
|
||||
|
||||
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
|
||||
if (place == phi::GPUPlace()) {
|
||||
phi::DeviceContextPool& pool = phi::DeviceContextPool::Instance();
|
||||
auto* dev_ctx = dynamic_cast<phi::GPUContext*>(pool.Get(place));
|
||||
auto stream = dev_ctx->stream();
|
||||
|
||||
paddle::memory::Copy(phi::CPUPlace(),
|
||||
host_data.data(),
|
||||
phi::GPUPlace(),
|
||||
t_ptr,
|
||||
sizeof(float) * tensor->numel(),
|
||||
stream);
|
||||
t_ptr = host_data.data();
|
||||
}
|
||||
#endif
|
||||
|
||||
VLOG(6) << "Tensor Value: " << t_ptr[0] << ", Expected Value: " << value;
|
||||
PADDLE_ENFORCE(
|
||||
t_ptr[0] == value,
|
||||
common::errors::Fatal(
|
||||
"Detected numerical Error, Expected %f but got %f", value, t_ptr[0]));
|
||||
}
|
||||
|
||||
static void FluidCheckGradTensorValue(
|
||||
const std::shared_ptr<imperative::VarBase>& X,
|
||||
const phi::Place& place,
|
||||
float value) {
|
||||
auto* grad_tensor = X->MutableGradVar()->GetMutable<phi::DenseTensor>();
|
||||
float* g_ptr = grad_tensor->mutable_data<float>(place);
|
||||
std::vector<float> g_host_data(grad_tensor->numel());
|
||||
|
||||
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
|
||||
if (place == phi::GPUPlace()) {
|
||||
phi::DeviceContextPool& pool = phi::DeviceContextPool::Instance();
|
||||
auto* dev_ctx = dynamic_cast<phi::GPUContext*>(pool.Get(place));
|
||||
auto stream = dev_ctx->stream();
|
||||
|
||||
paddle::memory::Copy(phi::CPUPlace(),
|
||||
g_host_data.data(),
|
||||
phi::GPUPlace(),
|
||||
g_ptr,
|
||||
sizeof(float) * grad_tensor->numel(),
|
||||
stream);
|
||||
g_ptr = g_host_data.data();
|
||||
}
|
||||
#endif
|
||||
|
||||
VLOG(6) << "Tensor Value: " << g_ptr[0] << ", Expected Value: " << value;
|
||||
PADDLE_ENFORCE(
|
||||
g_ptr[0] == value,
|
||||
common::errors::Fatal(
|
||||
"Detected numerical Error, Expected %f but got %f", value, g_ptr[0]));
|
||||
}
|
||||
|
||||
/* --------------------- */
|
||||
/* ---- Fluid Scale ---- */
|
||||
/* --------------------- */
|
||||
// TODO(jiabin): Change this and remove nolint
|
||||
void benchmark_fluid_scale(const std::shared_ptr<imperative::VarBase>& X,
|
||||
const phi::Place& place,
|
||||
bool accuracy_check) {
|
||||
imperative::Tracer tracer;
|
||||
framework::AttributeMap attrs;
|
||||
|
||||
attrs["use_onednn"] = false;
|
||||
attrs["scale"] = 2;
|
||||
attrs["bias"] = 3;
|
||||
attrs["bias_after_scale"] = true;
|
||||
|
||||
std::shared_ptr<imperative::VarBase> tmp_out = X;
|
||||
|
||||
size_t max_num_runs = accuracy_check ? 10 : max_num_benchmark_runs;
|
||||
for (size_t i = 0; i < max_num_runs; i++) {
|
||||
imperative::NameVarBaseMap ins = {{"X", {tmp_out}}};
|
||||
imperative::NameVarBaseMap outs = {
|
||||
{"Out", {std::make_shared<imperative::VarBase>(true, "Out")}}};
|
||||
|
||||
tracer.TraceOp<VarBase>("scale", ins, outs, attrs, place, true);
|
||||
|
||||
tmp_out = outs["Out"][0];
|
||||
}
|
||||
|
||||
auto* engine = tracer.GetEngine();
|
||||
std::vector<std::shared_ptr<imperative::VarBase>> grad_tensors{nullptr};
|
||||
engine->Init({tmp_out}, grad_tensors, false /*retain_graph*/);
|
||||
engine->Execute();
|
||||
|
||||
if (accuracy_check) {
|
||||
FluidCheckTensorValue(tmp_out, place, 8189.0);
|
||||
FluidCheckGradTensorValue(X, place, 1024.0);
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------- */
|
||||
/* ---- Fluid Matmul ---- */
|
||||
/* ---------------------- */
|
||||
void benchmark_fluid_matmul(const std::shared_ptr<imperative::VarBase>& X,
|
||||
const std::shared_ptr<imperative::VarBase>& Y,
|
||||
const phi::Place& place,
|
||||
bool accuracy_check) {
|
||||
imperative::Tracer tracer;
|
||||
|
||||
std::shared_ptr<imperative::VarBase> tmp_out = X;
|
||||
|
||||
size_t max_num_runs = accuracy_check ? 2 : max_num_benchmark_runs;
|
||||
for (size_t i = 0; i < max_num_runs; i++) {
|
||||
framework::AttributeMap attrs;
|
||||
imperative::NameVarBaseMap ins = {{"X", {tmp_out}}, {"Y", {Y}}};
|
||||
imperative::NameVarBaseMap outs = {
|
||||
{"Out", {std::make_shared<imperative::VarBase>(true, "Out")}}};
|
||||
|
||||
tracer.TraceOp<VarBase>("matmul_v2", ins, outs, attrs, place, true);
|
||||
|
||||
tmp_out = outs["Out"][0];
|
||||
}
|
||||
|
||||
auto* engine = tracer.GetEngine();
|
||||
std::vector<std::shared_ptr<imperative::VarBase>> grad_tensors{nullptr};
|
||||
engine->Init({tmp_out}, grad_tensors, false /*retain_graph*/);
|
||||
engine->Execute();
|
||||
|
||||
if (accuracy_check) {
|
||||
FluidCheckTensorValue(tmp_out, place, 16);
|
||||
FluidCheckGradTensorValue(X, place, 16);
|
||||
FluidCheckGradTensorValue(Y, place, 16);
|
||||
}
|
||||
}
|
||||
|
||||
/* ------------------- */
|
||||
/* ---- Fluid MLP ---- */
|
||||
/* ------------------- */
|
||||
void benchmark_fluid_mlp(
|
||||
const std::shared_ptr<imperative::VarBase>& X,
|
||||
const std::vector<std::shared_ptr<imperative::VarBase>>& Ws,
|
||||
const std::vector<std::shared_ptr<imperative::VarBase>>& Bs,
|
||||
const phi::Place& place,
|
||||
bool accuracy_check) {
|
||||
imperative::Tracer tracer;
|
||||
|
||||
imperative::NameVarBaseMap ins;
|
||||
imperative::NameVarBaseMap outs;
|
||||
framework::AttributeMap attrs;
|
||||
std::shared_ptr<imperative::VarBase> input0 = X;
|
||||
for (size_t i = 0; i < MLP_NUM_LINEAR; i++) {
|
||||
// Matmul0
|
||||
ins = {{"X", {input0}}, {"Y", {Ws[0]}}};
|
||||
outs = {{"Out", {std::make_shared<imperative::VarBase>(true, "Out")}}};
|
||||
|
||||
tracer.TraceOp<VarBase>("matmul_v2", ins, outs, attrs, place, true);
|
||||
|
||||
// EW-Add0
|
||||
ins = {{"X", outs["Out"]}, {"Y", {Bs[i]}}};
|
||||
outs = {{"Out", {std::make_shared<imperative::VarBase>(true, "Out")}}};
|
||||
|
||||
tracer.TraceOp<VarBase>("elementwise_add", ins, outs, attrs, place, true);
|
||||
input0 = outs["Out"][0];
|
||||
}
|
||||
|
||||
// ReduceSum
|
||||
ins = {{"X", {input0}}};
|
||||
outs = {{"Out", {std::make_shared<imperative::VarBase>(true, "Out")}}};
|
||||
attrs = {{"reduce_all", true}};
|
||||
|
||||
tracer.TraceOp<VarBase>("reduce_sum", ins, outs, attrs, place, true);
|
||||
|
||||
auto* engine = tracer.GetEngine();
|
||||
std::vector<std::shared_ptr<imperative::VarBase>> grad_tensors{nullptr};
|
||||
engine->Init(outs["Out"], grad_tensors, false /*retain_graph*/);
|
||||
engine->Execute();
|
||||
|
||||
if (accuracy_check) {
|
||||
std::unordered_map<std::string, float> result =
|
||||
egr::compute_mlp_expected_results();
|
||||
|
||||
FluidCheckTensorValue(outs["Out"][0], place, result["Out"]);
|
||||
FluidCheckGradTensorValue(X, place, result["GradX"]);
|
||||
FluidCheckGradTensorValue(Ws[0], place, result["GradW"]);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace imperative
|
||||
} // namespace paddle
|
||||
Reference in New Issue
Block a user