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)
129 boost::ignore_unused(memoryManager);
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,
181 boost::ignore_unused(memoryManager);
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>
1921 boost::ignore_unused(memoryManager);
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>(
2076 boost::ignore_unused(memoryManager);
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 boost::ignore_unused(memoryManager);
2351 unsigned int outputWidth = 3;
2352 unsigned int outputHeight = 6;
2353 unsigned int outputChannels = 3;
2355 unsigned int inputWidth1 = 3;
2356 unsigned int inputHeight1 = 6;
2357 unsigned int inputChannels1 = 2;
2359 unsigned int inputWidth2 = 3;
2360 unsigned int inputHeight2 = 6;
2361 unsigned int inputChannels2 = 1;
2369 const float inputScale1 = 0.015686f;
2370 const int32_t inputOffset1 = 192;
2372 auto input1 = MakeTensor<uint8_t, 3>(inputTensorInfo1, std::vector<uint8_t>(
2391 const float inputScale2 = 0.019608f;
2392 const int32_t inputOffset2 = 50;
2394 auto input2 = MakeTensor<uint8_t, 3>(inputTensorInfo2, std::vector<uint8_t>(
2407 const float outputScale = 0.015686f;
2408 const int32_t outputOffset = 192;
2412 ret.
outputExpected = MakeTensor<uint8_t, 3>(outputTensorInfo, std::vector<uint8_t>(
2437 outputTensorInfo.SetQuantizationScale(outputScale);
2438 outputTensorInfo.SetQuantizationOffset(outputOffset);
2439 inputTensorInfo1.SetQuantizationScale(inputScale1);
2440 inputTensorInfo1.SetQuantizationOffset(inputOffset1);
2441 inputTensorInfo2.SetQuantizationScale(inputScale2);
2442 inputTensorInfo2.SetQuantizationOffset(inputOffset2);
2444 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2447 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 };
2450 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2454 std::unique_ptr<ITensorHandle> inputHandle1 =
2455 subTensorsSupported ?
2456 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2459 std::unique_ptr<ITensorHandle> inputHandle2 =
2460 subTensorsSupported ?
2461 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2466 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2467 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2468 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2473 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2475 inputHandle1->Allocate();
2476 inputHandle2->Allocate();
2477 outputHandle->Allocate();
2482 workload->PostAllocationConfigure();
2483 workload->Execute();
2494 boost::ignore_unused(memoryManager);
2496 unsigned int outputWidth = 3;
2497 unsigned int outputHeight = 6;
2498 unsigned int outputChannels = 3;
2500 unsigned int inputWidth1 = 3;
2501 unsigned int inputHeight1 = 6;
2502 unsigned int inputChannels1 = 2;
2504 unsigned int inputWidth2 = 3;
2505 unsigned int inputHeight2 = 6;
2506 unsigned int inputChannels2 = 1;
2514 const float scale = 0.13497836f;
2515 const int32_t offset = -7;
2518 outputTensorInfo.SetQuantizationOffset(offset);
2519 inputTensorInfo1.SetQuantizationScale(scale);
2520 inputTensorInfo1.SetQuantizationOffset(offset);
2521 inputTensorInfo2.SetQuantizationScale(scale);
2522 inputTensorInfo2.SetQuantizationOffset(offset);
2526 ret.
outputExpected = MakeTensor<uint8_t, 3>(outputTensorInfo, std::vector<uint8_t>(
2551 auto input1 = MakeTensor<uint8_t, 3>(inputTensorInfo1, std::vector<uint8_t>(
2569 auto input2 = MakeTensor<uint8_t, 3>(inputTensorInfo2, std::vector<uint8_t>(
2580 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2583 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 };
2587 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2591 std::unique_ptr<ITensorHandle> inputHandle1 =
2592 subTensorsSupported ?
2593 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2596 std::unique_ptr<ITensorHandle> inputHandle2 =
2597 subTensorsSupported ?
2598 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2604 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2605 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2606 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2611 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2613 inputHandle1->Allocate();
2614 inputHandle2->Allocate();
2615 outputHandle->Allocate();
2620 workload->PostAllocationConfigure();
2621 workload->Execute();
2632 boost::ignore_unused(memoryManager);
2634 unsigned int outputWidth = 3;
2635 unsigned int outputHeight = 6;
2636 unsigned int outputChannels = 3;
2638 unsigned int inputWidth1 = 3;
2639 unsigned int inputHeight1 = 6;
2640 unsigned int inputChannels1 = 2;
2642 unsigned int inputWidth2 = 3;
2643 unsigned int inputHeight2 = 6;
2644 unsigned int inputChannels2 = 1;
2652 const float scale = 0.13497836f;
2653 const int32_t offset = -7;
2656 outputTensorInfo.SetQuantizationOffset(offset);
2657 inputTensorInfo1.SetQuantizationScale(scale);
2658 inputTensorInfo1.SetQuantizationOffset(offset);
2659 inputTensorInfo2.SetQuantizationScale(scale);
2660 inputTensorInfo2.SetQuantizationOffset(offset);
2664 ret.
outputExpected = MakeTensor<uint16_t, 3>(outputTensorInfo, std::vector<uint16_t>(
2688 auto input1 = MakeTensor<uint16_t, 3>(inputTensorInfo1, std::vector<uint16_t>(
2705 auto input2 = MakeTensor<uint16_t, 3>(inputTensorInfo2, std::vector<uint16_t>(
2715 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2718 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 };
2722 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2726 std::unique_ptr<ITensorHandle> inputHandle1 =
2727 subTensorsSupported ?
2728 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2731 std::unique_ptr<ITensorHandle> inputHandle2 =
2732 subTensorsSupported ?
2733 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2739 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2740 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2741 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2746 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2748 inputHandle1->Allocate();
2749 inputHandle2->Allocate();
2750 outputHandle->Allocate();
2755 workload->PostAllocationConfigure();
2756 workload->Execute();
2767 return Concat1dTestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2774 return Concat2dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2781 return Concat2dDim1TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2788 return Concat2dDim0DiffInputDimsTestImpl<DataType::QAsymmU8>(
2789 workloadFactory, memoryManager, 0.5f, -1);
2796 return Concat2dDim1DiffInputDimsTestImpl<DataType::QAsymmU8>(
2797 workloadFactory, memoryManager, 0.5f, -1);
2804 return Concat3dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2811 return Concat3dDim1TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2819 return Concat3dDim2TestImpl<DataType::QAsymmU8>(
2820 workloadFactory, memoryManager, useSubtensor, 0.5f, -1);
2827 return Concat3dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2834 return Concat3dDim1DiffInputDimsTestImpl<DataType::QAsymmU8>(
2835 workloadFactory, memoryManager, 0.5f, -1);
2843 return Concat3dDim2DiffInputDimsTestImpl<DataType::QAsymmU8>(
2844 workloadFactory, memoryManager, useSubtensor, 0.5f, -1);
2851 return Concat4dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2858 return Concat4dDim1TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2865 return Concat4dDim2TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2872 return Concat4dDim3TestImpl<DataType::QAsymmU8>(
2873 workloadFactory, memoryManager, 0.5f, -1, useSubtensor);
2880 return Concat4dDiffShapeDim0TestImpl<DataType::QAsymmU8>(
2881 workloadFactory, memoryManager, 0.5f, -1);
2888 return Concat4dDiffShapeDim1TestImpl<DataType::QAsymmU8>(
2889 workloadFactory, memoryManager, 0.5f, -1);
2896 return Concat4dDiffShapeDim2TestImpl<DataType::QAsymmU8>(
2897 workloadFactory, memoryManager, 0.5f, -1);
2905 return Concat4dDiffShapeDim3TestImpl<DataType::QAsymmU8>(
2906 workloadFactory, memoryManager, 0.5f, -1, useSubtensor);
LayerTestResult< T, 4 > Concat4dDim3TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset, bool useSubtensor)
LayerTestResult< uint8_t, 3 > Concat3dDim0Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
OriginsDescriptor CreateDescriptorForConcatenation(TensorShapeIt first, TensorShapeIt last, unsigned int concatenationDimension)
Convenience template to create an OriginsDescriptor to use when creating a ConcatLayer for performing...
LayerTestResult< T, 4 > Concat4dDiffShapeDim3TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset, bool useSubtensor)
LayerTestResult< uint8_t, 3 > Concat3dDim2DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
unsigned int GetNumDimensions() const
bool IsEqual(const PermutationVector &other) const
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
LayerTestResult< uint8_t, 4 > Concat4dDiffShapeDim1Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
OriginsDescriptor CreateDescriptorForConcat(const std::vector< TensorInfo > &inputTensorInfos, unsigned int concatDim)
LayerTestResult< uint16_t, 3 > ConcatUint16Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 2 > Concat2dDim0Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > Concat4dDim3Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< float, 4 > Concat4dDiffShapeDim3Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< float, 4 > Concat4dDim2Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerDescriptor m_Parameters
LayerTestResult< uint8_t, 3 > ConcatUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
virtual std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo, const bool IsMemoryManaged=true) const =0
LayerTestResult< uint8_t, 4 > Concat4dDim0Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 3 > Concat3dDim2DiffInputDimsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< float, 3 > Concat3dDim0DiffInputDimsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
void CopyDataFromITensorHandle(void *memory, const armnn::ITensorHandle *tensorHandle)
LayerTestResult< uint8_t, 2 > Concat2dDim0Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
std::shared_ptr< IMemoryManager > IMemoryManagerSharedPtr
armnn::TensorShape Permuted(const armnn::TensorShape &srcShape, const armnn::PermutationVector &mappings)
boost::multi_array< T, n > output
LayerTestResult< float, 4 > Concat4dDiffShapeDim1Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > Concat4dDiffShapeDim0Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 2 > Concat2dDim0DiffInputDimsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< Half, 3 > ConcatFloat16Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 2 > Concat2dDim0DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 4 > Concat4dDim2TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 2 > Concat2dTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const TensorInfo &outputTensorInfo, unsigned int dimension, const float qScale, const int32_t qOffset)
LayerTestResult< uint8_t, 1 > Concat1dUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > Concat4dDim1Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 3 > Concat3dDim1DiffInputDimsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
std::vector< ViewOrigin > m_ViewOrigins
LayerTestResult< float, 3 > ConcatTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
virtual std::unique_ptr< ITensorHandle > CreateSubTensorHandle(ITensorHandle &parent, TensorShape const &subTensorShape, unsigned int const *subTensorOrigin) const =0
LayerTestResult< T, 3 > ConcatDifferentInputOutputQParamTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
void PermuteOutputForConcat(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const TensorInfo &tensorInfo, const PermutationVector &permuteVector, std::unique_ptr< ITensorHandle > &&inputDataHandle, T *data)
LayerTestResult< float, 3 > Concat3dDim2Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< T, 3 > Concat3dDim0TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
virtual std::unique_ptr< IWorkload > CreateConcat(const ConcatQueueDescriptor &descriptor, const WorkloadInfo &info) const
LayerTestResult< T, 2 > Concat2dDim0TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< uint8_t, 3 > Concat3dDim2Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
const uint32_t * GetViewOrigin(uint32_t idx) const
Return the view origin at the int value idx.
LayerTestResult< T, 3 > Concat3dDim1DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
uint32_t GetNumViews() const
Get the number of views.
LayerTestResult< uint8_t, 2 > Concat2dDim0DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
virtual bool SupportsSubTensors() const =0
LayerTestResult< float, 1 > Concat1dTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 2 > Concat2dDim1DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
uint32_t GetNumDimensions() const
Get the number of dimensions.
void SetQuantizationScale(float scale)
LayerTestResult< uint8_t, 4 > Concat4dDim2Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > Concat4dDiffShapeDim2TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
boost::multi_array< T, n > outputExpected
LayerTestResult< T, 3 > Concat3dDim0DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
void SetShape(const TensorShape &newShape)
LayerTestResult< uint8_t, 2 > Concat2dDim1Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > Concat4dDim1Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > Concat4dDim0Test(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, 4 > Concat4dDim3Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< uint8_t, 4 > Concat4dDiffShapeDim0Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
TensorShape ExpandTensorShapeTo3dForPermute(const TensorShape &inputShape)
LayerTestResult< uint8_t, 3 > Concat3dDim1DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > Concat4dDim0TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 2 > Concat2dDim1TestImpl(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)
bool NeedPermuteForConcat(const std::vector< TensorInfo > &inputTensorInfos, unsigned int concatDim)
LayerTestResult< uint8_t, 3 > Concat3dDim1Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 3 > Concat3dDim0DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 3 > Concat3dDim1Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
virtual std::unique_ptr< IWorkload > CreatePermute(const PermuteQueueDescriptor &descriptor, const WorkloadInfo &info) const
LayerTestResult< T, 3 > Concat3dDim2DiffInputDimsTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor, float qScale, int32_t qOffset)
unsigned int GetNumElements() const
LayerTestResult< T, 4 > Concat4dDiffShapeDim1TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 4 > Concat4dTestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const TensorInfo &outputTensorInfo, unsigned int dimension, bool useSubtensor, float qScale, int32_t qOffset)
LayerTestResult< float, 3 > Concat3dDim0Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 2 > Concat2dDim1DiffInputDimsUint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > Concat4dDim1TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
void PermuteTensorData(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const PermutationVector &mappings, TensorInfo &inputTensorInfo, const T *inputData, std::vector< T > &outputData)
LayerTestResult< uint8_t, 4 > Concat4dDiffShapeDim2Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > Concat4dDiffShapeDim2Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
A PermuteDescriptor for the PermuteLayer.
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)
LayerTestResult< uint8_t, 4 > Concat4dDiffShapeDim3Uint8Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, bool useSubtensor)
LayerTestResult< float, 2 > Concat2dDim1Test(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
const TensorShape & GetShape() const
void Concatenate(const ConcatQueueDescriptor &data)
void Generate3dPermuteVectorForConcat(unsigned int numDimensions, unsigned int &concatDim, std::pair< PermutationVector, PermutationVector > &permutations)
LayerTestResult< T, 3 > Concat3dDim1TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 4 > Concat4dDiffShapeDim0TestImpl(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
An OriginsDescriptor for the ConcatLayer. Descriptor to configure the concatenation process...
LayerTestResult< uint8_t, 3 > ConcatUint8DifferentQParamsTest(IWorkloadFactory &workloadFactory, const IBackendInternal::IMemoryManagerSharedPtr &memoryManager)