39 #include "tests/datasets/LargeConvolutionLayerDataset.h"
40 #include "tests/datasets/SmallConvolutionLayerDataset.h"
45 #include "tests/validation/fixtures/ConvolutionLayerFixture.h"
46 #include "tests/validation/fixtures/WinogradConvolutionLayerFixture.h"
72 const RelativeTolerance<float> rel_tolerance_f32(0.01f);
73 const RelativeTolerance<float> rel_tolerance_winograd_3x3_f32(0.05f);
75 const AbsoluteTolerance<float> abs_tolerance_1xN_f32(0.0041f);
77 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
78 const AbsoluteTolerance<half> tolerance_convolution_layer_f16(
half(0.4f));
82 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
83 const RelativeTolerance<half_float::half> rel_tolerance_f16(
half_float::half(0.2f));
84 const AbsoluteTolerance<float> abs_tolerance_f16(0.2f);
88 #ifdef ARM_COMPUTE_ENABLE_SME
91 constexpr AbsoluteTolerance<float> tolerance_qasymm8(1.0);
92 #else // ARM_COMPUTE_ENABLE_SME
93 constexpr AbsoluteTolerance<float> tolerance_qasymm8(0.0);
94 #endif // ARM_COMPUTE_ENABLE_SME
97 const auto CNNDataTypes =
make(
"DataType",
99 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
112 const auto ActivationFunctionsDatasetNightly =
make(
"ActivationInfo",
114 ActivationLayerInfo(),
115 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU),
116 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 0.5f),
118 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU, 0.5f, -0.5f),
119 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LEAKY_RELU, 0.1f),
120 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::SOFT_RELU),
121 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::ELU),
122 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::ABS),
123 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LOGISTIC),
124 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::TANH),
125 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::SQUARE),
126 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::SWISH),
127 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::HARD_SWISH),
128 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LINEAR, 2.f, 1.f),
130 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::GELU),
131 #endif // __aarch64__
136 QuantizationInfo(0.5f, 10),
137 QuantizationInfo(0.3f, 3),
138 QuantizationInfo(1.f, 10),
139 QuantizationInfo(1.1f, 10),
164 make(
"ConvInfo", { PadStrideInfo(1, 1, 0, 0),
165 PadStrideInfo(1, 1, 0, 0),
166 PadStrideInfo(2, 1, 0, 0),
167 PadStrideInfo(3, 2, 1, 0)
169 make(
"FastMath", {
true,
179 &
output_info.clone()->set_is_resizable(
true),
conv_info, WeightsInfo(), Size2D(1U, 1U), ActivationLayerInfo(), fast_math);
195 template <typename T>
196 using NEWinogradConvolutionLayerFixture = WinogradConvolutionLayerFastMathValidationFixture<Tensor, Accessor, NEWinogradConvolutionLayer, T>;
197 template <typename T>
200 template <typename T>
212 auto winograd = std::make_unique<cpu::CpuWinogradConv2d>();
219 winograd->configure(&
src_info, &b_info, &w_info, &dst_info, pad_info);
222 auto a = create_tensor<Tensor>(
src_info);
223 auto b = create_tensor<Tensor>(b_info);
224 auto c = create_tensor<Tensor>(w_info);
225 a.allocator()->allocate();
226 b.allocator()->allocate();
227 c.allocator()->allocate();
233 auto ws = manage_workspace<Tensor>(winograd->workspace(), mg, run_pack, prep_pack);
234 auto run_conv = [&]() ->
Tensor
236 auto dst = create_tensor<Tensor>(dst_info);
237 dst.allocator()->allocate();
245 winograd->prepare(prep_pack);
246 winograd->run(run_pack);
250 auto result_0 = run_conv();
251 auto result_1 = run_conv();
253 for(
size_t i = 0; i < result_0.info()->tensor_shape().total_size(); ++i)
268 auto gemm = std::make_unique<NEWinogradConvolutionLayer>();
275 auto run_conv = [&]()
278 auto w = create_tensor<Tensor>(w_info);
279 auto b = create_tensor<Tensor>(b_info);
280 auto dst = create_tensor<Tensor>(dst_info);
284 src.allocator()->allocate();
285 b.allocator()->allocate();
286 w.allocator()->allocate();
287 dst.allocator()->allocate();
296 auto result_0 = run_conv();
297 auto result_1 = run_conv();
299 for(
size_t i = 0; i < result_0.info()->tensor_shape().total_size(); ++i)
368 weights_info_const, expected_const)
406 ActivationLayerInfo(),
419 combine(datasets::SmallWinogradConvolutionLayer1x3Dataset(),
443 combine(datasets::LargeWinogradConvolutionLayer1x3Dataset(),
449 validate(Accessor(_target), _reference, abs_tolerance_1xN_f32);
456 combine(datasets::SmallWinogradConvolutionLayer3x1Dataset(),
465 combine(datasets::LargeWinogradConvolutionLayer3x1Dataset(),
471 validate(Accessor(_target), _reference, abs_tolerance_1xN_f32);
478 combine(datasets::SmallWinogradConvolutionLayer1x5Dataset(),
487 combine(datasets::LargeWinogradConvolutionLayer1x5Dataset(),
493 validate(Accessor(_target), _reference, abs_tolerance_1xN_f32);
500 combine(datasets::SmallWinogradConvolutionLayer5x1Dataset(),
509 combine(datasets::LargeWinogradConvolutionLayer5x1Dataset(),
515 validate(Accessor(_target), _reference, abs_tolerance_1xN_f32);
522 combine(datasets::SmallWinogradConvolutionLayer7x1Dataset(),
538 validate(Accessor(_target), _reference, abs_tolerance_1xN_f32);
544 combine(datasets::SmallWinogradConvolutionLayer1x7Dataset(),
554 combine(datasets::LargeWinogradConvolutionLayer7x1Dataset(),
560 validate(Accessor(_target), _reference, abs_tolerance_1xN_f32);
566 combine(datasets::SmallWinogradConvolutionLayer3x3Dataset(),
588 ActivationFunctionsDatasetNightly,
596 combine(datasets::LargeWinogradConvolutionLayer3x3Dataset(),
610 combine(datasets::SmallWinogradConvolutionLayer5x5Dataset(),
620 combine(datasets::LargeWinogradConvolutionLayer5x5Dataset(),
634 datasets::SmallWinogradConvolutionLayer3x3Dataset(),
635 datasets::SmallWinogradConvolutionLayer5x5Dataset()),
646 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
654 make(
"WeightsInfo", { TensorInfo(TensorShape(3U, 3U, 32U, 21U), 1,
DataType::F16),
660 make(
"ConvInfo", { PadStrideInfo(1, 1, 0, 0),
661 PadStrideInfo(1, 1, 0, 0)
673 &
output_info.clone()->set_is_resizable(
true),
conv_info, WeightsInfo(), Size2D(1U, 1U), ActivationLayerInfo(), fast_math);
679 combine(datasets::SmallWinogradConvolutionLayer3x3Dataset(),
690 combine(datasets::LargeWinogradConvolutionLayer3x3Dataset(),
692 make(
"ActivationInfo", { ActivationLayerInfo() }),
704 #ifdef ARM_COMPUTE_ENABLE_FIXED_FORMAT_KERNELS
710 template <
typename ConvolutionClass>
711 using HasOptImplFixtureNoFastMath = HasOptImplFixture<ConvolutionClass,
false>;
713 template <
typename ConvolutionClass>
714 using HasOptImplFixtureFastMath = HasOptImplFixture<ConvolutionClass,
true>;
764 #if defined(ARM_COMPUTE_ENABLE_BF16)
782 #endif // ARM_COMPUTE_ENABLE_BF16
844 #if defined(ARM_COMPUTE_ENABLE_BF16)
866 #endif // ARM_COMPUTE_ENABLE_BF16
870 using TestCaseType = std::tuple<TensorShape, TensorShape, arm_compute::WeightFormat>;
932 prepare_weights_shapes, shapes)
934 const TensorShape
input_shape = std::get<0>(shapes);
935 const TensorShape expected_shape = std::get<1>(shapes);
939 const auto TI = TensorInfo(
input_shape, 1 , DT, DL);
940 const TensorInfo computed_info = ::arm_compute::test::validation::prepare_weights(TI, wf);
946 TEST_SUITE(ExperimentalCpuAPIVariableWeightWithFixtures)
948 template <typename ScalarType>
949 using VarWidth = VariableWeightsFixture<cpu::CpuGemmConv2d, Tensor, Accessor, ScalarType, false>;
960 #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
967 validate(Accessor(_target), _reference, rel_tolerance_f16, 0.f,
half(abs_tolerance_f16));
969 #endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
971 #if defined(ARM_COMPUTE_ENABLE_BF16)
972 template <
typename ScalarType>
973 using VarWidthFastMath = VariableWeightsFixture<cpu::CpuGemmConv2d,
Tensor, Accessor, ScalarType,
true>;
983 #endif // ARM_COMPUTE_ENABLE_BF16
987 TEST_SUITE(ExperimentalNEAPIVariableWeightWithFixtures)
989 template <typename ScalarType>
990 using NEGEMMVarWidth = VariableWeightsFixtureNEInterface<NEGEMMConvolutionLayer, Tensor, Accessor, ScalarType, false>;
1001 #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
1008 validate(Accessor(_target), _reference, rel_tolerance_f16, 0.f,
half(abs_tolerance_f16));
1010 #endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
1012 #if defined(ARM_COMPUTE_ENABLE_BF16)
1013 template <
typename ScalarType>
1014 using NEGEMMVarWidthFastMath = VariableWeightsFixtureNEInterface<NEGEMMConvolutionLayer,
Tensor, Accessor, ScalarType,
true>;
1024 #endif // ARM_COMPUTE_ENABLE_BF16
1029 #endif // ARM_COMPUTE_ENABLE_FIXED_FORMAT_KERNELS
1032 template <
typename T>
1033 using NEGEMMConvolutionLayerFixture = ConvolutionValidationFixture<Tensor, Accessor, NEConvolutionLayer, T>;
1034 template <
typename T>
1036 template <
typename T>
1048 auto conv = std::make_unique<cpu::CpuGemmConv2d>();
1059 auto weight = create_tensor<Tensor>(weight_info);
1060 auto bias = create_tensor<Tensor>(bias_info);
1061 src.allocator()->allocate();
1062 weight.allocator()->allocate();
1063 bias.allocator()->allocate();
1069 auto ws = manage_workspace<Tensor>(conv->workspace(), mg, run_pack, prep_pack);
1071 auto run_conv = [&]() ->
Tensor
1073 auto dst = create_tensor<Tensor>(dst_info);
1074 dst.allocator()->allocate();
1081 conv->prepare(prep_pack);
1082 conv->run(run_pack);
1085 auto result_0 = run_conv();
1086 auto result_1 = run_conv();
1087 for(
size_t i = 0; i < result_0.info()->tensor_shape().total_size(); ++i)
1102 auto conv = std::make_unique<NEGEMMConvolutionLayer>();
1109 auto run_conv = [&]()
1112 auto weight = create_tensor<Tensor>(weight_info);
1113 auto bias = create_tensor<Tensor>(bias_info);
1114 auto dst = create_tensor<Tensor>(dst_info);
1116 src.allocator()->allocate();
1117 weight.allocator()->allocate();
1118 bias.allocator()->allocate();
1119 dst.allocator()->allocate();
1126 auto result_0 = run_conv();
1127 auto result_1 = run_conv();
1128 for(
size_t i = 0; i < result_0.info()->tensor_shape().total_size(); ++i)
1135 #if defined(ARM_COMPUTE_ENABLE_BF16)
1149 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
1165 framework::dataset::
make("ReshapeWeights", {
true })),
1208 template <typename T>
1209 using NEGEMMConvolutionLayerQuantizedFixture = ConvolutionValidationQuantizedFixture<Tensor, Accessor, NEConvolutionLayer, T>;
1210 template <typename T>
1213 template <typename T>
1230 framework::dataset::
make("ReshapeWeights", {
true })),
1237 validate(Accessor(_target), _reference, tolerance_qasymm8);
1254 validate(Accessor(_target), _reference, tolerance_qasymm8);
1260 framework::dataset::
make("ReshapeWeights", {
true })),
1267 validate(Accessor(_target), _reference, tolerance_qasymm8);
1284 validate(Accessor(_target), _reference, tolerance_qasymm8);
1291 framework::dataset::
make("ReshapeWeights", {
true })),
1299 validate(Accessor(_target), _reference, tolerance_qasymm8);
1311 validate(Accessor(_target), _reference, tolerance_qasymm8);
1319 template <typename T>
1320 using NEDirectGEMMConv2dLayerFixture = ConvolutionValidationFixture<Tensor, Accessor, NEGEMMConv2d, T>;
1331 auto conv = std::make_unique<cpu::CpuGemmDirectConv2d>();
1341 auto weight = create_tensor<Tensor>(weight_info);
1342 auto bias = create_tensor<Tensor>(bias_info);
1343 src.allocator()->allocate();
1344 weight.allocator()->allocate();
1345 bias.allocator()->allocate();
1350 auto mg = MemoryGroup{};
1351 auto ws = manage_workspace<Tensor>(conv->workspace(), mg, run_pack, prep_pack);
1353 auto run_conv = [&]() -> Tensor
1355 auto dst = create_tensor<Tensor>(dst_info);
1356 dst.allocator()->allocate();
1359 library->fill_tensor_value(Accessor(
src), 1.f);
1360 library->fill_tensor_value(Accessor(weight), 2.f);
1363 conv->prepare(prep_pack);
1364 conv->run(run_pack);
1367 auto result_0 = run_conv();
1368 auto result_1 = run_conv();
1369 for(
size_t i = 0; i < result_0.info()->tensor_shape().total_size(); ++i)
1384 auto conv = std::make_unique<NEGEMMConv2d>();
1390 auto run_conv = [&]()
1393 auto weight = create_tensor<Tensor>(weight_info);
1394 auto bias = create_tensor<Tensor>(bias_info);
1395 auto dst = create_tensor<Tensor>(dst_info);
1397 src.allocator()->allocate();
1398 weight.allocator()->allocate();
1399 bias.allocator()->allocate();
1400 dst.allocator()->allocate();
1401 library->fill_tensor_value(Accessor(
src), 1.f);
1402 library->fill_tensor_value(Accessor(weight), 2.f);
1407 auto result_0 = run_conv();
1408 auto result_1 = run_conv();
1409 for(
size_t i = 0; i < result_0.info()->tensor_shape().total_size(); ++i)
1418 framework::dataset::
make("ReshapeWeights", {
true })),
1430 template <
typename T>
1431 using NEDirectGEMMConv2dLayerQuantizedFixture = ConvolutionValidationQuantizedFixture<Tensor, Accessor, NEGEMMConv2d, T>;
1433 template <
typename T>
1434 using NEDirectGEMMConv2dLayerQuantizedPerChannelFixture = ConvolutionValidationQuantizedPerChannelFixture<Tensor, Accessor, NEGEMMConv2d, T, int8_t>;
1438 ActivationLayerInfo(),
1439 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU),
1440 ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU, 6.f)
1452 validate(Accessor(_target), _reference, tolerance_qasymm8);
1458 framework::dataset::
make("ReshapeWeights", {
true })),
1465 validate(Accessor(_target), _reference, tolerance_qasymm8);
1472 framework::dataset::
make("ReshapeWeights", {
true })),
1480 validate(Accessor(_target), _reference, tolerance_qasymm8);
1484 #endif // __aarch64__