diff --git a/src/tim/vx/ops/conv2d_test.cc b/src/tim/vx/ops/conv2d_test.cc index 8858956..9533f51 100644 --- a/src/tim/vx/ops/conv2d_test.cc +++ b/src/tim/vx/ops/conv2d_test.cc @@ -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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0]}; - std::vector zeroPointsBias = {0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0]}; + std::vector zero_point_bias = {0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 golden_float = {18, 18, 2, 2, 5, 5, 17, 37, 4, 4, 3, 3}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); std::vector weight_data = - Quantize(weight_data_float, scalesWeight[0], zeroPointsInput[0]); + Quantize(weight_data_float, scales_weight[0], zero_point_input[0]); std::vector bias_data = - Quantize(bias_data_float, scalesBias[0], zeroPointsBias[0]); + Quantize(bias_data_float, scales_bias[0], zero_point_bias[0]); std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0]}; - std::vector zeroPointsBias = {0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0]}; + std::vector zero_point_bias = {0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 golden_float = {18, 18, 2, 2, 5, 5, 17, 37, 4, 4, 3, 3}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); std::vector weight_data = - Quantize(weight_data_float, scalesWeight[0], zeroPointsInput[0]); + Quantize(weight_data_float, scales_weight[0], zero_point_input[0]); std::vector bias_data = - Quantize(bias_data_float, scalesBias[0], zeroPointsBias[0]); + Quantize(bias_data_float, scales_bias[0], zero_point_bias[0]); std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0]}; - std::vector zeroPointsBias = {0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0]}; + std::vector zero_point_bias = {0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 golden_float = {30, -24, 40, -34}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); std::vector weight_data = - Quantize(weight_data_float, scalesWeight[0], zeroPointsInput[0]); + Quantize(weight_data_float, scales_weight[0], zero_point_input[0]); std::vector bias_data = - Quantize(bias_data_float, scalesBias[0], zeroPointsBias[0]); + Quantize(bias_data_float, scales_bias[0], zero_point_bias[0]); std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0]}; - std::vector zeroPointsBias = {0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0]}; + std::vector zero_point_bias = {0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 golden_float = {5, 5, 5, 5, 5, 5, 5, 5, 5}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); std::vector weight_data = - Quantize(weight_data_float, scalesWeight[0], zeroPointsInput[0]); + Quantize(weight_data_float, scales_weight[0], zero_point_input[0]); std::vector bias_data = - Quantize(bias_data_float, scalesBias[0], zeroPointsBias[0]); + Quantize(bias_data_float, scales_bias[0], zero_point_bias[0]); std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {1}; - std::vector zeroPointsWeight = {0}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {1}; + std::vector zero_point_weight = {0}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0]}; - std::vector zeroPointsBias = {0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0]}; + std::vector zero_point_bias = {0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data_float = {3, 1, -2, 4, 2, -3, 2, -1, -3, 3, -2, -4}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(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 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 bias_data_float = {3, -2}; std::vector bias_data = - Quantize(bias_data_float, scalesBias[0], zeroPointsBias[0]); + Quantize(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 golden_float = {31, -57, 56, -44}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {1, 2}; - std::vector zeroPointsWeight = {0, 0}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {1, 2}; + std::vector zero_point_weight = {0, 0}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0], - scalesInput[0] * scalesWeight[1]}; - std::vector zeroPointsBias = {0, 0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0], + scales_input[0] * scales_weight[1]}; + std::vector zero_point_bias = {0, 0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data_float = {3, 1, -2, 4, 2, -3, 2, -1, -3, 3, -2, -4}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(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 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 golden_float = {31, -57, 64, -46}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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> 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 scalesInput = {0.5}; - std::vector zeroPointsInput = {-1}; - std::vector scalesWeight(weight_shape[3]); - std::vector zeroPointsWeight(weight_shape[3]); - for(unsigned int ii = 0; ii < weight_shape[3]; ii++){ - - - scalesWeight[ii]=1; - zeroPointsWeight[ii]=0; + std::vector scales_input = {0.5}; + std::vector zero_point_input = {-1}; + std::vector scales_weight(weight_shape[3]); + std::vector 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 scalesBias(sizeofweight); - std::vector zeroPointsBias(sizeofweight); + int32_t sizeofweight = scales_weight.size(); + std::vector scales_bias(sizeofweight); + std::vector 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 scalesOutput = {0.5}; - std::vector zeroPointsOutput = {-1}; + std::vector scales_output = {0.5}; + std::vector 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 weight_data_float(weightSize); - for (uint32_t ii = 0; ii < weightSize; ii++) { - weight_data_float[ii] = 1; + std::vector weight_data_float(weight_size); + for (uint32_t i = 0; i < weight_size; i++) { + weight_data_float[i] = 1; } std::vector weight_data = Quantize(weight_data_float, 1, 0); // bias_data std::vector 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>::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 input_data_float(inputSize); - for (uint32_t ii = 0; ii < inputSize; ii++) { - input_data_float[ii] = 1; + std::vector input_data_float(input_size); + for (uint32_t i = 0; i < input_size; i++) { + input_data_float[i] = 1; } std::vector input_data = Quantize( - 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 golden_float(goldenSize); - for (uint32_t ii = 0; ii < goldenSize; ii++) { - golden_float[ii] = 128 + 1; + std::vector golden_float(golden_size); + for (uint32_t i = 0; i < golden_size; i++) { + golden_float[i] = 129; } std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 diff --git a/src/tim/vx/ops/depthwiseConv_test.cc b/src/tim/vx/ops/depthwiseConv_test.cc index 699270d..63137ab 100644 --- a/src/tim/vx/ops/depthwiseConv_test.cc +++ b/src/tim/vx/ops/depthwiseConv_test.cc @@ -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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0]}; - std::vector zeroPointsBias = {0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0]}; + std::vector zero_point_bias = {0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector 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(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data_float = {1, 7, 3, 9, 5, 11, 2, 8, 4, 10, 6, 12}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(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 weight_data_float = {1, -9, 5, 13, 2, 10, 6, -14, 3, -11, 7, 15, 4, 12, 8, -16}; std::vector weight_data = - Quantize(weight_data_float, scalesWeight[0], zeroPointsInput[0]); + Quantize(weight_data_float, scales_weight[0], zero_point_input[0]); // bias data // scale:0.25 Zp:0 std::vector bias_data_float = {1, 2, 3, 4}; std::vector bias_data = - Quantize(bias_data_float, scalesBias[0], zeroPointsBias[0]); + Quantize(bias_data_float, scales_bias[0], zero_point_bias[0]); // golden // min:-127 max:128 scale:1 Zp:-1 std::vector golden_float = {71, 91, -34, -26, 99, 127, -20, -4}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0]}; - std::vector zeroPointsBias = {0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0]}; + std::vector zero_point_bias = {0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector 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(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data iohw // min:0 max:255 scale:1 Zp:-128 std::vector weight_data_float = {1, 2, 3, 4, 5, 6, 7, 8, 9}; std::vector weight_data = - Quantize(weight_data_float, scalesWeight[0], zeroPointsInput[0]); + Quantize(weight_data_float, scales_weight[0], zero_point_input[0]); // bias data // scale:1 Zp:0 std::vector bias_data_float = {0}; std::vector bias_data = - Quantize(bias_data_float, scalesBias[0], zeroPointsBias[0]); + Quantize(bias_data_float, scales_bias[0], zero_point_bias[0]); // golden // min:0 max:255 scale:1 Zp:-128 std::vector golden_float = {5, 5, 5, 5, 5, 5, 5, 5, 5}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0]}; - std::vector zeroPointsBias = {0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0]}; + std::vector zero_point_bias = {0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector 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(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data_float = {1, 1, 1, 1, 1, 1, 1, 1, 1}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data iohw // min:0 max:255 scale:1 Zp:-128 std::vector weight_data_float = {1, 2, 3, 4}; std::vector weight_data = - Quantize(weight_data_float, scalesWeight[0], zeroPointsInput[0]); + Quantize(weight_data_float, scales_weight[0], zero_point_input[0]); // bias data // scale:1 Zp:0 std::vector bias_data_float = {0}; std::vector bias_data = - Quantize(bias_data_float, scalesBias[0], zeroPointsBias[0]); + Quantize(bias_data_float, scales_bias[0], zero_point_bias[0]); // golden // min:0 max:255 scale:1 Zp:-128 std::vector golden_float = {4, 7, 3, 6, 10, 4, 2, 3, 1}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - std::vector scalesWeight = {1}; - std::vector zeroPointsWeight = {0}; + std::vector scales_weight = {1}; + std::vector zero_point_weight = {0}; - int32_t sizeofweight = scalesWeight.size(); - std::vector scalesBias(sizeofweight); - std::vector zeroPointsBias(sizeofweight); + int32_t sizeofweight = scales_weight.size(); + std::vector scales_bias(sizeofweight); + std::vector 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(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector 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(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data_float = {3, 1, -2, 4, 2, -3, 2, -1, -3, 3, -2, -4}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data iohw std::vector weight_data_float = {1, 3, 7, 3, 2, 4, 8, 4, 3, 5, 5, 1, 4, 6, 6, 2}; std::vector weight_data = - Quantize(weight_data_float, scalesWeight[0], zeroPointsWeight[0]); + Quantize(weight_data_float, scales_weight[0], zero_point_weight[0]); // bias data std::vector 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 golden_float = {43, 3, 48, -4, 18, -28, 22, -36}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - std::vector scalesWeight = {1, 2, 3, 4}; - std::vector zeroPointsWeight = {0, 0, 0, 0}; + std::vector scales_weight = {1, 2, 3, 4}; + std::vector zero_point_weight = {0, 0, 0, 0}; - int32_t sizeofweight = scalesWeight.size(); - std::vector scalesBias(sizeofweight); - std::vector zeroPointsBias(sizeofweight); + int32_t sizeofweight = scales_weight.size(); + std::vector scales_bias(sizeofweight); + std::vector 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(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector 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(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data iohw std::vector 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 golden_float = {43, 3, 48, -4, 21, -30, 22, -54}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - std::vector scalesWeight = {0.1, 0.2, 0.3, 0.4, 0.4, 0.3, 0.2, 0.1}; - std::vector zeroPointsWeight = {0, 0, 0, 0, 0, 0, 0, 0}; + std::vector scales_weight = {0.1, 0.2, 0.3, 0.4, 0.4, 0.3, 0.2, 0.1}; + std::vector zero_point_weight = {0, 0, 0, 0, 0, 0, 0, 0}; - int32_t sizeofweight = scalesWeight.size(); - std::vector scalesBias(sizeofweight); - std::vector zeroPointsBias(sizeofweight); + int32_t sizeofweight = scales_weight.size(); + std::vector scales_bias(sizeofweight); + std::vector 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(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector 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(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data iohw std::vector 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 golden_float = {9, 18, 0, 0, 47, 54, 0, 0}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - std::vector scalesWeight = {0.1, 0.2, 0.3, 0.4, 0.4, 0.3, 0.2, 0.1}; - std::vector zeroPointsWeight = {0, 0, 0, 0, 0, 0, 0, 0}; + std::vector scales_weight = {0.1, 0.2, 0.3, 0.4, 0.4, 0.3, 0.2, 0.1}; + std::vector zero_point_weight = {0, 0, 0, 0, 0, 0, 0, 0}; - int32_t sizeofweight = scalesWeight.size(); - std::vector scalesBias(sizeofweight); - std::vector zeroPointsBias(sizeofweight); + int32_t sizeofweight = scales_weight.size(); + std::vector scales_bias(sizeofweight); + std::vector 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(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector 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(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data iohw std::vector 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 golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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()); diff --git a/src/tim/vx/ops/transposeConv_test.cc b/src/tim/vx/ops/transposeConv_test.cc index 0cb53e3..59e9131 100644 --- a/src/tim/vx/ops/transposeConv_test.cc +++ b/src/tim/vx/ops/transposeConv_test.cc @@ -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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({1, 1}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({1, 1}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({1, 1}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({2, 2}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({2, 2}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({3, 3}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({2, 2}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data_float = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data oihw std::vector weight_data = {129, 131, 133, 135, 137, @@ -554,16 +554,16 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedTest) { std::vector golden_float = {28, 64, 84, 76, 100, 192, 236, 200, 208, 372, 416, 332, 264, 448, 484, 364}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({1, 1}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 output(output_size); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); std::vector output_float = - Dequantize(output, scalesOutput[0], zeroPointsOutput[0]); + Dequantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 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 input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data oihw std::vector 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 golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({1, 1}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 output(output_size); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); std::vector output_float = - Dequantize(output, scalesOutput[0], zeroPointsOutput[0]); + Dequantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 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 input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data oihw std::vector 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 golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({1, 1}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 output(output_size); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); std::vector output_float = - Dequantize(output, scalesOutput[0], zeroPointsOutput[0]); + Dequantize(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 scalesAndZp; + std::pair scales_zp; - scalesAndZp = QuantizationParams(InputMin, InputMax); - std::vector scalesInput = {scalesAndZp.first}; - std::vector zeroPointsInput = {scalesAndZp.second}; + scales_zp = QuantizationParams(input_min, input_max); + std::vector scales_input = {scales_zp.first}; + std::vector zero_point_input = {scales_zp.second}; - scalesAndZp = QuantizationParams(WeightMin, WeightMax); - std::vector scalesWeight = {scalesAndZp.first}; - std::vector zeroPointsWeight = {scalesAndZp.second}; + scales_zp = QuantizationParams(weight_min, weight_max); + std::vector scales_weight = {scales_zp.first}; + std::vector zero_point_weight = {scales_zp.second}; - std::vector scalesBias = {scalesInput[0] * scalesWeight[0]}; - std::vector zeroPointsBias = {0}; + std::vector scales_bias = {scales_input[0] * scales_weight[0]}; + std::vector zero_point_bias = {0}; - scalesAndZp = QuantizationParams(OutputMin, OutputMax); - std::vector scalesOutput = {scalesAndZp.first}; - std::vector zeroPointsOutput = {scalesAndZp.second}; + scales_zp = QuantizationParams(output_min, output_max); + std::vector scales_output = {scales_zp.first}; + std::vector 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 input_data_float = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data oihw std::vector weight_data = {129, 131, 133, 135, 137, @@ -873,13 +873,13 @@ TEST(TransposeConv2d, shape_4_4_1_1_uint8_QuantizedBiasTest) { // bias data std::vector bias_data_float = {1}; std::vector bias_data = - Quantize(bias_data_float, scalesBias[0], zeroPointsBias[0]); + Quantize(bias_data_float, scales_bias[0], zero_point_bias[0]); // nchw std::vector golden_float = {32, 64, 84, 76, 100, 192, 240, 200, 208, 372, 420, 332, 264, 448, 488, 368}; std::vector golden = - Quantize(golden_float, scalesOutput[0], zeroPointsOutput[0]); + Quantize(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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({1, 1}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 output(output_size); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); std::vector output_float = - Dequantize(output, scalesOutput[0], zeroPointsOutput[0]); + Dequantize(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 scalesInput = {16.0 / 255}; - std::vector zeroPointsInput = {-128}; + std::vector scales_input = {16.0 / 255}; + std::vector zero_point_input = {-128}; - std::vector scalesWeight = {9.0 / 127}; - std::vector zeroPointsWeight = {0}; + std::vector scales_weight = {9.0 / 127}; + std::vector zero_point_weight = {0}; - int32_t sizeofweight = scalesWeight.size(); - std::vector scalesBias(sizeofweight); - std::vector zeroPointsBias(sizeofweight); + int32_t sizeofweight = scales_weight.size(); + std::vector scales_bias(sizeofweight); + std::vector 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 scalesOutput = {2}; - std::vector zeroPointsOutput = {-128}; + std::vector scales_output = {2}; + std::vector 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 input_data_float = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data oihw std::vector 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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({1, 1}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 output(output_size); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); std::vector output_float = - Dequantize(output, scalesOutput[0], zeroPointsOutput[0]); + Dequantize(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 scalesInput = {4.0 / 255}; - std::vector zeroPointsInput = {-128}; + std::vector scales_input = {4.0 / 255}; + std::vector zero_point_input = {-128}; - std::vector scalesWeight = {17.0 / 127, 18.0 / 127}; - std::vector zeroPointsWeight = {0, 0}; + std::vector scales_weight = {17.0 / 127, 18.0 / 127}; + std::vector zero_point_weight = {0, 0}; - int32_t sizeofweight = scalesWeight.size(); - std::vector scalesBias(sizeofweight); - std::vector zeroPointsBias(sizeofweight); + int32_t sizeofweight = scales_weight.size(); + std::vector scales_bias(sizeofweight); + std::vector 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 scalesOutput = {1}; - std::vector zeroPointsOutput = {-128}; + std::vector scales_output = {1}; + std::vector 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 input_data_float = {1, 2, 3, 4}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data oihw std::vector 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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({2, 2}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 output(output_size); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); std::vector output_float = - Dequantize(output, scalesOutput[0], zeroPointsOutput[0]); + Dequantize(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 scalesInput = {16.0 / 255}; - std::vector zeroPointsInput = {-128}; + std::vector scales_input = {16.0 / 255}; + std::vector zero_point_input = {-128}; - std::vector scalesWeight = {9.0 / 127}; - std::vector zeroPointsWeight = {0}; + std::vector scales_weight = {9.0 / 127}; + std::vector zero_point_weight = {0}; - int32_t sizeofweight = scalesWeight.size(); - std::vector scalesBias(sizeofweight); - std::vector zeroPointsBias(sizeofweight); + int32_t sizeofweight = scales_weight.size(); + std::vector scales_bias(sizeofweight); + std::vector 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 scalesOutput = {2}; - std::vector zeroPointsOutput = {-128}; + std::vector scales_output = {2}; + std::vector 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 input_data_float = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; std::vector input_data = - Quantize(input_data_float, scalesInput[0], zeroPointsInput[0]); + Quantize(input_data_float, scales_input[0], zero_point_input[0]); // weight data oihw std::vector 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 kernelSize({weight_shape[1], weight_shape[0]}); + std::array kernel_size({weight_shape[1], weight_shape[0]}); std::array stride({1, 1}); - std::array outputPadding({0, 0}); + std::array output_padding({0, 0}); int32_t pad_left_inter = static_cast(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 pad = {pad_left, pad_right, pad_top, pad_bottom}; auto transposeConv2d = graph->CreateOperation( - 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 output(output_size); EXPECT_TRUE(output_tensor->CopyDataFromTensor(output.data())); std::vector output_float = - Dequantize(output, scalesOutput[0], zeroPointsOutput[0]); + Dequantize(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]))); }