19 using namespace armnn;
27 const std::vector<TensorInfo> & inputTensorInfos,
28 unsigned int concatDim)
30 std::vector<TensorShape> shapes;
31 shapes.reserve(inputTensorInfos.size());
34 shapes.push_back(it.GetShape());
47 const std::vector<TensorInfo> & inputTensorInfos,
48 unsigned int concatDim)
52 unsigned int nDimensions = 0;
56 for (
auto && tensorInfo : inputTensorInfos)
60 nDimensions = tensorInfo.GetShape().GetNumDimensions();
64 BOOST_ASSERT_MSG(nDimensions == tensorInfo.GetShape().GetNumDimensions(),
65 "Input shapes must have the same number of dimensions");
69 return (nDimensions < 3 || (nDimensions == 3 && (nDimensions-concatDim) < 3 && (nDimensions-concatDim) != 1));
81 std::vector<unsigned int> newDims(
size_t(3), 1u);
82 unsigned int expandedBy = 3 - numDims;
83 for (
unsigned int i=0; i<numDims; ++i)
85 newDims[expandedBy+i] = inputShape[i];
91 unsigned int numDimensions,
92 unsigned int & concatDim,
93 std::pair<PermutationVector, PermutationVector> & permutations)
95 BOOST_ASSERT_MSG(numDimensions <= 3,
96 "Only dimensions 1,2 and 3 are supported by this helper");
97 unsigned int expandedBy = 3 - numDimensions;
98 unsigned int expandedConcatAxis = concatDim + expandedBy;
100 if (expandedConcatAxis == 2)
105 permutations = std::make_pair(forwardPermutation, reversePermutation);
107 else if (expandedConcatAxis == 1)
112 permutations = std::make_pair(forwardPermutation, reversePermutation);
116 BOOST_ASSERT(expandedConcatAxis == 0);
127 std::vector<T>& outputData)
130 BOOST_ASSERT_MSG(inputData !=
nullptr,
"inputData must not be null");
131 if (inputData ==
nullptr)
141 std::unique_ptr<ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfo);
142 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
147 AddInputToWorkload(queueDescriptor, workloadInfo, inputTensorInfo, inputHandle.get());
148 AddOutputToWorkload(queueDescriptor, workloadInfo, outputTensorInfo, outputHandle.get());
150 std::unique_ptr<IWorkload> workload = workloadFactory.
CreatePermute(queueDescriptor, workloadInfo);
152 inputHandle->Allocate();
153 outputHandle->Allocate();
157 workload->PostAllocationConfigure();
162 inputTensorInfo = outputTensorInfo;
174 std::vector<TensorInfo> & inputTensorInfos,
175 std::vector<T *> & inputData,
176 std::vector<std::vector<T>> & inputDataStorage,
178 unsigned int & concatDim,
182 BOOST_ASSERT_MSG(inputTensorInfos.size() > 1,
183 "Expecting more than one tensor to be concatenated here");
185 unsigned int numDims = 0;
186 unsigned int nthInput = 0;
189 std::pair<PermutationVector, PermutationVector> permutations =
190 std::make_pair(identity, identity);
192 inputDataStorage.resize(inputData.size());
194 for (
auto && tensorInfo : inputTensorInfos)
198 numDims = tensorInfo.GetShape().GetNumDimensions();
202 permuteVector = permutations.second;
203 BOOST_ASSERT_MSG(!permuteVector.
IsEqual(identity),
204 "Test logic error, we don't need permutation, so we shouldn't arrive here");
208 BOOST_ASSERT_MSG(numDims == tensorInfo.GetShape().GetNumDimensions(),
209 "All inputs must have the same number of dimensions");
215 PermuteTensorData<T>(workloadFactory,
220 inputDataStorage[nthInput]);
222 inputData[nthInput] = inputDataStorage[nthInput].data();
223 inputTensorInfos[nthInput] = newTensorInfo;
231 permutations.first));
244 std::unique_ptr<ITensorHandle> && inputDataHandle,
247 BOOST_ASSERT_MSG(data !=
nullptr,
"data must not be null");
258 std::vector<T> outputData;
262 PermuteTensorData<T>(workloadFactory,
269 ::memcpy(data, &outputData[0],
sizeof(T)*outputData.size());
275 std::initializer_list<const TensorInfo> inputTensorInfosOrig,
276 std::initializer_list<T *> inputsOrig,
279 unsigned int concatDim,
282 BOOST_ASSERT_MSG(output !=
nullptr,
"output must not be null");
283 if (output ==
nullptr)
292 std::vector<TensorInfo> inputTensorInfos(inputTensorInfosOrig.begin(), inputTensorInfosOrig.end());
293 std::vector<T *> inputs = inputsOrig;
294 TensorInfo outputTensorInfo = outputTensorInfoOrig;
299 std::vector<std::vector<T>> tmpInputDataStorage;
301 const size_t inputCount = inputTensorInfos.size();
305 if (needPermuteForConcat)
311 PermuteInputsForConcat<T>(workloadFactory,
323 std::vector<std::unique_ptr<ITensorHandle>> inputHandles;
324 inputHandles.reserve(inputCount);
326 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
335 for (
unsigned int i = 0; i < viewsDescriptor.
GetNumViews(); ++i)
344 for (
unsigned int i = 0; i < inputCount; ++i)
346 const TensorInfo& inputTensorInfo = inputTensorInfos[i];
347 std::unique_ptr<ITensorHandle> inputHandle =
348 subTensorsSupported ?
354 inputHandles.emplace_back(std::move(inputHandle));
360 for (
unsigned int i = 0; i < inputCount; ++i)
362 std::unique_ptr<ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfos[i]);
363 inputHandles.emplace_back(std::move(inputHandle));
367 for (
unsigned int i = 0; i < inputCount; ++i)
369 AddInputToWorkload(queueDescriptor, workloadInfo, inputTensorInfos[i], inputHandles[i].
get());
372 AddOutputToWorkload(queueDescriptor, workloadInfo, outputTensorInfo, outputHandle.get());
374 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(queueDescriptor, workloadInfo);
376 for (
auto& inputHandle : inputHandles)
378 inputHandle->Allocate();
381 outputHandle->Allocate();
383 unsigned int nextInputId = 0;
384 for (
auto& inputHandle : inputHandles)
390 workload->PostAllocationConfigure();
393 if (needPermuteForConcat)
395 PermuteOutputForConcat<T>(workloadFactory,
399 std::move(outputHandle),
412 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
419 TensorInfo inputTensorInfo({ 3 }, ArmnnType, qScale, qOffset);
421 auto input0 = MakeTensor<T, 1>(inputTensorInfo, QuantizedVector<T>({ 1.0f, 2.0f, 3.0f }, qScale, qOffset));
422 auto input1 = MakeTensor<T, 1>(inputTensorInfo, QuantizedVector<T>({ 4.0f, 5.0f, 6.0f }, qScale, qOffset));
423 auto input2 = MakeTensor<T, 1>(inputTensorInfo, QuantizedVector<T>({ 7.0f, 8.0f, 9.0f }, qScale, qOffset));
425 TensorInfo outputTensorInfo({ 9 }, ArmnnType, qScale, qOffset);
429 std::vector<T> output;
430 output.resize(outputTensorInfo.GetNumElements());
431 Concatenate<T>(workloadFactory, memoryManager,
432 { inputTensorInfo, inputTensorInfo, inputTensorInfo },
433 { input0.data(), input1.data(), input2.data() },
439 result.output = MakeTensor<T, 1>(outputTensorInfo, output);
440 result.outputExpected = MakeTensor<T, 1>(outputTensorInfo, QuantizedVector<T>(
442 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f
449 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
454 unsigned int dimension,
456 const int32_t qOffset)
458 TensorInfo inputTensorInfo({ 2, 3 }, ArmnnType, qScale, qOffset);
460 auto input0 = MakeTensor<T, 2>(inputTensorInfo, QuantizedVector<T>(
470 auto input1 = MakeTensor<T, 2>(inputTensorInfo, QuantizedVector<T>(
480 auto input2 = MakeTensor<T, 2>(inputTensorInfo, QuantizedVector<T>(
492 std::vector<T> output;
494 Concatenate<T>(workloadFactory, memoryManager,
495 { inputTensorInfo, inputTensorInfo, inputTensorInfo },
496 { input0.data(), input1.data(), input2.data() },
502 result.
output = MakeTensor<T, 2>(outputTensorInfo, output);
506 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
513 TensorInfo outputTensorInfo({ 6, 3 }, ArmnnType, qScale, qOffset);
516 workloadFactory, memoryManager, outputTensorInfo, 0, qScale, qOffset);
518 result.
outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(
543 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
550 TensorInfo outputTensorInfo({ 2, 9 }, ArmnnType, qScale, qOffset);
553 workloadFactory, memoryManager, outputTensorInfo, 1, qScale, qOffset);
555 result.
outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(
558 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
561 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f
568 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
575 TensorInfo input0TensorInfo({ 2, 3 }, ArmnnType, qScale, qOffset);
576 auto input0 = MakeTensor<T, 2>(input0TensorInfo, QuantizedVector<T>(
586 TensorInfo input1TensorInfo({ 3, 3 }, ArmnnType, qScale, qOffset);
587 auto input1 = MakeTensor<T, 2>(input1TensorInfo, QuantizedVector<T>(
600 TensorInfo input2TensorInfo({ 1, 3 }, ArmnnType, qScale, qOffset);
601 auto input2 = MakeTensor<T, 2>(input2TensorInfo, QuantizedVector<T>(
608 TensorInfo outputTensorInfo({ 6, 3 }, ArmnnType, qScale, qOffset);
611 std::vector<T> output;
612 output.resize(outputTensorInfo.GetNumElements());
613 Concatenate<T>(workloadFactory, memoryManager,
614 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
615 { input0.data(), input1.data(), input2.data() },
621 result.output = MakeTensor<T, 2>(outputTensorInfo, output);
622 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(
647 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
654 TensorInfo input0TensorInfo({ 2, 3 }, ArmnnType, qScale, qOffset);
655 auto input0 = MakeTensor<T, 2>(input0TensorInfo, QuantizedVector<T>(
665 TensorInfo input1TensorInfo({ 2, 5 }, ArmnnType, qScale, qOffset);
666 auto input1 = MakeTensor<T, 2>(input1TensorInfo, QuantizedVector<T>(
669 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
672 13.0f, 14.0f, 15.0f, 16.0f, 17.0f,
676 TensorInfo input2TensorInfo({ 2, 1 }, ArmnnType, qScale, qOffset);
677 auto input2 = MakeTensor<T, 2>(input2TensorInfo, QuantizedVector<T>(
687 TensorInfo outputTensorInfo({ 2, 9 }, ArmnnType, qScale, qOffset);
690 std::vector<T> output;
691 output.resize(outputTensorInfo.GetNumElements());
692 Concatenate<T>(workloadFactory, memoryManager,
693 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
694 { input0.data(), input1.data(), input2.data() },
700 result.output = MakeTensor<T, 2>(outputTensorInfo, output);
701 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(
704 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
707 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f,
714 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
719 unsigned int dimension,
724 TensorInfo inputTensorInfo({ 2, 3, 2 }, ArmnnType, qScale, qOffset);
726 auto input0 = MakeTensor<T, 3>(inputTensorInfo, QuantizedVector<T>(
748 auto input1 = MakeTensor<T, 3>(inputTensorInfo, QuantizedVector<T>(
770 auto input2 = MakeTensor<T, 3>(inputTensorInfo, QuantizedVector<T>(
794 std::vector<T> output;
796 Concatenate<T>(workloadFactory, memoryManager,
797 { inputTensorInfo, inputTensorInfo, inputTensorInfo },
798 { input0.data(), input1.data(), input2.data() },
804 result.
output = MakeTensor<T, 3>(outputTensorInfo, output);
808 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
815 TensorInfo outputTensorInfo({ 6, 3, 2 }, ArmnnType, qScale, qOffset);
818 workloadFactory, memoryManager, outputTensorInfo, 0,
true, qScale, qOffset);
820 result.
outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
881 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
888 TensorInfo outputTensorInfo({ 2, 9, 2 }, ArmnnType, qScale, qOffset);
891 workloadFactory, memoryManager, outputTensorInfo, 1,
true, qScale, qOffset);
893 result.
outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
954 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
962 TensorInfo outputTensorInfo({ 2, 3, 6 }, ArmnnType, qScale, qOffset);
965 workloadFactory, memoryManager, outputTensorInfo, 2, useSubtensor, qScale, qOffset);
967 result.
outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
970 1.0f, 2.0f, 7.0f, 8.0f, 13.0f, 14.0f,
973 3.0f, 4.0f, 9.0f, 10.0f, 15.0f, 16.0f,
976 5.0f, 6.0f, 11.0f, 12.0f, 17.0f, 18.0f,
979 19.0f, 20.0f, 25.0f, 26.0f, 31.0f, 32.0f,
982 21.0f, 22.0f, 27.0f, 28.0f, 33.0f, 34.0f,
985 23.0f, 24.0f, 29.0f, 30.0f, 35.0f, 36.0f,
992 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
999 TensorInfo input0TensorInfo({ 2, 3, 2 }, ArmnnType);
1000 auto input0 = MakeTensor<T, 3>(input0TensorInfo, QuantizedVector<T>(
1022 TensorInfo input1TensorInfo({ 1, 3, 2 }, ArmnnType);
1023 auto input1 = MakeTensor<T, 3>(input1TensorInfo, QuantizedVector<T>(
1036 TensorInfo input2TensorInfo({ 3, 3, 2 }, ArmnnType);
1037 auto input2 = MakeTensor<T, 3>(input2TensorInfo, QuantizedVector<T>(
1068 TensorInfo outputTensorInfo({ 6, 3, 2 }, ArmnnType);
1071 std::vector<T> output;
1072 output.resize(outputTensorInfo.GetNumElements());
1073 Concatenate<T>(workloadFactory, memoryManager,
1074 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
1075 { input0.data(), input1.data(), input2.data() },
1081 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
1082 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
1143 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1150 TensorInfo input0TensorInfo({ 2, 3, 2 }, ArmnnType, qScale, qOffset);
1151 auto input0 = MakeTensor<T, 3>(input0TensorInfo, QuantizedVector<T>(
1173 TensorInfo input1TensorInfo({ 2, 4, 2 }, ArmnnType, qScale, qOffset);
1174 auto input1 = MakeTensor<T, 3>(input1TensorInfo, QuantizedVector<T>(
1202 TensorInfo input2TensorInfo({ 2, 1, 2 }, ArmnnType, qScale, qOffset);
1203 auto input2 = MakeTensor<T, 3>(input2TensorInfo, QuantizedVector<T>(
1213 TensorInfo outputTensorInfo({ 2, 8, 2 }, ArmnnType, qScale, qOffset);
1216 std::vector<T> output;
1217 output.resize(outputTensorInfo.GetNumElements());
1218 Concatenate<T>(workloadFactory, memoryManager,
1219 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
1220 { input0.data(), input1.data(), input2.data() },
1226 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
1227 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
1282 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1290 TensorInfo input0TensorInfo({ 2, 3, 2 }, ArmnnType, qScale, qOffset);
1291 auto input0 = MakeTensor<T, 3>(input0TensorInfo, QuantizedVector<T>(
1313 TensorInfo input1TensorInfo({ 2, 3, 1 }, ArmnnType, qScale, qOffset);
1314 auto input1 = MakeTensor<T, 3>(input1TensorInfo, QuantizedVector<T>(
1336 TensorInfo input2TensorInfo({ 2, 3, 3 }, ArmnnType, qScale, qOffset);
1337 auto input2 = MakeTensor<T, 3>(input2TensorInfo, QuantizedVector<T>(
1340 13.0f, 14.0f, 50.0f,
1343 15.0f, 16.0f, 51.0f,
1346 17.0f, 18.0f, 52.0f,
1349 31.0f, 32.0f, 53.0f,
1352 33.0f, 34.0f, 54.0f,
1355 35.0f, 36.0f, 55.0f,
1359 TensorInfo outputTensorInfo({ 2, 3, 6 }, ArmnnType, qScale, qOffset);
1362 std::vector<T> output;
1363 output.resize(outputTensorInfo.GetNumElements());
1364 Concatenate<T>(workloadFactory, memoryManager,
1365 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
1366 { input0.data(), input1.data(), input2.data() },
1372 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
1373 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
1376 1.0f, 2.0f, 7.0f, 13.0f, 14.0f, 50.0f,
1379 3.0f, 4.0f, 9.0f, 15.0f, 16.0f, 51.0f,
1382 5.0f, 6.0f, 11.0f, 17.0f, 18.0f, 52.0f,
1385 19.0f, 20.0f, 25.0f, 31.0f, 32.0f, 53.0f,
1388 21.0f, 22.0f, 27.0f, 33.0f, 34.0f, 54.0f,
1391 23.0f, 24.0f, 29.0f, 35.0f, 36.0f, 55.0f,
1398 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1403 unsigned int dimension,
1408 TensorInfo inputTensorInfo({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1410 auto input0 = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(
1421 auto input1 = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(
1432 auto input2 = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(
1445 std::vector<T> output;
1448 Concatenate<T>(workloadFactory,
1450 {inputTensorInfo, inputTensorInfo, inputTensorInfo},
1451 {input0.data(), input1.data(), input2.data()},
1457 result.
output = MakeTensor<T, 4>(outputTensorInfo, output);
1461 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1468 TensorInfo outputTensorInfo({ 3, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1471 workloadFactory, memoryManager, outputTensorInfo, 0,
true, qScale, qOffset);
1473 result.
outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1501 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1508 TensorInfo outputTensorInfo({ 1, 9, 2, 2 }, ArmnnType, qScale, qOffset);
1511 workloadFactory, memoryManager, outputTensorInfo, 1,
true, qScale, qOffset);
1513 result.
outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1541 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1548 TensorInfo outputTensorInfo({ 1, 3, 6, 2 }, ArmnnType, qScale, qOffset);
1551 workloadFactory, memoryManager, outputTensorInfo, 2,
true, qScale, qOffset);
1553 result.
outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1581 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1589 TensorInfo outputTensorInfo({ 1, 3, 2, 6 }, ArmnnType, qScale, qOffset);
1592 workloadFactory, memoryManager, outputTensorInfo, 3, useSubtensor, qScale, qOffset);
1594 result.
outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1622 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1629 constexpr
unsigned int dimension = 0u;
1631 TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1632 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(
1643 TensorInfo inputTensorInfo1({ 2, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1645 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(
1663 TensorInfo outputTensorInfo({ 3, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1667 std::vector<T> output;
1668 output.resize(outputTensorInfo.GetNumElements());
1669 Concatenate<T>(workloadFactory,
1671 {inputTensorInfo0, inputTensorInfo1},
1672 {input0.data(), input1.data()},
1678 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
1679 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1707 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1714 constexpr
unsigned int dimension = 1u;
1716 TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1717 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(
1728 TensorInfo inputTensorInfo1({ 1, 2, 2, 2 }, ArmnnType, qScale, qOffset);
1730 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(
1739 TensorInfo outputTensorInfo({ 1, 5, 2, 2 }, ArmnnType, qScale, qOffset);
1743 std::vector<T> output;
1744 output.resize(outputTensorInfo.GetNumElements());
1745 Concatenate<T>(workloadFactory,
1747 {inputTensorInfo0, inputTensorInfo1},
1748 {input0.data(), input1.data()},
1754 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
1755 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1773 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1780 constexpr
unsigned int dimension = 2u;
1782 TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1783 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(
1794 TensorInfo inputTensorInfo1({ 1, 3, 3, 2 }, ArmnnType, qScale, qOffset);
1795 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(
1809 TensorInfo outputTensorInfo({ 1, 3, 5, 2 }, ArmnnType, qScale, qOffset);
1812 std::vector<T> output;
1813 output.resize(outputTensorInfo.GetNumElements());
1814 Concatenate<T>(workloadFactory,
1816 {inputTensorInfo0, inputTensorInfo1},
1817 {input0.data(), input1.data()},
1823 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
1824 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1849 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1857 constexpr
unsigned int dimension = 3u;
1859 TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1860 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(
1871 TensorInfo inputTensorInfo1({ 1, 3, 2, 3 }, ArmnnType, qScale, qOffset);
1872 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(
1874 11.0f, 12.0f, 13.0f,
1875 14.0f, 15.0f, 16.0f,
1877 17.0f, 18.0f, 19.0f,
1878 20.0f, 21.0f, 22.0f,
1880 23.0f, 24.0f, 25.0f,
1885 TensorInfo outputTensorInfo({ 1, 3, 2, 5 }, ArmnnType, qScale, qOffset);
1889 std::vector<T> output;
1890 output.resize(outputTensorInfo.GetNumElements());
1891 Concatenate<T>(workloadFactory,
1893 {inputTensorInfo0, inputTensorInfo1},
1894 {input0.data(), input1.data()},
1900 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
1901 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1903 1.0f, 2.0f, 11.0f, 12.0f, 13.0f,
1904 3.0f, 4.0f, 14.0f, 15.0f, 16.0f,
1905 5.0f, 6.0f, 17.0f, 18.0f, 19.0f,
1906 7.0f, 8.0f, 20.0f, 21.0f, 22.0f,
1907 9.0f, 10.0f, 23.0f, 24.0f, 25.0f,
1908 11.0f, 12.0f, 26.0f, 27.0f, 28.0f
1915 template<DataType ArmnnType,
typename T>
1924 TensorInfo outputTensorInfo({ 3, 6, 3 }, ArmnnType);
1925 TensorInfo inputTensorInfo1({ 3, 6, 2 }, ArmnnType);
1926 TensorInfo inputTensorInfo2({ 3, 6, 1 }, ArmnnType);
1928 std::vector<TensorShape> inputTensorShapes({inputTensorInfo1.GetShape(), inputTensorInfo2.GetShape()});
1931 const float inputScale1 = 0.5f;
1932 const int32_t inputOffset1 = 5;
1934 auto input1 = MakeTensor<T, 3>(inputTensorInfo1, std::vector<T>(
1952 const float inputScale2 = 0.2f;
1953 const int32_t inputOffset2 = 10;
1955 auto input2 = MakeTensor<T, 3>(inputTensorInfo2, std::vector<T>(
1966 const float outputScale = 0.1f;
1967 const int32_t outputOffset = 20;
1971 ret.
outputExpected = MakeTensor<T, 3>(outputTensorInfo, std::vector<T>(
1995 outputTensorInfo.SetQuantizationScale(outputScale);
1996 outputTensorInfo.SetQuantizationOffset(outputOffset);
1997 inputTensorInfo1.SetQuantizationScale(inputScale1);
1998 inputTensorInfo1.SetQuantizationOffset(inputOffset1);
1999 inputTensorInfo2.SetQuantizationScale(inputScale2);
2000 inputTensorInfo2.SetQuantizationOffset(inputOffset2);
2002 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2005 std::vector<unsigned int> wOrigin2 = { 0, 0, 2 };
2008 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2012 std::unique_ptr<ITensorHandle> inputHandle1 =
2013 subTensorsSupported ?
2014 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2017 std::unique_ptr<ITensorHandle> inputHandle2 =
2018 subTensorsSupported ?
2019 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2024 inputTensorShapes.begin(),inputTensorShapes.end(), 2);
2028 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2029 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2030 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2035 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2037 inputHandle1->Allocate();
2038 inputHandle2->Allocate();
2039 outputHandle->Allocate();
2044 workload->PostAllocationConfigure();
2045 workload->Execute();
2057 ConcatDifferentInputOutputQParamTest<DataType::QAsymmU8>(
2063 ConcatDifferentInputOutputQParamTest<DataType::QSymmS16>(
2078 unsigned int outputWidth = 3;
2079 unsigned int outputHeight = 6;
2080 unsigned int outputChannels = 3;
2082 unsigned int inputWidth1 = 3;
2083 unsigned int inputHeight1 = 6;
2084 unsigned int inputChannels1 = 2;
2086 unsigned int inputWidth2 = 3;
2087 unsigned int inputHeight2 = 6;
2088 unsigned int inputChannels2 = 1;
2097 ret.outputExpected = MakeTensor<float, 3>(outputTensorInfo, std::vector<float>(
2102 10.0f, 11.0f, 12.0f,
2103 13.0f, 14.0f, 15.0f,
2104 16.0f, 17.0f, 18.0f,
2106 19.0f, 20.0f, 21.0f,
2107 22.0f, 23.0f, 24.0f,
2108 25.0f, 26.0f, 27.0f,
2109 28.0f, 29.0f, 30.0f,
2110 31.0f, 32.0f, 33.0f,
2111 34.0f, 35.0f, 36.0f,
2113 37.0f, 38.0f, 39.0f,
2114 40.0f, 41.0f, 42.0f,
2115 43.0f, 44.0f, 45.0f,
2116 46.0f, 47.0f, 48.0f,
2117 49.0f, 50.0f, 51.0f,
2118 52.0f, 53.0f, 54.0f,
2122 auto input1 = MakeTensor<float, 3>(inputTensorInfo1, std::vector<float>(
2127 10.0f, 11.0f, 12.0f,
2128 13.0f, 14.0f, 15.0f,
2129 16.0f, 17.0f, 18.0f,
2131 19.0f, 20.0f, 21.0f,
2132 22.0f, 23.0f, 24.0f,
2133 25.0f, 26.0f, 27.0f,
2134 28.0f, 29.0f, 30.0f,
2135 31.0f, 32.0f, 33.0f,
2136 34.0f, 35.0f, 36.0f,
2140 auto input2 = MakeTensor<float, 3>(inputTensorInfo2, std::vector<float>(
2142 37.0f, 38.0f, 39.0f,
2143 40.0f, 41.0f, 42.0f,
2144 43.0f, 44.0f, 45.0f,
2145 46.0f, 47.0f, 48.0f,
2146 49.0f, 50.0f, 51.0f,
2147 52.0f, 53.0f, 54.0f,
2151 std::vector<unsigned int> wOrigin1 = {0, 0, 0};
2154 std::vector<unsigned int> wOrigin2 = {2, 0, 0};
2157 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2161 std::unique_ptr<ITensorHandle> inputHandle1 =
2162 subTensorsSupported ?
2163 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2166 std::unique_ptr<ITensorHandle> inputHandle2 =
2167 subTensorsSupported ?
2168 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2173 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2174 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2175 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2180 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2182 inputHandle1->Allocate();
2183 inputHandle2->Allocate();
2184 outputHandle->Allocate();
2189 workload->PostAllocationConfigure();
2190 workload->Execute();
2201 return Concat1dTestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2208 return Concat2dDim0TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2215 return Concat2dDim1TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2222 return Concat2dDim0DiffInputDimsTestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2229 return Concat2dDim1DiffInputDimsTestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2236 return Concat3dDim0TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2243 return Concat3dDim1TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2251 return Concat3dDim2TestImpl<DataType::Float32>(workloadFactory, memoryManager, useSubtensor, 0.0f, 0);
2258 return Concat3dDim0DiffInputDimsTestImpl<DataType::Float32>(
2259 workloadFactory, memoryManager, 0.0f, 0);
2266 return Concat3dDim1DiffInputDimsTestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2274 return Concat3dDim2DiffInputDimsTestImpl<DataType::Float32>(
2275 workloadFactory, memoryManager, useSubtensor, 0.0f, 0);
2282 return Concat4dDim0TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2289 return Concat4dDim1TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2296 return Concat4dDim2TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2304 return Concat4dDim3TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0, useSubtensor);
2311 return Concat4dDiffShapeDim0TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2318 return Concat4dDiffShapeDim1TestImpl<DataType::Float32>(
2319 workloadFactory, memoryManager, 0.0f, 0);
2326 return Concat4dDiffShapeDim2TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2334 return Concat4dDiffShapeDim3TestImpl<DataType::Float32>(
2335 workloadFactory, memoryManager, 0.0f, 0, useSubtensor);
2342 return Concat3dDim1TestImpl<DataType::Float16>(workloadFactory, memoryManager, 0.0f, 0);
2349 return Concat3dDim1TestImpl<DataType::BFloat16>(workloadFactory, memoryManager, 0.0f, 0);
2358 unsigned int outputWidth = 3;
2359 unsigned int outputHeight = 6;
2360 unsigned int outputChannels = 3;
2362 unsigned int inputWidth1 = 3;
2363 unsigned int inputHeight1 = 6;
2364 unsigned int inputChannels1 = 2;
2366 unsigned int inputWidth2 = 3;
2367 unsigned int inputHeight2 = 6;
2368 unsigned int inputChannels2 = 1;
2376 const float inputScale1 = 0.015686f;
2377 const int32_t inputOffset1 = 192;
2379 auto input1 = MakeTensor<uint8_t, 3>(inputTensorInfo1, std::vector<uint8_t>(
2398 const float inputScale2 = 0.019608f;
2399 const int32_t inputOffset2 = 50;
2401 auto input2 = MakeTensor<uint8_t, 3>(inputTensorInfo2, std::vector<uint8_t>(
2414 const float outputScale = 0.015686f;
2415 const int32_t outputOffset = 192;
2419 ret.
outputExpected = MakeTensor<uint8_t, 3>(outputTensorInfo, std::vector<uint8_t>(
2444 outputTensorInfo.SetQuantizationScale(outputScale);
2445 outputTensorInfo.SetQuantizationOffset(outputOffset);
2446 inputTensorInfo1.SetQuantizationScale(inputScale1);
2447 inputTensorInfo1.SetQuantizationOffset(inputOffset1);
2448 inputTensorInfo2.SetQuantizationScale(inputScale2);
2449 inputTensorInfo2.SetQuantizationOffset(inputOffset2);
2451 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2454 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 };
2457 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2461 std::unique_ptr<ITensorHandle> inputHandle1 =
2462 subTensorsSupported ?
2463 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2466 std::unique_ptr<ITensorHandle> inputHandle2 =
2467 subTensorsSupported ?
2468 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2473 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2474 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2475 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2480 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2482 inputHandle1->Allocate();
2483 inputHandle2->Allocate();
2484 outputHandle->Allocate();
2489 workload->PostAllocationConfigure();
2490 workload->Execute();
2503 unsigned int outputWidth = 3;
2504 unsigned int outputHeight = 6;
2505 unsigned int outputChannels = 3;
2507 unsigned int inputWidth1 = 3;
2508 unsigned int inputHeight1 = 6;
2509 unsigned int inputChannels1 = 2;
2511 unsigned int inputWidth2 = 3;
2512 unsigned int inputHeight2 = 6;
2513 unsigned int inputChannels2 = 1;
2521 const float scale = 0.13497836f;
2522 const int32_t offset = -7;
2525 outputTensorInfo.SetQuantizationOffset(offset);
2526 inputTensorInfo1.SetQuantizationScale(scale);
2527 inputTensorInfo1.SetQuantizationOffset(offset);
2528 inputTensorInfo2.SetQuantizationScale(scale);
2529 inputTensorInfo2.SetQuantizationOffset(offset);
2533 ret.
outputExpected = MakeTensor<uint8_t, 3>(outputTensorInfo, std::vector<uint8_t>(
2558 auto input1 = MakeTensor<uint8_t, 3>(inputTensorInfo1, std::vector<uint8_t>(
2576 auto input2 = MakeTensor<uint8_t, 3>(inputTensorInfo2, std::vector<uint8_t>(
2587 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2590 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 };
2594 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2598 std::unique_ptr<ITensorHandle> inputHandle1 =
2599 subTensorsSupported ?
2600 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2603 std::unique_ptr<ITensorHandle> inputHandle2 =
2604 subTensorsSupported ?
2605 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2611 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2612 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2613 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2618 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2620 inputHandle1->Allocate();
2621 inputHandle2->Allocate();
2622 outputHandle->Allocate();
2627 workload->PostAllocationConfigure();
2628 workload->Execute();
2641 unsigned int outputWidth = 3;
2642 unsigned int outputHeight = 6;
2643 unsigned int outputChannels = 3;
2645 unsigned int inputWidth1 = 3;
2646 unsigned int inputHeight1 = 6;
2647 unsigned int inputChannels1 = 2;
2649 unsigned int inputWidth2 = 3;
2650 unsigned int inputHeight2 = 6;
2651 unsigned int inputChannels2 = 1;
2659 const float scale = 0.13497836f;
2660 const int32_t offset = -7;
2663 outputTensorInfo.SetQuantizationOffset(offset);
2664 inputTensorInfo1.SetQuantizationScale(scale);
2665 inputTensorInfo1.SetQuantizationOffset(offset);
2666 inputTensorInfo2.SetQuantizationScale(scale);
2667 inputTensorInfo2.SetQuantizationOffset(offset);
2671 ret.
outputExpected = MakeTensor<uint16_t, 3>(outputTensorInfo, std::vector<uint16_t>(
2695 auto input1 = MakeTensor<uint16_t, 3>(inputTensorInfo1, std::vector<uint16_t>(
2712 auto input2 = MakeTensor<uint16_t, 3>(inputTensorInfo2, std::vector<uint16_t>(
2722 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2725 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 };
2729 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2733 std::unique_ptr<ITensorHandle> inputHandle1 =
2734 subTensorsSupported ?
2735 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2738 std::unique_ptr<ITensorHandle> inputHandle2 =
2739 subTensorsSupported ?
2740 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2746 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2747 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2748 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2753 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2755 inputHandle1->Allocate();
2756 inputHandle2->Allocate();
2757 outputHandle->Allocate();
2762 workload->PostAllocationConfigure();
2763 workload->Execute();
2774 return Concat1dTestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2781 return Concat2dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2788 return Concat2dDim1TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2795 return Concat2dDim0DiffInputDimsTestImpl<DataType::QAsymmU8>(
2796 workloadFactory, memoryManager, 0.5f, -1);
2803 return Concat2dDim1DiffInputDimsTestImpl<DataType::QAsymmU8>(
2804 workloadFactory, memoryManager, 0.5f, -1);
2811 return Concat3dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2818 return Concat3dDim1TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2826 return Concat3dDim2TestImpl<DataType::QAsymmU8>(
2827 workloadFactory, memoryManager, useSubtensor, 0.5f, -1);
2834 return Concat3dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2841 return Concat3dDim1DiffInputDimsTestImpl<DataType::QAsymmU8>(
2842 workloadFactory, memoryManager, 0.5f, -1);
2850 return Concat3dDim2DiffInputDimsTestImpl<DataType::QAsymmU8>(
2851 workloadFactory, memoryManager, useSubtensor, 0.5f, -1);
2858 return Concat4dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2865 return Concat4dDim1TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2872 return Concat4dDim2TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2879 return Concat4dDim3TestImpl<DataType::QAsymmU8>(
2880 workloadFactory, memoryManager, 0.5f, -1, useSubtensor);
2887 return Concat4dDiffShapeDim0TestImpl<DataType::QAsymmU8>(
2888 workloadFactory, memoryManager, 0.5f, -1);
2895 return Concat4dDiffShapeDim1TestImpl<DataType::QAsymmU8>(
2896 workloadFactory, memoryManager, 0.5f, -1);
2903 return Concat4dDiffShapeDim2TestImpl<DataType::QAsymmU8>(
2904 workloadFactory, memoryManager, 0.5f, -1);
2912 return Concat4dDiffShapeDim3TestImpl<DataType::QAsymmU8>(
2913 workloadFactory, memoryManager, 0.5f, -1, useSubtensor);
LayerTestResult< float, 4 > Concat4dDiffShapeDim2Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > Concat4dDim2TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 2 > Concat2dDim0DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< float, 3 > Concat3dDim1DiffInputDimsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 1 > Concat1dUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 3 > ConcatUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > Concat4dDim0Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
const TensorShape & GetShape() const
LayerTestResult< float, 3 > Concat3dDim2DiffInputDimsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< T, 4 > Concat4dDiffShapeDim0TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< uint8_t, 2 > Concat2dDim0DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > Concat4dDiffShapeDim2Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > Concat4dDim2Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 3 > Concat3dDim0Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 3 > Concat3dDim0DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
boost::multi_array< T, n > outputExpected
LayerTestResult< float, 2 > Concat2dDim1Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
virtual std::unique_ptr< ITensorHandle > CreateSubTensorHandle(ITensorHandle &parent, TensorShape const &subTensorShape, unsigned int const *subTensorOrigin) const =0
LayerTestResult< uint8_t, 4 > Concat4dDiffShapeDim0Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
void PermuteOutputForConcat(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const TensorInfo &tensorInfo, const PermutationVector &permuteVector, std::unique_ptr< ITensorHandle > &&inputDataHandle, T *data)
LayerTestResult< uint8_t, 4 > Concat4dDim1Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > Concat4dDiffShapeDim3Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< float, 1 > Concat1dTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > Concat4dDim0Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 2 > Concat2dDim1Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
Copyright (c) 2020 ARM Limited.
void IgnoreUnused(Ts &&...)
LayerTestResult< uint8_t, 3 > ConcatUint8DifferentQParamsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerDescriptor m_Parameters
LayerTestResult< float, 3 > Concat3dDim0Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
void Generate3dPermuteVectorForConcat(unsigned int numDimensions, unsigned int &concatDim, std::pair< PermutationVector, PermutationVector > &permutations)
LayerTestResult< float, 3 > ConcatTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > Concat4dDim2Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
virtual std::unique_ptr< IWorkload > CreateConcat(const ConcatQueueDescriptor &descriptor, const WorkloadInfo &info) const
void SetShape(const TensorShape &newShape)
LayerTestResult< T, 4 > Concat4dTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const TensorInfo &outputTensorInfo, unsigned int dimension, bool useSubtensor, float qScale, int32_t qOffset)
LayerTestResult< T, 3 > Concat3dDim1DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
const uint32_t * GetViewOrigin(uint32_t idx) const
Return the view origin at the int value idx.
LayerTestResult< T, 4 > Concat4dDim3TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset, bool useSubtensor)
LayerTestResult< float, 3 > Concat3dDim2Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
std::vector< ViewOrigin > m_ViewOrigins
std::shared_ptr< IMemoryManager > IMemoryManagerSharedPtr
An OriginsDescriptor for the ConcatLayer.
LayerTestResult< uint8_t, 3 > Concat3dDim1DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
void PermuteTensorData(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const PermutationVector &mappings, TensorInfo &inputTensorInfo, const T *inputData, std::vector< T > &outputData)
LayerTestResult< uint8_t, 4 > Concat4dDiffShapeDim1Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 2 > Concat2dTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const TensorInfo &outputTensorInfo, unsigned int dimension, const float qScale, const int32_t qOffset)
LayerTestResult< T, 4 > Concat4dDim1TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 3 > Concat3dDim2DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor, float qScale, int32_t qOffset)
void SetQuantizationScale(float scale)
LayerTestResult< float, 4 > Concat4dDiffShapeDim1Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 3 > Concat3dTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const TensorInfo &outputTensorInfo, unsigned int dimension, bool useSubtensor, float qScale, int32_t qOffset)
LayerTestResult< T, 1 > Concat1dTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
OriginsDescriptor CreateDescriptorForConcat(const std::vector< TensorInfo > &inputTensorInfos, unsigned int concatDim)
void CopyDataFromITensorHandle(void *memory, const armnn::ITensorHandle *tensorHandle)
virtual std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo, const bool IsMemoryManaged=true) const =0
virtual std::unique_ptr< IWorkload > CreatePermute(const PermuteQueueDescriptor &descriptor, const WorkloadInfo &info) const
LayerTestResult< T, 3 > ConcatDifferentInputOutputQParamTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< T, 3 > Concat3dDim0TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
TensorShape ExpandTensorShapeTo3dForPermute(const TensorShape &inputShape)
LayerTestResult< T, 2 > Concat2dDim1DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
boost::multi_array< T, n > output
LayerTestResult< T, 3 > Concat3dDim1TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 4 > Concat4dDiffShapeDim3TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset, bool useSubtensor)
bool IsEqual(const PermutationVector &other) const
LayerTestResult< uint8_t, 4 > Concat4dDiffShapeDim3Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
void Concatenate(const ConcatQueueDescriptor &data)
LayerTestResult< uint8_t, 2 > Concat2dDim1DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > Concat4dDiffShapeDim0Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 2 > Concat2dDim0Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 3 > Concat3dDim2Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< T, 2 > Concat2dDim0TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
unsigned int GetNumDimensions() const
LayerTestResult< uint8_t, 4 > Concat4dDim3Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< uint8_t, 3 > Concat3dDim2DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< T, 3 > Concat3dDim0DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 3 > Concat3dDim2TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor, float qScale, int32_t qOffset)
uint32_t GetNumDimensions() const
Get the number of dimensions.
LayerTestResult< T, 2 > Concat2dDim1TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< uint16_t, 3 > ConcatUint16Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
Contains information about inputs and outputs to a layer.
OriginsDescriptor CreateDescriptorForConcatenation(TensorShapeIt first, TensorShapeIt last, unsigned int concatenationDimension)
Convenience template to create an OriginsDescriptor to use when creating a ConcatLayer for performing...
uint32_t GetNumViews() const
Get the number of views.
LayerTestResult< T, 4 > Concat4dDiffShapeDim2TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< BFloat16, 3 > ConcatBFloat16Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > Concat4dDim0TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< float, 4 > Concat4dDim1Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 2 > Concat2dDim0DiffInputDimsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 3 > Concat3dDim0DiffInputDimsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 2 > Concat2dDim1DiffInputDimsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
void PermuteInputsForConcat(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, std::vector< TensorInfo > &inputTensorInfos, std::vector< T *> &inputData, std::vector< std::vector< T >> &inputDataStorage, PermutationVector &permuteVector, unsigned int &concatDim, TensorInfo &outputTensorInfo)
LayerTestResult< float, 3 > Concat3dDim1Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 2 > Concat2dDim0Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
armnn::TensorShape Permuted(const armnn::TensorShape &srcShape, const armnn::PermutationVector &mappings)
LayerTestResult< uint8_t, 3 > Concat3dDim1Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > Concat4dDim3Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
unsigned int GetNumElements() const
LayerTestResult< Half, 3 > ConcatFloat16Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
bool NeedPermuteForConcat(const std::vector< TensorInfo > &inputTensorInfos, unsigned int concatDim)
A PermuteDescriptor for the PermuteLayer.
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
virtual bool SupportsSubTensors() const =0
LayerTestResult< T, 4 > Concat4dDiffShapeDim1TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)