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();
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)
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);
127 std::vector<T>& outputData)
131 if (inputData ==
nullptr)
141 std::unique_ptr<ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfo);
142 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
148 AddInputToWorkload(queueDescriptor, workloadInfo, inputTensorInfo, inputHandle.get());
149 AddOutputToWorkload(queueDescriptor, workloadInfo, outputTensorInfo, outputHandle.get());
151 std::unique_ptr<IWorkload> workload = workloadFactory.
CreatePermute(queueDescriptor, workloadInfo);
153 inputHandle->Allocate();
154 outputHandle->Allocate();
158 workload->PostAllocationConfigure();
163 inputTensorInfo = outputTensorInfo;
175 std::vector<TensorInfo> & inputTensorInfos,
176 std::vector<T *> & inputData,
177 std::vector<std::vector<T>> & inputDataStorage,
179 unsigned int & concatDim,
184 "Expecting more than one tensor to be concatenated here");
186 unsigned int numDims = 0;
187 unsigned int nthInput = 0;
190 std::pair<PermutationVector, PermutationVector> permutations =
191 std::make_pair(identity, identity);
193 inputDataStorage.resize(inputData.size());
195 for (
auto && tensorInfo : inputTensorInfos)
199 numDims = tensorInfo.GetShape().GetNumDimensions();
203 permuteVector = permutations.second;
205 "Test logic error, we don't need permutation, so we shouldn't arrive here");
210 "All inputs must have the same number of dimensions");
216 PermuteTensorData<T>(workloadFactory,
221 inputDataStorage[nthInput]);
223 inputData[nthInput] = inputDataStorage[nthInput].data();
224 inputTensorInfos[nthInput] = newTensorInfo;
232 permutations.first));
245 std::unique_ptr<ITensorHandle> && inputDataHandle,
259 std::vector<T> outputData;
263 PermuteTensorData<T>(workloadFactory,
270 ::memcpy(data, &outputData[0],
sizeof(T)*outputData.size());
276 std::initializer_list<const TensorInfo> inputTensorInfosOrig,
277 std::initializer_list<T *> inputsOrig,
280 unsigned int concatDim,
284 if (output ==
nullptr)
293 std::vector<TensorInfo> inputTensorInfos(inputTensorInfosOrig.begin(), inputTensorInfosOrig.end());
294 std::vector<T *> inputs = inputsOrig;
295 TensorInfo outputTensorInfo = outputTensorInfoOrig;
300 std::vector<std::vector<T>> tmpInputDataStorage;
302 const size_t inputCount = inputTensorInfos.size();
306 if (needPermuteForConcat)
312 PermuteInputsForConcat<T>(workloadFactory,
324 std::vector<std::unique_ptr<ITensorHandle>> inputHandles;
325 inputHandles.reserve(inputCount);
327 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
331 queueDescriptor.m_Parameters = viewsDescriptor;
335 queueDescriptor.m_ViewOrigins.reserve(viewsDescriptor.
GetNumViews());
336 for (
unsigned int i = 0; i < viewsDescriptor.
GetNumViews(); ++i)
338 queueDescriptor.m_ViewOrigins.emplace_back(std::vector<unsigned int>(viewsDescriptor.
GetViewOrigin(i),
345 for (
unsigned int i = 0; i < inputCount; ++i)
347 const TensorInfo& inputTensorInfo = inputTensorInfos[i];
349 std::unique_ptr<ITensorHandle> inputHandle =
350 subTensorsSupported ?
353 queueDescriptor.m_ViewOrigins[i].m_Origin.data()) :
356 inputHandles.emplace_back(std::move(inputHandle));
363 for (
unsigned int i = 0; i < inputCount; ++i)
366 std::unique_ptr<ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfos[i]);
368 inputHandles.emplace_back(std::move(inputHandle));
372 for (
unsigned int i = 0; i < inputCount; ++i)
374 AddInputToWorkload(queueDescriptor, workloadInfo, inputTensorInfos[i], inputHandles[i].
get());
377 AddOutputToWorkload(queueDescriptor, workloadInfo, outputTensorInfo, outputHandle.get());
379 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(queueDescriptor, workloadInfo);
381 for (
auto& inputHandle : inputHandles)
383 inputHandle->Allocate();
386 outputHandle->Allocate();
388 unsigned int nextInputId = 0;
389 for (
auto& inputHandle : inputHandles)
395 workload->PostAllocationConfigure();
398 if (needPermuteForConcat)
400 PermuteOutputForConcat<T>(workloadFactory,
404 std::move(outputHandle),
417 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
424 TensorInfo inputTensorInfo({ 3 }, ArmnnType, qScale, qOffset);
426 auto input0 = MakeTensor<T, 1>(inputTensorInfo, QuantizedVector<T>({ 1.0f, 2.0f, 3.0f }, qScale, qOffset));
427 auto input1 = MakeTensor<T, 1>(inputTensorInfo, QuantizedVector<T>({ 4.0f, 5.0f, 6.0f }, qScale, qOffset));
428 auto input2 = MakeTensor<T, 1>(inputTensorInfo, QuantizedVector<T>({ 7.0f, 8.0f, 9.0f }, qScale, qOffset));
430 TensorInfo outputTensorInfo({ 9 }, ArmnnType, qScale, qOffset);
434 std::vector<T> output;
435 output.resize(outputTensorInfo.GetNumElements());
436 Concatenate<T>(workloadFactory, memoryManager,
437 { inputTensorInfo, inputTensorInfo, inputTensorInfo },
438 { input0.data(), input1.data(), input2.data() },
444 result.output = MakeTensor<T, 1>(outputTensorInfo, output);
445 result.outputExpected = MakeTensor<T, 1>(outputTensorInfo, QuantizedVector<T>(
447 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f
454 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
459 unsigned int dimension,
461 const int32_t qOffset)
463 TensorInfo inputTensorInfo({ 2, 3 }, ArmnnType, qScale, qOffset);
465 auto input0 = MakeTensor<T, 2>(inputTensorInfo, QuantizedVector<T>(
475 auto input1 = MakeTensor<T, 2>(inputTensorInfo, QuantizedVector<T>(
485 auto input2 = MakeTensor<T, 2>(inputTensorInfo, QuantizedVector<T>(
497 std::vector<T> output;
499 Concatenate<T>(workloadFactory, memoryManager,
500 { inputTensorInfo, inputTensorInfo, inputTensorInfo },
501 { input0.data(), input1.data(), input2.data() },
507 result.
output = MakeTensor<T, 2>(outputTensorInfo, output);
511 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
518 TensorInfo outputTensorInfo({ 6, 3 }, ArmnnType, qScale, qOffset);
521 workloadFactory, memoryManager, outputTensorInfo, 0, qScale, qOffset);
523 result.
outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(
548 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
555 TensorInfo outputTensorInfo({ 2, 9 }, ArmnnType, qScale, qOffset);
558 workloadFactory, memoryManager, outputTensorInfo, 1, qScale, qOffset);
560 result.
outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(
563 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
566 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f
573 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
580 TensorInfo input0TensorInfo({ 2, 3 }, ArmnnType, qScale, qOffset);
581 auto input0 = MakeTensor<T, 2>(input0TensorInfo, QuantizedVector<T>(
591 TensorInfo input1TensorInfo({ 3, 3 }, ArmnnType, qScale, qOffset);
592 auto input1 = MakeTensor<T, 2>(input1TensorInfo, QuantizedVector<T>(
605 TensorInfo input2TensorInfo({ 1, 3 }, ArmnnType, qScale, qOffset);
606 auto input2 = MakeTensor<T, 2>(input2TensorInfo, QuantizedVector<T>(
613 TensorInfo outputTensorInfo({ 6, 3 }, ArmnnType, qScale, qOffset);
616 std::vector<T> output;
617 output.resize(outputTensorInfo.GetNumElements());
618 Concatenate<T>(workloadFactory, memoryManager,
619 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
620 { input0.data(), input1.data(), input2.data() },
626 result.output = MakeTensor<T, 2>(outputTensorInfo, output);
627 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(
652 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
659 TensorInfo input0TensorInfo({ 2, 3 }, ArmnnType, qScale, qOffset);
660 auto input0 = MakeTensor<T, 2>(input0TensorInfo, QuantizedVector<T>(
670 TensorInfo input1TensorInfo({ 2, 5 }, ArmnnType, qScale, qOffset);
671 auto input1 = MakeTensor<T, 2>(input1TensorInfo, QuantizedVector<T>(
674 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
677 13.0f, 14.0f, 15.0f, 16.0f, 17.0f,
681 TensorInfo input2TensorInfo({ 2, 1 }, ArmnnType, qScale, qOffset);
682 auto input2 = MakeTensor<T, 2>(input2TensorInfo, QuantizedVector<T>(
692 TensorInfo outputTensorInfo({ 2, 9 }, ArmnnType, qScale, qOffset);
695 std::vector<T> output;
696 output.resize(outputTensorInfo.GetNumElements());
697 Concatenate<T>(workloadFactory, memoryManager,
698 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
699 { input0.data(), input1.data(), input2.data() },
705 result.output = MakeTensor<T, 2>(outputTensorInfo, output);
706 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(
709 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
712 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f,
719 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
724 unsigned int dimension,
729 TensorInfo inputTensorInfo({ 2, 3, 2 }, ArmnnType, qScale, qOffset);
731 auto input0 = MakeTensor<T, 3>(inputTensorInfo, QuantizedVector<T>(
753 auto input1 = MakeTensor<T, 3>(inputTensorInfo, QuantizedVector<T>(
775 auto input2 = MakeTensor<T, 3>(inputTensorInfo, QuantizedVector<T>(
799 std::vector<T> output;
801 Concatenate<T>(workloadFactory, memoryManager,
802 { inputTensorInfo, inputTensorInfo, inputTensorInfo },
803 { input0.data(), input1.data(), input2.data() },
809 result.
output = MakeTensor<T, 3>(outputTensorInfo, output);
813 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
820 TensorInfo outputTensorInfo({ 6, 3, 2 }, ArmnnType, qScale, qOffset);
823 workloadFactory, memoryManager, outputTensorInfo, 0,
true, qScale, qOffset);
825 result.
outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
886 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
893 TensorInfo outputTensorInfo({ 2, 9, 2 }, ArmnnType, qScale, qOffset);
896 workloadFactory, memoryManager, outputTensorInfo, 1,
true, qScale, qOffset);
898 result.
outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
959 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
967 TensorInfo outputTensorInfo({ 2, 3, 6 }, ArmnnType, qScale, qOffset);
970 workloadFactory, memoryManager, outputTensorInfo, 2, useSubtensor, qScale, qOffset);
972 result.
outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
975 1.0f, 2.0f, 7.0f, 8.0f, 13.0f, 14.0f,
978 3.0f, 4.0f, 9.0f, 10.0f, 15.0f, 16.0f,
981 5.0f, 6.0f, 11.0f, 12.0f, 17.0f, 18.0f,
984 19.0f, 20.0f, 25.0f, 26.0f, 31.0f, 32.0f,
987 21.0f, 22.0f, 27.0f, 28.0f, 33.0f, 34.0f,
990 23.0f, 24.0f, 29.0f, 30.0f, 35.0f, 36.0f,
997 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1004 TensorInfo input0TensorInfo({ 2, 3, 2 }, ArmnnType);
1005 auto input0 = MakeTensor<T, 3>(input0TensorInfo, QuantizedVector<T>(
1027 TensorInfo input1TensorInfo({ 1, 3, 2 }, ArmnnType);
1028 auto input1 = MakeTensor<T, 3>(input1TensorInfo, QuantizedVector<T>(
1041 TensorInfo input2TensorInfo({ 3, 3, 2 }, ArmnnType);
1042 auto input2 = MakeTensor<T, 3>(input2TensorInfo, QuantizedVector<T>(
1073 TensorInfo outputTensorInfo({ 6, 3, 2 }, ArmnnType);
1076 std::vector<T> output;
1077 output.resize(outputTensorInfo.GetNumElements());
1078 Concatenate<T>(workloadFactory, memoryManager,
1079 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
1080 { input0.data(), input1.data(), input2.data() },
1086 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
1087 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
1148 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1155 TensorInfo input0TensorInfo({ 2, 3, 2 }, ArmnnType, qScale, qOffset);
1156 auto input0 = MakeTensor<T, 3>(input0TensorInfo, QuantizedVector<T>(
1178 TensorInfo input1TensorInfo({ 2, 4, 2 }, ArmnnType, qScale, qOffset);
1179 auto input1 = MakeTensor<T, 3>(input1TensorInfo, QuantizedVector<T>(
1207 TensorInfo input2TensorInfo({ 2, 1, 2 }, ArmnnType, qScale, qOffset);
1208 auto input2 = MakeTensor<T, 3>(input2TensorInfo, QuantizedVector<T>(
1218 TensorInfo outputTensorInfo({ 2, 8, 2 }, ArmnnType, qScale, qOffset);
1221 std::vector<T> output;
1222 output.resize(outputTensorInfo.GetNumElements());
1223 Concatenate<T>(workloadFactory, memoryManager,
1224 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
1225 { input0.data(), input1.data(), input2.data() },
1231 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
1232 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
1287 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1295 TensorInfo input0TensorInfo({ 2, 3, 2 }, ArmnnType, qScale, qOffset);
1296 auto input0 = MakeTensor<T, 3>(input0TensorInfo, QuantizedVector<T>(
1318 TensorInfo input1TensorInfo({ 2, 3, 1 }, ArmnnType, qScale, qOffset);
1319 auto input1 = MakeTensor<T, 3>(input1TensorInfo, QuantizedVector<T>(
1341 TensorInfo input2TensorInfo({ 2, 3, 3 }, ArmnnType, qScale, qOffset);
1342 auto input2 = MakeTensor<T, 3>(input2TensorInfo, QuantizedVector<T>(
1345 13.0f, 14.0f, 50.0f,
1348 15.0f, 16.0f, 51.0f,
1351 17.0f, 18.0f, 52.0f,
1354 31.0f, 32.0f, 53.0f,
1357 33.0f, 34.0f, 54.0f,
1360 35.0f, 36.0f, 55.0f,
1364 TensorInfo outputTensorInfo({ 2, 3, 6 }, ArmnnType, qScale, qOffset);
1367 std::vector<T> output;
1368 output.resize(outputTensorInfo.GetNumElements());
1369 Concatenate<T>(workloadFactory, memoryManager,
1370 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
1371 { input0.data(), input1.data(), input2.data() },
1377 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
1378 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(
1381 1.0f, 2.0f, 7.0f, 13.0f, 14.0f, 50.0f,
1384 3.0f, 4.0f, 9.0f, 15.0f, 16.0f, 51.0f,
1387 5.0f, 6.0f, 11.0f, 17.0f, 18.0f, 52.0f,
1390 19.0f, 20.0f, 25.0f, 31.0f, 32.0f, 53.0f,
1393 21.0f, 22.0f, 27.0f, 33.0f, 34.0f, 54.0f,
1396 23.0f, 24.0f, 29.0f, 35.0f, 36.0f, 55.0f,
1403 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1408 unsigned int dimension,
1413 TensorInfo inputTensorInfo({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1415 auto input0 = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(
1426 auto input1 = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(
1437 auto input2 = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(
1450 std::vector<T> output;
1453 Concatenate<T>(workloadFactory,
1455 {inputTensorInfo, inputTensorInfo, inputTensorInfo},
1456 {input0.data(), input1.data(), input2.data()},
1462 result.
output = MakeTensor<T, 4>(outputTensorInfo, output);
1466 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1473 TensorInfo outputTensorInfo({ 3, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1476 workloadFactory, memoryManager, outputTensorInfo, 0,
true, qScale, qOffset);
1478 result.
outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1506 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1513 TensorInfo outputTensorInfo({ 1, 9, 2, 2 }, ArmnnType, qScale, qOffset);
1516 workloadFactory, memoryManager, outputTensorInfo, 1,
true, qScale, qOffset);
1518 result.
outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1546 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1553 TensorInfo outputTensorInfo({ 1, 3, 6, 2 }, ArmnnType, qScale, qOffset);
1556 workloadFactory, memoryManager, outputTensorInfo, 2,
true, qScale, qOffset);
1558 result.
outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1586 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1594 TensorInfo outputTensorInfo({ 1, 3, 2, 6 }, ArmnnType, qScale, qOffset);
1597 workloadFactory, memoryManager, outputTensorInfo, 3, useSubtensor, qScale, qOffset);
1599 result.
outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1627 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1634 constexpr
unsigned int dimension = 0u;
1636 TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1637 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(
1648 TensorInfo inputTensorInfo1({ 2, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1650 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(
1668 TensorInfo outputTensorInfo({ 3, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1672 std::vector<T> output;
1673 output.resize(outputTensorInfo.GetNumElements());
1674 Concatenate<T>(workloadFactory,
1676 {inputTensorInfo0, inputTensorInfo1},
1677 {input0.data(), input1.data()},
1683 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
1684 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1712 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1719 constexpr
unsigned int dimension = 1u;
1721 TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1722 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(
1733 TensorInfo inputTensorInfo1({ 1, 2, 2, 2 }, ArmnnType, qScale, qOffset);
1735 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(
1744 TensorInfo outputTensorInfo({ 1, 5, 2, 2 }, ArmnnType, qScale, qOffset);
1748 std::vector<T> output;
1749 output.resize(outputTensorInfo.GetNumElements());
1750 Concatenate<T>(workloadFactory,
1752 {inputTensorInfo0, inputTensorInfo1},
1753 {input0.data(), input1.data()},
1759 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
1760 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1778 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1785 constexpr
unsigned int dimension = 2u;
1787 TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1788 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(
1799 TensorInfo inputTensorInfo1({ 1, 3, 3, 2 }, ArmnnType, qScale, qOffset);
1800 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(
1814 TensorInfo outputTensorInfo({ 1, 3, 5, 2 }, ArmnnType, qScale, qOffset);
1817 std::vector<T> output;
1818 output.resize(outputTensorInfo.GetNumElements());
1819 Concatenate<T>(workloadFactory,
1821 {inputTensorInfo0, inputTensorInfo1},
1822 {input0.data(), input1.data()},
1828 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
1829 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1854 template<DataType ArmnnType,
typename T = ResolveType<ArmnnType>>
1862 constexpr
unsigned int dimension = 3u;
1864 TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
1865 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(
1876 TensorInfo inputTensorInfo1({ 1, 3, 2, 3 }, ArmnnType, qScale, qOffset);
1877 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(
1879 11.0f, 12.0f, 13.0f,
1880 14.0f, 15.0f, 16.0f,
1882 17.0f, 18.0f, 19.0f,
1883 20.0f, 21.0f, 22.0f,
1885 23.0f, 24.0f, 25.0f,
1890 TensorInfo outputTensorInfo({ 1, 3, 2, 5 }, ArmnnType, qScale, qOffset);
1894 std::vector<T> output;
1895 output.resize(outputTensorInfo.GetNumElements());
1896 Concatenate<T>(workloadFactory,
1898 {inputTensorInfo0, inputTensorInfo1},
1899 {input0.data(), input1.data()},
1905 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
1906 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
1908 1.0f, 2.0f, 11.0f, 12.0f, 13.0f,
1909 3.0f, 4.0f, 14.0f, 15.0f, 16.0f,
1910 5.0f, 6.0f, 17.0f, 18.0f, 19.0f,
1911 7.0f, 8.0f, 20.0f, 21.0f, 22.0f,
1912 9.0f, 10.0f, 23.0f, 24.0f, 25.0f,
1913 11.0f, 12.0f, 26.0f, 27.0f, 28.0f
1920 template<DataType ArmnnType,
typename T>
1929 TensorInfo outputTensorInfo({ 3, 6, 3 }, ArmnnType);
1930 TensorInfo inputTensorInfo1({ 3, 6, 2 }, ArmnnType);
1931 TensorInfo inputTensorInfo2({ 3, 6, 1 }, ArmnnType);
1933 std::vector<TensorShape> inputTensorShapes({inputTensorInfo1.GetShape(), inputTensorInfo2.GetShape()});
1936 const float inputScale1 = 0.5f;
1937 const int32_t inputOffset1 = 5;
1939 auto input1 = MakeTensor<T, 3>(inputTensorInfo1, std::vector<T>(
1957 const float inputScale2 = 0.2f;
1958 const int32_t inputOffset2 = 10;
1960 auto input2 = MakeTensor<T, 3>(inputTensorInfo2, std::vector<T>(
1971 const float outputScale = 0.1f;
1972 const int32_t outputOffset = 20;
1976 ret.
outputExpected = MakeTensor<T, 3>(outputTensorInfo, std::vector<T>(
2000 outputTensorInfo.SetQuantizationScale(outputScale);
2001 outputTensorInfo.SetQuantizationOffset(outputOffset);
2002 inputTensorInfo1.SetQuantizationScale(inputScale1);
2003 inputTensorInfo1.SetQuantizationOffset(inputOffset1);
2004 inputTensorInfo2.SetQuantizationScale(inputScale2);
2005 inputTensorInfo2.SetQuantizationOffset(inputOffset2);
2007 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2010 std::vector<unsigned int> wOrigin2 = { 0, 0, 2 };
2013 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2017 std::unique_ptr<ITensorHandle> inputHandle1 =
2018 subTensorsSupported ?
2019 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2022 std::unique_ptr<ITensorHandle> inputHandle2 =
2023 subTensorsSupported ?
2024 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2029 inputTensorShapes.begin(),inputTensorShapes.end(), 2);
2030 data.m_Parameters = desc;
2033 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2034 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2035 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2037 data.m_ViewOrigins.push_back(window1);
2038 data.m_ViewOrigins.push_back(window2);
2040 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2042 inputHandle1->Allocate();
2043 inputHandle2->Allocate();
2044 outputHandle->Allocate();
2049 workload->PostAllocationConfigure();
2050 workload->Execute();
2062 ConcatDifferentInputOutputQParamTest<DataType::QAsymmU8>(
2068 ConcatDifferentInputOutputQParamTest<DataType::QSymmS16>(
2083 unsigned int outputWidth = 3;
2084 unsigned int outputHeight = 6;
2085 unsigned int outputChannels = 3;
2087 unsigned int inputWidth1 = 3;
2088 unsigned int inputHeight1 = 6;
2089 unsigned int inputChannels1 = 2;
2091 unsigned int inputWidth2 = 3;
2092 unsigned int inputHeight2 = 6;
2093 unsigned int inputChannels2 = 1;
2102 ret.outputExpected = MakeTensor<float, 3>(outputTensorInfo, std::vector<float>(
2107 10.0f, 11.0f, 12.0f,
2108 13.0f, 14.0f, 15.0f,
2109 16.0f, 17.0f, 18.0f,
2111 19.0f, 20.0f, 21.0f,
2112 22.0f, 23.0f, 24.0f,
2113 25.0f, 26.0f, 27.0f,
2114 28.0f, 29.0f, 30.0f,
2115 31.0f, 32.0f, 33.0f,
2116 34.0f, 35.0f, 36.0f,
2118 37.0f, 38.0f, 39.0f,
2119 40.0f, 41.0f, 42.0f,
2120 43.0f, 44.0f, 45.0f,
2121 46.0f, 47.0f, 48.0f,
2122 49.0f, 50.0f, 51.0f,
2123 52.0f, 53.0f, 54.0f,
2127 auto input1 = MakeTensor<float, 3>(inputTensorInfo1, std::vector<float>(
2132 10.0f, 11.0f, 12.0f,
2133 13.0f, 14.0f, 15.0f,
2134 16.0f, 17.0f, 18.0f,
2136 19.0f, 20.0f, 21.0f,
2137 22.0f, 23.0f, 24.0f,
2138 25.0f, 26.0f, 27.0f,
2139 28.0f, 29.0f, 30.0f,
2140 31.0f, 32.0f, 33.0f,
2141 34.0f, 35.0f, 36.0f,
2145 auto input2 = MakeTensor<float, 3>(inputTensorInfo2, std::vector<float>(
2147 37.0f, 38.0f, 39.0f,
2148 40.0f, 41.0f, 42.0f,
2149 43.0f, 44.0f, 45.0f,
2150 46.0f, 47.0f, 48.0f,
2151 49.0f, 50.0f, 51.0f,
2152 52.0f, 53.0f, 54.0f,
2156 std::vector<unsigned int> wOrigin1 = {0, 0, 0};
2159 std::vector<unsigned int> wOrigin2 = {2, 0, 0};
2162 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2166 std::unique_ptr<ITensorHandle> inputHandle1 =
2167 subTensorsSupported ?
2168 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2171 std::unique_ptr<ITensorHandle> inputHandle2 =
2172 subTensorsSupported ?
2173 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2178 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2179 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2180 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2182 data.m_ViewOrigins.push_back(window1);
2183 data.m_ViewOrigins.push_back(window2);
2185 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2187 inputHandle1->Allocate();
2188 inputHandle2->Allocate();
2189 outputHandle->Allocate();
2194 workload->PostAllocationConfigure();
2195 workload->Execute();
2206 return Concat1dTestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2213 return Concat2dDim0TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2220 return Concat2dDim1TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2227 return Concat2dDim0DiffInputDimsTestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2234 return Concat2dDim1DiffInputDimsTestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2241 return Concat3dDim0TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2248 return Concat3dDim1TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2256 return Concat3dDim2TestImpl<DataType::Float32>(workloadFactory, memoryManager, useSubtensor, 0.0f, 0);
2263 return Concat3dDim0DiffInputDimsTestImpl<DataType::Float32>(
2264 workloadFactory, memoryManager, 0.0f, 0);
2271 return Concat3dDim1DiffInputDimsTestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2279 return Concat3dDim2DiffInputDimsTestImpl<DataType::Float32>(
2280 workloadFactory, memoryManager, useSubtensor, 0.0f, 0);
2287 return Concat4dDim0TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2294 return Concat4dDim1TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2301 return Concat4dDim2TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2309 return Concat4dDim3TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0, useSubtensor);
2316 return Concat4dDiffShapeDim0TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2323 return Concat4dDiffShapeDim1TestImpl<DataType::Float32>(
2324 workloadFactory, memoryManager, 0.0f, 0);
2331 return Concat4dDiffShapeDim2TestImpl<DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2339 return Concat4dDiffShapeDim3TestImpl<DataType::Float32>(
2340 workloadFactory, memoryManager, 0.0f, 0, useSubtensor);
2347 return Concat3dDim1TestImpl<DataType::Float16>(workloadFactory, memoryManager, 0.0f, 0);
2354 return Concat3dDim1TestImpl<DataType::BFloat16>(workloadFactory, memoryManager, 0.0f, 0);
2363 unsigned int outputWidth = 3;
2364 unsigned int outputHeight = 6;
2365 unsigned int outputChannels = 3;
2367 unsigned int inputWidth1 = 3;
2368 unsigned int inputHeight1 = 6;
2369 unsigned int inputChannels1 = 2;
2371 unsigned int inputWidth2 = 3;
2372 unsigned int inputHeight2 = 6;
2373 unsigned int inputChannels2 = 1;
2381 const float inputScale1 = 0.015686f;
2382 const int32_t inputOffset1 = 192;
2384 auto input1 = MakeTensor<uint8_t, 3>(inputTensorInfo1, std::vector<uint8_t>(
2403 const float inputScale2 = 0.019608f;
2404 const int32_t inputOffset2 = 50;
2406 auto input2 = MakeTensor<uint8_t, 3>(inputTensorInfo2, std::vector<uint8_t>(
2419 const float outputScale = 0.015686f;
2420 const int32_t outputOffset = 192;
2424 ret.
outputExpected = MakeTensor<uint8_t, 3>(outputTensorInfo, std::vector<uint8_t>(
2449 outputTensorInfo.SetQuantizationScale(outputScale);
2450 outputTensorInfo.SetQuantizationOffset(outputOffset);
2451 inputTensorInfo1.SetQuantizationScale(inputScale1);
2452 inputTensorInfo1.SetQuantizationOffset(inputOffset1);
2453 inputTensorInfo2.SetQuantizationScale(inputScale2);
2454 inputTensorInfo2.SetQuantizationOffset(inputOffset2);
2456 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2459 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 };
2462 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2466 std::unique_ptr<ITensorHandle> inputHandle1 =
2467 subTensorsSupported ?
2468 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2471 std::unique_ptr<ITensorHandle> inputHandle2 =
2472 subTensorsSupported ?
2473 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2478 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2479 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2480 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2482 data.m_ViewOrigins.push_back(window1);
2483 data.m_ViewOrigins.push_back(window2);
2485 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2487 inputHandle1->Allocate();
2488 inputHandle2->Allocate();
2489 outputHandle->Allocate();
2494 workload->PostAllocationConfigure();
2495 workload->Execute();
2508 unsigned int outputWidth = 3;
2509 unsigned int outputHeight = 6;
2510 unsigned int outputChannels = 3;
2512 unsigned int inputWidth1 = 3;
2513 unsigned int inputHeight1 = 6;
2514 unsigned int inputChannels1 = 2;
2516 unsigned int inputWidth2 = 3;
2517 unsigned int inputHeight2 = 6;
2518 unsigned int inputChannels2 = 1;
2526 const float scale = 0.13497836f;
2527 const int32_t offset = -7;
2530 outputTensorInfo.SetQuantizationOffset(offset);
2531 inputTensorInfo1.SetQuantizationScale(scale);
2532 inputTensorInfo1.SetQuantizationOffset(offset);
2533 inputTensorInfo2.SetQuantizationScale(scale);
2534 inputTensorInfo2.SetQuantizationOffset(offset);
2538 ret.
outputExpected = MakeTensor<uint8_t, 3>(outputTensorInfo, std::vector<uint8_t>(
2563 auto input1 = MakeTensor<uint8_t, 3>(inputTensorInfo1, std::vector<uint8_t>(
2581 auto input2 = MakeTensor<uint8_t, 3>(inputTensorInfo2, std::vector<uint8_t>(
2592 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2595 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 };
2599 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2603 std::unique_ptr<ITensorHandle> inputHandle1 =
2604 subTensorsSupported ?
2605 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2608 std::unique_ptr<ITensorHandle> inputHandle2 =
2609 subTensorsSupported ?
2610 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2616 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2617 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2618 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2620 data.m_ViewOrigins.push_back(window1);
2621 data.m_ViewOrigins.push_back(window2);
2623 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2625 inputHandle1->Allocate();
2626 inputHandle2->Allocate();
2627 outputHandle->Allocate();
2632 workload->PostAllocationConfigure();
2633 workload->Execute();
2646 unsigned int outputWidth = 3;
2647 unsigned int outputHeight = 6;
2648 unsigned int outputChannels = 3;
2650 unsigned int inputWidth1 = 3;
2651 unsigned int inputHeight1 = 6;
2652 unsigned int inputChannels1 = 2;
2654 unsigned int inputWidth2 = 3;
2655 unsigned int inputHeight2 = 6;
2656 unsigned int inputChannels2 = 1;
2664 const float scale = 0.13497836f;
2665 const int32_t offset = -7;
2668 outputTensorInfo.SetQuantizationOffset(offset);
2669 inputTensorInfo1.SetQuantizationScale(scale);
2670 inputTensorInfo1.SetQuantizationOffset(offset);
2671 inputTensorInfo2.SetQuantizationScale(scale);
2672 inputTensorInfo2.SetQuantizationOffset(offset);
2676 ret.
outputExpected = MakeTensor<uint16_t, 3>(outputTensorInfo, std::vector<uint16_t>(
2700 auto input1 = MakeTensor<uint16_t, 3>(inputTensorInfo1, std::vector<uint16_t>(
2717 auto input2 = MakeTensor<uint16_t, 3>(inputTensorInfo2, std::vector<uint16_t>(
2727 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 };
2730 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 };
2734 std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
2738 std::unique_ptr<ITensorHandle> inputHandle1 =
2739 subTensorsSupported ?
2740 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2743 std::unique_ptr<ITensorHandle> inputHandle2 =
2744 subTensorsSupported ?
2745 workloadFactory.
CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2751 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2752 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2753 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2755 data.m_ViewOrigins.push_back(window1);
2756 data.m_ViewOrigins.push_back(window2);
2758 std::unique_ptr<IWorkload> workload = workloadFactory.
CreateConcat(data, info);
2760 inputHandle1->Allocate();
2761 inputHandle2->Allocate();
2762 outputHandle->Allocate();
2767 workload->PostAllocationConfigure();
2768 workload->Execute();
2779 return Concat1dTestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2786 return Concat2dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2793 return Concat2dDim1TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2800 return Concat2dDim0DiffInputDimsTestImpl<DataType::QAsymmU8>(
2801 workloadFactory, memoryManager, 0.5f, -1);
2808 return Concat2dDim1DiffInputDimsTestImpl<DataType::QAsymmU8>(
2809 workloadFactory, memoryManager, 0.5f, -1);
2816 return Concat3dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2823 return Concat3dDim1TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2831 return Concat3dDim2TestImpl<DataType::QAsymmU8>(
2832 workloadFactory, memoryManager, useSubtensor, 0.5f, -1);
2839 return Concat3dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2846 return Concat3dDim1DiffInputDimsTestImpl<DataType::QAsymmU8>(
2847 workloadFactory, memoryManager, 0.5f, -1);
2855 return Concat3dDim2DiffInputDimsTestImpl<DataType::QAsymmU8>(
2856 workloadFactory, memoryManager, useSubtensor, 0.5f, -1);
2863 return Concat4dDim0TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2870 return Concat4dDim1TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2877 return Concat4dDim2TestImpl<DataType::QAsymmU8>(workloadFactory, memoryManager, 0.5f, -1);
2884 return Concat4dDim3TestImpl<DataType::QAsymmU8>(
2885 workloadFactory, memoryManager, 0.5f, -1, useSubtensor);
2892 return Concat4dDiffShapeDim0TestImpl<DataType::QAsymmU8>(
2893 workloadFactory, memoryManager, 0.5f, -1);
2900 return Concat4dDiffShapeDim1TestImpl<DataType::QAsymmU8>(
2901 workloadFactory, memoryManager, 0.5f, -1);
2908 return Concat4dDiffShapeDim2TestImpl<DataType::QAsymmU8>(
2909 workloadFactory, memoryManager, 0.5f, -1);
2917 return Concat4dDiffShapeDim3TestImpl<DataType::QAsymmU8>(
2918 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)
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
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)
#define ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_ASSERT_MSG(COND, MSG)
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)
#define ARMNN_ASSERT(COND)
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
Function that returns the tensor rank.
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)