13 #include <boost/test/unit_test.hpp> 20 template<
typename armnn::DataType DataType>
21 INetworkPtr CreateSplitterNetwork(
const TensorShape& inputShape,
22 const std::vector<TensorShape>& outputShapes,
23 unsigned int splitAxis,
24 unsigned int numSplit,
25 const float qScale = 1.0f,
26 const int32_t qOffset = 0)
28 using namespace armnn;
34 std::vector<unsigned int> splitterDimSizes(inputShape.GetNumDimensions());
37 for (
unsigned int i = 0; i < inputShape.GetNumDimensions(); ++i)
39 splitterDimSizes[i] = inputTensorInfo.GetShape()[i];
42 if (splitterDimSizes[splitAxis] % numSplit != 0)
44 throw ParseException(
"Number of splits must evenly divide the dimension");
46 splitterDimSizes[splitAxis] /= numSplit;
49 for (
unsigned int g = 0; g < numSplit; ++g)
52 for (
unsigned int dimIdx = 0; dimIdx < splitterDimSizes.size(); ++dimIdx)
54 splitDesc.
SetViewSize(g, dimIdx, splitterDimSizes[dimIdx]);
56 splitDesc.SetViewOriginCoord(g, splitAxis, splitterDimSizes[splitAxis] * g);
61 Connect(input, splitter, inputTensorInfo, 0, 0);
63 for (
unsigned int i = 0; i < outputShapes.size(); ++i)
66 IConnectableLayer* output = net->AddOutputLayer(boost::numeric_cast<LayerBindingId>(i));
67 Connect(splitter, output, outputTensorInfo, i, 0);
73 template<armnn::DataType ArmnnType>
74 void Splitter1dEndToEnd(
const std::vector<BackendId>& backends)
76 using namespace armnn;
79 unsigned int splitAxis = 0;
80 unsigned int numSplit = 2;
82 const std::vector<TensorShape> outputShapes{{ 2 }, { 2 }};
85 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
87 BOOST_TEST_CHECKPOINT(
"create a network");
90 std::vector<T> inputData{ 1, 2, 3, 4 };
92 std::vector<T> expectedOutput0{ 1, 2 };
93 std::vector<T> expectedOutput1{ 3, 4 };
95 std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
96 std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 }, {1, expectedOutput1} };
98 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
101 template<armnn::DataType ArmnnType>
102 void Splitter2dDim0EndToEnd(
const std::vector<BackendId>& backends)
104 using namespace armnn;
107 unsigned int splitAxis = 0;
108 unsigned int numSplit = 2;
110 const std::vector<TensorShape> outputShapes{{ 2, 3 }, { 2, 3 }};
113 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
115 BOOST_TEST_CHECKPOINT(
"create a network");
118 std::vector<T> inputData{
127 std::vector<T> expectedOutput0{ 1, 2, 3, 4, 5, 6 };
128 std::vector<T> expectedOutput1{ 7, 8, 9, 10, 11, 12 };
130 std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
131 std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 }, {1, expectedOutput1} };
133 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
136 template<armnn::DataType ArmnnType>
137 void Splitter2dDim1EndToEnd(
const std::vector<BackendId>& backends)
139 using namespace armnn;
142 unsigned int splitAxis = 1;
143 unsigned int numSplit = 3;
145 const std::vector<TensorShape> outputShapes{{ 4, 1 }, { 4, 1 }, { 4, 1 }};
148 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
150 BOOST_TEST_CHECKPOINT(
"create a network");
153 std::vector<T> inputData{
162 std::vector<T> expectedOutput0{ 1, 4, 7, 10 };
163 std::vector<T> expectedOutput1{ 2, 5, 8, 11 };
164 std::vector<T> expectedOutput2{ 3, 6, 9, 12 };
166 std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
167 std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 },
168 { 1, expectedOutput1 },
169 { 2, expectedOutput2 } };
171 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
174 template<armnn::DataType ArmnnType>
175 void Splitter3dDim0EndToEnd(
const std::vector<BackendId>& backends)
177 using namespace armnn;
180 unsigned int splitAxis = 0;
181 unsigned int numSplit = 2;
183 const std::vector<TensorShape> outputShapes{{ 1, 4, 3 }, { 1, 4, 3 }};
186 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
188 BOOST_TEST_CHECKPOINT(
"create a network");
191 std::vector<T> inputData{
202 std::vector<T> expectedOutput0{
208 std::vector<T> expectedOutput1{
215 std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
216 std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 },
217 { 1, expectedOutput1 } };
219 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
222 template<armnn::DataType ArmnnType>
223 void Splitter3dDim1EndToEnd(
const std::vector<BackendId>& backends)
225 using namespace armnn;
228 unsigned int splitAxis = 1;
229 unsigned int numSplit = 2;
231 const std::vector<TensorShape> outputShapes{{ 2, 2, 3 }, { 2, 2, 3 }};
234 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
236 BOOST_TEST_CHECKPOINT(
"create a network");
239 std::vector<T> inputData{
250 std::vector<T> expectedOutput0{
256 std::vector<T> expectedOutput1{
263 std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
264 std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 },
265 { 1, expectedOutput1 } };
267 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
270 template<armnn::DataType ArmnnType>
271 void Splitter3dDim2EndToEnd(
const std::vector<BackendId>& backends)
273 using namespace armnn;
276 unsigned int splitAxis = 2;
277 unsigned int numSplit = 3;
279 const std::vector<TensorShape> outputShapes{{ 2, 4, 1 }, { 2, 4, 1 }, { 2, 4, 1 }};
282 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
284 BOOST_TEST_CHECKPOINT(
"create a network");
287 std::vector<T> inputData{
298 std::vector<T> expectedOutput0{ 1, 4, 7, 10, 13, 16, 19, 22 };
299 std::vector<T> expectedOutput1{ 2, 5, 8, 11, 14, 17, 20, 23 };
300 std::vector<T> expectedOutput2{ 3, 6, 9, 12, 15, 18, 21, 24 };
302 std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
303 std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 },
304 { 1, expectedOutput1 },
305 { 2, expectedOutput2 } };
307 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
310 template<armnn::DataType ArmnnType>
311 void Splitter4dDim0EndToEnd(
const std::vector<BackendId>& backends)
313 using namespace armnn;
316 unsigned int splitAxis = 0;
317 unsigned int numSplit = 2;
319 const std::vector<TensorShape> outputShapes{{ 2, 3, 2, 2 }, { 2, 3, 2, 2 }};
322 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
324 BOOST_TEST_CHECKPOINT(
"create a network");
327 std::vector<T> inputData{
354 std::vector<T> expectedOutput0{
369 std::vector<T> expectedOutput1{
384 std::map<int, std::vector<T>> inputTensorData = {{ 0,inputData }};
385 std::map<int, std::vector<T>> expectedOutputData = {{ 0, expectedOutput0 }, { 1, expectedOutput1 }};
387 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
390 template<armnn::DataType ArmnnType>
391 void Splitter4dDim1EndToEnd(
const std::vector<BackendId>& backends)
393 using namespace armnn;
396 unsigned int splitAxis = 1;
397 unsigned int numSplit = 2;
399 const std::vector<TensorShape> outputShapes{{ 2, 3, 2, 2 }, { 2, 3, 2, 2 }};
402 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
404 BOOST_TEST_CHECKPOINT(
"create a network");
407 std::vector<T> inputData{
434 std::vector<T> expectedOutput0{
449 std::vector<T> expectedOutput1{
464 std::map<int, std::vector<T>> inputTensorData = {{ 0,inputData }};
465 std::map<int, std::vector<T>> expectedOutputData = {{ 0, expectedOutput0 }, { 1, expectedOutput1 }};
467 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
470 template<armnn::DataType ArmnnType>
471 void Splitter4dDim2EndToEnd(
const std::vector<BackendId>& backends)
473 using namespace armnn;
476 unsigned int splitAxis = 2;
477 unsigned int numSplit = 2;
479 const std::vector<TensorShape> outputShapes{{ 2, 3, 2, 2 }, { 2, 3, 2, 2 }};
482 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
484 BOOST_TEST_CHECKPOINT(
"create a network");
487 std::vector<T> inputData{
514 std::vector<T> expectedOutput0{
529 std::vector<T> expectedOutput1{
544 std::map<int, std::vector<T>> inputTensorData = {{ 0,inputData }};
545 std::map<int, std::vector<T>> expectedOutputData = {{ 0, expectedOutput0 }, { 1, expectedOutput1 }};
547 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
550 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
551 void Splitter4dDim3EndToEnd(
const std::vector<BackendId>& backends)
553 using namespace armnn;
555 unsigned int splitAxis = 3;
556 unsigned int numSplit = 2;
558 const std::vector<TensorShape> outputShapes{{ 2, 3, 4, 1 }, { 2, 3, 4, 1 }};
561 INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
563 BOOST_TEST_CHECKPOINT(
"create a network");
566 std::vector<T> inputData{
593 std::vector<T> expectedOutput0{
602 std::vector<T> expectedOutput1{
611 std::map<int, std::vector<T>> inputTensorData = {{ 0,inputData }};
612 std::map<int, std::vector<T>> expectedOutputData = {{ 0, expectedOutput0 }, { 1, expectedOutput1 }};
614 EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
A ViewsDescriptor for the SplitterLayer.
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
typename ResolveTypeImpl< DT >::Type ResolveType
Copyright (c) 2020 ARM Limited.
Status SetViewSize(uint32_t view, uint32_t coord, uint32_t value)
Set the size of the views.
void Connect(armnn::IConnectableLayer *from, armnn::IConnectableLayer *to, const armnn::TensorInfo &tensorInfo, unsigned int fromIndex, unsigned int toIndex)
std::unique_ptr< INetwork, void(*)(INetwork *network)> INetworkPtr
static INetworkPtr Create()