add the customer case.(only include wrong case)
Signed-off-by: Jing.Deng <Jing.Deng@verisilicon.com>
This commit is contained in:
Jing.Deng
Sven
parent
e27e15925c
commit
4d53e042c8
|
|
@ -892,45 +892,45 @@ TEST(Conv2d, shape_4_2_1_2_uint8_QuantizedTest1) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{2, 1, weight_shape[3], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, WeightMin = -63.5, WeightMax = 64,
|
||||
OutputMin = -127, OutputMax = 128;
|
||||
float input_min = -63.5, input_max = 64, weight_min = -63.5, weight_max = 64,
|
||||
output_min = -127, output_max = 128;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0]};
|
||||
std::vector<int32_t> zeroPointsBias = {0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0]};
|
||||
std::vector<int32_t> zero_point_bias = {0};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
|
|
@ -948,13 +948,13 @@ TEST(Conv2d, shape_4_2_1_2_uint8_QuantizedTest1) {
|
|||
std::vector<float> golden_float = {18, 18, 2, 2, 5, 5, 17, 37, 4, 4, 3, 3};
|
||||
|
||||
std::vector<u_int8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
std::vector<u_int8_t> weight_data =
|
||||
Quantize<uint8_t>(weight_data_float, scalesWeight[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(weight_data_float, scales_weight[0], zero_point_input[0]);
|
||||
std::vector<int32_t> bias_data =
|
||||
Quantize<int32_t>(bias_data_float, scalesBias[0], zeroPointsBias[0]);
|
||||
Quantize<int32_t>(bias_data_float, scales_bias[0], zero_point_bias[0]);
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
auto bias_tensor = graph->CreateTensor(bias_spec, bias_data.data());
|
||||
|
|
@ -996,45 +996,45 @@ TEST(Conv2d, shape_4_2_1_2_uint8_QuantizedTest2) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{2, 1, weight_shape[3], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -128.5, InputMax = 128, WeightMin = -128.5, WeightMax = 128,
|
||||
OutputMin = -127, OutputMax = 128;
|
||||
float input_min = -128.5, input_max = 128, weight_min = -128.5, weight_max = 128,
|
||||
output_min = -127, output_max = 128;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0]};
|
||||
std::vector<int32_t> zeroPointsBias = {0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0]};
|
||||
std::vector<int32_t> zero_point_bias = {0};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-128.5 max:128 scale:1.00588 Zp:0
|
||||
|
|
@ -1052,13 +1052,13 @@ TEST(Conv2d, shape_4_2_1_2_uint8_QuantizedTest2) {
|
|||
std::vector<float> golden_float = {18, 18, 2, 2, 5, 5, 17, 37, 4, 4, 3, 3};
|
||||
|
||||
std::vector<u_int8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
std::vector<u_int8_t> weight_data =
|
||||
Quantize<uint8_t>(weight_data_float, scalesWeight[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(weight_data_float, scales_weight[0], zero_point_input[0]);
|
||||
std::vector<int32_t> bias_data =
|
||||
Quantize<int32_t>(bias_data_float, scalesBias[0], zeroPointsBias[0]);
|
||||
Quantize<int32_t>(bias_data_float, scales_bias[0], zero_point_bias[0]);
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -1101,45 +1101,45 @@ TEST(Conv2d, shape_6_3_1_1_uint8_AnisotropicStridesQuantizedTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{2, 2, weight_shape[3], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, WeightMin = -63.5, WeightMax = 64,
|
||||
OutputMin = -127, OutputMax = 128;
|
||||
float input_min = -63.5, input_max = 64, weight_min = -63.5, weight_max = 64,
|
||||
output_min = -127, output_max = 128;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0]};
|
||||
std::vector<int32_t> zeroPointsBias = {0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0]};
|
||||
std::vector<int32_t> zero_point_bias = {0};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
|
|
@ -1156,13 +1156,13 @@ TEST(Conv2d, shape_6_3_1_1_uint8_AnisotropicStridesQuantizedTest) {
|
|||
std::vector<float> golden_float = {30, -24, 40, -34};
|
||||
|
||||
std::vector<u_int8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
std::vector<u_int8_t> weight_data =
|
||||
Quantize<uint8_t>(weight_data_float, scalesWeight[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(weight_data_float, scales_weight[0], zero_point_input[0]);
|
||||
std::vector<int32_t> bias_data =
|
||||
Quantize<int32_t>(bias_data_float, scalesBias[0], zeroPointsBias[0]);
|
||||
Quantize<int32_t>(bias_data_float, scales_bias[0], zero_point_bias[0]);
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -1205,45 +1205,45 @@ TEST(Conv2d, shape_9_9_1_1_uint8_DilationQuantizedTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{3, 3, weight_shape[3], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -128, InputMax = 127, WeightMin = -128, WeightMax = 127,
|
||||
OutputMin = 0, OutputMax = 255;
|
||||
float input_min = -128, input_max = 127, weight_min = -128, weight_max = 127,
|
||||
output_min = 0, output_max = 255;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0]};
|
||||
std::vector<int32_t> zeroPointsBias = {0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0]};
|
||||
std::vector<int32_t> zero_point_bias = {0};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-128 max:127 scale:1 Zp:0
|
||||
|
|
@ -1263,13 +1263,13 @@ TEST(Conv2d, shape_9_9_1_1_uint8_DilationQuantizedTest) {
|
|||
std::vector<float> golden_float = {5, 5, 5, 5, 5, 5, 5, 5, 5};
|
||||
|
||||
std::vector<u_int8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
std::vector<u_int8_t> weight_data =
|
||||
Quantize<uint8_t>(weight_data_float, scalesWeight[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(weight_data_float, scales_weight[0], zero_point_input[0]);
|
||||
std::vector<int32_t> bias_data =
|
||||
Quantize<int32_t>(bias_data_float, scalesBias[0], zeroPointsBias[0]);
|
||||
Quantize<int32_t>(bias_data_float, scales_bias[0], zero_point_bias[0]);
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -1312,52 +1312,52 @@ TEST(Conv2d, shape_3_2_2_1_int8_QuantizedPerTensorTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{2, 1, weight_shape[3], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, WeightMin = -63.5, WeightMax = 64,
|
||||
OutputMin = -63.5, OutputMax = 64;
|
||||
float input_min = -63.5, input_max = 64, weight_min = -63.5, weight_max = 64,
|
||||
output_min = -63.5, output_max = 64;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {1};
|
||||
std::vector<int32_t> zeroPointsWeight = {0};
|
||||
scales_zp = QuantizationParams<int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {1};
|
||||
std::vector<int32_t> zero_point_weight = {0};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0]};
|
||||
std::vector<int32_t> zeroPointsBias = {0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0]};
|
||||
std::vector<int32_t> zero_point_bias = {0};
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> input_data_float = {3, 1, -2, 4, 2, -3,
|
||||
2, -1, -3, 3, -2, -4};
|
||||
std::vector<int8_t> input_data =
|
||||
Quantize<int8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<int8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight_float_data = {1, 3, 3, 5, 2, 4, 4, 6, 7, 5, 3, 1, 8, 6, 4, 2};
|
||||
std::vector<int8_t> weight_data = {1, 3, 3, 5, 2, 4, 4, 6,
|
||||
|
|
@ -1366,13 +1366,13 @@ TEST(Conv2d, shape_3_2_2_1_int8_QuantizedPerTensorTest) {
|
|||
// bias data
|
||||
std::vector<float> bias_data_float = {3, -2};
|
||||
std::vector<int32_t> bias_data =
|
||||
Quantize<int32_t>(bias_data_float, scalesBias[0], zeroPointsBias[0]);
|
||||
Quantize<int32_t>(bias_data_float, scales_bias[0], zero_point_bias[0]);
|
||||
|
||||
// golden_int8_data = {61, -115, 111, -89}
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> golden_float = {31, -57, 56, -44};
|
||||
std::vector<int8_t> golden =
|
||||
Quantize<int8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<int8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -1415,53 +1415,53 @@ TEST(Conv2d, shape_3_2_2_1_int8_QuantizedPerChannelTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{2, 1, weight_shape[3], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, WeightMin = 0, WeightMax = 0,
|
||||
OutputMin = -63.5, OutputMax = 64;
|
||||
float input_min = -63.5, input_max = 64, weight_min = 0, weight_max = 0,
|
||||
output_min = -63.5, output_max = 64;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {1, 2};
|
||||
std::vector<int32_t> zeroPointsWeight = {0, 0};
|
||||
scales_zp = QuantizationParams<int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {1, 2};
|
||||
std::vector<int32_t> zero_point_weight = {0, 0};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0],
|
||||
scalesInput[0] * scalesWeight[1]};
|
||||
std::vector<int32_t> zeroPointsBias = {0, 0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0],
|
||||
scales_input[0] * scales_weight[1]};
|
||||
std::vector<int32_t> zero_point_bias = {0, 0};
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scalesBias, zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scales_bias, zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> input_data_float = {3, 1, -2, 4, 2, -3,
|
||||
2, -1, -3, 3, -2, -4};
|
||||
std::vector<int8_t> input_data =
|
||||
Quantize<int8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<int8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight_data_float = {1, 3, 3, 5, 2, 4, 4, 6, 7, 5, 3, 1, 8, 6, 4, 2};
|
||||
std::vector<int8_t> weight_data = {1, 3, 3, 5, 2, 4, 4, 6,
|
||||
|
|
@ -1474,7 +1474,7 @@ TEST(Conv2d, shape_3_2_2_1_int8_QuantizedPerChannelTest) {
|
|||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> golden_float = {31, -57, 64, -46};
|
||||
std::vector<int8_t> golden =
|
||||
Quantize<int8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<int8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -1508,94 +1508,101 @@ TEST(Conv2d, shape_3_2_2_1_int8_QuantizedPerChannelTest) {
|
|||
EXPECT_EQ(golden, output);
|
||||
}
|
||||
|
||||
#if 0
|
||||
TEST(Conv2d, shape_w_h_128_1_ksize_1_1_stride_2_int8_QuantizedPerChannel_customer_Test) {
|
||||
TEST(Conv2d, shape_w_h_128_1_ksize_1_1_stride_2_int8_QuantizedPerChannelTest) {
|
||||
std::map<uint32_t, std::vector<uint32_t>> input_shape_list;
|
||||
input_shape_list[32] = {18, 20, 22, 26, 28, 30, 34, 36, 38,
|
||||
42, 44, 46, 50, 52, 54, 58, 60, 62};
|
||||
input_shape_list[63] = {18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62};
|
||||
input_shape_list[95] = {18, 20, 22, 26, 28, 30, 34, 36, 38,
|
||||
42, 44, 46, 50, 52, 54, 58, 60, 62};
|
||||
input_shape_list[96] = {18, 20, 22, 26, 28, 30, 34, 36, 38,
|
||||
42, 44, 46, 50, 52, 54, 58, 60, 62};
|
||||
tim::vx::ShapeType input_shape({2, 2, 128, 1}); //whcn
|
||||
tim::vx::ShapeType weight_shape({1, 1, 128, 256}); //whio
|
||||
tim::vx::ShapeType bias_shape({weight_shape[3]});
|
||||
tim::vx::ShapeType output_shape(
|
||||
{1, 1, weight_shape[3], input_shape[3]}); //whcn
|
||||
|
||||
std::vector<float> scalesInput = {0.5};
|
||||
std::vector<int32_t> zeroPointsInput = {-1};
|
||||
std::vector<float> scalesWeight(weight_shape[3]);
|
||||
std::vector<int32_t> zeroPointsWeight(weight_shape[3]);
|
||||
for(unsigned int ii = 0; ii < weight_shape[3]; ii++){
|
||||
|
||||
|
||||
scalesWeight[ii]=1;
|
||||
zeroPointsWeight[ii]=0;
|
||||
std::vector<float> scales_input = {0.5};
|
||||
std::vector<int32_t> zero_point_input = {-1};
|
||||
std::vector<float> scales_weight(weight_shape[3]);
|
||||
std::vector<int32_t> zero_point_weight(weight_shape[3]);
|
||||
for (unsigned int i = 0; i < weight_shape[3]; i++) {
|
||||
scales_weight[i] = 1;
|
||||
zero_point_weight[i] = 0;
|
||||
}
|
||||
|
||||
int32_t sizeofweight = scalesWeight.size();
|
||||
std::vector<float> scalesBias(sizeofweight);
|
||||
std::vector<int32_t> zeroPointsBias(sizeofweight);
|
||||
int32_t sizeofweight = scales_weight.size();
|
||||
std::vector<float> scales_bias(sizeofweight);
|
||||
std::vector<int32_t> zero_point_bias(sizeofweight);
|
||||
for (int i = 0; i < sizeofweight; i++) {
|
||||
scalesBias[i] = scalesInput[0] * scalesWeight[i];
|
||||
zeroPointsBias[i] = 0;
|
||||
scales_bias[i] = scales_input[0] * scales_weight[i];
|
||||
zero_point_bias[i] = 0;
|
||||
}
|
||||
|
||||
std::vector<float> scalesOutput = {0.5};
|
||||
std::vector<int32_t> zeroPointsOutput = {-1};
|
||||
std::vector<float> scales_output = {0.5};
|
||||
std::vector<int32_t> zero_point_output = {-1};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scalesBias, zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scales_bias, zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
uint32_t weightSize =
|
||||
uint32_t weight_size =
|
||||
weight_shape[0] * weight_shape[1] * weight_shape[2] * weight_shape[3];
|
||||
std::vector<float> weight_data_float(weightSize);
|
||||
for (uint32_t ii = 0; ii < weightSize; ii++) {
|
||||
weight_data_float[ii] = 1;
|
||||
std::vector<float> weight_data_float(weight_size);
|
||||
for (uint32_t i = 0; i < weight_size; i++) {
|
||||
weight_data_float[i] = 1;
|
||||
}
|
||||
std::vector<int8_t> weight_data = Quantize<int8_t>(weight_data_float, 1, 0);
|
||||
|
||||
// bias_data
|
||||
std::vector<int32_t> bias_data(weight_shape[3]);
|
||||
for (uint32_t ii = 0; ii < weight_shape[3]; ii++) {
|
||||
bias_data[ii] = 2;
|
||||
for (uint32_t i = 0; i < weight_shape[3]; i++) {
|
||||
bias_data[i] = 2;
|
||||
}
|
||||
|
||||
for (int ww = 32; ww < 97; ww++) {
|
||||
for (int hh = 16; hh < 65; hh++) {
|
||||
input_shape[0] = ww;
|
||||
input_shape[1] = hh;
|
||||
output_shape[0] = (ww + 1) / 2;
|
||||
output_shape[1] = (hh + 1) / 2;
|
||||
for (std::map<uint32_t, std::vector<uint32_t>>::iterator iter =
|
||||
input_shape_list.begin();
|
||||
iter != input_shape_list.end(); iter++) {
|
||||
for (uint32_t j = 0; j < iter->second.size(); j++) {
|
||||
input_shape[0] = iter->first;
|
||||
input_shape[1] = iter->second[j];
|
||||
output_shape[0] = (input_shape[0] + 1) / 2;
|
||||
output_shape[1] = (input_shape[1] + 1) / 2;
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT,
|
||||
quantInput);
|
||||
quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantBias);
|
||||
quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
uint32_t inputSize =
|
||||
quant_output);
|
||||
uint32_t input_size =
|
||||
input_shape[0] * input_shape[1] * input_shape[2] * input_shape[3];
|
||||
std::vector<float> input_data_float(inputSize);
|
||||
for (uint32_t ii = 0; ii < inputSize; ii++) {
|
||||
input_data_float[ii] = 1;
|
||||
std::vector<float> input_data_float(input_size);
|
||||
for (uint32_t i = 0; i < input_size; i++) {
|
||||
input_data_float[i] = 1;
|
||||
}
|
||||
std::vector<int8_t> input_data = Quantize<int8_t>(
|
||||
input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
uint32_t goldenSize =
|
||||
uint32_t golden_size =
|
||||
output_shape[0] * output_shape[1] * output_shape[2] * output_shape[3];
|
||||
std::vector<float> golden_float(goldenSize);
|
||||
for (uint32_t ii = 0; ii < goldenSize; ii++) {
|
||||
golden_float[ii] = 128 + 1;
|
||||
std::vector<float> golden_float(golden_size);
|
||||
for (uint32_t i = 0; i < golden_size; i++) {
|
||||
golden_float[i] = 129;
|
||||
}
|
||||
std::vector<int8_t> golden =
|
||||
Quantize<int8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<int8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto ctx = tim::vx::Context::Create();
|
||||
auto graph = ctx->CreateGraph();
|
||||
|
|
@ -1632,4 +1639,3 @@ TEST(Conv2d, shape_w_h_128_1_ksize_1_1_stride_2_int8_QuantizedPerChannel_custome
|
|||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -615,69 +615,69 @@ TEST(DepthwiseConv, shape_2_3_2_1_uint8_QuantizedTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{1, 2, weight_shape[2], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, WeightMin = -63.5, WeightMax = 64,
|
||||
OutputMin = -127, OutputMax = 128;
|
||||
float input_min = -63.5, input_max = 64, weight_min = -63.5, weight_max = 64,
|
||||
output_min = -127, output_max = 128;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0]};
|
||||
std::vector<int32_t> zeroPointsBias = {0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0]};
|
||||
std::vector<int32_t> zero_point_bias = {0};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> input_data_float = {1, 7, 3, 9, 5, 11, 2, 8, 4, 10, 6, 12};
|
||||
std::vector<uint8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data iohw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> weight_data_float = {1, -9, 5, 13, 2, 10, 6, -14,
|
||||
3, -11, 7, 15, 4, 12, 8, -16};
|
||||
std::vector<uint8_t> weight_data =
|
||||
Quantize<uint8_t>(weight_data_float, scalesWeight[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(weight_data_float, scales_weight[0], zero_point_input[0]);
|
||||
|
||||
// bias data
|
||||
// scale:0.25 Zp:0
|
||||
std::vector<float> bias_data_float = {1, 2, 3, 4};
|
||||
std::vector<int32_t> bias_data =
|
||||
Quantize<int32_t>(bias_data_float, scalesBias[0], zeroPointsBias[0]);
|
||||
Quantize<int32_t>(bias_data_float, scales_bias[0], zero_point_bias[0]);
|
||||
|
||||
// golden
|
||||
// min:-127 max:128 scale:1 Zp:-1
|
||||
std::vector<float> golden_float = {71, 91, -34, -26, 99, 127, -20, -4};
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -723,44 +723,44 @@ TEST(DepthwiseConv, shape_9_9_1_1_uint8_QuantizedDilationdValidTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{3, 3, weight_shape[2], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = 0, InputMax = 255, WeightMin = 0, WeightMax = 255,
|
||||
OutputMin = 0, OutputMax = 255;
|
||||
float input_min = 0, input_max = 255, weight_min = 0, weight_max = 255,
|
||||
output_min = 0, output_max = 255;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0]};
|
||||
std::vector<int32_t> zeroPointsBias = {0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0]};
|
||||
std::vector<int32_t> zero_point_bias = {0};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:0 max:255 scale:1 Zp:-128
|
||||
|
|
@ -770,25 +770,25 @@ TEST(DepthwiseConv, shape_9_9_1_1_uint8_QuantizedDilationdValidTest) {
|
|||
0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
std::vector<uint8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data iohw
|
||||
// min:0 max:255 scale:1 Zp:-128
|
||||
std::vector<float> weight_data_float = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
std::vector<uint8_t> weight_data =
|
||||
Quantize<uint8_t>(weight_data_float, scalesWeight[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(weight_data_float, scales_weight[0], zero_point_input[0]);
|
||||
|
||||
// bias data
|
||||
// scale:1 Zp:0
|
||||
std::vector<float> bias_data_float = {0};
|
||||
std::vector<int32_t> bias_data =
|
||||
Quantize<int32_t>(bias_data_float, scalesBias[0], zeroPointsBias[0]);
|
||||
Quantize<int32_t>(bias_data_float, scales_bias[0], zero_point_bias[0]);
|
||||
|
||||
// golden
|
||||
// min:0 max:255 scale:1 Zp:-128
|
||||
std::vector<float> golden_float = {5, 5, 5, 5, 5, 5, 5, 5, 5};
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -834,68 +834,68 @@ TEST(DepthwiseConv, shape_3_3_1_1_uint8_QuantizedDilationdSameTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{3, 3, weight_shape[2], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = 0, InputMax = 255, WeightMin = 0, WeightMax = 255,
|
||||
OutputMin = 0, OutputMax = 255;
|
||||
float input_min = 0, input_max = 255, weight_min = 0, weight_max = 255,
|
||||
output_min = 0, output_max = 255;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0]};
|
||||
std::vector<int32_t> zeroPointsBias = {0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0]};
|
||||
std::vector<int32_t> zero_point_bias = {0};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:0 max:255 scale:1 Zp:-128
|
||||
std::vector<float> input_data_float = {1, 1, 1, 1, 1, 1, 1, 1, 1};
|
||||
std::vector<uint8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data iohw
|
||||
// min:0 max:255 scale:1 Zp:-128
|
||||
std::vector<float> weight_data_float = {1, 2, 3, 4};
|
||||
std::vector<uint8_t> weight_data =
|
||||
Quantize<uint8_t>(weight_data_float, scalesWeight[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(weight_data_float, scales_weight[0], zero_point_input[0]);
|
||||
|
||||
// bias data
|
||||
// scale:1 Zp:0
|
||||
std::vector<float> bias_data_float = {0};
|
||||
std::vector<int32_t> bias_data =
|
||||
Quantize<int32_t>(bias_data_float, scalesBias[0], zeroPointsBias[0]);
|
||||
Quantize<int32_t>(bias_data_float, scales_bias[0], zero_point_bias[0]);
|
||||
|
||||
// golden
|
||||
// min:0 max:255 scale:1 Zp:-128
|
||||
std::vector<float> golden_float = {4, 7, 3, 6, 10, 4, 2, 3, 1};
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -941,60 +941,60 @@ TEST(DepthwiseConv, shape_3_2_2_1_int8_PerTensorTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{2, 1, weight_shape[2], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, OutputMin = -63.5, OutputMax = 64;
|
||||
float input_min = -63.5, input_max = 64, output_min = -63.5, output_max = 64;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesWeight = {1};
|
||||
std::vector<int32_t> zeroPointsWeight = {0};
|
||||
std::vector<float> scales_weight = {1};
|
||||
std::vector<int32_t> zero_point_weight = {0};
|
||||
|
||||
int32_t sizeofweight = scalesWeight.size();
|
||||
std::vector<float> scalesBias(sizeofweight);
|
||||
std::vector<int32_t> zeroPointsBias(sizeofweight);
|
||||
int32_t sizeofweight = scales_weight.size();
|
||||
std::vector<float> scales_bias(sizeofweight);
|
||||
std::vector<int32_t> zero_point_bias(sizeofweight);
|
||||
for (int i = 0; i < sizeofweight; i++) {
|
||||
scalesBias[i] = scalesInput[0] * scalesWeight[i];
|
||||
zeroPointsBias[i] = 0;
|
||||
scales_bias[i] = scales_input[0] * scales_weight[i];
|
||||
zero_point_bias[i] = 0;
|
||||
}
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
scales_zp = QuantizationParams<int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> input_data_float = {3, 1, -2, 4, 2, -3,
|
||||
2, -1, -3, 3, -2, -4};
|
||||
std::vector<int8_t> input_data =
|
||||
Quantize<int8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<int8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data iohw
|
||||
std::vector<float> weight_data_float = {1, 3, 7, 3, 2, 4, 8, 4,
|
||||
3, 5, 5, 1, 4, 6, 6, 2};
|
||||
std::vector<int8_t> weight_data =
|
||||
Quantize<int8_t>(weight_data_float, scalesWeight[0], zeroPointsWeight[0]);
|
||||
Quantize<int8_t>(weight_data_float, scales_weight[0], zero_point_weight[0]);
|
||||
|
||||
// bias data
|
||||
std::vector<int32_t> bias_data = {6, -4, 8, 12};
|
||||
|
|
@ -1003,7 +1003,7 @@ TEST(DepthwiseConv, shape_3_2_2_1_int8_PerTensorTest) {
|
|||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> golden_float = {43, 3, 48, -4, 18, -28, 22, -36};
|
||||
std::vector<int8_t> golden =
|
||||
Quantize<int8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<int8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -1049,47 +1049,47 @@ TEST(DepthwiseConv, shape_3_2_2_1_int8_PerAxisTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{2, 1, weight_shape[2], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, OutputMin = -63.5, OutputMax = 64;
|
||||
float input_min = -63.5, input_max = 64, output_min = -63.5, output_max = 64;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesWeight = {1, 2, 3, 4};
|
||||
std::vector<int32_t> zeroPointsWeight = {0, 0, 0, 0};
|
||||
std::vector<float> scales_weight = {1, 2, 3, 4};
|
||||
std::vector<int32_t> zero_point_weight = {0, 0, 0, 0};
|
||||
|
||||
int32_t sizeofweight = scalesWeight.size();
|
||||
std::vector<float> scalesBias(sizeofweight);
|
||||
std::vector<int32_t> zeroPointsBias(sizeofweight);
|
||||
int32_t sizeofweight = scales_weight.size();
|
||||
std::vector<float> scales_bias(sizeofweight);
|
||||
std::vector<int32_t> zero_point_bias(sizeofweight);
|
||||
for (int i = 0; i < sizeofweight; i++) {
|
||||
scalesBias[i] = scalesInput[0] * scalesWeight[i];
|
||||
zeroPointsBias[i] = 0;
|
||||
scales_bias[i] = scales_input[0] * scales_weight[i];
|
||||
zero_point_bias[i] = 0;
|
||||
}
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
2, scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scalesBias, zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
scales_zp = QuantizationParams<int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
2, scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scales_bias, zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
|
|
@ -1097,7 +1097,7 @@ TEST(DepthwiseConv, shape_3_2_2_1_int8_PerAxisTest) {
|
|||
2, -1, -3, 3, -2, -4};
|
||||
|
||||
std::vector<int8_t> input_data =
|
||||
Quantize<int8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<int8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data iohw
|
||||
std::vector<int8_t> weight_data = {1, 3, 7, 3, 1, 2, 4, 2,
|
||||
|
|
@ -1110,7 +1110,7 @@ TEST(DepthwiseConv, shape_3_2_2_1_int8_PerAxisTest) {
|
|||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> golden_float = {43, 3, 48, -4, 21, -30, 22, -54};
|
||||
std::vector<int8_t> golden =
|
||||
Quantize<int8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<int8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -1156,47 +1156,47 @@ TEST(DepthwiseConv, shape_3_3_8_1_int8_PerChannelValidTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{1, 1, weight_shape[2], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, OutputMin = -63.5, OutputMax = 64;
|
||||
float input_min = -63.5, input_max = 64, output_min = -63.5, output_max = 64;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesWeight = {0.1, 0.2, 0.3, 0.4, 0.4, 0.3, 0.2, 0.1};
|
||||
std::vector<int32_t> zeroPointsWeight = {0, 0, 0, 0, 0, 0, 0, 0};
|
||||
std::vector<float> scales_weight = {0.1, 0.2, 0.3, 0.4, 0.4, 0.3, 0.2, 0.1};
|
||||
std::vector<int32_t> zero_point_weight = {0, 0, 0, 0, 0, 0, 0, 0};
|
||||
|
||||
int32_t sizeofweight = scalesWeight.size();
|
||||
std::vector<float> scalesBias(sizeofweight);
|
||||
std::vector<int32_t> zeroPointsBias(sizeofweight);
|
||||
int32_t sizeofweight = scales_weight.size();
|
||||
std::vector<float> scales_bias(sizeofweight);
|
||||
std::vector<int32_t> zero_point_bias(sizeofweight);
|
||||
for (int i = 0; i < sizeofweight; i++) {
|
||||
scalesBias[i] = scalesInput[0] * scalesWeight[i];
|
||||
zeroPointsBias[i] = 0;
|
||||
scales_bias[i] = scales_input[0] * scales_weight[i];
|
||||
zero_point_bias[i] = 0;
|
||||
}
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
2, scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scalesBias, zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
scales_zp = QuantizationParams<int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
2, scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scales_bias, zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
|
|
@ -1206,7 +1206,7 @@ TEST(DepthwiseConv, shape_3_3_8_1_int8_PerChannelValidTest) {
|
|||
1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
|
||||
std::vector<int8_t> input_data =
|
||||
Quantize<int8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<int8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data iohw
|
||||
std::vector<int8_t> weight_data = {
|
||||
|
|
@ -1222,7 +1222,7 @@ TEST(DepthwiseConv, shape_3_3_8_1_int8_PerChannelValidTest) {
|
|||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
std::vector<float> golden_float = {9, 18, 0, 0, 47, 54, 0, 0};
|
||||
std::vector<int8_t> golden =
|
||||
Quantize<int8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<int8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -1268,47 +1268,47 @@ TEST(DepthwiseConv, shape_3_3_8_1_int8_PerChannelSameTest) {
|
|||
tim::vx::ShapeType output_shape(
|
||||
{3, 3, weight_shape[2], input_shape[3]}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, OutputMin = -63.5, OutputMax = 64;
|
||||
float input_min = -63.5, input_max = 64, output_min = -63.5, output_max = 64;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesWeight = {0.1, 0.2, 0.3, 0.4, 0.4, 0.3, 0.2, 0.1};
|
||||
std::vector<int32_t> zeroPointsWeight = {0, 0, 0, 0, 0, 0, 0, 0};
|
||||
std::vector<float> scales_weight = {0.1, 0.2, 0.3, 0.4, 0.4, 0.3, 0.2, 0.1};
|
||||
std::vector<int32_t> zero_point_weight = {0, 0, 0, 0, 0, 0, 0, 0};
|
||||
|
||||
int32_t sizeofweight = scalesWeight.size();
|
||||
std::vector<float> scalesBias(sizeofweight);
|
||||
std::vector<int32_t> zeroPointsBias(sizeofweight);
|
||||
int32_t sizeofweight = scales_weight.size();
|
||||
std::vector<float> scales_bias(sizeofweight);
|
||||
std::vector<int32_t> zero_point_bias(sizeofweight);
|
||||
for (int i = 0; i < sizeofweight; i++) {
|
||||
scalesBias[i] = scalesInput[0] * scalesWeight[i];
|
||||
zeroPointsBias[i] = 0;
|
||||
scales_bias[i] = scales_input[0] * scales_weight[i];
|
||||
zero_point_bias[i] = 0;
|
||||
}
|
||||
|
||||
scalesAndZp = QuantizationParams<int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
2, scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scalesBias, zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
scales_zp = QuantizationParams<int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
2, scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scales_bias, zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
// min:-63.5 max:64 scale:0.5 Zp:-1
|
||||
|
|
@ -1318,7 +1318,7 @@ TEST(DepthwiseConv, shape_3_3_8_1_int8_PerChannelSameTest) {
|
|||
1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
|
||||
std::vector<int8_t> input_data =
|
||||
Quantize<int8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<int8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data iohw
|
||||
std::vector<int8_t> weight_data = {
|
||||
|
|
@ -1338,7 +1338,7 @@ TEST(DepthwiseConv, shape_3_3_8_1_int8_PerChannelSameTest) {
|
|||
21, 31, 21, 31, 47, 31, 21, 31, 21, 24, 36, 24, 36, 54, 36, 24, 36, 24,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
std::vector<int8_t> golden =
|
||||
Quantize<int8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<int8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
|
|||
|
|
@ -37,9 +37,9 @@ TEST(TransposeConv2d, shape_4_4_1_1_float32_SimpleTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::SAME;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({1, 1});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -53,7 +53,7 @@ TEST(TransposeConv2d, shape_4_4_1_1_float32_SimpleTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -107,9 +107,9 @@ TEST(TransposeConv2d, shape_4_4_2_1_float32_SameTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::SAME;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({1, 1});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -123,7 +123,7 @@ TEST(TransposeConv2d, shape_4_4_2_1_float32_SameTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -179,9 +179,9 @@ TEST(TransposeConv2d, shape_4_4_2_1_float32_ValidTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::VALID;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({1, 1});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -195,7 +195,7 @@ TEST(TransposeConv2d, shape_4_4_2_1_float32_ValidTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -247,9 +247,9 @@ TEST(TransposeConv2d, shape_2_2_1_1_float32_StrideTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::VALID;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({2, 2});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -263,7 +263,7 @@ TEST(TransposeConv2d, shape_2_2_1_1_float32_StrideTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -317,9 +317,9 @@ TEST(TransposeConv2d, shape_2_2_1_1_float32_ChannelTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::VALID;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({2, 2});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -333,7 +333,7 @@ TEST(TransposeConv2d, shape_2_2_1_1_float32_ChannelTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -384,9 +384,9 @@ TEST(TransposeConv2d, shape_2_1_1_1_float32_AccuracyTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::SAME;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({3, 3});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -400,7 +400,7 @@ TEST(TransposeConv2d, shape_2_1_1_1_float32_AccuracyTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -461,9 +461,9 @@ TEST(TransposeConv2d, shape_2_2_1_1_float32_BiasChannelTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::VALID;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({2, 2});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -477,7 +477,7 @@ TEST(TransposeConv2d, shape_2_2_1_1_float32_BiasChannelTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -507,44 +507,44 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedTest) {
|
|||
tim::vx::ShapeType weight_shape({3, 3, 1, 1}); //whio
|
||||
tim::vx::ShapeType output_shape({4, 4, 1, 1}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, WeightMin = -63.5, WeightMax = 64,
|
||||
OutputMin = -508, OutputMax = 512;
|
||||
float input_min = -63.5, input_max = 64, weight_min = -63.5, weight_max = 64,
|
||||
output_min = -508, output_max = 512;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
std::vector<float> input_data_float = {1, 2, 3, 4, 5, 6, 7, 8,
|
||||
9, 10, 11, 12, 13, 14, 15, 16};
|
||||
std::vector<u_int8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data oihw
|
||||
std::vector<u_int8_t> weight_data = {129, 131, 133, 135, 137,
|
||||
|
|
@ -554,16 +554,16 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedTest) {
|
|||
std::vector<float> golden_float = {28, 64, 84, 76, 100, 192, 236, 200,
|
||||
208, 372, 416, 332, 264, 448, 484, 364};
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::SAME;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({1, 1});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -577,7 +577,7 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -596,9 +596,9 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedTest) {
|
|||
std::vector<uint8_t> output(output_size);
|
||||
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
|
||||
std::vector<float> output_float =
|
||||
Dequantize<uint8_t>(output, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Dequantize<uint8_t>(output, scales_output[0], zero_point_output[0]);
|
||||
EXPECT_THAT(output_float,
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scalesOutput[0])));
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scales_output[0])));
|
||||
}
|
||||
|
||||
TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedTwoFiltersTest) {
|
||||
|
|
@ -609,45 +609,45 @@ TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedTwoFiltersTest) {
|
|||
tim::vx::ShapeType weight_shape({3, 3, 2, 1}); //whio
|
||||
tim::vx::ShapeType output_shape({4, 4, 1, 1}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, WeightMin = -63.5, WeightMax = 64,
|
||||
OutputMin = -4064, OutputMax = 4096;
|
||||
float input_min = -63.5, input_max = 64, weight_min = -63.5, weight_max = 64,
|
||||
output_min = -4064, output_max = 4096;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
std::vector<float> input_data_float = {
|
||||
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31,
|
||||
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
|
||||
std::vector<u_int8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data oihw
|
||||
std::vector<u_int8_t> weight_data = {129, 133, 137, 141, 145, 149,
|
||||
|
|
@ -659,16 +659,16 @@ TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedTwoFiltersTest) {
|
|||
1696, 1440, 1504, 2720, 3072, 2432,
|
||||
1984, 3360, 3648, 2752};
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::SAME;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({1, 1});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -682,7 +682,7 @@ TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedTwoFiltersTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -701,9 +701,9 @@ TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedTwoFiltersTest) {
|
|||
std::vector<uint8_t> output(output_size);
|
||||
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
|
||||
std::vector<float> output_float =
|
||||
Dequantize<uint8_t>(output, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Dequantize<uint8_t>(output, scales_output[0], zero_point_output[0]);
|
||||
EXPECT_THAT(output_float,
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scalesOutput[0])));
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scales_output[0])));
|
||||
}
|
||||
|
||||
TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedValidTest) {
|
||||
|
|
@ -714,45 +714,45 @@ TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedValidTest) {
|
|||
tim::vx::ShapeType weight_shape({3, 3, 2, 1}); //whio
|
||||
tim::vx::ShapeType output_shape({6, 6, 1, 1}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, WeightMin = -63.5, WeightMax = 64,
|
||||
OutputMin = -4064, OutputMax = 4096;
|
||||
float input_min = -63.5, input_max = 64, weight_min = -63.5, weight_max = 64,
|
||||
output_min = -4064, output_max = 4096;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
std::vector<float> input_data_float = {
|
||||
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31,
|
||||
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
|
||||
std::vector<u_int8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data oihw
|
||||
std::vector<u_int8_t> weight_data = {129, 133, 137, 141, 145, 149,
|
||||
|
|
@ -765,16 +765,16 @@ TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedValidTest) {
|
|||
224, 672, 1344, 1696, 1440, 864, 608, 1504, 2720, 3072, 2432, 1440,
|
||||
864, 1984, 3360, 3648, 2752, 1536, 704, 1536, 2528, 2720, 2016, 1088};
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::VALID;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({1, 1});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -788,7 +788,7 @@ TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedValidTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -807,9 +807,9 @@ TEST(TransposeConv2d, shape_4_4_2_1_uint8_QuantizedValidTest) {
|
|||
std::vector<uint8_t> output(output_size);
|
||||
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
|
||||
std::vector<float> output_float =
|
||||
Dequantize<uint8_t>(output, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Dequantize<uint8_t>(output, scales_output[0], zero_point_output[0]);
|
||||
EXPECT_THAT(output_float,
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scalesOutput[0])));
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scales_output[0])));
|
||||
}
|
||||
|
||||
TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedBiasTest) {
|
||||
|
|
@ -821,51 +821,51 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedBiasTest) {
|
|||
tim::vx::ShapeType bias_shape({weight_shape[3]});
|
||||
tim::vx::ShapeType output_shape({4, 4, 1, 1}); //whcn
|
||||
|
||||
float InputMin = -63.5, InputMax = 64, WeightMin = -63.5, WeightMax = 64,
|
||||
OutputMin = -508, OutputMax = 512;
|
||||
float input_min = -63.5, input_max = 64, weight_min = -63.5, weight_max = 64,
|
||||
output_min = -508, output_max = 512;
|
||||
|
||||
std::pair<float, int32_t> scalesAndZp;
|
||||
std::pair<float, int32_t> scales_zp;
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(InputMin, InputMax);
|
||||
std::vector<float> scalesInput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsInput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(input_min, input_max);
|
||||
std::vector<float> scales_input = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_input = {scales_zp.second};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(WeightMin, WeightMax);
|
||||
std::vector<float> scalesWeight = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsWeight = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(weight_min, weight_max);
|
||||
std::vector<float> scales_weight = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_weight = {scales_zp.second};
|
||||
|
||||
std::vector<float> scalesBias = {scalesInput[0] * scalesWeight[0]};
|
||||
std::vector<int32_t> zeroPointsBias = {0};
|
||||
std::vector<float> scales_bias = {scales_input[0] * scales_weight[0]};
|
||||
std::vector<int32_t> zero_point_bias = {0};
|
||||
|
||||
scalesAndZp = QuantizationParams<u_int8_t>(OutputMin, OutputMax);
|
||||
std::vector<float> scalesOutput = {scalesAndZp.first};
|
||||
std::vector<int32_t> zeroPointsOutput = {scalesAndZp.second};
|
||||
scales_zp = QuantizationParams<u_int8_t>(output_min, output_max);
|
||||
std::vector<float> scales_output = {scales_zp.first};
|
||||
std::vector<int32_t> zero_point_output = {scales_zp.second};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::ASYMMETRIC, 2, scalesBias,
|
||||
zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::ASYMMETRIC, 2, scales_bias,
|
||||
zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::UINT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::UINT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::UINT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
std::vector<float> input_data_float = {1, 2, 3, 4, 5, 6, 7, 8,
|
||||
9, 10, 11, 12, 13, 14, 15, 16};
|
||||
std::vector<u_int8_t> input_data =
|
||||
Quantize<uint8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<uint8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data oihw
|
||||
std::vector<u_int8_t> weight_data = {129, 131, 133, 135, 137,
|
||||
|
|
@ -873,13 +873,13 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedBiasTest) {
|
|||
// bias data
|
||||
std::vector<float> bias_data_float = {1};
|
||||
std::vector<int32_t> bias_data =
|
||||
Quantize<int32_t>(bias_data_float, scalesBias[0], zeroPointsBias[0]);
|
||||
Quantize<int32_t>(bias_data_float, scales_bias[0], zero_point_bias[0]);
|
||||
|
||||
// nchw
|
||||
std::vector<float> golden_float = {32, 64, 84, 76, 100, 192, 240, 200,
|
||||
208, 372, 420, 332, 264, 448, 488, 368};
|
||||
std::vector<u_int8_t> golden =
|
||||
Quantize<uint8_t>(golden_float, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Quantize<uint8_t>(golden_float, scales_output[0], zero_point_output[0]);
|
||||
|
||||
auto input_tensor = graph->CreateTensor(input_spec);
|
||||
auto weight_tensor = graph->CreateTensor(weight_spec, weight_data.data());
|
||||
|
|
@ -887,9 +887,9 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedBiasTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::SAME;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({1, 1});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -903,7 +903,7 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedBiasTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -923,9 +923,9 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedBiasTest) {
|
|||
std::vector<uint8_t> output(output_size);
|
||||
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
|
||||
std::vector<float> output_float =
|
||||
Dequantize<uint8_t>(output, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Dequantize<uint8_t>(output, scales_output[0], zero_point_output[0]);
|
||||
EXPECT_THAT(output_float,
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scalesOutput[0])));
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scales_output[0])));
|
||||
}
|
||||
|
||||
TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedPerChannelOneTest) {
|
||||
|
|
@ -937,48 +937,48 @@ TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedPerChannelOneTest) {
|
|||
tim::vx::ShapeType bias_shape({weight_shape[3]});
|
||||
tim::vx::ShapeType output_shape({4, 4, 1, 1}); //whcn
|
||||
|
||||
std::vector<float> scalesInput = {16.0 / 255};
|
||||
std::vector<int32_t> zeroPointsInput = {-128};
|
||||
std::vector<float> scales_input = {16.0 / 255};
|
||||
std::vector<int32_t> zero_point_input = {-128};
|
||||
|
||||
std::vector<float> scalesWeight = {9.0 / 127};
|
||||
std::vector<int32_t> zeroPointsWeight = {0};
|
||||
std::vector<float> scales_weight = {9.0 / 127};
|
||||
std::vector<int32_t> zero_point_weight = {0};
|
||||
|
||||
int32_t sizeofweight = scalesWeight.size();
|
||||
std::vector<float> scalesBias(sizeofweight);
|
||||
std::vector<int32_t> zeroPointsBias(sizeofweight);
|
||||
int32_t sizeofweight = scales_weight.size();
|
||||
std::vector<float> scales_bias(sizeofweight);
|
||||
std::vector<int32_t> zero_point_bias(sizeofweight);
|
||||
for (int i = 0; i < sizeofweight; i++) {
|
||||
scalesBias[i] = scalesInput[0] * scalesWeight[i];
|
||||
zeroPointsBias[i] = 0;
|
||||
scales_bias[i] = scales_input[0] * scales_weight[i];
|
||||
zero_point_bias[i] = 0;
|
||||
}
|
||||
|
||||
std::vector<float> scalesOutput = {2};
|
||||
std::vector<int32_t> zeroPointsOutput = {-128};
|
||||
std::vector<float> scales_output = {2};
|
||||
std::vector<int32_t> zero_point_output = {-128};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scalesBias, zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scales_bias, zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
std::vector<float> input_data_float = {1, 2, 3, 4, 5, 6, 7, 8,
|
||||
9, 10, 11, 12, 13, 14, 15, 16};
|
||||
std::vector<int8_t> input_data =
|
||||
Quantize<int8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<int8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data oihw
|
||||
std::vector<int8_t> weight_data = {14, 28, 42, 56, 71, 85, 99, 113, 127};
|
||||
|
|
@ -994,9 +994,9 @@ TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedPerChannelOneTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::SAME;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({1, 1});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -1010,7 +1010,7 @@ TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedPerChannelOneTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -1030,9 +1030,9 @@ TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedPerChannelOneTest) {
|
|||
std::vector<int8_t> output(output_size);
|
||||
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
|
||||
std::vector<float> output_float =
|
||||
Dequantize<int8_t>(output, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Dequantize<int8_t>(output, scales_output[0], zero_point_output[0]);
|
||||
EXPECT_THAT(output_float,
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scalesOutput[0])));
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scales_output[0])));
|
||||
}
|
||||
|
||||
TEST(TransposeConv2d, shape_2_2_1_1_int8_QuantizedPerChannelTwoTest) {
|
||||
|
|
@ -1044,47 +1044,47 @@ TEST(TransposeConv2d, shape_2_2_1_1_int8_QuantizedPerChannelTwoTest) {
|
|||
tim::vx::ShapeType bias_shape({weight_shape[3]});
|
||||
tim::vx::ShapeType output_shape({5, 5, 2, 1}); //whcn
|
||||
|
||||
std::vector<float> scalesInput = {4.0 / 255};
|
||||
std::vector<int32_t> zeroPointsInput = {-128};
|
||||
std::vector<float> scales_input = {4.0 / 255};
|
||||
std::vector<int32_t> zero_point_input = {-128};
|
||||
|
||||
std::vector<float> scalesWeight = {17.0 / 127, 18.0 / 127};
|
||||
std::vector<int32_t> zeroPointsWeight = {0, 0};
|
||||
std::vector<float> scales_weight = {17.0 / 127, 18.0 / 127};
|
||||
std::vector<int32_t> zero_point_weight = {0, 0};
|
||||
|
||||
int32_t sizeofweight = scalesWeight.size();
|
||||
std::vector<float> scalesBias(sizeofweight);
|
||||
std::vector<int32_t> zeroPointsBias(sizeofweight);
|
||||
int32_t sizeofweight = scales_weight.size();
|
||||
std::vector<float> scales_bias(sizeofweight);
|
||||
std::vector<int32_t> zero_point_bias(sizeofweight);
|
||||
for (int i = 0; i < sizeofweight; i++) {
|
||||
scalesBias[i] = scalesInput[0] * scalesWeight[i];
|
||||
zeroPointsBias[i] = 0;
|
||||
scales_bias[i] = scales_input[0] * scales_weight[i];
|
||||
zero_point_bias[i] = 0;
|
||||
}
|
||||
|
||||
std::vector<float> scalesOutput = {1};
|
||||
std::vector<int32_t> zeroPointsOutput = {-128};
|
||||
std::vector<float> scales_output = {1};
|
||||
std::vector<int32_t> zero_point_output = {-128};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scalesBias, zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scales_bias, zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
std::vector<float> input_data_float = {1, 2, 3, 4};
|
||||
std::vector<int8_t> input_data =
|
||||
Quantize<int8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<int8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data oihw
|
||||
std::vector<int8_t> weight_data = {7, 22, 37, 52, 67, 82, 97, 112, 127,
|
||||
|
|
@ -1103,9 +1103,9 @@ TEST(TransposeConv2d, shape_2_2_1_1_int8_QuantizedPerChannelTwoTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::VALID;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({2, 2});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -1119,7 +1119,7 @@ TEST(TransposeConv2d, shape_2_2_1_1_int8_QuantizedPerChannelTwoTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -1139,9 +1139,9 @@ TEST(TransposeConv2d, shape_2_2_1_1_int8_QuantizedPerChannelTwoTest) {
|
|||
std::vector<int8_t> output(output_size);
|
||||
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
|
||||
std::vector<float> output_float =
|
||||
Dequantize<int8_t>(output, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Dequantize<int8_t>(output, scales_output[0], zero_point_output[0]);
|
||||
EXPECT_THAT(output_float,
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scalesOutput[0])));
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scales_output[0])));
|
||||
}
|
||||
|
||||
TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedBiasPerChannelTest) {
|
||||
|
|
@ -1153,48 +1153,48 @@ TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedBiasPerChannelTest) {
|
|||
tim::vx::ShapeType bias_shape({weight_shape[3]});
|
||||
tim::vx::ShapeType output_shape({4, 4, 1, 1}); //whcn
|
||||
|
||||
std::vector<float> scalesInput = {16.0 / 255};
|
||||
std::vector<int32_t> zeroPointsInput = {-128};
|
||||
std::vector<float> scales_input = {16.0 / 255};
|
||||
std::vector<int32_t> zero_point_input = {-128};
|
||||
|
||||
std::vector<float> scalesWeight = {9.0 / 127};
|
||||
std::vector<int32_t> zeroPointsWeight = {0};
|
||||
std::vector<float> scales_weight = {9.0 / 127};
|
||||
std::vector<int32_t> zero_point_weight = {0};
|
||||
|
||||
int32_t sizeofweight = scalesWeight.size();
|
||||
std::vector<float> scalesBias(sizeofweight);
|
||||
std::vector<int32_t> zeroPointsBias(sizeofweight);
|
||||
int32_t sizeofweight = scales_weight.size();
|
||||
std::vector<float> scales_bias(sizeofweight);
|
||||
std::vector<int32_t> zero_point_bias(sizeofweight);
|
||||
for (int i = 0; i < sizeofweight; i++) {
|
||||
scalesBias[i] = scalesInput[0] * scalesWeight[i];
|
||||
zeroPointsBias[i] = 0;
|
||||
scales_bias[i] = scales_input[0] * scales_weight[i];
|
||||
zero_point_bias[i] = 0;
|
||||
}
|
||||
|
||||
std::vector<float> scalesOutput = {2};
|
||||
std::vector<int32_t> zeroPointsOutput = {-128};
|
||||
std::vector<float> scales_output = {2};
|
||||
std::vector<int32_t> zero_point_output = {-128};
|
||||
|
||||
tim::vx::Quantization quantInput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesInput, zeroPointsInput);
|
||||
tim::vx::Quantization quantWeight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scalesWeight, zeroPointsWeight);
|
||||
tim::vx::Quantization quantBias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scalesBias, zeroPointsBias);
|
||||
tim::vx::Quantization quantOutput(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scalesOutput, zeroPointsOutput);
|
||||
tim::vx::Quantization quant_input(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_input, zero_point_input);
|
||||
tim::vx::Quantization quant_weight(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL,
|
||||
3, scales_weight, zero_point_weight);
|
||||
tim::vx::Quantization quant_bias(tim::vx::QuantType::SYMMETRIC_PER_CHANNEL, 0,
|
||||
scales_bias, zero_point_bias);
|
||||
tim::vx::Quantization quant_output(tim::vx::QuantType::ASYMMETRIC, 2,
|
||||
scales_output, zero_point_output);
|
||||
|
||||
tim::vx::TensorSpec input_spec(tim::vx::DataType::INT8, input_shape,
|
||||
tim::vx::TensorAttribute::INPUT, quantInput);
|
||||
tim::vx::TensorAttribute::INPUT, quant_input);
|
||||
tim::vx::TensorSpec weight_spec(tim::vx::DataType::INT8, weight_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT,
|
||||
quantWeight);
|
||||
quant_weight);
|
||||
tim::vx::TensorSpec bias_spec(tim::vx::DataType::INT32, bias_shape,
|
||||
tim::vx::TensorAttribute::CONSTANT, quantBias);
|
||||
tim::vx::TensorAttribute::CONSTANT, quant_bias);
|
||||
tim::vx::TensorSpec output_spec(tim::vx::DataType::INT8, output_shape,
|
||||
tim::vx::TensorAttribute::OUTPUT,
|
||||
quantOutput);
|
||||
quant_output);
|
||||
|
||||
// Input data nchw
|
||||
std::vector<float> input_data_float = {1, 2, 3, 4, 5, 6, 7, 8,
|
||||
9, 10, 11, 12, 13, 14, 15, 16};
|
||||
std::vector<int8_t> input_data =
|
||||
Quantize<int8_t>(input_data_float, scalesInput[0], zeroPointsInput[0]);
|
||||
Quantize<int8_t>(input_data_float, scales_input[0], zero_point_input[0]);
|
||||
|
||||
// weight data oihw
|
||||
std::vector<int8_t> weight_data = {14, 28, 42, 56, 71, 85, 99, 113, 127};
|
||||
|
|
@ -1210,9 +1210,9 @@ TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedBiasPerChannelTest) {
|
|||
auto output_tensor = graph->CreateTensor(output_spec);
|
||||
|
||||
auto padding = tim::vx::PadType::SAME;
|
||||
std::array<uint32_t, 2> kernelSize({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> kernel_size({weight_shape[1], weight_shape[0]});
|
||||
std::array<uint32_t, 2> stride({1, 1});
|
||||
std::array<uint32_t, 2> outputPadding({0, 0});
|
||||
std::array<uint32_t, 2> output_padding({0, 0});
|
||||
int32_t pad_left_inter =
|
||||
static_cast<int32_t>(weight_shape[0] + stride[0] * (input_shape[0] - 1) -
|
||||
output_shape[1]) / 2;
|
||||
|
|
@ -1226,7 +1226,7 @@ TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedBiasPerChannelTest) {
|
|||
std::array<uint32_t, 4> pad = {pad_left, pad_right, pad_top, pad_bottom};
|
||||
|
||||
auto transposeConv2d = graph->CreateOperation<tim::vx::ops::DeConv2d>(
|
||||
weight_shape[3], padding, kernelSize, stride, outputPadding, pad);
|
||||
weight_shape[3], padding, kernel_size, stride, output_padding, pad);
|
||||
(*transposeConv2d)
|
||||
.BindInput(input_tensor)
|
||||
.BindInput(weight_tensor)
|
||||
|
|
@ -1246,7 +1246,7 @@ TEST(TransposeConv2d, shape_4_4_1_1_int8_QuantizedBiasPerChannelTest) {
|
|||
std::vector<int8_t> output(output_size);
|
||||
EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data()));
|
||||
std::vector<float> output_float =
|
||||
Dequantize<int8_t>(output, scalesOutput[0], zeroPointsOutput[0]);
|
||||
Dequantize<int8_t>(output, scales_output[0], zero_point_output[0]);
|
||||
EXPECT_THAT(output_float,
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scalesOutput[0])));
|
||||
ElementsAreArray(ArrayFloatNear(golden_float, scales_output[0])));
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue