From e24e3cd94d0f5d6d8dbd5fec3e2d1e9385c6ff81 Mon Sep 17 00:00:00 2001
From: Francis Murtagh <francis.murtagh@arm.com>
Date: Tue, 25 Jun 2019 14:41:55 +0100
Subject: IVGCVSW-3347 Add EndToEnd test for BatchToSpaceNd

 * Add Simple and complex end to end tests based on tensorflow.org examples

Change-Id: Ifa758a48cf5ea09f9be7945859cd37377dbb9465
Signed-off-by: Francis Murtagh <francis.murtagh@arm.com>
---
 .../test/BatchToSpaceNdEndToEndTestImpl.hpp        | 119 +++++++++++++++++++++
 src/backends/reference/test/RefEndToEndTests.cpp   |  61 +++++++++++
 2 files changed, 180 insertions(+)
 create mode 100644 src/backends/backendsCommon/test/BatchToSpaceNdEndToEndTestImpl.hpp

(limited to 'src/backends')

diff --git a/src/backends/backendsCommon/test/BatchToSpaceNdEndToEndTestImpl.hpp b/src/backends/backendsCommon/test/BatchToSpaceNdEndToEndTestImpl.hpp
new file mode 100644
index 0000000000..d1be409480
--- /dev/null
+++ b/src/backends/backendsCommon/test/BatchToSpaceNdEndToEndTestImpl.hpp
@@ -0,0 +1,119 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include <ResolveType.hpp>
+
+#include <armnn/INetwork.hpp>
+
+#include <backendsCommon/test/CommonTestUtils.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace
+{
+
+template<typename armnn::DataType DataType>
+INetworkPtr CreateBatchToSpaceNdNetwork(const armnn::TensorShape& inputShape,
+                                        const armnn::TensorShape& outputShape,
+                                        std::vector<unsigned int>& blockShape,
+                                        std::vector<std::pair<unsigned int, unsigned int>>& crops,
+                                        armnn::DataLayout dataLayout,
+                                        const float qScale = 1.0f,
+                                        const int32_t qOffset = 0)
+{
+    using namespace armnn;
+    // Builds up the structure of the network.
+    INetworkPtr net(INetwork::Create());
+
+    TensorInfo inputTensorInfo(inputShape, DataType, qScale, qOffset);
+    TensorInfo outputTensorInfo(outputShape, DataType, qScale, qOffset);
+
+    BatchToSpaceNdDescriptor batchToSpaceNdDesc(blockShape, crops);
+    batchToSpaceNdDesc.m_DataLayout = dataLayout;
+
+    IConnectableLayer* batchToSpaceNd = net->AddBatchToSpaceNdLayer(batchToSpaceNdDesc, "batchToSpaceNd");
+    IConnectableLayer* input = net->AddInputLayer(0, "input");
+    IConnectableLayer* output = net->AddOutputLayer(0, "output");
+
+    Connect(batchToSpaceNd, output, outputTensorInfo, 0, 0);
+    Connect(input, batchToSpaceNd, inputTensorInfo, 0, 0);
+
+    return net;
+}
+
+template<armnn::DataType ArmnnType>
+void BatchToSpaceNdEndToEnd(const std::vector<BackendId>& backends, armnn::DataLayout dataLayout)
+{
+    using namespace armnn;
+    using T = ResolveType<ArmnnType>;
+
+    std::vector<unsigned int> blockShape {2, 2};
+    std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
+    const TensorShape& inputShape  = { 4, 1, 1, 1 };
+    const TensorShape& outputShape = (dataLayout == DataLayout::NCHW)
+                                     ? std::initializer_list<unsigned int>({ 1, 1, 2, 2 })
+                                     : std::initializer_list<unsigned int>({ 1, 2, 2, 1 });
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateBatchToSpaceNdNetwork<ArmnnType>(inputShape, outputShape, blockShape, crops, dataLayout);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    // Creates structures for input & output.
+    std::vector<T> inputData{ 1, 2, 3, 4 };
+
+    std::vector<T> expectedOutput{ 1, 2, 3, 4 };
+
+    std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
+    std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput } };
+
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+template<armnn::DataType ArmnnType>
+void BatchToSpaceNdComplexEndToEnd(const std::vector<BackendId>& backends, armnn::DataLayout dataLayout)
+{
+    using namespace armnn;
+    using T = ResolveType<ArmnnType>;
+
+    std::vector<unsigned int> blockShape {2, 2};
+    std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {2, 0}};
+    const TensorShape& inputShape  = (dataLayout == DataLayout::NCHW)
+                                     ? std::initializer_list<unsigned int>({ 8, 1, 1, 3 })
+                                     : std::initializer_list<unsigned int>({ 8, 1, 3, 1 });
+    const TensorShape& outputShape = (dataLayout == DataLayout::NCHW)
+                                     ? std::initializer_list<unsigned int>({ 2, 1, 2, 4 })
+                                     : std::initializer_list<unsigned int>({ 2, 2, 4, 1 });
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateBatchToSpaceNdNetwork<ArmnnType>(inputShape, outputShape, blockShape, crops, dataLayout);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    // Creates structures for input & output.
+    std::vector<T> inputData{
+                              0, 1, 3, 0,  9, 11,
+                              0, 2, 4, 0, 10, 12,
+                              0, 5, 7, 0, 13, 15,
+                              0, 6, 8, 0, 14, 16
+                            };
+
+    std::vector<T> expectedOutput{
+                                   1,   2,  3,  4,
+                                   5,   6,  7,  8,
+                                   9,  10, 11, 12,
+                                   13, 14, 15, 16
+                                 };
+
+    std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
+    std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput } };
+
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+} // anonymous namespace
diff --git a/src/backends/reference/test/RefEndToEndTests.cpp b/src/backends/reference/test/RefEndToEndTests.cpp
index c186c03984..4d56952e27 100644
--- a/src/backends/reference/test/RefEndToEndTests.cpp
+++ b/src/backends/reference/test/RefEndToEndTests.cpp
@@ -5,6 +5,7 @@
 
 #include <backendsCommon/test/EndToEndTestImpl.hpp>
 
+#include <backendsCommon/test/BatchToSpaceNdEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DetectionPostProcessTestImpl.hpp>
 #include <backendsCommon/test/GatherEndToEndTestImpl.hpp>
@@ -398,6 +399,66 @@ BOOST_AUTO_TEST_CASE(RefGreaterBroadcastEndToEndUint8Test)
                                                                                             expectedOutput);
 }
 
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndFloat32NHWCTest)
+{
+    BatchToSpaceNdEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndUint8NHWCTest)
+{
+    BatchToSpaceNdEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndQSymm16NHWCTest)
+{
+    BatchToSpaceNdEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndFloat32NCHWTest)
+{
+    BatchToSpaceNdEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndUint8NCHWTest)
+{
+    BatchToSpaceNdEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndQSymm16NCHWTest)
+{
+    BatchToSpaceNdEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexFloat32NHWCTest)
+{
+    BatchToSpaceNdComplexEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexUint8NHWCTest)
+{
+    BatchToSpaceNdComplexEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexQSymm16NHWCTest)
+{
+    BatchToSpaceNdComplexEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexFloat32NCHWTest)
+{
+    BatchToSpaceNdComplexEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexUint8NCHWTest)
+{
+    BatchToSpaceNdComplexEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(RefBatchToSpaceNdEndToEndComplexQSymm16NCHWTest)
+{
+    BatchToSpaceNdComplexEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
 BOOST_AUTO_TEST_CASE(RefConcatEndToEndDim0Test)
 {
     ConcatDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
-- 
cgit v1.2.1