patch/23.02/_arm_compute_subgraph_utils_8hpp_source.xhtml

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

 #pragma once

 #include <armnn/backends/OptimizationViews.hpp>
 #include <armnn/utility/Assert.hpp>

 #include <aclCommon/ArmComputeUtils.hpp>
 #include <backendsCommon/SubgraphUtils.hpp>

 namespace armnn
 {

 namespace
 {

 //
 // this helper only works if all layers where the inputs connect to are not selected
 //

 bool checkDataTypeInputandOutput(const Layer& layer)
 {
     auto inputInfo = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
     auto outputInfo = layer.GetOutputSlot(0).GetTensorInfo();
     bool sameDataType = (inputInfo.GetDataType() == outputInfo.GetDataType());

     // Check is same quantization info (same scale and offset)
     if (sameDataType)
     {
         if (IsQuantizedType(inputInfo.GetDataType()))
         {
             bool sameScale = (inputInfo.GetQuantizationScale() == outputInfo.GetQuantizationScale());
             bool sameOffset = (inputInfo.GetQuantizationOffset() == outputInfo.GetQuantizationOffset());

             return (sameScale && sameOffset);
         }
         else
         {
             return true;
         }
     }
     else
     {
         return false;
     }
 }

 } // namespace

 template<typename LayerType>
 LayerType* FuseLayer(OptimizationViews& optimizationViews,
                      LayerType* baseLayer,
                      LayerType* replacementLayer,
                      ActivationLayer* activationLayer,
                      ActivationDescriptor& activationDesc)
 {
     replacementLayer->SetAdditionalInfoForObject(
         std::make_shared<ActivationDescriptor>(activationDesc));

     SubgraphView substitutionSubgraph({baseLayer, activationLayer},
                                       CreateIInputsFrom({baseLayer}),
                                       CreateIOutputsFrom({activationLayer}));
     SubgraphView replacementSubgraph(replacementLayer);

     optimizationViews.AddSubstitution({substitutionSubgraph, replacementSubgraph});

     return replacementLayer;
 }

 template<typename LayerType>
 LayerType* FuseAdditionLayer(OptimizationViews& optimizationViews,
                              LayerType* baseLayer,
                              ActivationLayer* activationLayer,
                              ActivationDescriptor& activationDesc,
                              std::string name)
 {
     IConnectableLayer* replacement = optimizationViews.GetINetwork()->AddAdditionLayer(name.c_str());
     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

     FuseLayer(optimizationViews,
               baseLayer,
               replacementLayer,
               activationLayer,
               activationDesc);

     return replacementLayer;
 }

 template<typename LayerType>
 LayerType* FuseSubtractionLayer(OptimizationViews& optimizationViews,
                                 LayerType* baseLayer,
                                 ActivationLayer* activationLayer,
                                 ActivationDescriptor& activationDesc,
                                 std::string name)
 {
     IConnectableLayer* replacement = optimizationViews.GetINetwork()->AddSubtractionLayer(name.c_str());
     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

     FuseLayer(optimizationViews,
               baseLayer,
               replacementLayer,
               activationLayer,
               activationDesc);

     return replacementLayer;
 }

 template<typename LayerType>
 LayerType* FuseDivisionLayer(OptimizationViews& optimizationViews,
                              LayerType* baseLayer,
                              ActivationLayer* activationLayer,
                              ActivationDescriptor& activationDesc,
                              std::string name)
 {
     IConnectableLayer* replacement = optimizationViews.GetINetwork()->AddDivisionLayer(name.c_str());
     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

     FuseLayer(optimizationViews,
               baseLayer,
               replacementLayer,
               activationLayer,
               activationDesc);

     return replacementLayer;
 }

 template<typename LayerType>
 LayerType* FuseMultiplicationLayer(OptimizationViews& optimizationViews,
                                    LayerType* baseLayer,
                                    ActivationLayer* activationLayer,
                                    ActivationDescriptor& activationDesc,
                                    std::string name)
 {
     IConnectableLayer* replacement = optimizationViews.GetINetwork()->AddMultiplicationLayer(name.c_str());
     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

     FuseLayer(optimizationViews,
               baseLayer,
               replacementLayer,
               activationLayer,
               activationDesc);

     return replacementLayer;
 }

 template<typename LayerType>
 LayerType* FuseBatchNormalizationLayer(OptimizationViews& optimizationViews,
                                        LayerType* baseLayer,
                                        ActivationLayer* activationLayer,
                                        ActivationDescriptor& activationDesc,
                                        std::string name)
 {
     IConnectableLayer* replacement =
         optimizationViews.GetINetwork()->AddBatchNormalizationLayer(baseLayer->GetParameters(),
                                                                     ConstTensor(),
                                                                     ConstTensor(),
                                                                     ConstTensor(),
                                                                     ConstTensor(),
                                                                     name.c_str());
     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

     FuseLayer(optimizationViews,
               baseLayer,
               replacementLayer,
               activationLayer,
               activationDesc);

     SubgraphView substitutionSubgraph({baseLayer, activationLayer},
                                       CreateIInputsFrom({baseLayer}),
                                       CreateIOutputsFrom({activationLayer}));
     SubgraphView replacementSubgraph(replacementLayer);

     return replacementLayer;
 }

 template<typename LayerType>
 LayerType* FuseConvolution2dLayer(OptimizationViews& optimizationViews,
                                   LayerType* baseLayer,
                                   ActivationLayer* activationLayer,
                                   ActivationDescriptor& activationDesc,
                                   std::string name)
 {
     IConnectableLayer* replacement = optimizationViews.GetINetwork()
                                                       ->AddConvolution2dLayer(baseLayer->GetParameters(), name.c_str());

     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);


     FuseLayer(optimizationViews,
               baseLayer,
               replacementLayer,
               activationLayer,
               activationDesc);

     return replacementLayer;
 }

 template<typename LayerType>
 LayerType* FuseDepthwiseConvolution2dLayer(OptimizationViews& optimizationViews,
                                            LayerType* baseLayer,
                                            ActivationLayer* activationLayer,
                                            ActivationDescriptor& activationDesc,
                                            std::string name)
 {
     IConnectableLayer* replacement =
         optimizationViews.GetINetwork()->AddDepthwiseConvolution2dLayer(baseLayer->GetParameters(), name.c_str());

     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);


     FuseLayer(optimizationViews,
               baseLayer,
               replacementLayer,
               activationLayer,
               activationDesc);

     return replacementLayer;
 }

 template<typename LayerType>
 LayerType* FuseFullyConnectedLayer(OptimizationViews& optimizationViews,
                                    LayerType* baseLayer,
                                    ActivationLayer* activationLayer,
                                    ActivationDescriptor& activationDesc,
                                    std::string name)
 {
     IConnectableLayer* replacement =
         optimizationViews.GetINetwork()->AddFullyConnectedLayer(baseLayer->GetParameters(),
                                                                 name.c_str());
     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

     FuseLayer(optimizationViews,
               baseLayer,
               replacementLayer,
               activationLayer,
               activationDesc);


     return replacementLayer;
 }

 //
 // If reduce layer has multiple axes, add new layer for each axis to simulate the same behaviour
 // as currently only one axis is supported.
 //
 template<typename LayerType>
 std::vector<IConnectableLayer*> ChainReduceLayers(OptimizationViews& optimizationViews,
                                       LayerType* baseLayer,
                                       ReduceDescriptor& desc)
 {
     // Vector of new chained layers, used for substitution.
     std::vector<IConnectableLayer*> layers;

     // Vector of axes so each layer is reshaped correctly.
     std::vector<uint32_t> axes;
     unsigned int recalulatedAxis = 0;

     for (unsigned int i = 0; i != desc.m_vAxis.size(); ++i)
     {
         // Get TensorInfo from base layer and reduce shape using axis.
         TensorInfo layerInfo = baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo();

         axes.emplace_back(desc.m_vAxis[i]);

         const TensorInfo& reducedTensorInfo = ComputeReductionTensorShape(layerInfo,
                                                                           axes,
                                                                           desc.m_KeepDims);

         // Create a vector for the single axis to be assigned to the descriptor.
         // Update axis if keepDims is set reduce layers correctly.
         std::vector<uint32_t> singleAxis(1, desc.m_vAxis[i] - recalulatedAxis);

         // Create a descriptor and assign single axis.
         ReduceDescriptor newReduceDescriptor = baseLayer->GetParameters();
         newReduceDescriptor.m_vAxis.assign(singleAxis.begin(), singleAxis.end());

         // Add new layer to graph.
         std::string layerName = "reduce_layer_" + std::to_string(i);

         Layer* replacementLayer = PolymorphicDowncast<Layer*>(
             optimizationViews.GetINetwork()->AddReduceLayer(newReduceDescriptor,
                                                             layerName.c_str()));

         // Connect previous layer with new layer.
         // The first and last layer will be connected when the subgraph is replaced.
         if (!layers.empty())
         {
             layers[i - 1]->GetOutputSlot(0).Connect(replacementLayer->GetInputSlot(0));
         }

         // Set updated tensorInfo for new layer.
         replacementLayer->GetOutputSlot(0).SetTensorInfo(reducedTensorInfo);

         if (!desc.m_KeepDims)
         {
             recalulatedAxis++;
         }

         layers.emplace_back(replacementLayer);
     }

     // Check if the TensorInfo from the last layer equals the inferred output from the original layer.
     ARMNN_ASSERT(baseLayer->GetOutputSlot(0).GetTensorInfo() ==
                  PolymorphicDowncast<Layer*>(layers.back())->GetOutputSlot().GetTensorInfo());

     return layers;
 }

 //
 // Substitute baseLayer with new subgraph
 //
 template<typename LayerType>
 void ReplaceLayers(OptimizationViews& optimizationViews,
                    LayerType* baseLayer,
                    std::vector<IConnectableLayer*>& layers)
 {
     std::list<IConnectableLayer*> replacementLayers(layers.begin(), layers.end());

     SubgraphView substitutionSubgraph(baseLayer);
     SubgraphView replacementSubgraph(std::move(replacementLayers),
                                      CreateIInputsFrom({replacementLayers.front()}),
                                      CreateIOutputsFrom({replacementLayers.back()}));

     optimizationViews.AddSubstitution({substitutionSubgraph, replacementSubgraph});
 }

 } // namespace armnn
