colin
/
TIM-VX
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

delete Non-approximate option, recommend to use 

the approximate option

Signed-off-by: Chen Xin <jack.chen@verisilicon.com>
This commit is contained in:
Chen Xin 2021-09-07 19:07:50 +08:00 committed by Sven
parent 6f2e92ffa6
commit 633075f689
2 changed files with 111 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/tim/vx/ops/activations.h
View File

@ -48,7 +48,7 @@ namespace ops {
* Sigmoid(x) : 1/(1 + e^{-x}) * Sigmoid(x) : 1/(1 + e^{-x})
* *
* Swish(x) : x * sigmoid(x) * Swish(x) : x * sigmoid(x)
* *
* HardSwish(x) : 0 if x <= -3; x(x + 3)/6 if -3 < x < 3; x if x >= 3 * HardSwish(x) : 0 if x <= -3; x(x + 3)/6 if -3 < x < 3; x if x >= 3
* *
* Mish(x) : x if x >= 0 else alpha * x * Mish(x) : x if x >= 0 else alpha * x
@ -122,9 +122,13 @@ class Linear : public Operation {
}; };
class Gelu : public Operation { class Gelu : public Operation {
public: public:
explicit Gelu(Graph* graph, bool approximate = false); /****************************************************************************
std::shared_ptr<Operation> Clone( *Non-approximate calculations will also have errors when the data type is
*fp32, it is recommended to use the approximate option.
****************************************************************************/
explicit Gelu(Graph* graph, bool approximate = true);
std::shared_ptr<Operation> Clone(
std::shared_ptr<Graph>& graph) const override; std::shared_ptr<Graph>& graph) const override;
}; };

235
src/tim/vx/ops/activations_test.cc
View File

