Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / dc8ed9d75e54e914a970e137900930fa64a0782b / . / src / backends / backendsCommon / test / layerTests / BatchMatMulTestImpl.cpp
blob: 6fcc35ab5249561542c2e23e30969c59aca260fb [file] [log] [blame]
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]1//
2// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
3// SPDX-License-Identifier: MIT
4//
5
6#include "BatchMatMulTestImpl.hpp"
7
8#include <armnn/backends/IBackendInternal.hpp>
9#include <armnn/backends/Workload.hpp>
10#include <armnn/backends/WorkloadData.hpp>
11#include <armnn/backends/WorkloadFactory.hpp>
12
13#include <armnnTestUtils/WorkloadTestUtils.hpp>
14#include <armnnUtils/QuantizeHelper.hpp>
15#include <armnnTestUtils/TensorCopyUtils.hpp>
16#include <armnn/Optional.hpp>
17
18
19template<armnn::DataType ArmnnType, typename T, std::size_t NumDims>
20LayerTestResult<T, NumDims> BatchMatMulTestImpl(
21 armnn::IWorkloadFactory& workloadFactory,
22 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
23 const armnn::ITensorHandleFactory& tensorHandleFactory,
24 armnn::BatchMatMulDescriptor descriptor,
25 const std::vector<T>& inputX,
26 const std::vector<T>& inputY,
27 const std::vector<T>& outputExpected,
28 const armnn::TensorInfo& inputXInfo,
29 const armnn::TensorInfo& inputYInfo,
30 const armnn::TensorInfo& outputInfo)
31{
32 std::vector<T> outputActual(outputInfo.GetNumElements());
33
34 std::unique_ptr<armnn::ITensorHandle> inputXHandle = tensorHandleFactory.CreateTensorHandle(inputXInfo);
35 std::unique_ptr<armnn::ITensorHandle> inputYHandle = tensorHandleFactory.CreateTensorHandle(inputYInfo);
36 std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
37
38 armnn::BatchMatMulQueueDescriptor queueDescriptor;
39 queueDescriptor.m_Parameters = descriptor;
40 armnn::WorkloadInfo workloadInfo;
41
42 AddInputToWorkload(queueDescriptor, workloadInfo, inputXInfo, inputXHandle.get());
43 AddInputToWorkload(queueDescriptor, workloadInfo, inputYInfo, inputYHandle.get());
44 AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, outputHandle.get());
45
46 auto workload = workloadFactory.CreateWorkload(armnn::LayerType::BatchMatMul, queueDescriptor, workloadInfo);
47
48 inputXHandle->Allocate();
49 inputYHandle->Allocate();
50 outputHandle->Allocate();
51
52 CopyDataToITensorHandle(inputXHandle.get(), inputX.data());
53 CopyDataToITensorHandle(inputYHandle.get(), inputY.data());
54
55 workload->PostAllocationConfigure();
56 ExecuteWorkload(*workload, memoryManager);
57
58 CopyDataFromITensorHandle(outputActual.data(), outputHandle.get());
59
60 return LayerTestResult<T, NumDims>(outputActual,
61 outputExpected,
62 outputHandle->GetShape(),
63 outputInfo.GetShape());
64}
65
66template<armnn::DataType ArmnnType, typename T>
67LayerTestResult<T, 2> BatchMatMul2DSimpleTest(
68 armnn::IWorkloadFactory& workloadFactory,
69 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
70 const armnn::ITensorHandleFactory& tensorHandleFactory)
71{
72 auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
73
74 float qScale = 0.0f;
75 int32_t qOffset = 0;
76
77 switch(ArmnnType)
78 {
79 case armnn::DataType::QAsymmS8:
80 case armnn::DataType::QAsymmU8:
81 case armnn::DataType::QSymmS16:
82 qScale = 1.0f;
83 break;
84 default:
85 break;
86 }
87
88 armnn::TensorInfo inputXInfo({2,2}, ArmnnType, qScale, qOffset);
89 armnn::TensorInfo inputYInfo({2,2}, ArmnnType, qScale, qOffset);
90 armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
91
92 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
93 1, 2,
94 3, 4
95 }, qScale, qOffset);
96
97 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
98 5, 6,
99 7, 8
100 }, qScale, qOffset);
101
102 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
103 19, 22,
104 43, 50
105 }, qScale, qOffset);
106
107 return BatchMatMulTestImpl<ArmnnType, T, 2>(workloadFactory,
108 memoryManager,
109 tensorHandleFactory,
110 descriptor,
111 inputX,
112 inputY,
113 outputExpected,
114 inputXInfo,
115 inputYInfo,
116 outputInfo);
117}
118
119template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 2>
120BatchMatMul2DSimpleTest<armnn::DataType::BFloat16>(
121 armnn::IWorkloadFactory& workloadFactory,
122 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
123 const armnn::ITensorHandleFactory& tensorHandleFactory);
124
125template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
126BatchMatMul2DSimpleTest<armnn::DataType::Float32>(
127 armnn::IWorkloadFactory& workloadFactory,
128 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
129 const armnn::ITensorHandleFactory& tensorHandleFactory);
130
131template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2>
132BatchMatMul2DSimpleTest<armnn::DataType::Float16>(
133 armnn::IWorkloadFactory& workloadFactory,
134 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
135 const armnn::ITensorHandleFactory& tensorHandleFactory);
136
137template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2>
138BatchMatMul2DSimpleTest<armnn::DataType::QAsymmS8>(
139 armnn::IWorkloadFactory& workloadFactory,
140 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
141 const armnn::ITensorHandleFactory& tensorHandleFactory);
142
143template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2>
144BatchMatMul2DSimpleTest<armnn::DataType::QAsymmU8>(
145 armnn::IWorkloadFactory& workloadFactory,
146 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
147 const armnn::ITensorHandleFactory& tensorHandleFactory);
148
149template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2>
150BatchMatMul2DSimpleTest<armnn::DataType::QSymmS16>(
151 armnn::IWorkloadFactory& workloadFactory,
152 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
153 const armnn::ITensorHandleFactory& tensorHandleFactory);
154
155template<armnn::DataType ArmnnType, typename T>
156LayerTestResult<T, 3> BatchMatMul3DSimpleTest(
157 armnn::IWorkloadFactory& workloadFactory,
158 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
159 const armnn::ITensorHandleFactory& tensorHandleFactory)
160{
161 auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
162
163 float qScale = 0.0f;
164 int32_t qOffset = 0;
165
166 switch(ArmnnType)
167 {
168 case armnn::DataType::QAsymmS8:
169 case armnn::DataType::QAsymmU8:
170 case armnn::DataType::QSymmS16:
171 qScale = 1.0f;
172 break;
173 default:
174 break;
175 }
176
177 armnn::TensorInfo inputXInfo({1,2,2}, ArmnnType, qScale, qOffset);
178 armnn::TensorInfo inputYInfo({1,2,2}, ArmnnType, qScale, qOffset);
179 armnn::TensorInfo outputInfo({1,2,2}, ArmnnType, qScale, qOffset);
180
181 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
182 1, 2,
183 3, 4
184 }, qScale, qOffset);
185
186 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
187 5, 6,
188 7, 8
189 }, qScale, qOffset);
190
191 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
192 19, 22,
193 43, 50
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]194 }, qScale, qOffset);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]195
196 return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
197 memoryManager,
198 tensorHandleFactory,
199 descriptor,
200 inputX,
201 inputY,
202 outputExpected,
203 inputXInfo,
204 inputYInfo,
205 outputInfo);
206}
207
208template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
209BatchMatMul3DSimpleTest<armnn::DataType::BFloat16>(
210 armnn::IWorkloadFactory& workloadFactory,
211 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
212 const armnn::ITensorHandleFactory& tensorHandleFactory);
213
214template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
215BatchMatMul3DSimpleTest<armnn::DataType::Float32>(
216 armnn::IWorkloadFactory& workloadFactory,
217 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
218 const armnn::ITensorHandleFactory& tensorHandleFactory);
219
220template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
221BatchMatMul3DSimpleTest<armnn::DataType::Float16>(
222 armnn::IWorkloadFactory& workloadFactory,
223 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
224 const armnn::ITensorHandleFactory& tensorHandleFactory);
225
226template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
227BatchMatMul3DSimpleTest<armnn::DataType::QAsymmS8>(
228 armnn::IWorkloadFactory& workloadFactory,
229 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
230 const armnn::ITensorHandleFactory& tensorHandleFactory);
231
232template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
233BatchMatMul3DSimpleTest<armnn::DataType::QAsymmU8>(
234 armnn::IWorkloadFactory& workloadFactory,
235 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
236 const armnn::ITensorHandleFactory& tensorHandleFactory);
237
238template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
239BatchMatMul3DSimpleTest<armnn::DataType::QSymmS16>(
240 armnn::IWorkloadFactory& workloadFactory,
241 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
242 const armnn::ITensorHandleFactory& tensorHandleFactory);
243
244template<armnn::DataType ArmnnType, typename T>
245LayerTestResult<T, 4> BatchMatMulNCHWSimpleTest(
246 armnn::IWorkloadFactory& workloadFactory,
247 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
248 const armnn::ITensorHandleFactory& tensorHandleFactory)
249{
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]250 auto descriptor = armnn::BatchMatMulDescriptor(); // Default arbitrary layout is treated the same as NCHW
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]251
252 float qScale = 0.0f;
253 int32_t qOffset = 0;
254
255 switch(ArmnnType)
256 {
257 case armnn::DataType::QAsymmS8:
258 case armnn::DataType::QAsymmU8:
259 case armnn::DataType::QSymmS16:
260 qScale = 1.0f;
261 break;
262 default:
263 break;
264 }
265
266 armnn::TensorInfo inputXInfo({1,1,2,2}, ArmnnType, qScale, qOffset);
267 armnn::TensorInfo inputYInfo({1,1,2,2}, ArmnnType, qScale, qOffset);
268 armnn::TensorInfo outputInfo({1,1,2,2}, ArmnnType, qScale, qOffset);
269
270 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
271 1, 2,
272 3, 4
273 }, qScale, qOffset);
274
275 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
276 5, 6,
277 7, 8
278 }, qScale, qOffset);
279
280 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
281 19, 22,
282 43, 50
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]283 }, qScale, qOffset);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]284
285 return BatchMatMulTestImpl<ArmnnType, T, 4>(workloadFactory,
286 memoryManager,
287 tensorHandleFactory,
288 descriptor,
289 inputX,
290 inputY,
291 outputExpected,
292 inputXInfo,
293 inputYInfo,
294 outputInfo);
295}
296
297template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 4>
298BatchMatMulNCHWSimpleTest<armnn::DataType::BFloat16>(
299 armnn::IWorkloadFactory& workloadFactory,
300 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
301 const armnn::ITensorHandleFactory& tensorHandleFactory);
302
303template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
304BatchMatMulNCHWSimpleTest<armnn::DataType::Float32>(
305 armnn::IWorkloadFactory& workloadFactory,
306 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
307 const armnn::ITensorHandleFactory& tensorHandleFactory);
308
309template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
310BatchMatMulNCHWSimpleTest<armnn::DataType::Float16>(
311 armnn::IWorkloadFactory& workloadFactory,
312 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
313 const armnn::ITensorHandleFactory& tensorHandleFactory);
314
315template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
316BatchMatMulNCHWSimpleTest<armnn::DataType::QAsymmS8>(
317 armnn::IWorkloadFactory& workloadFactory,
318 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
319 const armnn::ITensorHandleFactory& tensorHandleFactory);
320
321template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
322BatchMatMulNCHWSimpleTest<armnn::DataType::QAsymmU8>(
323 armnn::IWorkloadFactory& workloadFactory,
324 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
325 const armnn::ITensorHandleFactory& tensorHandleFactory);
326
327template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
328BatchMatMulNCHWSimpleTest<armnn::DataType::QSymmS16>(
329 armnn::IWorkloadFactory& workloadFactory,
330 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
331 const armnn::ITensorHandleFactory& tensorHandleFactory);
332
333template<armnn::DataType ArmnnType, typename T>
334LayerTestResult<T, 4> BatchMatMulNHWCSimpleTest(
335 armnn::IWorkloadFactory& workloadFactory,
336 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
337 const armnn::ITensorHandleFactory& tensorHandleFactory)
338{
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]339 auto descriptor = armnn::BatchMatMulDescriptor(false,
340 false,
341 false,
342 false,
343 armnn::DataLayout::NHWC,
344 armnn::DataLayout::NHWC);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]345
346 float qScale = 0.0f;
347 int32_t qOffset = 0;
348
349 switch(ArmnnType)
350 {
351 case armnn::DataType::QAsymmS8:
352 case armnn::DataType::QAsymmU8:
353 case armnn::DataType::QSymmS16:
354 qScale = 1.0f;
355 break;
356 default:
357 break;
358 }
359
360 armnn::TensorInfo inputXInfo({1,2,2,1}, ArmnnType, qScale, qOffset);
361 armnn::TensorInfo inputYInfo({1,2,2,1}, ArmnnType, qScale, qOffset);
362 armnn::TensorInfo outputInfo({1,2,2,1}, ArmnnType, qScale, qOffset);
363
364 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
365 1, 2,
366 3, 4
367 }, qScale, qOffset);
368
369 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
370 5, 6,
371 7, 8
372 }, qScale, qOffset);
373
374 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
375 19, 22,
376 43, 50
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]377 }, qScale, qOffset);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]378
379 return BatchMatMulTestImpl<ArmnnType, T, 4>(workloadFactory,
380 memoryManager,
381 tensorHandleFactory,
382 descriptor,
383 inputX,
384 inputY,
385 outputExpected,
386 inputXInfo,
387 inputYInfo,
388 outputInfo);
389}
390
391template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 4>
392BatchMatMulNHWCSimpleTest<armnn::DataType::BFloat16>(
393 armnn::IWorkloadFactory& workloadFactory,
394 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
395 const armnn::ITensorHandleFactory& tensorHandleFactory);
396
397template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
398BatchMatMulNHWCSimpleTest<armnn::DataType::Float32>(
399 armnn::IWorkloadFactory& workloadFactory,
400 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
401 const armnn::ITensorHandleFactory& tensorHandleFactory);
402
403template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
404BatchMatMulNHWCSimpleTest<armnn::DataType::Float16>(
405 armnn::IWorkloadFactory& workloadFactory,
406 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
407 const armnn::ITensorHandleFactory& tensorHandleFactory);
408
409template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
410BatchMatMulNHWCSimpleTest<armnn::DataType::QAsymmS8>(
411 armnn::IWorkloadFactory& workloadFactory,
412 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
413 const armnn::ITensorHandleFactory& tensorHandleFactory);
414
415template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
416BatchMatMulNHWCSimpleTest<armnn::DataType::QAsymmU8>(
417 armnn::IWorkloadFactory& workloadFactory,
418 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
419 const armnn::ITensorHandleFactory& tensorHandleFactory);
420
421template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
422BatchMatMulNHWCSimpleTest<armnn::DataType::QSymmS16>(
423 armnn::IWorkloadFactory& workloadFactory,
424 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
425 const armnn::ITensorHandleFactory& tensorHandleFactory);
426
427template<armnn::DataType ArmnnType, typename T>
428LayerTestResult<T, 3> BatchMatMul3DBatchTest(
429 armnn::IWorkloadFactory& workloadFactory,
430 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
431 const armnn::ITensorHandleFactory& tensorHandleFactory)
432{
433 auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
434
435 float qScale = 0.0f;
436 int32_t qOffset = 0;
437
438 switch(ArmnnType)
439 {
440 case armnn::DataType::QAsymmS8:
441 case armnn::DataType::QAsymmU8:
442 case armnn::DataType::QSymmS16:
443 qScale = 1.0f;
444 break;
445 default:
446 break;
447 }
448
449 armnn::TensorInfo inputXInfo({2,2,2}, ArmnnType, qScale, qOffset);
450 armnn::TensorInfo inputYInfo({2,2,2}, ArmnnType, qScale, qOffset);
451 armnn::TensorInfo outputInfo({2,2,2}, ArmnnType, qScale, qOffset);
452
453 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
454 1, 2,
455 3, 4,
456
457 9, 10,
458 11, 12
459 }, qScale, qOffset);
460
461 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
462 5, 6,
463 7, 8,
464
465 13, 14,
466 15, 16
467 }, qScale, qOffset);
468
469 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
470 19, 22,
471 43, 50,
472
473 267, 286,
474 323, 346
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]475 }, qScale, qOffset);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]476
477 return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
478 memoryManager,
479 tensorHandleFactory,
480 descriptor,
481 inputX,
482 inputY,
483 outputExpected,
484 inputXInfo,
485 inputYInfo,
486 outputInfo);
487}
488
489template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
490BatchMatMul3DBatchTest<armnn::DataType::BFloat16>(
491 armnn::IWorkloadFactory& workloadFactory,
492 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
493 const armnn::ITensorHandleFactory& tensorHandleFactory);
494
495template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
496BatchMatMul3DBatchTest<armnn::DataType::Float32>(
497 armnn::IWorkloadFactory& workloadFactory,
498 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
499 const armnn::ITensorHandleFactory& tensorHandleFactory);
500
501template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
502BatchMatMul3DBatchTest<armnn::DataType::Float16>(
503 armnn::IWorkloadFactory& workloadFactory,
504 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
505 const armnn::ITensorHandleFactory& tensorHandleFactory);
506
507template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
508BatchMatMul3DBatchTest<armnn::DataType::QAsymmS8>(
509 armnn::IWorkloadFactory& workloadFactory,
510 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
511 const armnn::ITensorHandleFactory& tensorHandleFactory);
512
513template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
514BatchMatMul3DBatchTest<armnn::DataType::QAsymmU8>(
515 armnn::IWorkloadFactory& workloadFactory,
516 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
517 const armnn::ITensorHandleFactory& tensorHandleFactory);
518
519template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
520BatchMatMul3DBatchTest<armnn::DataType::QSymmS16>(
521 armnn::IWorkloadFactory& workloadFactory,
522 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
523 const armnn::ITensorHandleFactory& tensorHandleFactory);
524
525template<armnn::DataType ArmnnType, typename T>
526LayerTestResult<T, 3> BatchMatMul3DBroadcastTest(
527 armnn::IWorkloadFactory& workloadFactory,
528 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
529 const armnn::ITensorHandleFactory& tensorHandleFactory)
530{
531 auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
532
533 float qScale = 0.0f;
534 int32_t qOffset = 0;
535
536 switch(ArmnnType)
537 {
538 case armnn::DataType::QAsymmS8:
539 case armnn::DataType::QAsymmU8:
540 case armnn::DataType::QSymmS16:
541 qScale = 1.0f;
542 break;
543 default:
544 break;
545 }
546
547 armnn::TensorInfo inputXInfo({2,2,2}, ArmnnType, qScale, qOffset);
548 armnn::TensorInfo inputYInfo({1,2,2}, ArmnnType, qScale, qOffset);
549 armnn::TensorInfo outputInfo({2,2,2}, ArmnnType, qScale, qOffset);
550
551 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
552 1, 2,
553 3, 4,
554
555 9, 10,
556 11, 12
557 }, qScale, qOffset);
558
559 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
560 13, 14,
561 15, 16
562 }, qScale, qOffset);
563
564 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
565 43, 46,
566 99, 106,
567
568 267, 286,
569 323, 346
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]570 }, qScale, qOffset);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]571
572 return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
573 memoryManager,
574 tensorHandleFactory,
575 descriptor,
576 inputX,
577 inputY,
578 outputExpected,
579 inputXInfo,
580 inputYInfo,
581 outputInfo);
582}
583
584template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
585BatchMatMul3DBroadcastTest<armnn::DataType::BFloat16>(
586 armnn::IWorkloadFactory& workloadFactory,
587 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
588 const armnn::ITensorHandleFactory& tensorHandleFactory);
589
590template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
591BatchMatMul3DBroadcastTest<armnn::DataType::Float32>(
592 armnn::IWorkloadFactory& workloadFactory,
593 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
594 const armnn::ITensorHandleFactory& tensorHandleFactory);
595
596template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
597BatchMatMul3DBroadcastTest<armnn::DataType::Float16>(
598 armnn::IWorkloadFactory& workloadFactory,
599 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
600 const armnn::ITensorHandleFactory& tensorHandleFactory);
601
602template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
603BatchMatMul3DBroadcastTest<armnn::DataType::QAsymmS8>(
604 armnn::IWorkloadFactory& workloadFactory,
605 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
606 const armnn::ITensorHandleFactory& tensorHandleFactory);
607
608template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
609BatchMatMul3DBroadcastTest<armnn::DataType::QAsymmU8>(
610 armnn::IWorkloadFactory& workloadFactory,
611 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
612 const armnn::ITensorHandleFactory& tensorHandleFactory);
613
614template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
615BatchMatMul3DBroadcastTest<armnn::DataType::QSymmS16>(
616 armnn::IWorkloadFactory& workloadFactory,
617 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
618 const armnn::ITensorHandleFactory& tensorHandleFactory);
619
620template<armnn::DataType ArmnnType, typename T>
621LayerTestResult<T, 3> BatchMatMul3D2DBroadcastTest(
622 armnn::IWorkloadFactory& workloadFactory,
623 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
624 const armnn::ITensorHandleFactory& tensorHandleFactory)
625{
626 auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
627
628 float qScale = 0.0f;
629 int32_t qOffset = 0;
630
631 switch(ArmnnType)
632 {
633 case armnn::DataType::QAsymmS8:
634 case armnn::DataType::QAsymmU8:
635 case armnn::DataType::QSymmS16:
636 qScale = 1.0f;
637 break;
638 default:
639 break;
640 }
641
642 armnn::TensorInfo inputXInfo({2,2,2}, ArmnnType, qScale, qOffset);
643 armnn::TensorInfo inputYInfo({2,2}, ArmnnType, qScale, qOffset);
644 armnn::TensorInfo outputInfo({2,2,2}, ArmnnType, qScale, qOffset);
645
646 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
647 1, 2,
648 3, 4,
649
650 9, 10,
651 11, 12
652 }, qScale, qOffset);
653
654 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
655 13, 14,
656 15, 16
657 }, qScale, qOffset);
658
659 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
660 43, 46,
661 99, 106,
662
663 267, 286,
664 323, 346
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]665 }, qScale, qOffset);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]666
667 return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
668 memoryManager,
669 tensorHandleFactory,
670 descriptor,
671 inputX,
672 inputY,
673 outputExpected,
674 inputXInfo,
675 inputYInfo,
676 outputInfo);
677}
678
679template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
680BatchMatMul3D2DBroadcastTest<armnn::DataType::BFloat16>(
681 armnn::IWorkloadFactory& workloadFactory,
682 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
683 const armnn::ITensorHandleFactory& tensorHandleFactory);
684
685template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
686BatchMatMul3D2DBroadcastTest<armnn::DataType::Float32>(
687 armnn::IWorkloadFactory& workloadFactory,
688 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
689 const armnn::ITensorHandleFactory& tensorHandleFactory);
690
691template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
692BatchMatMul3D2DBroadcastTest<armnn::DataType::Float16>(
693 armnn::IWorkloadFactory& workloadFactory,
694 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
695 const armnn::ITensorHandleFactory& tensorHandleFactory);
696
697template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
698BatchMatMul3D2DBroadcastTest<armnn::DataType::QAsymmS8>(
699 armnn::IWorkloadFactory& workloadFactory,
700 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
701 const armnn::ITensorHandleFactory& tensorHandleFactory);
702
703template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
704BatchMatMul3D2DBroadcastTest<armnn::DataType::QAsymmU8>(
705 armnn::IWorkloadFactory& workloadFactory,
706 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
707 const armnn::ITensorHandleFactory& tensorHandleFactory);
708
709template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
710BatchMatMul3D2DBroadcastTest<armnn::DataType::QSymmS16>(
711 armnn::IWorkloadFactory& workloadFactory,
712 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
713 const armnn::ITensorHandleFactory& tensorHandleFactory);
714
715template<armnn::DataType ArmnnType, typename T>
716LayerTestResult<T, 5> BatchMatMulNDHWCNHWCTest(
717 armnn::IWorkloadFactory& workloadFactory,
718 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
719 const armnn::ITensorHandleFactory& tensorHandleFactory)
720{
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]721 auto descriptor = armnn::BatchMatMulDescriptor(false,
722 false,
723 false,
724 false,
725 armnn::DataLayout::NDHWC,
726 armnn::DataLayout::NHWC);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]727
728 float qScale = 0.0f;
729 int32_t qOffset = 0;
730
731 switch(ArmnnType)
732 {
733 case armnn::DataType::QAsymmS8:
734 case armnn::DataType::QAsymmU8:
735 case armnn::DataType::QSymmS16:
736 qScale = 1.0f;
737 break;
738 default:
739 break;
740 }
741
742 armnn::TensorInfo inputXInfo({1,1,2,2,2}, ArmnnType, qScale, qOffset);
743 armnn::TensorInfo inputYInfo({1,2,2,2}, ArmnnType, qScale, qOffset);
744 armnn::TensorInfo outputInfo({1,1,2,2,2}, ArmnnType, qScale, qOffset);
745
746 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
747 1, 20,
748 3, 22,
749
750 2, 21,
751 4, 23
752 }, qScale, qOffset);
753
754 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
755 5, 24,
756 7, 26,
757
758 6, 25,
759 8, 27
760 }, qScale, qOffset);
761
762 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
763 23, 1030,
764 31, 1114,
765
766 34, 1079,
767 46, 1167
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]768 }, qScale, qOffset);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]769
770 return BatchMatMulTestImpl<ArmnnType, T, 5>(workloadFactory,
771 memoryManager,
772 tensorHandleFactory,
773 descriptor,
774 inputX,
775 inputY,
776 outputExpected,
777 inputXInfo,
778 inputYInfo,
779 outputInfo);
780}
781
782template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 5>
783BatchMatMulNDHWCNHWCTest<armnn::DataType::BFloat16>(
784 armnn::IWorkloadFactory& workloadFactory,
785 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
786 const armnn::ITensorHandleFactory& tensorHandleFactory);
787
788template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 5>
789BatchMatMulNDHWCNHWCTest<armnn::DataType::Float32>(
790 armnn::IWorkloadFactory& workloadFactory,
791 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
792 const armnn::ITensorHandleFactory& tensorHandleFactory);
793
794template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 5>
795BatchMatMulNDHWCNHWCTest<armnn::DataType::Float16>(
796 armnn::IWorkloadFactory& workloadFactory,
797 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
798 const armnn::ITensorHandleFactory& tensorHandleFactory);
799
800template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 5>
801BatchMatMulNDHWCNHWCTest<armnn::DataType::QAsymmS8>(
802 armnn::IWorkloadFactory& workloadFactory,
803 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
804 const armnn::ITensorHandleFactory& tensorHandleFactory);
805
806template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 5>
807BatchMatMulNDHWCNHWCTest<armnn::DataType::QAsymmU8>(
808 armnn::IWorkloadFactory& workloadFactory,
809 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
810 const armnn::ITensorHandleFactory& tensorHandleFactory);
811
812template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 5>
813BatchMatMulNDHWCNHWCTest<armnn::DataType::QSymmS16>(
814 armnn::IWorkloadFactory& workloadFactory,
815 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
816 const armnn::ITensorHandleFactory& tensorHandleFactory);
817
818template<armnn::DataType ArmnnType, typename T>
819LayerTestResult<T, 2> BatchMatMul2DTinyTest(
820 armnn::IWorkloadFactory& workloadFactory,
821 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
822 const armnn::ITensorHandleFactory& tensorHandleFactory)
823{
824 auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
825
826 float qScale = 0.0f;
827 int32_t qOffset = 0;
828
829 switch(ArmnnType)
830 {
831 case armnn::DataType::QAsymmS8:
832 case armnn::DataType::QAsymmU8:
833 case armnn::DataType::QSymmS16:
834 qScale = 1.0f;
835 break;
836 default:
837 break;
838 }
839
840 armnn::TensorInfo inputXInfo({1,1}, ArmnnType, qScale, qOffset);
841 armnn::TensorInfo inputYInfo({1,1}, ArmnnType, qScale, qOffset);
842 armnn::TensorInfo outputInfo({1,1}, ArmnnType, qScale, qOffset);
843
844 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
845 3
846 }, qScale, qOffset);
847
848 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
849 5
850 }, qScale, qOffset);
851
852 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
853 15
854 }, qScale, qOffset);
855
856 return BatchMatMulTestImpl<ArmnnType, T, 2>(workloadFactory,
857 memoryManager,
858 tensorHandleFactory,
859 descriptor,
860 inputX,
861 inputY,
862 outputExpected,
863 inputXInfo,
864 inputYInfo,
865 outputInfo);
866}
867
868template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 2>
869BatchMatMul2DTinyTest<armnn::DataType::BFloat16>(
870 armnn::IWorkloadFactory& workloadFactory,
871 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
872 const armnn::ITensorHandleFactory& tensorHandleFactory);
873
874template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
875BatchMatMul2DTinyTest<armnn::DataType::Float32>(
876 armnn::IWorkloadFactory& workloadFactory,
877 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
878 const armnn::ITensorHandleFactory& tensorHandleFactory);
879
880template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2>
881BatchMatMul2DTinyTest<armnn::DataType::Float16>(
882 armnn::IWorkloadFactory& workloadFactory,
883 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
884 const armnn::ITensorHandleFactory& tensorHandleFactory);
885
886template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2>
887BatchMatMul2DTinyTest<armnn::DataType::QAsymmS8>(
888 armnn::IWorkloadFactory& workloadFactory,
889 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
890 const armnn::ITensorHandleFactory& tensorHandleFactory);
891
892template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2>
893BatchMatMul2DTinyTest<armnn::DataType::QAsymmU8>(
894 armnn::IWorkloadFactory& workloadFactory,
895 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
896 const armnn::ITensorHandleFactory& tensorHandleFactory);
897
898template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2>
899BatchMatMul2DTinyTest<armnn::DataType::QSymmS16>(
900 armnn::IWorkloadFactory& workloadFactory,
901 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
902 const armnn::ITensorHandleFactory& tensorHandleFactory);
903
904template<armnn::DataType ArmnnType, typename T>
905LayerTestResult<T, 3> BatchMatMul3DNonSquareTest(
906 armnn::IWorkloadFactory& workloadFactory,
907 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
908 const armnn::ITensorHandleFactory& tensorHandleFactory)
909{
910 auto descriptor = armnn::BatchMatMulDescriptor(); // Arbitrary layout with no transpose/adjointing
911
912 float qScale = 0.0f;
913 int32_t qOffset = 0;
914
915 switch(ArmnnType)
916 {
917 case armnn::DataType::QAsymmS8:
918 case armnn::DataType::QAsymmU8:
919 case armnn::DataType::QSymmS16:
920 qScale = 1.0f;
921 break;
922 default:
923 break;
924 }
925
926 armnn::TensorInfo inputXInfo({2,5,3}, ArmnnType, qScale, qOffset);
927 armnn::TensorInfo inputYInfo({2,3,4}, ArmnnType, qScale, qOffset);
928 armnn::TensorInfo outputInfo({2,5,4}, ArmnnType, qScale, qOffset);
929
930 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
931 8, 8, 4,
932 6, 1, 3,
933 8, 8, 3,
934 8, 9, 8,
935 5, 4, 4,
936
937 1, 8, 5,
938 7, 1, 1,
939 8, 7, 9,
940 3, 2, 7,
941 8, 5, 3
942 }, qScale, qOffset);
943
944 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
945 6, 2, 3, 2,
946 6, 2, 2, 8,
947 3, 7, 8, 1,
948
949 7, 2, 9, 5,
950 2, 3, 1, 3,
951 2, 7, 7, 5
952 }, qScale, qOffset);
953
954 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
955 108, 60, 72, 84,
956 51, 35, 44, 23,
957 105, 53, 64, 83,
958 126, 90, 106, 96,
959 66, 46, 55, 46,
960
961 33, 61, 52, 54,
962 53, 24, 71, 43,
963 88, 100, 142, 106,
964 39, 61, 78, 56,
965 72, 52, 98, 70
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]966 }, qScale, qOffset);
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]967
968 return BatchMatMulTestImpl<ArmnnType, T, 3>(workloadFactory,
969 memoryManager,
970 tensorHandleFactory,
971 descriptor,
972 inputX,
973 inputY,
974 outputExpected,
975 inputXInfo,
976 inputYInfo,
977 outputInfo);
978}
979
980template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 3>
981BatchMatMul3DNonSquareTest<armnn::DataType::BFloat16>(
982 armnn::IWorkloadFactory& workloadFactory,
983 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
984 const armnn::ITensorHandleFactory& tensorHandleFactory);
985
986template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 3>
987BatchMatMul3DNonSquareTest<armnn::DataType::Float32>(
988 armnn::IWorkloadFactory& workloadFactory,
989 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
990 const armnn::ITensorHandleFactory& tensorHandleFactory);
991
992template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 3>
993BatchMatMul3DNonSquareTest<armnn::DataType::Float16>(
994 armnn::IWorkloadFactory& workloadFactory,
995 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
996 const armnn::ITensorHandleFactory& tensorHandleFactory);
997
998template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 3>
999BatchMatMul3DNonSquareTest<armnn::DataType::QAsymmS8>(
1000 armnn::IWorkloadFactory& workloadFactory,
1001 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1002 const armnn::ITensorHandleFactory& tensorHandleFactory);
1003
1004template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 3>
1005BatchMatMul3DNonSquareTest<armnn::DataType::QAsymmU8>(
1006 armnn::IWorkloadFactory& workloadFactory,
1007 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1008 const armnn::ITensorHandleFactory& tensorHandleFactory);
1009
1010template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 3>
1011BatchMatMul3DNonSquareTest<armnn::DataType::QSymmS16>(
1012 armnn::IWorkloadFactory& workloadFactory,
1013 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Samuel Yapdc8ed9d2022-08-08 14:07:42 +0100[diff] [blame^]1014 const armnn::ITensorHandleFactory& tensorHandleFactory);
1015
1016template<armnn::DataType ArmnnType, typename T>
1017LayerTestResult<T, 2> BatchMatMul2DTranspSimpleTest(
1018 armnn::IWorkloadFactory& workloadFactory,
1019 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1020 const armnn::ITensorHandleFactory& tensorHandleFactory)
1021{
1022 auto descriptor = armnn::BatchMatMulDescriptor(true,
1023 false,
1024 false,
1025 false);
1026
1027 float qScale = 0.0f;
1028 int32_t qOffset = 0;
1029
1030 switch(ArmnnType)
1031 {
1032 case armnn::DataType::QAsymmS8:
1033 case armnn::DataType::QAsymmU8:
1034 case armnn::DataType::QSymmS16:
1035 qScale = 1.0f;
1036 break;
1037 default:
1038 break;
1039 }
1040
1041 armnn::TensorInfo inputXInfo({2,3}, ArmnnType, qScale, qOffset);
1042 armnn::TensorInfo inputYInfo({2,3}, ArmnnType, qScale, qOffset);
1043 armnn::TensorInfo outputInfo({3,3}, ArmnnType, qScale, qOffset);
1044
1045 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
1046 1, 2, 3,
1047 4, 5, 6
1048 }, qScale, qOffset);
1049
1050 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
1051 7, 8, 9,
1052 10, 11, 12
1053 }, qScale, qOffset);
1054
1055 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
1056 47, 52, 57,
1057 64, 71, 78,
1058 81, 90, 99
1059 }, qScale, qOffset);
1060
1061 return BatchMatMulTestImpl<ArmnnType, T, 2>(workloadFactory,
1062 memoryManager,
1063 tensorHandleFactory,
1064 descriptor,
1065 inputX,
1066 inputY,
1067 outputExpected,
1068 inputXInfo,
1069 inputYInfo,
1070 outputInfo);
1071}
1072
1073template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 2>
1074BatchMatMul2DTranspSimpleTest<armnn::DataType::BFloat16>(
1075 armnn::IWorkloadFactory& workloadFactory,
1076 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1077 const armnn::ITensorHandleFactory& tensorHandleFactory);
1078
1079template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
1080BatchMatMul2DTranspSimpleTest<armnn::DataType::Float32>(
1081 armnn::IWorkloadFactory& workloadFactory,
1082 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1083 const armnn::ITensorHandleFactory& tensorHandleFactory);
1084
1085template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2>
1086BatchMatMul2DTranspSimpleTest<armnn::DataType::Float16>(
1087 armnn::IWorkloadFactory& workloadFactory,
1088 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1089 const armnn::ITensorHandleFactory& tensorHandleFactory);
1090
1091template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2>
1092BatchMatMul2DTranspSimpleTest<armnn::DataType::QAsymmS8>(
1093 armnn::IWorkloadFactory& workloadFactory,
1094 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1095 const armnn::ITensorHandleFactory& tensorHandleFactory);
1096
1097template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2>
1098BatchMatMul2DTranspSimpleTest<armnn::DataType::QAsymmU8>(
1099 armnn::IWorkloadFactory& workloadFactory,
1100 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1101 const armnn::ITensorHandleFactory& tensorHandleFactory);
1102
1103template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2>
1104BatchMatMul2DTranspSimpleTest<armnn::DataType::QSymmS16>(
1105 armnn::IWorkloadFactory& workloadFactory,
1106 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1107 const armnn::ITensorHandleFactory& tensorHandleFactory);
1108
1109template<armnn::DataType ArmnnType, typename T>
1110LayerTestResult<T, 2> BatchMatMul2DAdjointSimpleTest(
1111 armnn::IWorkloadFactory& workloadFactory,
1112 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1113 const armnn::ITensorHandleFactory& tensorHandleFactory)
1114{
1115 auto descriptor = armnn::BatchMatMulDescriptor(false,
1116 false,
1117 true,
1118 false);
1119
1120 float qScale = 0.0f;
1121 int32_t qOffset = 0;
1122
1123 switch(ArmnnType)
1124 {
1125 case armnn::DataType::QAsymmS8:
1126 case armnn::DataType::QAsymmU8:
1127 case armnn::DataType::QSymmS16:
1128 qScale = 1.0f;
1129 break;
1130 default:
1131 break;
1132 }
1133
1134 armnn::TensorInfo inputXInfo({3,3}, ArmnnType, qScale, qOffset);
1135 armnn::TensorInfo inputYInfo({3,3}, ArmnnType, qScale, qOffset);
1136 armnn::TensorInfo outputInfo({3,3}, ArmnnType, qScale, qOffset);
1137
1138 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
1139 3, 1, 1,
1140 1, 3, -1,
1141 2, 4, 1
1142 }, qScale, qOffset);
1143
1144 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
1145 1, 0, 0,
1146 0, 1, 0,
1147 0, 0, 1
1148 }, qScale, qOffset);
1149
1150 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
1151 7, 3, -4,
1152 -3, 1, 4,
1153 -2, -10, 8
1154 }, qScale, qOffset);
1155
1156 switch (ArmnnType)
1157 {
1158 case armnn::DataType::QAsymmU8:
1159 outputExpected = armnnUtils::QuantizedVector<T>({
1160 3, 3, 0,
1161 0, 1, 1,
1162 0, 0, 8
1163 }, qScale, qOffset);
1164 break;
1165 default:
1166 break;
1167 }
1168
1169 return BatchMatMulTestImpl<ArmnnType, T, 2>(workloadFactory,
1170 memoryManager,
1171 tensorHandleFactory,
1172 descriptor,
1173 inputX,
1174 inputY,
1175 outputExpected,
1176 inputXInfo,
1177 inputYInfo,
1178 outputInfo);
1179}
1180
1181template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 2>
1182BatchMatMul2DAdjointSimpleTest<armnn::DataType::BFloat16>(
1183 armnn::IWorkloadFactory& workloadFactory,
1184 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1185 const armnn::ITensorHandleFactory& tensorHandleFactory);
1186
1187template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
1188BatchMatMul2DAdjointSimpleTest<armnn::DataType::Float32>(
1189 armnn::IWorkloadFactory& workloadFactory,
1190 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1191 const armnn::ITensorHandleFactory& tensorHandleFactory);
1192
1193template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2>
1194BatchMatMul2DAdjointSimpleTest<armnn::DataType::Float16>(
1195 armnn::IWorkloadFactory& workloadFactory,
1196 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1197 const armnn::ITensorHandleFactory& tensorHandleFactory);
1198
1199template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2>
1200BatchMatMul2DAdjointSimpleTest<armnn::DataType::QAsymmS8>(
1201 armnn::IWorkloadFactory& workloadFactory,
1202 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1203 const armnn::ITensorHandleFactory& tensorHandleFactory);
1204
1205template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2>
1206BatchMatMul2DAdjointSimpleTest<armnn::DataType::QAsymmU8>(
1207 armnn::IWorkloadFactory& workloadFactory,
1208 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1209 const armnn::ITensorHandleFactory& tensorHandleFactory);
1210
1211template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2>
1212BatchMatMul2DAdjointSimpleTest<armnn::DataType::QSymmS16>(
1213 armnn::IWorkloadFactory& workloadFactory,
1214 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1215 const armnn::ITensorHandleFactory& tensorHandleFactory);
1216
1217template<armnn::DataType ArmnnType, typename T>
1218LayerTestResult<T, 4> BatchMatMulNHWCParamsTest(
1219 armnn::IWorkloadFactory& workloadFactory,
1220 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1221 const armnn::ITensorHandleFactory& tensorHandleFactory)
1222{
1223 auto descriptor = armnn::BatchMatMulDescriptor(false,
1224 true,
1225 true,
1226 false,
1227 armnn::DataLayout::NHWC,
1228 armnn::DataLayout::NHWC);
1229
1230 float qScale = 0.0f;
1231 int32_t qOffset = 0;
1232
1233 switch(ArmnnType)
1234 {
1235 case armnn::DataType::QAsymmS8:
1236 case armnn::DataType::QAsymmU8:
1237 case armnn::DataType::QSymmS16:
1238 qScale = 1.0f;
1239 break;
1240 default:
1241 break;
1242 }
1243
1244 armnn::TensorInfo inputXInfo({1,4,4,2}, ArmnnType, qScale, qOffset);
1245 armnn::TensorInfo inputYInfo({2,2,4,1}, ArmnnType, qScale, qOffset);
1246 armnn::TensorInfo outputInfo({2,4,2,2}, ArmnnType, qScale, qOffset);
1247
1248 std::vector<T> inputX = armnnUtils::QuantizedVector<T>({
1249 1, -3, 1, 4, 4, 9, 1, 2,
1250 2, 4, 2, 2, 10, 7, 6, -5,
1251 3, 8, 9, 9, 21, 1, 17, 7,
1252 5, 11, 11, 8, 29, 3, 23, 6
1253 }, qScale, qOffset);
1254
1255 std::vector<T> inputY = armnnUtils::QuantizedVector<T>({
1256 1, 2, 3, 4,
1257 5, 6, 7, 8,
1258
1259 9, 10, 11, 12,
1260 13, 14, 15, 16
1261 }, qScale, qOffset);
1262
1263 std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
1264 28, 625, 140, 585,
1265 8, 110, -8, 1662,
1266 -24, 401, -120, 921,
1267 12, 131, 108, -501,
1268
1269 252, 545, 364, 505,
1270 -24, 3214, -40, 4766,
1271 -216, 1441, -312, 1961,
1272 204, -1133, 300, -1765
1273 }, qScale, qOffset);
1274
1275 switch (ArmnnType)
1276 {
1277 case armnn::DataType::QAsymmU8:
1278 outputExpected = armnnUtils::QuantizedVector<T>({
1279 28, 80, 140, 80,
1280 8, 45, 0, 255,
1281 0, 18, 0, 18,
1282 12, 0, 108, 0,
1283
1284 252, 80, 255, 80,
1285 0, 255, 0, 255,
1286 0, 18, 0, 18,
1287 204, 0, 255, 0
1288 }, qScale, qOffset);
1289 break;
1290 default:
1291 break;
1292 }
1293
1294 return BatchMatMulTestImpl<ArmnnType, T, 4>(workloadFactory,
1295 memoryManager,
1296 tensorHandleFactory,
1297 descriptor,
1298 inputX,
1299 inputY,
1300 outputExpected,
1301 inputXInfo,
1302 inputYInfo,
1303 outputInfo);
1304}
1305
1306template LayerTestResult<armnn::ResolveType<armnn::DataType::BFloat16>, 4>
1307BatchMatMulNHWCParamsTest<armnn::DataType::BFloat16>(
1308 armnn::IWorkloadFactory& workloadFactory,
1309 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1310 const armnn::ITensorHandleFactory& tensorHandleFactory);
1311
1312template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
1313BatchMatMulNHWCParamsTest<armnn::DataType::Float32>(
1314 armnn::IWorkloadFactory& workloadFactory,
1315 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1316 const armnn::ITensorHandleFactory& tensorHandleFactory);
1317
1318template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
1319BatchMatMulNHWCParamsTest<armnn::DataType::Float16>(
1320 armnn::IWorkloadFactory& workloadFactory,
1321 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1322 const armnn::ITensorHandleFactory& tensorHandleFactory);
1323
1324template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
1325BatchMatMulNHWCParamsTest<armnn::DataType::QAsymmS8>(
1326 armnn::IWorkloadFactory& workloadFactory,
1327 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1328 const armnn::ITensorHandleFactory& tensorHandleFactory);
1329
1330template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
1331BatchMatMulNHWCParamsTest<armnn::DataType::QAsymmU8>(
1332 armnn::IWorkloadFactory& workloadFactory,
1333 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1334 const armnn::ITensorHandleFactory& tensorHandleFactory);
1335
1336template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
1337BatchMatMulNHWCParamsTest<armnn::DataType::QSymmS16>(
1338 armnn::IWorkloadFactory& workloadFactory,
1339 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Samuel Yap6b478092022-07-06 15:36:03 +0100[diff] [blame]1340 const armnn::ITensorHandleFactory& tensorHandleFactory);