armnn::INetwork::AddSubtractionLayer
IConnectableLayer * AddSubtractionLayer(const char *name=nullptr)
Adds a subtraction layer to the network.
Definition: Network.cpp:314

-armnn::IConnectableLayer
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
Definition: INetwork.hpp:68

-ArmComputeUtils.hpp

-armnn::IsQuantizedType
constexpr bool IsQuantizedType()
Definition: TypesUtils.hpp:284

-armnn::TensorInfo
Definition: Tensor.hpp:152

-armnn::INetwork::AddDepthwiseConvolution2dLayer
IConnectableLayer * AddDepthwiseConvolution2dLayer(const DepthwiseConvolution2dDescriptor &convolution2dDescriptor, const char *name=nullptr)
Adds a 2D depthwise convolution layer to the network.
Definition: Network.cpp:107

-armnn::FuseConvolution2dLayer
LayerType * FuseConvolution2dLayer(OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
Definition: ArmComputeSubgraphUtils.hpp:180

-armnn::OptimizationViews::GetINetwork
INetwork * GetINetwork()
Definition: OptimizationViews.hpp:67

-armnn::ReduceDescriptor::m_KeepDims
bool m_KeepDims
if true then output shape has no change.
Definition: Descriptors.hpp:1501

-armnn::OptimizationViews::AddSubstitution
void AddSubstitution(SubstitutionPair &&substitution)
Definition: OptimizationViews.hpp:39

-armnn::ActivationLayer
This layer represents an activation operation with the specified activation function.
Definition: ActivationLayer.hpp:12

-armnn::OptimizationViews
Definition: OptimizationViews.hpp:18

-armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6

-armnn::INetwork::AddDivisionLayer
IConnectableLayer * AddDivisionLayer(const char *name=nullptr)
Adds a division layer to the network.
Definition: Network.cpp:309

-armnn::INetwork::AddFullyConnectedLayer
IConnectableLayer * AddFullyConnectedLayer(const FullyConnectedDescriptor &fullyConnectedDescriptor, const char *name=nullptr)
Adds a fully connected layer to the network.
Definition: Network.cpp:143

-SubgraphUtils.hpp

-armnn::SubgraphView
The SubgraphView class represents a subgraph of a Graph.
Definition: SubgraphView.hpp:31

-armnn::Layer::GetInputSlot
const InputSlot & GetInputSlot(unsigned int index) const override
Get a const input slot handle by slot index.
Definition: Layer.hpp:324

-armnn::FuseDivisionLayer
LayerType * FuseDivisionLayer(OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
Definition: ArmComputeSubgraphUtils.hpp:112

-armnn::ReduceDescriptor
A ReduceDescriptor for the REDUCE operators.
Definition: Descriptors.hpp:1485

-armnn::ConstTensor
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
Definition: Tensor.hpp:327

-ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14

-armnn::FuseLayer
LayerType * FuseLayer(OptimizationViews &optimizationViews, LayerType *baseLayer, LayerType *replacementLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc)
Definition: ArmComputeSubgraphUtils.hpp:54

-armnn::FuseBatchNormalizationLayer
LayerType * FuseBatchNormalizationLayer(OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
Definition: ArmComputeSubgraphUtils.hpp:150

-armnn::ActivationDescriptor
An ActivationDescriptor for the ActivationLayer.
Definition: Descriptors.hpp:36

-armnn::INetwork::AddBatchNormalizationLayer
IConnectableLayer * AddBatchNormalizationLayer(const BatchNormalizationDescriptor &desc, const ConstTensor &mean, const ConstTensor &variance, const ConstTensor &beta, const ConstTensor &gamma, const char *name=nullptr)
Adds a batch normalization layer to the network.
Definition: Network.cpp:224

-OptimizationViews.hpp

-armnn::ReduceDescriptor::m_vAxis
std::vector< uint32_t > m_vAxis
The indices of the dimensions to reduce.
Definition: Descriptors.hpp:1503

-armnn::INetwork::AddAdditionLayer
IConnectableLayer * AddAdditionLayer(const char *name=nullptr)
Adds an addition layer to the network.
Definition: Network.cpp:214

-Assert.hpp

-armnn::ChainReduceLayers
std::vector< IConnectableLayer * > ChainReduceLayers(OptimizationViews &optimizationViews, LayerType *baseLayer, ReduceDescriptor &desc)
Definition: ArmComputeSubgraphUtils.hpp:250

-armnn::FuseSubtractionLayer
LayerType * FuseSubtractionLayer(OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
Definition: ArmComputeSubgraphUtils.hpp:93

-armnn::INetwork::AddConvolution2dLayer
IConnectableLayer * AddConvolution2dLayer(const Convolution2dDescriptor &convolution2dDescriptor, const char *name=nullptr)
Adds a 2D convolution layer to the network.
Definition: Network.cpp:87

-armnn::OutputSlot::SetTensorInfo
void SetTensorInfo(const TensorInfo &tensorInfo) override
Definition: Layer.cpp:87

-armnn::Layer::GetOutputSlot
const OutputSlot & GetOutputSlot(unsigned int index=0) const override
Get the const output slot handle by slot index.
Definition: Layer.hpp:326

-armnn::INetwork::AddMultiplicationLayer
IConnectableLayer * AddMultiplicationLayer(const char *name=nullptr)
Adds a multiplication layer to the network.
Definition: Network.cpp:219

-armnn::INetwork::AddReduceLayer
IConnectableLayer * AddReduceLayer(const ReduceDescriptor &reduceDescriptor, const char *name=nullptr)
Adds a reduce layer to the network.
Definition: Network.cpp:245

-armnn::FuseAdditionLayer
LayerType * FuseAdditionLayer(OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
Definition: ArmComputeSubgraphUtils.hpp:74

-armnn::FuseDepthwiseConvolution2dLayer
LayerType * FuseDepthwiseConvolution2dLayer(OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
Definition: ArmComputeSubgraphUtils.hpp:202

-armnn::ReplaceLayers
void ReplaceLayers(OptimizationViews &optimizationViews, LayerType *baseLayer, std::vector< IConnectableLayer *> &layers)
Definition: ArmComputeSubgraphUtils.hpp:316

-armnn::ComputeReductionTensorShape
const TensorInfo ComputeReductionTensorShape(const armnn::TensorInfo &input, const std::vector< uint32_t > &vAxis, const bool keepDims)
Function to compute the output tensor shape based on the axes and if keepDims is set.
Definition: ArmComputeUtils.hpp:352

-armnn::Layer
Definition: Layer.hpp:217

-armnn::FuseMultiplicationLayer
LayerType * FuseMultiplicationLayer(OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
Definition: ArmComputeSubgraphUtils.hpp:131

-armnn::FuseFullyConnectedLayer
LayerType * FuseFullyConnectedLayer(OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
Definition: ArmComputeSubgraphUtils.hpp:224

-armnn::LayerType
LayerType
When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below...
Definition: Types.hpp:466

+Go to the documentation of this file. //

+ // Copyright © 2020,2022 Arm Ltd and Contributors. All rights reserved.

+ // SPDX-License-Identifier: MIT

+ //

+

+ #pragma once

+

+ #include <armnn/backends/OptimizationViews.hpp>

+ #include <armnn/utility/Assert.hpp>

+

+ #include <aclCommon/ArmComputeUtils.hpp>

+ #include <backendsCommon/SubgraphUtils.hpp>

+

+ namespace armnn

+ {

+

+ namespace

+ {

+

+ //

+ // this helper only works if all layers where the inputs connect to are not selected

+ //

+

+ bool checkDataTypeInputandOutput(const Layer& layer)

+ {

+     auto inputInfo = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();

+     auto outputInfo = layer.GetOutputSlot(0).GetTensorInfo();

+     bool sameDataType = (inputInfo.GetDataType() == outputInfo.GetDataType());

+

+     // Check is same quantization info (same scale and offset)

+     if (sameDataType)

+     {

+         if (IsQuantizedType(inputInfo.GetDataType()))

+         {

+             bool sameScale = (inputInfo.GetQuantizationScale() == outputInfo.GetQuantizationScale());

+             bool sameOffset = (inputInfo.GetQuantizationOffset() == outputInfo.GetQuantizationOffset());

+

+             return (sameScale && sameOffset);

+         }

+         else

+         {

+             return true;

+         }

+     }

+     else

+     {

+         return false;

+     }

+ }

+

+ } // namespace

+

+ template<typename LayerType>

+ LayerType* FuseLayer(OptimizationViews& optimizationViews,

+                      LayerType* baseLayer,

+                      LayerType* replacementLayer,

+                      ActivationLayer* activationLayer,

+                      ActivationDescriptor& activationDesc)

+ {

+     replacementLayer->SetAdditionalInfoForObject(

+         std::make_shared<ActivationDescriptor>(activationDesc));

+

+     SubgraphView substitutionSubgraph({baseLayer, activationLayer},

+                                       CreateIInputsFrom({baseLayer}),

+                                       CreateIOutputsFrom({activationLayer}));

+     SubgraphView replacementSubgraph(replacementLayer);

+

+     optimizationViews.AddSubstitution({substitutionSubgraph, replacementSubgraph});

+

+     return replacementLayer;

+ }

+

+ template<typename LayerType>

+ LayerType* FuseAdditionLayer(OptimizationViews& optimizationViews,

+                              LayerType* baseLayer,

+                              ActivationLayer* activationLayer,

+                              ActivationDescriptor& activationDesc,

+                              std::string name)

+ {

+     IConnectableLayer* replacement = optimizationViews.GetINetwork()->AddAdditionLayer(name.c_str());

+     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

+

+     FuseLayer(optimizationViews,

+               baseLayer,

+               replacementLayer,

+               activationLayer,

+               activationDesc);

+

+     return replacementLayer;

+ }

+

+ template<typename LayerType>

+ LayerType* FuseSubtractionLayer(OptimizationViews& optimizationViews,

+                                 LayerType* baseLayer,

+                                 ActivationLayer* activationLayer,

+                                 ActivationDescriptor& activationDesc,

+                                 std::string name)

+ {

+     IConnectableLayer* replacement = optimizationViews.GetINetwork()->AddSubtractionLayer(name.c_str());

+     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

+

+     FuseLayer(optimizationViews,

+               baseLayer,

+               replacementLayer,

+               activationLayer,

+               activationDesc);

+

+     return replacementLayer;

+ }

+

+ template<typename LayerType>

+ LayerType* FuseDivisionLayer(OptimizationViews& optimizationViews,

+                              LayerType* baseLayer,

+                              ActivationLayer* activationLayer,

+                              ActivationDescriptor& activationDesc,

+                              std::string name)

+ {

+     IConnectableLayer* replacement = optimizationViews.GetINetwork()->AddDivisionLayer(name.c_str());

+     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

+

+     FuseLayer(optimizationViews,

+               baseLayer,

+               replacementLayer,

+               activationLayer,

+               activationDesc);

+

+     return replacementLayer;

+ }

+

+ template<typename LayerType>

+ LayerType* FuseMultiplicationLayer(OptimizationViews& optimizationViews,

+                                    LayerType* baseLayer,

+                                    ActivationLayer* activationLayer,

+                                    ActivationDescriptor& activationDesc,

+                                    std::string name)

+ {

+     IConnectableLayer* replacement = optimizationViews.GetINetwork()->AddMultiplicationLayer(name.c_str());

+     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

+

+     FuseLayer(optimizationViews,

+               baseLayer,

+               replacementLayer,

+               activationLayer,

+               activationDesc);

+

+     return replacementLayer;

+ }

+

+ template<typename LayerType>

+ LayerType* FuseBatchNormalizationLayer(OptimizationViews& optimizationViews,

+                                        LayerType* baseLayer,

+                                        ActivationLayer* activationLayer,

+                                        ActivationDescriptor& activationDesc,

+                                        std::string name)

+ {

+     IConnectableLayer* replacement =

+         optimizationViews.GetINetwork()->AddBatchNormalizationLayer(baseLayer->GetParameters(),

+                                                                     ConstTensor(),

+                                                                     ConstTensor(),

+                                                                     ConstTensor(),

+                                                                     ConstTensor(),

+                                                                     name.c_str());

+     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

+

+     FuseLayer(optimizationViews,

+               baseLayer,

+               replacementLayer,

+               activationLayer,

+               activationDesc);

+

+     SubgraphView substitutionSubgraph({baseLayer, activationLayer},

+                                       CreateIInputsFrom({baseLayer}),

+                                       CreateIOutputsFrom({activationLayer}));

+     SubgraphView replacementSubgraph(replacementLayer);

+

+     return replacementLayer;

+ }

+

+ template<typename LayerType>

+ LayerType* FuseConvolution2dLayer(OptimizationViews& optimizationViews,

+                                   LayerType* baseLayer,

+                                   ActivationLayer* activationLayer,

+                                   ActivationDescriptor& activationDesc,

+                                   std::string name)

+ {

+     IConnectableLayer* replacement = optimizationViews.GetINetwork()

+                                                       ->AddConvolution2dLayer(baseLayer->GetParameters(), name.c_str());

+

+     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

+

+

+     FuseLayer(optimizationViews,

+               baseLayer,

+               replacementLayer,

+               activationLayer,

+               activationDesc);

+

+     return replacementLayer;

+ }

+

+ template<typename LayerType>

+ LayerType* FuseDepthwiseConvolution2dLayer(OptimizationViews& optimizationViews,

+                                            LayerType* baseLayer,

+                                            ActivationLayer* activationLayer,

+                                            ActivationDescriptor& activationDesc,

+                                            std::string name)

+ {

+     IConnectableLayer* replacement =

+         optimizationViews.GetINetwork()->AddDepthwiseConvolution2dLayer(baseLayer->GetParameters(), name.c_str());

+

+     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

+

+

+     FuseLayer(optimizationViews,

+               baseLayer,

+               replacementLayer,

+               activationLayer,

+               activationDesc);

+

+     return replacementLayer;

+ }

+

+ template<typename LayerType>

+ LayerType* FuseFullyConnectedLayer(OptimizationViews& optimizationViews,

+                                    LayerType* baseLayer,

+                                    ActivationLayer* activationLayer,

+                                    ActivationDescriptor& activationDesc,

+                                    std::string name)

+ {

+     IConnectableLayer* replacement =

+         optimizationViews.GetINetwork()->AddFullyConnectedLayer(baseLayer->GetParameters(),

+                                                                 name.c_str());

+     LayerType* replacementLayer = PolymorphicDowncast<LayerType*>(replacement);

+

+     FuseLayer(optimizationViews,

+               baseLayer,

+               replacementLayer,

+               activationLayer,

+               activationDesc);

+

+

+     return replacementLayer;

+ }

+

+ //

+ // If reduce layer has multiple axes, add new layer for each axis to simulate the same behaviour

+ // as currently only one axis is supported.

+ //

+ template<typename LayerType>

+ std::vector<IConnectableLayer*> ChainReduceLayers(OptimizationViews& optimizationViews,

+                                       LayerType* baseLayer,

+                                       ReduceDescriptor& desc)

+ {

+     // Vector of new chained layers, used for substitution.

+     std::vector<IConnectableLayer*> layers;

+

+     // Vector of axes so each layer is reshaped correctly.

+     std::vector<uint32_t> axes;

+     unsigned int recalulatedAxis = 0;

+

+     for (unsigned int i = 0; i != desc.m_vAxis.size(); ++i)

+     {

+         // Get TensorInfo from base layer and reduce shape using axis.

+         TensorInfo layerInfo = baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo();

+

+         axes.emplace_back(desc.m_vAxis[i]);

+

+         const TensorInfo& reducedTensorInfo = ComputeReductionTensorShape(layerInfo,

+                                                                           axes,

+                                                                           desc.m_KeepDims);

+

+         // Create a vector for the single axis to be assigned to the descriptor.

+         // Update axis if keepDims is set reduce layers correctly.

+         std::vector<uint32_t> singleAxis(1, desc.m_vAxis[i] - recalulatedAxis);

+

+         // Create a descriptor and assign single axis.

+         ReduceDescriptor newReduceDescriptor = baseLayer->GetParameters();

+         newReduceDescriptor.m_vAxis.assign(singleAxis.begin(), singleAxis.end());

+

+         // Add new layer to graph.

+         std::string layerName = "reduce_layer_" + std::to_string(i);

+

+         Layer* replacementLayer = PolymorphicDowncast<Layer*>(

+             optimizationViews.GetINetwork()->AddReduceLayer(newReduceDescriptor,

+                                                             layerName.c_str()));

+

+         // Connect previous layer with new layer.

+         // The first and last layer will be connected when the subgraph is replaced.

+         if (!layers.empty())

+         {

+             layers[i - 1]->GetOutputSlot(0).Connect(replacementLayer->GetInputSlot(0));

+         }

+

+         // Set updated tensorInfo for new layer.

+         replacementLayer->GetOutputSlot(0).SetTensorInfo(reducedTensorInfo);

+

+         if (!desc.m_KeepDims)

+         {

+             recalulatedAxis++;

+         }

+

+         layers.emplace_back(replacementLayer);

+     }

+

+     // Check if the TensorInfo from the last layer equals the inferred output from the original layer.

+     ARMNN_ASSERT(baseLayer->GetOutputSlot(0).GetTensorInfo() ==

+                  PolymorphicDowncast<Layer*>(layers.back())->GetOutputSlot().GetTensorInfo());

+

+     return layers;

+ }

+

+ //

+ // Substitute baseLayer with new subgraph

+ //

+ template<typename LayerType>

+ void ReplaceLayers(OptimizationViews& optimizationViews,

+                    LayerType* baseLayer,

+                    std::vector<IConnectableLayer*>& layers)

+ {

+     std::list<IConnectableLayer*> replacementLayers(layers.begin(), layers.end());

+

+     SubgraphView substitutionSubgraph(baseLayer);

+     SubgraphView replacementSubgraph(std::move(replacementLayers),

+                                      CreateIInputsFrom({replacementLayers.front()}),

+                                      CreateIOutputsFrom({replacementLayers.back()}));

+

+     optimizationViews.AddSubstitution({substitutionSubgraph, replacementSubgraph});

+ }

+

+ } // namespace armnn