IVGCVSW-3283 Add test for converting CONV2D and DEPTHWISE_CONV2D operators with dilation params

Signed-off-by: Aron Virginas-Tar <Aron.Virginas-Tar@arm.com>
Change-Id: I51a9c71d7a277ab530ac35faea2e8a069c134f45

1 files changed, 179 insertions, 0 deletions

diff --git a/test/Dilation.hpp b/test/Dilation.hpp
new file mode 100644
index 00000000..adc9947d
--- /dev/null
+++ b/test/Dilation.hpp
@@ -0,0 +1,179 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "DriverTestHelpers.hpp"
+
+#include <armnn/LayerVisitorBase.hpp>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <numeric>
+
+BOOST_AUTO_TEST_SUITE(DilationTests)
+
+using namespace armnn;
+using namespace boost;
+using namespace driverTestHelpers;
+
+struct DilationTestOptions
+{
+    DilationTestOptions() :
+        m_IsDepthwiseConvolution{false},
+        m_IsPaddingExplicit{false},
+        m_HasDilation{false}
+    {}
+
+    ~DilationTestOptions() = default;
+
+    bool m_IsDepthwiseConvolution;
+    bool m_IsPaddingExplicit;
+    bool m_HasDilation;
+};
+
+class DilationTestVisitor : public LayerVisitorBase<VisitorThrowingPolicy>
+{
+public:
+    DilationTestVisitor() :
+        DilationTestVisitor(1u, 1u)
+    {}
+
+    DilationTestVisitor(uint32_t expectedDilationX, uint32_t expectedDilationY) :
+        m_ExpectedDilationX{expectedDilationX},
+        m_ExpectedDilationY{expectedDilationY}
+    {}
+
+    void VisitConvolution2dLayer(const IConnectableLayer *layer,
+                                 const Convolution2dDescriptor& descriptor,
+                                 const ConstTensor& weights,
+                                 const Optional<ConstTensor>& biases,
+                                 const char *name = nullptr) override
+    {
+        ignore_unused(layer);
+        ignore_unused(weights);
+        ignore_unused(biases);
+        ignore_unused(name);
+
+        CheckDilationParams(descriptor);
+    }
+
+    void VisitDepthwiseConvolution2dLayer(const IConnectableLayer *layer,
+                                          const DepthwiseConvolution2dDescriptor& descriptor,
+                                          const ConstTensor& weights,
+                                          const Optional<ConstTensor>& biases,
+                                          const char *name = nullptr) override
+    {
+        ignore_unused(layer);
+        ignore_unused(weights);
+        ignore_unused(biases);
+        ignore_unused(name);
+
+        CheckDilationParams(descriptor);
+    }
+
+private:
+    uint32_t m_ExpectedDilationX;
+    uint32_t m_ExpectedDilationY;
+
+    template<typename ConvolutionDescriptor>
+    void CheckDilationParams(const ConvolutionDescriptor& descriptor)
+    {
+        BOOST_CHECK_EQUAL(descriptor.m_DilationX, m_ExpectedDilationX);
+        BOOST_CHECK_EQUAL(descriptor.m_DilationY, m_ExpectedDilationY);
+    }
+};
+
+template<typename HalPolicy>
+void DilationTestImpl(const DilationTestOptions& options)
+{
+    using HalModel         = typename HalPolicy::Model;
+    using HalOperationType = typename HalPolicy::OperationType;
+
+    const armnn::Compute backend = armnn::Compute::CpuRef;
+    auto driver = std::make_unique<ArmnnDriver>(DriverOptions(backend, false));
+    HalModel model = {};
+
+    // add operands
+    std::vector<float> weightData(9, 1.0f);
+    std::vector<float> biasData(1, 0.0f );
+
+    // input
+    AddInputOperand<HalPolicy>(model, hidl_vec<uint32_t>{1, 3, 3, 1});
+
+    // weights & biases
+    AddTensorOperand<HalPolicy>(model, hidl_vec<uint32_t>{1, 3, 3, 1}, weightData.data());
+    AddTensorOperand<HalPolicy>(model, hidl_vec<uint32_t>{1}, biasData.data());
+
+    uint32_t numInputs = 3u;
+    // padding
+    if (options.m_IsPaddingExplicit)
+    {
+        AddIntOperand<HalPolicy>(model, 1);
+        AddIntOperand<HalPolicy>(model, 1);
+        AddIntOperand<HalPolicy>(model, 1);
+        AddIntOperand<HalPolicy>(model, 1);
+        numInputs += 4;
+    }
+    else
+    {
+        AddIntOperand<HalPolicy>(model, android::nn::kPaddingSame);
+        numInputs += 1;
+    }
+
+    AddIntOperand<HalPolicy>(model, 2); // stride x
+    AddIntOperand<HalPolicy>(model, 2); // stride y
+    numInputs += 2;
+
+    if (options.m_IsDepthwiseConvolution)
+    {
+        AddIntOperand<HalPolicy>(model, 1); // depth multiplier
+        numInputs++;
+    }
+
+    AddIntOperand<HalPolicy>(model, 0); // no activation
+    numInputs += 1;
+
+    // dilation
+    if (options.m_HasDilation)
+    {
+        AddBoolOperand<HalPolicy>(model, false); // default data layout
+
+        AddIntOperand<HalPolicy>(model, 2); // dilation X
+        AddIntOperand<HalPolicy>(model, 2); // dilation Y
+
+        numInputs += 3;
+    }
+
+    // output
+    AddOutputOperand<HalPolicy>(model, hidl_vec<uint32_t>{1, 1, 1, 1});
+
+    // set up the convolution operation
+    model.operations.resize(1);
+    model.operations[0].type = options.m_IsDepthwiseConvolution ?
+        HalOperationType::DEPTHWISE_CONV_2D : HalOperationType::CONV_2D;
+
+    std::vector<uint32_t> inputs(numInputs);
+    std::iota(inputs.begin(), inputs.end(), 0u);
+    std::vector<uint32_t> outputs = { numInputs };
+
+    model.operations[0].inputs  = hidl_vec<uint32_t>(inputs);
+    model.operations[0].outputs = hidl_vec<uint32_t>(outputs);
+
+    // convert model
+    ConversionData data({backend});
+    data.m_Network = armnn::INetwork::Create();
+    data.m_OutputSlotForOperand = std::vector<IOutputSlot*>(model.operands.size(), nullptr);
+
+    bool ok = HalPolicy::ConvertOperation(model.operations[0], model, data);
+    BOOST_CHECK(ok);
+
+    // check if dilation params are as expected
+    DilationTestVisitor visitor = options.m_HasDilation ? DilationTestVisitor(2, 2) : DilationTestVisitor();
+    data.m_Network->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_SUITE_END()