src/backends/backendsCommon/test/SubgraphUtilsTest.hpp

//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include <ResolveType.hpp>

#include <armnn/INetwork.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <GraphUtils.hpp>
#include <CommonTestUtils.hpp>
#include <armnnTestUtils/DataLayoutUtils.hpp>

#include <doctest/doctest.h>

#include <vector>
#include "backendsCommon/SubgraphUtils.hpp"

namespace armnn
{

template<DataType ArmnnIType, DataType ArmnnOType,
        typename TInput = ResolveType<ArmnnIType>, typename TOutput = ResolveType<ArmnnOType>>
void EndToEndLayerTest(IRuntimePtr runtime,
                       IOptimizedNetworkPtr optNet,
                       const std::map<int, std::vector<TInput>>& inputTensorData,
                       const std::map<int, std::vector<TOutput>>& expectedOutputData,
                       float tolerance = 0.000001f)
{
    // Loads it into the runtime.
    NetworkId netId;
    std::string errorMessage;
    armnn::Status loadingStatus = runtime->LoadNetwork(netId, std::move(optNet), errorMessage);
    CHECK_MESSAGE(loadingStatus == Status::Success, errorMessage);

    InputTensors inputTensors;
    inputTensors.reserve(inputTensorData.size());
    for (auto&& it : inputTensorData)
    {
        inputTensors.push_back({it.first,
                                ConstTensor(runtime->GetInputTensorInfo(netId, it.first), it.second.data())});
    }
    OutputTensors outputTensors;
    outputTensors.reserve(expectedOutputData.size());
    std::map<int, std::vector<TOutput>> outputStorage;
    for (auto&& it : expectedOutputData)
    {
        std::vector<TOutput> out(it.second.size());
        outputStorage.emplace(it.first, out);
        outputTensors.push_back({it.first,
                                 Tensor(runtime->GetOutputTensorInfo(netId, it.first),
                                        outputStorage.at(it.first).data())});
    }

    // Does the inference.
    runtime->EnqueueWorkload(netId, inputTensors, outputTensors);

    // Checks the results.
    for (auto&& it : expectedOutputData)
    {
        std::vector<TOutput> out = outputStorage.at(it.first);
        for (unsigned int i = 0; i < out.size(); ++i)
        {
            CHECK_MESSAGE(Compare<ArmnnOType>(it.second[i], out[i], tolerance) == true,
                          "Actual output: " << out[i] << ". Expected output:" << it.second[i]);

        }
    }
}

template<armnn::DataType ArmnnType, typename T = ResolveType<ArmnnType>>
armnn::INetworkPtr CreateReshapeInOutNetwork(const armnn::TensorShape& inputShape,
                                             const armnn::TensorShape& outputShape,
                                             ReshapeDescriptor& descriptor,
                                             const float qScale = 1.0f,
                                             const int32_t qOffset = 0)
{
    armnn::INetworkPtr network(armnn::INetwork::Create());

    TensorInfo inputTensorInfo(inputShape, ArmnnType, qScale, qOffset, true);
    TensorInfo outputTensorInfo(outputShape, ArmnnType, qScale, qOffset);

    IConnectableLayer* activation0 = network->AddActivationLayer(ActivationFunction::ReLu, "act0");
    IConnectableLayer* activation1 = network->AddActivationLayer(ActivationFunction::ReLu, "act1");
    IConnectableLayer* activation2 = network->AddActivationLayer(ActivationFunction::ReLu, "act2");
    IConnectableLayer* activation3 = network->AddActivationLayer(ActivationFunction::ReLu, "act3");
    IConnectableLayer* reshape = network->AddReshapeLayer(descriptor, "reshape");

    IConnectableLayer* input   = network->AddInputLayer(0, "input");
    IConnectableLayer* output1  = network->AddOutputLayer(0, "output1");
    IConnectableLayer* output2  = network->AddOutputLayer(1, "output2");
    IConnectableLayer* output3  = network->AddOutputLayer(2, "output3");

    Connect(input, activation0, inputTensorInfo, 0, 0);
    Connect(activation0, reshape, inputTensorInfo, 0, 0);

    Connect(reshape, activation1, outputTensorInfo, 0, 0);
    Connect(reshape, activation2, outputTensorInfo, 0, 0);
    Connect(reshape, activation3, outputTensorInfo, 0, 0);
    Connect(activation1, output1, outputTensorInfo, 0, 0);
    Connect(activation2, output2, outputTensorInfo, 0, 0);
    Connect(activation3, output3, outputTensorInfo, 0, 0);

    return network;
}

template<armnn::DataType ArmnnType, typename T = ResolveType<ArmnnType>>
armnn::INetworkPtr CreateReshapeConv2dInOutNetwork(const armnn::TensorShape& inputShape,
                                                   const armnn::TensorShape& weightsShape,
                                                   const armnn::TensorShape& convOutputShape,
                                                   const armnn::TensorShape& outputShape,
                                                   std::vector<float>& weightsData,
                                                   ReshapeDescriptor& descriptor,
                                                   Convolution2dDescriptor& convolution2DDescriptor,
                                                   bool convFirst,
                                                   const float qScale = 1.0f,
                                                   const int32_t qOffset = 0)
{
    armnn::INetworkPtr network(armnn::INetwork::Create());
    TensorInfo weightsTensorInfo(weightsShape, ArmnnType, qScale, qOffset, true);
    ConstTensor weights(weightsTensorInfo, weightsData);

    IConnectableLayer* convolution1 = network->AddConvolution2dLayer(convolution2DDescriptor, "conv2d");
    IConnectableLayer* weightsLayer = network->AddConstantLayer(weights, "weights");

    IConnectableLayer* activation1 = network->AddActivationLayer(ActivationFunction::ReLu, "act");
    IConnectableLayer* reshape = network->AddReshapeLayer(descriptor, "reshape");

    IConnectableLayer* input   = network->AddInputLayer(0, "input");
    IConnectableLayer* output  = network->AddOutputLayer(0, "output");

    TensorInfo inputTensorInfo(inputShape, ArmnnType, qScale, qOffset, true);
    TensorInfo convTensorInfo(convOutputShape, ArmnnType, qScale, qOffset, true);
    TensorInfo outputTensorInfo(outputShape, ArmnnType, qScale, qOffset);
    TensorInfo reshapeTensorInfo(descriptor.m_TargetShape, ArmnnType, qScale, qOffset, true);

    if (convFirst)
    {
        Connect(input, convolution1, inputTensorInfo, 0, 0);
        Connect(weightsLayer, convolution1, weightsTensorInfo, 0, 1);
        Connect(convolution1, reshape, convTensorInfo, 0, 0);
        Connect(reshape, activation1, reshapeTensorInfo, 0, 0);
        Connect(activation1, output, outputTensorInfo, 0, 0);
    }
    else
    {
        Connect(input, activation1, inputTensorInfo, 0, 0);
        Connect(activation1, reshape, inputTensorInfo, 0, 0);
        Connect(reshape, convolution1, reshapeTensorInfo, 0, 0);
        Connect(weightsLayer, convolution1, weightsTensorInfo, 0, 1);
        Connect(convolution1, output, outputTensorInfo, 0, 0);
    }
    return network;
}

template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
void ReshapeRemovalEndToEnd(const std::vector<armnn::BackendId>& backends)
{
    using namespace armnn;

    const TensorShape& inputShape = { 2, 3 };
    const TensorShape& outputShape = { 6 };

    ReshapeDescriptor descriptor;
    descriptor.m_TargetShape = outputShape;

    INetworkPtr network = CreateReshapeInOutNetwork<ArmnnType>(inputShape, outputShape, descriptor);

    CHECK(network);

    std::vector<T> data{ 1, 2, 3,
                         4, 5, 6 };

    std::map<int, std::vector<float>> inputTensorData = { { 0, data } };
    std::map<int, std::vector<float>> expectedOutputData = { { 0, data }, { 1, data }, { 2, data } };

    // Create runtime in which test will run
    IRuntime::CreationOptions options;
    IRuntimePtr runtime(IRuntime::Create(options));

    // optimize the network
    IOptimizedNetworkPtr optNet = Optimize(*network, backends, runtime->GetDeviceSpec());

    Graph& graph = GetGraphForTesting(optNet.get());
    CHECK(CheckSequence(graph.cbegin(), graph.cend(),
                        LayerNameAndTypeCheck(LayerType::Input, "input"),
                        LayerNameAndTypeCheck(LayerType::Activation, "act0"),
                        LayerNameAndTypeCheck(LayerType::Activation, "act1"),
                        LayerNameAndTypeCheck(LayerType::Activation, "act2"),
                        LayerNameAndTypeCheck(LayerType::Activation, "act3"),
                        LayerNameAndTypeCheck(LayerType::Output, "output1"),
                        LayerNameAndTypeCheck(LayerType::Output, "output2"),
                        LayerNameAndTypeCheck(LayerType::Output, "output3")));

    EndToEndLayerTest<ArmnnType, ArmnnType>(std::move(runtime), std::move(optNet), inputTensorData, expectedOutputData);
}

template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
void ReshapeRemovalNCHWEndToEnd(const std::vector<armnn::BackendId>& backends, bool shouldBeRemoved, bool convFirst)
{
    using namespace armnn;

    // shapes are different if convFirst or not
    //these are convFirst
    TensorShape inputShape;
    TensorShape convOutputShape;
    TensorShape weightsShape;
    TensorShape reshapeShape;
    TensorShape outputShape;

    if (convFirst)
    {
        inputShape = { 1, 1, 5, 5 };
        convOutputShape = { 1, 1, 3, 3 };
        weightsShape = { 1, 1, 3, 3 };
        reshapeShape = { 9 };
        outputShape = { 9 };
    }
    else
    {
        inputShape = { 5, 5 };
        reshapeShape = { 1, 1, 5, 5 };
        convOutputShape = { 1, 1, 3, 3 };
        weightsShape = { 1, 1, 3, 3 };
        outputShape = { 1, 1, 3, 3 };
    }

    ReshapeDescriptor descriptor;
    descriptor.m_TargetShape = reshapeShape;

    Convolution2dDescriptor convolution2DDescriptor;
    convolution2DDescriptor.m_PadLeft     = 0;
    convolution2DDescriptor.m_PadRight    = 0;
    convolution2DDescriptor.m_PadTop      = 0;
    convolution2DDescriptor.m_PadBottom   = 0;
    convolution2DDescriptor.m_StrideX     = 1;
    convolution2DDescriptor.m_StrideY     = 1;
    convolution2DDescriptor.m_DataLayout  = DataLayout::NCHW;
    convolution2DDescriptor.m_BiasEnabled = false;

    TensorInfo inputInfo(inputShape, DataType::Float32, true);
    TensorInfo outputInfo(convOutputShape, DataType::Float32);
    TensorInfo weightsInfo(weightsShape, DataType::Float32, true);

    std::vector<float> inputData =
    {
        1.0f, 8.0f, 3.0f, 4.0f, 6.0f,
        5.0f, 7.0f, 3.0f, 1.0f, 8.0f,
        2.0f, 3.0f, 9.0f, 8.0f, 1.0f,
        3.0f, 6.0f, 1.0f, 1.0f, 9.0f,
        5.0f, 3.0f, 9.0f, 3.0f, 2.0f
    };

    std::vector<float> weightsData =
    {
        4.0f, 0.0f, 3.0f,
        5.0f, 0.0f, 2.0f,
        6.0f, 0.0f, 1.0f
    };

    std::vector<float> outputData =
    {
        65.0f, 107.0f, 116.0f,
        76.0f,  99.0f,  98.0f,
        91.0f,  89.0f, 118.0f
    };

    INetworkPtr network = CreateReshapeConv2dInOutNetwork<DataType::Float32>(inputShape,
                                                                             weightsShape,
                                                                             convOutputShape,
                                                                             outputShape,
                                                                             weightsData,
                                                                             descriptor,
                                                                             convolution2DDescriptor,
                                                                             convFirst);
    CHECK(network);

    std::map<int, std::vector<float>> inputTensorData = { { 0, inputData } };
    std::map<int, std::vector<float>> expectedOutputData = { { 0, outputData } };

    // Create runtime in which test will run
    IRuntime::CreationOptions options;
    IRuntimePtr runtime(IRuntime::Create(options));

    // optimize the network
    IOptimizedNetworkPtr optNet = Optimize(*network, backends, runtime->GetDeviceSpec());

    Graph& graph = GetGraphForTesting(optNet.get());

    if (shouldBeRemoved)
    {
        if (convFirst)
        {
            CHECK(CheckSequence(graph.cbegin(), graph.cend(),
                                LayerNameAndTypeCheck(LayerType::Input, "input"),
                                LayerNameAndTypeCheck(LayerType::Constant, "weights"),
                                LayerNameAndTypeCheck(LayerType::Convolution2d, "conv2d"),
                                LayerNameAndTypeCheck(LayerType::Activation, "act"),
                                LayerNameAndTypeCheck(LayerType::Output, "output")));
        }
        else
        {
            CHECK(CheckSequence(graph.cbegin(), graph.cend(),
                                LayerNameAndTypeCheck(LayerType::Input, "input"),
                                LayerNameAndTypeCheck(LayerType::Constant, "weights"),
                                LayerNameAndTypeCheck(LayerType::Activation, "act"),
                                LayerNameAndTypeCheck(LayerType::Convolution2d, "conv2d"),
                                LayerNameAndTypeCheck(LayerType::Output, "output")));
        }
    }
    else
    {
        if (convFirst)
        {
            CHECK(CheckSequence(graph.cbegin(), graph.cend(),
                                LayerNameAndTypeCheck(LayerType::Input, "input"),
                                LayerNameAndTypeCheck(LayerType::Constant, "weights"),
                                LayerNameAndTypeCheck(LayerType::Convolution2d, "conv2d"),
                                LayerNameAndTypeCheck(LayerType::Reshape, "reshape"),
                                LayerNameAndTypeCheck(LayerType::Activation, "act"),
                                LayerNameAndTypeCheck(LayerType::Output, "output")));
        }
        else
        {
            CHECK(CheckSequence(graph.cbegin(), graph.cend(),
                                LayerNameAndTypeCheck(LayerType::Input, "input"),
                                LayerNameAndTypeCheck(LayerType::Constant, "weights"),
                                LayerNameAndTypeCheck(LayerType::Activation, "act"),
                                LayerNameAndTypeCheck(LayerType::Reshape, "reshape"),
                                LayerNameAndTypeCheck(LayerType::Convolution2d, "conv2d"),
                                LayerNameAndTypeCheck(LayerType::Output, "output")));
        }
    }

    EndToEndLayerTest<ArmnnType, ArmnnType>(std::move(runtime), std::move(optNet), inputTensorData, expectedOutputData);
}

template<typename Descriptor, typename LayerType>
void CheckIsNCHW()
{
    Graph graph;
    Descriptor nchwDesc;
    nchwDesc.m_DataLayout = DataLayout::NCHW;
    auto nchwLayer = graph.AddLayer<LayerType>(nchwDesc, "");
    CHECK(IsNCHW(*nchwLayer));

    Descriptor nhwcDesc;
    nhwcDesc.m_DataLayout = DataLayout::NHWC;
    auto nhwcLayer = graph.AddLayer<LayerType>(nhwcDesc, "");
    CHECK_FALSE(IsNCHW(*nhwcLayer));
}

TEST_CASE("CheckIsNCHW")
{
    Graph graph;
    BatchMatMulDescriptor descriptor1;
    descriptor1.m_DataLayoutX = DataLayout::NHWC;
    descriptor1.m_DataLayoutY = DataLayout::NHWC;
    auto batchMatMulLayer1 = graph.AddLayer<BatchMatMulLayer>(descriptor1, "");
    CHECK_FALSE(IsNCHW(*batchMatMulLayer1));

    BatchMatMulDescriptor descriptor2;
    descriptor2.m_DataLayoutX = DataLayout::NCHW;
    descriptor2.m_DataLayoutY = DataLayout::NHWC;
    auto batchMatMulLayer2 = graph.AddLayer<BatchMatMulLayer>(descriptor2, "");
    CHECK(IsNCHW(*batchMatMulLayer2));

    BatchMatMulDescriptor descriptor3;
    descriptor3.m_DataLayoutX = DataLayout::NHWC;
    descriptor3.m_DataLayoutY = DataLayout::NCHW;
    auto batchMatMulLayer3 = graph.AddLayer<BatchMatMulLayer>(descriptor3, "");
    CHECK(IsNCHW(*batchMatMulLayer3));

    BatchMatMulDescriptor descriptor4;
    descriptor4.m_DataLayoutX = DataLayout::NCHW;
    descriptor4.m_DataLayoutY = DataLayout::NCHW;
    auto batchMatMulLayer4 = graph.AddLayer<BatchMatMulLayer>(descriptor4, "");
    CHECK(IsNCHW(*batchMatMulLayer4));

    CheckIsNCHW<BatchToSpaceNdDescriptor, BatchToSpaceNdLayer>();
    CheckIsNCHW<Convolution2dDescriptor, Convolution2dLayer>();
    CheckIsNCHW<Convolution3dDescriptor, Convolution3dLayer>();
    CheckIsNCHW<DepthwiseConvolution2dDescriptor, DepthwiseConvolution2dLayer>();
    CheckIsNCHW<InstanceNormalizationDescriptor, InstanceNormalizationLayer>();
    CheckIsNCHW<L2NormalizationDescriptor, L2NormalizationLayer>();
    CheckIsNCHW<NormalizationDescriptor, NormalizationLayer>();
    CheckIsNCHW<Pooling2dDescriptor, Pooling2dLayer>();
    CheckIsNCHW<Pooling3dDescriptor, Pooling3dLayer>();
    CheckIsNCHW<SpaceToBatchNdDescriptor, SpaceToBatchNdLayer>();
    CheckIsNCHW<SpaceToDepthDescriptor, SpaceToDepthLayer>();
    CheckIsNCHW<StridedSliceDescriptor, StridedSliceLayer>();

    // Check Default
    auto elementwiseLayer = graph.AddLayer<ElementwiseBinaryLayer>(BinaryOperation::Add, "");
    CHECK_FALSE(IsNCHW(*elementwiseLayer));
}


} // Namespace