python/pyarmnn/src/pyarmnn/swig/modules/armnn_network.i

//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
%{
#include "armnn/INetwork.hpp"
#include "armnn/BackendId.hpp"
#include "armnn/Types.hpp"
#include "armnn/Optional.hpp"
#include <fstream>
%}

%include <typemaps/network_optimize.i>
%include <typemaps/model_options.i>

namespace std {
    %template() std::vector<armnn::BackendOptions>;
}

namespace armnn
{
%feature("docstring",
"
Struct for holding options relating to the Arm NN optimizer. See `Optimize`.

Contains:
    m_debug (bool): Add debug data for easier troubleshooting.
    m_ReduceFp32ToBf16 (bool): Reduces Fp32 network to BFloat16 (Bf16) for faster processing. Layers
                               that can not be reduced will be left in Fp32.
    m_ReduceFp32ToFp16 (bool): Reduces Fp32 network to Fp16 for faster processing. Layers
                               that can not be reduced will be left in Fp32.
    m_ImportEnabled (bool):    Enable memory import of inport tensors.
    m_shapeInferenceMethod:    The ShapeInferenceMethod modifies how the output shapes are treated.
                               When ValidateOnly is selected, the output shapes are inferred from the input parameters
                               of the layer and any mismatch is reported.
                               When InferAndValidate is selected 2 actions are performed: (1)infer output shape from
                               inputs and (2)validate the shapes as in ValidateOnly. This option has been added to work
                               with tensors which rank or dimension sizes are not specified explicitly, however this
                               information can be calculated from the inputs.
    m_ModelOptions:            List of backends optimisation options.
    m_ExportEnabled (bool):    Enable memory export of output tensors.

") OptimizerOptions;

%model_options_typemap;
struct OptimizerOptions
{
    OptimizerOptions();

    OptimizerOptions(bool reduceFp32ToFp16,
                     bool debug,
                     bool reduceFp32ToBf16 = false,
                     ShapeInferenceMethod shapeInferenceMethod = armnn::ShapeInferenceMethod::ValidateOnly,
                     bool importEnabled = false,
                     std::vector<armnn::BackendOptions> modelOptions = {},
                     bool exportEnabled = false);

    bool m_ReduceFp32ToBf16;
    bool m_ReduceFp32ToFp16;
    bool m_Debug;
    ShapeInferenceMethod m_shapeInferenceMethod;
    bool m_ImportEnabled;
    std::vector<armnn::BackendOptions> m_ModelOptions;
    bool m_ExportEnabled;
};
%model_options_clear;

%feature("docstring",
"
An input connection slot for a layer. Slot lifecycle is managed by the layer.

The input slot can be connected to an output slot of the preceding layer in the graph.
Only one connection to the input slot is allowed.

") IInputSlot;
%nodefaultctor IInputSlot;
%nodefaultdtor IInputSlot;
class IInputSlot
{
public:
    %feature("docstring",
    "
    Returns output slot of a preceding layer that is connected to the given input slot.

    Returns:
        IOutputSlot: Borrowed reference to an output connection slot for a preceding layer.

    ") GetConnection;

    armnn::IOutputSlot* GetConnection();
};

%feature("docstring",
"
An output connection slot for a layer. Slot lifecycle is managed by the layer.

The output slot may be connected to 1 or more input slots of subsequent layers in the graph.
") IOutputSlot;
%nodefaultctor IOutputSlot;
%nodefaultdtor IOutputSlot;
class IOutputSlot
{
public:

    %feature("docstring",
    "
    Returns the total number of connected input slots.

    The same result could be obtained by calling `len()`:

    >>> output_slot = ...
    >>> size = len(output_slot)
    >>> assert size == output_slot.GetNumConnections()

    Returns:
        int: Number of connected input slots.
    ") GetNumConnections;
    unsigned int GetNumConnections();


    %feature("docstring",
    "
    Retrieves connected input slot by index.

    The same result could be obtained by using square brackets:

    >>> output_slot = ...
    >>> connected_input_slot = output_slot[0]

    Args:
       index (int): Slot index.

    Returns:
        IInputSlot: Borrowed reference to connected input slot with given index.

    Raises:
        RuntimeError: If index out of bounds.
    ") GetConnection;
    armnn::IInputSlot* GetConnection(unsigned int index);

    %feature("docstring",
    "
    Sets tensor info for output slot.
    Operation does not change TensorInfo ownership.
    Args:
        tensorInfo (TensorInfo): Output tensor info.

    ") SetTensorInfo;
    void SetTensorInfo(const armnn::TensorInfo& tensorInfo);

    %feature("docstring",
    "
    Gets tensor info for output slot.

    Args:
        tensorInfo (TensorInfo): Output tensor info.

    ") GetTensorInfo;
    const armnn::TensorInfo& GetTensorInfo();

    %feature("docstring",
    "
    Checks if tensor info was set previously.

    Returns:
        bool: True if output tensor info was set, False - otherwise.

    ") IsTensorInfoSet;
    bool IsTensorInfoSet();

    %feature("docstring",
    "
    Connects this output slot with given input slot.
    Input slot is updated with this output connection.

    Args:
        destination (IInputSlot): Output tensor info.

    Returns:
        int: Total number of connections.

    Raises:
        RuntimeError: If input slot was already connected.

    ") Connect;
    int Connect(IInputSlot& destination);

    %feature("docstring",
    "
    Disconnects this output slot from given input slot.

    Args:
        slot (IInputSlot): Input slot to disconnect from.

    ") Disconnect;
    void Disconnect(IInputSlot& slot);

    %feature("docstring",
    "
    Calculates the index of this slot for the layer.

    Returns:
        int: Slot index.

    ") CalculateIndexOnOwner;
    unsigned int CalculateIndexOnOwner();

    %feature("docstring",
    "
    Returns the index of the layer. Same value as `IConnectableLayer.GetGuid`.

    Returns:
        int: Layer id.

    ") GetOwningLayerGuid;
    unsigned int GetOwningLayerGuid();

};

%extend IOutputSlot {

    armnn::IInputSlot* __getitem__(unsigned int index) {
        return $self->GetConnection(index);
    }

    unsigned int __len__() const {
        return $self->GetNumConnections();
    }

}

%feature("docstring",
"
Interface for a layer that is connectable to other layers via `IInputSlot` and `IOutputSlot`.
The object implementing this interface is returned by `INetwork` when calling `add*Layer` methods.

") IConnectableLayer;
%nodefaultctor IConnectableLayer;
%nodefaultdtor IConnectableLayer;
class IConnectableLayer
{
public:
    %feature("docstring",
    "
    Returns the name of the layer. Name attribute is optional for a layer, thus
    `None` value could be returned.

    Returns:
        str: Layer name or `None`.

    ") GetName;
    const char* GetName();

    %feature("docstring",
    "
    Gets the number of input slots for the layer.

    Returns:
        int: Number of input slots.

    ") GetNumInputSlots;
    unsigned int GetNumInputSlots();

    %feature("docstring",
    "
    Gets the number of output slots for the layer.

    Returns:
        int: Number of output slots.

    ") GetNumOutputSlots;
    unsigned int GetNumOutputSlots();

    %feature("docstring",
    "
    Gets the input slot by index.

    Args:
        index (int): Slot index.

    Returns:
        IInputSlot: Borrowed reference to input slot.

    ") GetInputSlot;
    armnn::IInputSlot& GetInputSlot(unsigned int index);

    %feature("docstring",
    "
    Gets the output slot by index.

    Args:
        index (int): Slot index.

    Returns:
        IOutputSlot: Borrowed reference to output slot.

    ") GetOutputSlot;
    armnn::IOutputSlot& GetOutputSlot(unsigned int index);


    %feature("docstring",
    "
    Gets the unique layer id (within one process).
    Guid is generated and assigned automatically when the layer is created.

    Returns:
        int: The unique layer id.

    ") GetGuid;
    unsigned int GetGuid();
};

%feature("docstring",
    "
    Interface for a network object. Network objects contain the whole computation graph, made up of different layers connected together.

    INetwork objects can be constructed manually or obtained by using parsers. INetwork objects are used to create optimized networks, see `Optimize`.

    ") INetwork;
%nodefaultctor INetwork;
%nodefaultdtor INetwork;
class INetwork
{
public:

    %feature("docstring",
        "
        Adds an input layer to the network. Input layers are placed at the start of a network and used for feeding input data during inference.

        Args:
            id (int): User generated id to uniquely identify a particular input. The same id needs to be specified
                      when passing the inputs to the IRuntime::EnqueueWorkload() function.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddInputLayer;
    armnn::IConnectableLayer* AddInputLayer(int id, const char* name = nullptr);

    %feature("docstring",
        "
        Adds an addition layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddAdditionLayer;
    armnn::IConnectableLayer* AddAdditionLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds an output layer to the network. Output layer is the final layer in your network.

    Args:
        id (int): User generated id to uniquely identify a particular input. The same id needs to be specified
                  when passing the inputs to `IRuntime.EnqueueWorkload()`.
        name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddOutputLayer;
    armnn::IConnectableLayer* AddOutputLayer(int id, const char* name = nullptr);


    %feature("docstring",
        "
        Adds an Activation layer to the network. Type of activation is decided by activationDescriptor.

        Args:
            activationDescriptor (ActivationDescriptor): ActivationDescriptor to configure the activation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddActivationLayer;
    armnn::IConnectableLayer* AddActivationLayer(const ActivationDescriptor& activationDescriptor,
        const char* name = nullptr);


    %feature("docstring",
        "
        Adds an ArgMinMax layer to the network.

        Args:
            desc (ArgMinMaxDescriptor): Parameters for the ArgMinMax layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddArgMinMaxLayer;
    armnn::IConnectableLayer* AddArgMinMaxLayer(const armnn::ArgMinMaxDescriptor& desc,
                                                 const char* name = nullptr);


    %feature("docstring",
        "
        Adds a Batch Normalization layer to the network.

        Args:
            mean (ConstTensor): Pre-calculated mean for each channel.
            variance (ConstTensor): Pre-calculated variance for each channel.
            beta (ConstTensor): Per-channel additive factor.
            gamma (ConstTensor): Per-channel multiplicative factor.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddBatchNormalizationLayer;
    armnn::IConnectableLayer* AddBatchNormalizationLayer(const armnn::BatchNormalizationDescriptor& desc,
        const armnn::ConstTensor& mean,
        const armnn::ConstTensor& variance,
        const armnn::ConstTensor& beta,
        const armnn::ConstTensor& gamma,
        const char* name = nullptr);


    %feature("docstring",
        "
        Adds a Batch To Space ND layer to the network.

        Args:
            batchToSpaceNdDescriptor (BatchToSpaceNdDescriptor): Configuration parameters for the layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddBatchToSpaceNdLayer;
    armnn::IConnectableLayer* AddBatchToSpaceNdLayer(const armnn::BatchToSpaceNdDescriptor& batchToSpaceNdDescriptor,
                                                     const char* name = nullptr);

    %feature("docstring",
         "
        Adds a ChannelShuffle layer to the network.

        Args:
            channelShuffleDescriptor (ChannelShuffleDescriptor): Configuration parameters for the layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddChannelShuffleLayer;
    armnn::IConnectableLayer* AddChannelShuffleLayer(const armnn::ChannelShuffleDescriptor& channelShuffleDescriptor,
                                                     const char* name = nullptr);



    %feature("docstring",
        "
        Adds a Cast layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddCastLayer;
    armnn::IConnectableLayer* AddCastLayer(const char* name = nullptr);


    %feature("docstring",
        "
        Adds a Comparison layer to the network.

        Args:
            comparisonDescriptor (ComparisonDescriptor): Configuration parameters for the layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddComparisonLayer;
    armnn::IConnectableLayer* AddComparisonLayer(const armnn::ComparisonDescriptor& comparisonDescriptor,
                                                 const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Concatenation layer to the network.

        Args:
            concatDescriptor (ConcatDescriptor): Parameters to configure the Concatenation layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddConcatLayer;
    armnn::IConnectableLayer* AddConcatLayer(const armnn::ConcatDescriptor& concatDescriptor,
                                             const char* name = nullptr);


    %feature("docstring",
        "
        Adds a layer with no inputs and a single output, which always corresponds to the passed in constant tensor.

        Args:
            input (ConstTensor): Tensor to be provided as the only output of the layer. The layer will maintain
                    its own copy of the tensor data, meaning the memory referenced by input can
                    be freed or reused after this function is called.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddConstantLayer;
    armnn::IConnectableLayer* AddConstantLayer(const armnn::ConstTensor& input,
                                               const char* name = nullptr);


    %feature("docstring",
             "
    Adds a 3D Convolution layer to the network.

            Args:
    convolution3dDescriptor (Convolution3dDescriptor): Description of the 3D convolution layer.
            name (str): Optional name for the layer.

            Returns:
    IConnectableLayer: Interface for configuring the layer.
    ") AddConvolution3dLayer;

    armnn::IConnectableLayer* AddConvolution3dLayer(const armnn::Convolution3dDescriptor& convolution3dDescriptor,
    const char* name = nullptr);


    %feature("docstring",
        "
        Adds a Depth To Space layer to the network.

        Args:
            depthToSpaceDescriptor (DepthToSpaceDescriptor): Parameters for the depth to space operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddDepthToSpaceLayer;
    armnn::IConnectableLayer* AddDepthToSpaceLayer(const armnn::DepthToSpaceDescriptor& depthToSpaceDescriptor,
                                                   const char* name = nullptr);

    %feature("docstring",
        "
        Adds a 2D Depthwise Convolution layer to the network.

        Args:
            convolution2dDescriptor (DepthwiseConvolution2dDescriptor): Description of the 2D depthwise convolution layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddDepthwiseConvolution2dLayer;

    armnn::IConnectableLayer* AddDepthwiseConvolution2dLayer(
        const armnn::DepthwiseConvolution2dDescriptor& convolution2dDescriptor,
        const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Dequantize layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddDequantizeLayer;
    armnn::IConnectableLayer* AddDequantizeLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Detection PostProcess layer to the network. Detection PostProcess is a custom layer for SSD MobilenetV1.

        Args:
            descriptor (DetectionPostProcessDescriptor): Description of the Detection PostProcess layer.
            anchors (ConstTensor): Tensor for anchors.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddDetectionPostProcessLayer;
    armnn::IConnectableLayer* AddDetectionPostProcessLayer(
        const armnn::DetectionPostProcessDescriptor& descriptor,
        const armnn::ConstTensor& anchors,
        const char* name = nullptr);


    %feature("docstring",
        "
        Adds a Division layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddDivisionLayer;
    armnn::IConnectableLayer* AddDivisionLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds an Elementwise Unary layer to the network. Type of unary operation to use is decided by elementwiseUnaryDescriptor. Unary operations supported are (Abs, Exp, Neg, Rsqrt, Sqrt)

        Args:
            elementwiseUnaryDescriptor (ElementwiseUnaryDescriptor): ElementwiseUnaryDescriptor to configure the choice of unary operation added to the network.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddElementwiseUnaryLayer;
    armnn::IConnectableLayer* AddElementwiseUnaryLayer(const ElementwiseUnaryDescriptor& elementwiseUnaryDescriptor,
                                                       const char* name = nullptr);

    %feature("docstring",
        "
        Add a Fill layer to the network.

        Args:
            FillDescriptor (FillDescriptor): Descriptor for the fill operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddFillLayer;
    armnn::IConnectableLayer* AddFillLayer(const FillDescriptor& fillDescriptor,
                                           const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Floor layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddFloorLayer;
    armnn::IConnectableLayer* AddFloorLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Add Gather layer to the network.

        Args:
            descriptor (GatherDescriptor): Descriptor for the gather operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddGatherLayer;
    armnn::IConnectableLayer* AddGatherLayer(const GatherDescriptor& descriptor,
                                             const char* name = nullptr);

    %feature("docstring",
        "
        Add GatherNd layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddGatherNdLayer;
    armnn::IConnectableLayer* AddGatherNdLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds an Instance Normalization layer to the network.

        Args:
            desc (InstanceNormalizationDescriptor): Parameters for the instance normalization operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddInstanceNormalizationLayer;
    armnn::IConnectableLayer* AddInstanceNormalizationLayer(const armnn::InstanceNormalizationDescriptor& desc,
                                                            const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Log Softmax layer to the network.

        Args:
            desc (SoftmaxDescriptor): parameters to configure the log softmax.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddLogSoftmaxLayer;
    armnn::IConnectableLayer* AddLogSoftmaxLayer(const armnn::LogSoftmaxDescriptor& logSoftmaxDescriptor,
                                                  const char* name = nullptr);

    %feature("docstring",
        "
        Adds an L2 Normalization layer to the network.
        Normalization is performed along dimension 1, but requires a 4d input.

        Args:
            desc (L2NormalizationDescriptor): Parameters for the L2 normalization operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddL2NormalizationLayer;
    armnn::IConnectableLayer* AddL2NormalizationLayer(const armnn::L2NormalizationDescriptor& desc,
                                                       const char* name = nullptr);

    %feature("docstring",
        "
        Add a Long Short-Term Memory layer to the network.

        Args:
            descriptor (LstmDescriptor): Parameters for the Lstm operation.
            params (LstmInputParams): Weights and biases for the LSTM cell.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddLstmLayer;
    armnn::IConnectableLayer* AddLstmLayer(const armnn::LstmDescriptor& descriptor,
                                            const armnn::LstmInputParams& params,
                                            const char* name = nullptr);

    %feature("docstring",
        "
        Add a Maximum layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddMaximumLayer;
    armnn::IConnectableLayer* AddMaximumLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Mean layer to the network.

        Args:
            meanDescriptor (meanDescriptor): Parameters for the mean operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddMeanLayer;
    armnn::IConnectableLayer* AddMeanLayer(const armnn::MeanDescriptor& meanDescriptor, const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Merge layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddMergeLayer;
    armnn::IConnectableLayer* AddMergeLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Minimum layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddMinimumLayer;
    armnn::IConnectableLayer* AddMinimumLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Multiplication layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddMultiplicationLayer;
    armnn::IConnectableLayer* AddMultiplicationLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Normalization layer to the network.

        Args:
            normalizationDescriptor (NormalizationDescriptor): Parameters to configure the normalization.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddNormalizationLayer;
    armnn::IConnectableLayer* AddNormalizationLayer(const armnn::NormalizationDescriptor& normalizationDescriptor,
        const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Pad layer to the network.

        Args:
            padDescriptor (PadDescriptor): Padding configuration for the layer. See `PadDescriptor` for more details.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddPadLayer;
    armnn::IConnectableLayer* AddPadLayer(const armnn::PadDescriptor& padDescriptor,
                                           const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Permute layer to the network.

        Args:
            permuteDescriptor (PermuteDescriptor): Configuration of the permutation layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddPermuteLayer;
    armnn::IConnectableLayer* AddPermuteLayer(const armnn::PermuteDescriptor& permuteDescriptor,
                                               const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Pooling layer to the network. Type of pooling is decided by the configuration.

        Args:
            pooling2dDescriptor (Pooling2dDescriptor): Configuration for the pooling layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddPooling2dLayer;
    armnn::IConnectableLayer* AddPooling2dLayer(const armnn::Pooling2dDescriptor& pooling2dDescriptor,
                                                const char* name = nullptr);

    %feature("docstring",
        "
        Adds a 3D Pooling layer to the network. Type of 3D pooling is decided by the configuration.

        Args:
            pooling3dDescriptor (Pooling3dDescriptor): Configuration for the 3D pooling layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddPooling3dLayer;
    armnn::IConnectableLayer* AddPooling3dLayer(const armnn::Pooling3dDescriptor& pooling3dDescriptor,
                                                const char* name = nullptr);

    %feature("docstring",
        "
        Adds a PReLU layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddPreluLayer;
    armnn::IConnectableLayer* AddPreluLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Quantize layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddQuantizeLayer;
    armnn::IConnectableLayer* AddQuantizeLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Quantized Long Short-Term Memory layer to the network.

        Args:
            params (`QuantizedLstmInputParams`): The weights and biases for the Quantized LSTM cell.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddQuantizedLstmLayer;
    armnn::IConnectableLayer* AddQuantizedLstmLayer(const armnn::QuantizedLstmInputParams& params,
                                                     const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Rank layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddRankLayer;
    armnn::IConnectableLayer* AddRankLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Reduce layer to the network.

        Args:
            reduceDescriptor (ReduceDescriptor): Parameters for the reduce operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddReduceLayer;
    armnn::IConnectableLayer* AddReduceLayer(const armnn::ReduceDescriptor& reduceDescriptor,
                                             const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Reshape layer to the network.

        Args:
            reshapeDescriptor (ReshapeDescriptor): Parameters for the reshape operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddReshapeLayer;
    armnn::IConnectableLayer* AddReshapeLayer(const armnn::ReshapeDescriptor& reshapeDescriptor,
                                               const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Resize layer to the network.

        Args:
            resizeDescriptor (ResizeDescriptor): Configuration for the resize layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddResizeLayer;
    armnn::IConnectableLayer* AddResizeLayer(const armnn::ResizeDescriptor& resizeDescriptor,
                                              const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Shape layer to the network.

        Args:
            name(str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer
        ") AddShapeLayer;
    armnn::IConnectableLayer* AddShapeLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Slice layer to the network.

        Args:
            sliceDescriptor (SliceDescriptor): Descriptor to configure the slice operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddSliceLayer;
    armnn::IConnectableLayer* AddSliceLayer(const armnn::SliceDescriptor& sliceDescriptor,
                                            const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Softmax layer to the network.

        If the data type is `DataType_QuantisedAsymm8`, then the output quantization parameters
        must have a scale of 1/256 and an offset of 0.

        Args:
            softmaxDescriptor (SoftmaxDescriptor): Configuration for the softmax layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddSoftmaxLayer;
    armnn::IConnectableLayer* AddSoftmaxLayer(const armnn::SoftmaxDescriptor& softmaxDescriptor,
        const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Space To Batch layer to the network.

        Args:
            spaceToBatchNdDescriptor (SpaceToBatchNdDescriptor): Configuration for the space to batch layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddSpaceToBatchNdLayer;
    armnn::IConnectableLayer* AddSpaceToBatchNdLayer(const armnn::SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
                                                      const char* name = nullptr);

    %feature("docstring",
        "
        Adds a space to depth layer to the network.

        Args:
            spaceToDepthDescriptor (SpaceToDepthDescriptor): Parameters for the space to depth operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddSpaceToDepthLayer;
    armnn::IConnectableLayer* AddSpaceToDepthLayer(const armnn::SpaceToDepthDescriptor& spaceToDepthDescriptor,
                                                    const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Splitter layer to the network.

        Args:
            splitterDescriptor (SplitterDescriptor): Parameters to configure the splitter layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddSplitterLayer;
    armnn::IConnectableLayer* AddSplitterLayer(const armnn::SplitterDescriptor& splitterDescriptor,
                                                const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Stack layer to the network.

        Args:
            descriptor (StackDescriptor):  Descriptor to configure the stack layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddStackLayer;
    armnn::IConnectableLayer* AddStackLayer(const armnn::StackDescriptor& descriptor,
                                             const char* name = nullptr);

    %feature("docstring",
        "
        Adds a StandIn layer to the network.

        Args:
            descriptor (StandInDescriptor): Parameters to configure the standIn layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddStandInLayer;
    armnn::IConnectableLayer* AddStandInLayer(const armnn::StandInDescriptor& descriptor,
                                              const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Strided Slice layer to the network.

        Args:
            stridedSliceDescriptor (StridedSliceDescriptor): Parameters for the strided slice operation.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddStridedSliceLayer;
    armnn::IConnectableLayer* AddStridedSliceLayer(const armnn::StridedSliceDescriptor& stridedSliceDescriptor,
                                                   const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Subtraction layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddSubtractionLayer;
    armnn::IConnectableLayer* AddSubtractionLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Switch layer to the network.

        Args:
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddSwitchLayer;
    armnn::IConnectableLayer* AddSwitchLayer(const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Fully Connected layer to the network. Also known as a Linear or Dense layer.

        Args:
            fullyConnectedDescriptor (FullyConnectedDescriptor): Description of the fully connected layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddFullyConnectedLayer;
    armnn::IConnectableLayer* AddFullyConnectedLayer(const armnn::FullyConnectedDescriptor& fullyConnectedDescriptor,
                                                     const char* name = nullptr);

    %feature("docstring",
        "
        Adds a LogicalBinary layer to the network.

        Args:
            logicalBinaryDescriptor (LogicalBinaryDescriptor): Description of the LogicalBinary layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddLogicalBinaryLayer;
    armnn::IConnectableLayer* AddLogicalBinaryLayer(const armnn::LogicalBinaryDescriptor& logicalBinaryDescriptor,
                                                    const char* name = nullptr);

    %feature("docstring",
        "
        Adds a Transpose layer to the network.

        Args:
            transposeDescriptor (TransposeDescriptor): Description of the transpose layer.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddTransposeLayer;
    armnn::IConnectableLayer* AddTransposeLayer(const armnn::TransposeDescriptor& transposeDescriptor,
                                                const char* name = nullptr);
};

%extend INetwork {

    INetwork() {
        return armnn::INetwork::CreateRaw();
    }

    ~INetwork() {
        armnn::INetwork::Destroy($self);
    }

    %feature("docstring",
        "
        Adds a 2D Transpose Convolution layer to the network.

        Args:
            descriptor (TransposeConvolution2dDescriptor): Descriptor containing all parameters to configure this layer.
            weights (ConstTensor): Tensor for the weights data.
            biases (ConstTensor): Optional tensor for the bias data.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddTransposeConvolution2dLayer;
    armnn::IConnectableLayer* AddTransposeConvolution2dLayer(const armnn::TransposeConvolution2dDescriptor& descriptor,
                                                             const armnn::ConstTensor& weights,
                                                             armnn::ConstTensor* biases = nullptr,
                                                             const char* name = nullptr) {

        if (biases) {
            return $self->AddTransposeConvolution2dLayer(descriptor, weights,
                                                 armnn::Optional<armnn::ConstTensor>(*biases), name);
        } else {
            return $self->AddTransposeConvolution2dLayer(descriptor, weights,
                                                 armnn::Optional<armnn::ConstTensor>(), name);
        }
    }


    %feature("docstring",
        "
        Adds a 2D Convolution layer to the network.

        Args:
            convolution2dDescriptor (Convolution2dDescriptor): Description of the 2D convolution layer.
            weights (ConstTensor): Tensor for the weights data.
            biases (ConstTensor): Optional tensor for the bias data. If specified, must match the output tensor shape.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddConvolution2dLayer;
    armnn::IConnectableLayer* AddConvolution2dLayer(const armnn::Convolution2dDescriptor& convolution2dDescriptor,
                                                    const armnn::ConstTensor& weights,
                                                    armnn::ConstTensor* biases = nullptr,
                                                    const char* name = nullptr) {

        if (biases) {
            return $self->AddConvolution2dLayer(convolution2dDescriptor, weights,
                                                 armnn::Optional<armnn::ConstTensor>(*biases), name);
        } else {
            return $self->AddConvolution2dLayer(convolution2dDescriptor, weights,
                                                 armnn::Optional<armnn::ConstTensor>(), name);
        }
    }

    %feature("docstring",
        "
        Adds a 2D Depthwise Convolution layer to the network.

        Args:
            convolution2dDescriptor (DepthwiseConvolution2dDescriptor): Description of the 2D depthwise convolution layer.
            weights (ConstTensor): Tensor for the weights. Expected format: [channelMultiplier, inputChannels, height, width].
            biases (ConstTensor): Optional tensor for the bias data. If specified, must match the output tensor shape.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") AddDepthwiseConvolution2dLayer;

    armnn::IConnectableLayer* AddDepthwiseConvolution2dLayer(
        const armnn::DepthwiseConvolution2dDescriptor& convolution2dDescriptor,
        const armnn::ConstTensor& weights,
        const armnn::ConstTensor* biases = nullptr,
        const char* name = nullptr) {

        ARMNN_NO_DEPRECATE_WARN_BEGIN
        if (biases) {
            return $self->AddDepthwiseConvolution2dLayer(convolution2dDescriptor, weights,
                                                 armnn::Optional<armnn::ConstTensor>(*biases), name);
        } else {
            return $self->AddDepthwiseConvolution2dLayer(convolution2dDescriptor, weights,
                                                 armnn::Optional<armnn::ConstTensor>(), name);
        }
        ARMNN_NO_DEPRECATE_WARN_END
    }

}

%feature("docstring",
        "
        Interface class for an optimzied network object. Optimized networks are obtained after running `Optimize` on
        an `INetwork` object.
        Optimized networks are passed to `EnqueueWorkload`.

        Args:
            convolution2dDescriptor (DepthwiseConvolution2dDescriptor): Description of the 2D depthwise convolution layer.
            weights (ConstTensor): Tensor for the weights. Expected format: [channelMultiplier, inputChannels, height, width].
            biases (ConstTensor): Optional tensor for the bias data. If specified, must match the output tensor shape.
            name (str): Optional name for the layer.

        Returns:
            IConnectableLayer: Interface for configuring the layer.
        ") IOptimizedNetwork;
%nodefaultctor IOptimizedNetwork;
%nodefaultdtor IOptimizedNetwork;
class IOptimizedNetwork
{
};

%extend IOptimizedNetwork {

    ~IOptimizedNetwork() {
        armnn::IOptimizedNetwork::Destroy($self);
    }

    %feature("docstring",
        "
        Saves optimized network graph as dot file.

        Args:
            fileName (str): File path to save to.
        Raises:
            RuntimeError: If serialization failure.
        ") SerializeToDot;

    void SerializeToDot(const std::string& fileName) {
        std::ofstream dot;
        dot.open(fileName);
        if(!dot.is_open())
        {
            throw armnn::Exception("Failed to open dot file");
        } else {
            armnn::Status status = $self->SerializeToDot(dot);
            dot.close();
            if(status == armnn::Status::Failure)
            {
                throw armnn::Exception("Failed to serialize to dot");
            }
        }
    };
}
}

%{
    std::pair<armnn::IOptimizedNetwork*, std::vector<std::string>> Optimize(const armnn::INetwork* network,
                                       const std::vector<armnn::BackendId>& backendPreferences,
                                       const armnn::IDeviceSpec& deviceSpec,
                                       const armnn::OptimizerOptions& options = armnn::OptimizerOptions())
    {
        std::vector<std::string> errorMessages;
        armnn::IOptimizedNetwork* optimizedNetwork = armnn::Optimize(*network, backendPreferences, deviceSpec,
            options, armnn::Optional<std::vector<std::string> &>(errorMessages)).release();

        if(!optimizedNetwork)
        {
            std::string errorString;

            for (auto error : errorMessages) {
                errorString.append(error);
            }

            throw armnn::Exception(errorString);
        }

        return std::make_pair(optimizedNetwork, errorMessages);
    };
%}

%feature("docstring",
    "
    Create an optimized version of the given network. Should be called before loading a network into the runtime.

    Examples:
        Optimize a loaded network ready for inference.
        >>> parser = ann.ITfLiteParser()
        >>> network = parser.CreateNetworkFromBinaryFile('./model.tflite')
        >>>
        >>> preferredBackends = [ann.BackendId('CpuAcc'), ann.BackendId('CpuRef')]
        >>> opt_network, messages = ann.Optimize(network, preferredBackends, runtime.GetDeviceSpec(), ann.OptimizerOptions())

    Args:
        network (INetwork): INetwork description of the network to be optimized.
        backendPreferences (list): The choice of the backend ordered by user preferences. See `BackendId`.
        deviceSpec (IDeviceSpec): DeviceSpec object as queried from the runtime. See `IRuntime.GetDeviceSpec`.
        options (OptimizerOptions): Object with optimizer configuration options.

    Returns:
        tuple: (`IOptimizedNetwork`, a tuple of failures or warnings).

    Raises:
        RuntimeError: If process fails.
    ") Optimize;

%optimize_typemap_out;
std::pair<armnn::IOptimizedNetwork*, std::vector<std::string>> Optimize(const armnn::INetwork* network,
                                   const std::vector<armnn::BackendId>& backendPreferences,
                                   const armnn::IDeviceSpec& deviceSpec,
                                   const armnn::OptimizerOptions& options = OptimizerOptions());
%clear_optimize_typemap_out;