@ -29,181 +29,152 @@
#include "src/tim/vx/test_utils.h" #include "src/tim/vx/test_utils.h"
TEST(Linear, shape_5_1_fp32) { TEST(Linear, shape_5_1_fp32) {
auto ctx = tim::vx::Context::Create(); auto ctx = tim::vx::Context::Create();
auto graph = ctx->CreateGraph(); auto graph = ctx->CreateGraph();
tim::vx::ShapeType io_shape({5, 1}); tim::vx::ShapeType io_shape({5, 1});
tim::vx::TensorSpec input_spec(tim::vx::DataType::FLOAT32, tim::vx::TensorSpec input_spec(tim::vx::DataType::FLOAT32, io_shape,
io_shape, tim::vx::TensorAttribute::INPUT); tim::vx::TensorAttribute::INPUT);
tim::vx::TensorSpec output_spec(tim::vx::DataType::FLOAT32, tim::vx::TensorSpec output_spec(tim::vx::DataType::FLOAT32, io_shape,
io_shape, tim::vx::TensorAttribute::OUTPUT); tim::vx::TensorAttribute::OUTPUT);
auto input_tensor = graph->CreateTensor(input_spec); auto input_tensor = graph->CreateTensor(input_spec);
auto output_tensor = graph->CreateTensor(output_spec); auto output_tensor = graph->CreateTensor(output_spec);
std::vector<float> in_data = { -2.5, -0.1, 0, 0.55, std::numeric_limits<float>::infinity() }; std::vector<float> in_data = {-2.5, -0.1, 0, 0.55,
std::vector<float> golden = {-0.5, 1.9, 2, 2.55, std::numeric_limits<float>::infinity() }; std::numeric_limits<float>::infinity()};
std::vector<float> golden = {-0.5, 1.9, 2, 2.55,
std::numeric_limits<float>::infinity()};
EXPECT_TRUE(input_tensor->CopyDataToTensor(in_data.data(), in_data.size()*4)); EXPECT_TRUE(
input_tensor->CopyDataToTensor(in_data.data(), in_data.size() * 4));
auto op = graph->CreateOperation<tim::vx::ops::Linear>(1, 2); auto op = graph->CreateOperation<tim::vx::ops::Linear>(1, 2);
(*op).BindInputs({input_tensor}).BindOutputs({output_tensor}); (*op).BindInputs({input_tensor}).BindOutputs({output_tensor});
EXPECT_TRUE(graph->Compile()); EXPECT_TRUE(graph->Compile());
EXPECT_TRUE(graph->Run()); EXPECT_TRUE(graph->Run());
std::vector<float> output(5, 0); std::vector<float> output(5, 0);
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
EXPECT_EQ(golden, output); EXPECT_EQ(golden, output);
} }
TEST(Linear, shape_5_1_fp32_omit_b) { TEST(Linear, shape_5_1_fp32_omit_b) {
auto ctx = tim::vx::Context::Create(); auto ctx = tim::vx::Context::Create();
auto graph = ctx->CreateGraph(); auto graph = ctx->CreateGraph();
tim::vx::ShapeType io_shape({5, 1}); tim::vx::ShapeType io_shape({5, 1});
tim::vx::TensorSpec input_spec(tim::vx::DataType::FLOAT32, tim::vx::TensorSpec input_spec(tim::vx::DataType::FLOAT32, io_shape,
io_shape, tim::vx::TensorAttribute::INPUT); tim::vx::TensorAttribute::INPUT);
tim::vx::TensorSpec output_spec(tim::vx::DataType::FLOAT32, tim::vx::TensorSpec output_spec(tim::vx::DataType::FLOAT32, io_shape,
io_shape, tim::vx::TensorAttribute::OUTPUT); tim::vx::TensorAttribute::OUTPUT);
auto input_tensor = graph->CreateTensor(input_spec); auto input_tensor = graph->CreateTensor(input_spec);
auto output_tensor = graph->CreateTensor(output_spec); auto output_tensor = graph->CreateTensor(output_spec);
std::vector<float> in_data = { -2.5, -0.1, 0, 0.55, std::numeric_limits<float>::infinity() }; std::vector<float> in_data = {-2.5, -0.1, 0, 0.55,
std::vector<float> golden = {-5.0, -0.2, 0, 1.1, std::numeric_limits<float>::infinity() }; std::numeric_limits<float>::infinity()};
std::vector<float> golden = {-5.0, -0.2, 0, 1.1,
std::numeric_limits<float>::infinity()};
EXPECT_TRUE(input_tensor->CopyDataToTensor(in_data.data(), in_data.size()*4)); EXPECT_TRUE(
input_tensor->CopyDataToTensor(in_data.data(), in_data.size() * 4));
auto op = graph->CreateOperation<tim::vx::ops::Linear>(2); auto op = graph->CreateOperation<tim::vx::ops::Linear>(2);
(*op).BindInputs({input_tensor}).BindOutputs({output_tensor}); (*op).BindInputs({input_tensor}).BindOutputs({output_tensor});
EXPECT_TRUE(graph->Compile()); EXPECT_TRUE(graph->Compile());
EXPECT_TRUE(graph->Run()); EXPECT_TRUE(graph->Run());
std::vector<float> output(5, 0); std::vector<float> output(5, 0);
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
EXPECT_EQ(golden, output); EXPECT_EQ(golden, output);
}
TEST(Gelu, shape_5_1_fp32) {
auto ctx = tim::vx::Context::Create();
auto graph = ctx->CreateGraph();
tim::vx::ShapeType in_shape({5, 1});
tim::vx::ShapeType out_shape({5, 1});
tim::vx::TensorSpec in_spec(tim::vx::DataType::FLOAT32,
in_shape, tim::vx::TensorAttribute::INPUT);
tim::vx::TensorSpec out_spec(tim::vx::DataType::FLOAT32,
out_shape, tim::vx::TensorAttribute::OUTPUT);
auto in_tensor = graph->CreateTensor(in_spec);
auto out_tensor = graph->CreateTensor(out_spec);
std::vector<float> in_data = {
-3, -1, 0, 1, 3
};
std::vector<float> golden = {
-0.00404951, -0.15865529, 0, 0.8413447, 2.9959507
};
EXPECT_TRUE(in_tensor->CopyDataToTensor(in_data.data(), in_data.size() * sizeof(float)));
auto op = graph->CreateOperation<tim::vx::ops::Gelu>(false);
(*op).BindInput(in_tensor).BindOutput(out_tensor);
EXPECT_TRUE(graph->Compile());
EXPECT_TRUE(graph->Run());
std::vector<float> output(golden.size());
EXPECT_TRUE(out_tensor->CopyDataFromTensor(output.data()));
EXPECT_TRUE(ArraysMatch(golden, output, 1e-5f));
} }
TEST(Gelu, shape_5_1_fp32_approximate) { TEST(Gelu, shape_5_1_fp32_approximate) {
auto ctx = tim::vx::Context::Create(); auto ctx = tim::vx::Context::Create();
auto graph = ctx->CreateGraph(); auto graph = ctx->CreateGraph();
tim::vx::ShapeType in_shape({5, 1}); tim::vx::ShapeType in_shape({5, 1});
tim::vx::ShapeType out_shape({5, 1}); tim::vx::ShapeType out_shape({5, 1});
tim::vx::TensorSpec in_spec(tim::vx::DataType::FLOAT32, tim::vx::TensorSpec in_spec(tim::vx::DataType::FLOAT32, in_shape,
in_shape, tim::vx::TensorAttribute::INPUT); tim::vx::TensorAttribute::INPUT);
tim::vx::TensorSpec out_spec(tim::vx::DataType::FLOAT32, tim::vx::TensorSpec out_spec(tim::vx::DataType::FLOAT32, out_shape,
out_shape, tim::vx::TensorAttribute::OUTPUT); tim::vx::TensorAttribute::OUTPUT);
auto in_tensor = graph->CreateTensor(in_spec); auto in_tensor = graph->CreateTensor(in_spec);
auto out_tensor = graph->CreateTensor(out_spec); auto out_tensor = graph->CreateTensor(out_spec);
std::vector<float> in_data = { std::vector<float> in_data = {-3, -1, 0, 1, 3};
-3, -1, 0, 1, 3 std::vector<float> golden = {-0.00363752, -0.15880796, 0, 0.841192,
}; 2.9963627};
std::vector<float> golden = {
-0.00363752, -0.15880796, 0, 0.841192, 2.9963627
};
EXPECT_TRUE(in_tensor->CopyDataToTensor(in_data.data(), in_data.size() * sizeof(float))); EXPECT_TRUE(in_tensor->CopyDataToTensor(in_data.data(),
auto op = graph->CreateOperation<tim::vx::ops::Gelu>(true); in_data.size() * sizeof(float)));
(*op).BindInput(in_tensor).BindOutput(out_tensor); auto op = graph->CreateOperation<tim::vx::ops::Gelu>(true);
(*op).BindInput(in_tensor).BindOutput(out_tensor);
EXPECT_TRUE(graph->Compile()); EXPECT_TRUE(graph->Compile());
EXPECT_TRUE(graph->Run()); EXPECT_TRUE(graph->Run());
std::vector<float> output(golden.size()); std::vector<float> output(golden.size());
EXPECT_TRUE(out_tensor->CopyDataFromTensor(output.data())); EXPECT_TRUE(out_tensor->CopyDataFromTensor(output.data()));
EXPECT_TRUE(ArraysMatch(golden, output, 1e-5f)); EXPECT_TRUE(ArraysMatch(golden, output, 1e-5f));
} }
TEST(Gelu, shape_5_1_uint8_Quantized) { TEST(Gelu, shape_5_1_uint8_Quantized) {
auto ctx = tim::vx::Context::Create(); auto ctx = tim::vx::Context::Create();
auto graph = ctx->CreateGraph(); auto graph = ctx->CreateGraph();
tim::vx::ShapeType in_shape({5, 1}); tim::vx::ShapeType in_shape({5, 1});
tim::vx::ShapeType out_shape({5, 1}); tim::vx::ShapeType out_shape({5, 1});
const float InputMin = -127, InputMax = 128, OutputMin = -127, OutputMax = 128; const float InputMin = -127, InputMax = 128, OutputMin = -127,
OutputMax = 128;
std::pair<float, int32_t> scalesAndZp; std::pair<float, int32_t> scalesAndZp;
scalesAndZp = QuantizationParams<uint8_t>(InputMin, InputMax); scalesAndZp = QuantizationParams<uint8_t>(InputMin, InputMax);
std::vector<float> scalesInput = {scalesAndZp.first}; //scale std::vector<float> scalesInput = {scalesAndZp.first}; //scale
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second}; //zero point std::vector<int32_t> zeroPointsInput = {scalesAndZp.second}; //zero point
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax); scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
std::vector<float> scalesOutput = {scalesAndZp.first}; std::vector<float> scalesOutput = {scalesAndZp.first};
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second}; std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 1,
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 1,
scalesInput, zeroPointsInput); scalesInput, zeroPointsInput);
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 1, tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 1,
scalesOutput, zeroPointsOutput); scalesOutput, zeroPointsOutput);
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, in_shape, tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, in_shape,
tim::vx::TensorAttribute::INPUT, quantInput); tim::vx::TensorAttribute::INPUT, quantInput);
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, out_shape, tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, out_shape,
tim::vx::TensorAttribute::OUTPUT, quantOutput); tim::vx::TensorAttribute::OUTPUT,
quantOutput);
auto input_tensor = graph->CreateTensor(input_spec); auto input_tensor = graph->CreateTensor(input_spec);
auto output_tensor = graph->CreateTensor(output_spec); auto output_tensor = graph->CreateTensor(output_spec);
std::vector<float> in_float_data = { std::vector<float> in_float_data = {-3, -1, 0, 1, 3};
-3, -1, 0, 1, 3 std::vector<float> golden_float = {-0.00404951, -0.15865529, 0, 0.8413447,
}; 2.9959507};
std::vector<float> golden_float = {
-0.00404951, -0.15865529, 0, 0.8413447, 2.9959507
};
std::vector<uint8_t> input_data = std::vector<uint8_t> input_data =
Quantize<uint8_t>(in_float_data, scalesInput[0], zeroPointsInput[0]); //Quantification process Quantize<uint8_t>(in_float_data, scalesInput[0],
std::vector<uint8_t> golden = zeroPointsInput[0]); //Quantification process
std::vector<uint8_t> golden =
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]); Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
EXPECT_TRUE(input_tensor->CopyDataToTensor(input_data.data(), input_data.size()*4)); EXPECT_TRUE(
auto op = graph->CreateOperation<tim::vx::ops::Gelu>(false); input_tensor->CopyDataToTensor(input_data.data(), input_data.size() * 4));
(*op).BindInput(input_tensor).BindOutput(output_tensor); auto op = graph->CreateOperation<tim::vx::ops::Gelu>(false);
(*op).BindInput(input_tensor).BindOutput(output_tensor);
EXPECT_TRUE(graph->Compile()); EXPECT_TRUE(graph->Compile());
EXPECT_TRUE(graph->Run()); EXPECT_TRUE(graph->Run());
std::vector<uint8_t> output(golden.size()); std::vector<uint8_t> output(golden.size());
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
EXPECT_TRUE(ArraysMatch(golden, output, (uint8_t)1)); EXPECT_TRUE(ArraysMatch(golden, output, (uint8_t)1));
} }