ModelToINetworkTransformer.cpp

Go to the documentation of this file.

//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
 
#define LOG_TAG "arm-armnn-sl"
 
#include "ModelToINetworkTransformer.hpp"
#include "CanonicalUtils.hpp"
#include "Converter.hpp"
 
#include <log/log.h>
#include <type_traits>
 
namespace armnn_driver
{
 
ModelToINetworkTransformer::ModelToINetworkTransformer(
    const std::vector<armnn::BackendId>& backends,
    const Model& model,
    const std::set<unsigned int>& forcedUnsupportedOperations)
    : m_Data(backends)
    , m_Model(model)
    , m_ForcedUnsupportedOperations(forcedUnsupportedOperations)
    , m_ConversionResult(ConversionResult::Success)
{
    try
    {
        Convert();
    }
    catch (std::exception& e)
    {
        m_ConversionResult = ConversionResult::UnsupportedFeature;
        VLOG(DRIVER) << "ModelToINetworkTransformer: Unexpected exception: " << e.what() << " Model was: "
                     << GetModelSummary(model);
        assert(false);
    }
}
 
void ModelToINetworkTransformer::Convert()
{
    VLOG(DRIVER) << "ModelToINetworkTransformer: Convert()";
    //VLOG(DRIVER) << "ModelToINetworkTransformer: Convert(): " << GetModelSummary(m_Model).c_str();
 
    // map the memory pool into shared pointers
    m_Data.m_MemPools.clear();
    if (!setRunTimePoolInfosFromCanonicalMemories(&m_Data.m_MemPools, m_Model.pools))
    {
        VLOG(DRIVER) << "Setting of run time pool infos from Hidl Memories has failed." << __func__;
        m_ConversionResult = ConversionResult::ErrorMappingPools;
        return;
    }
 
    using NetworkOptions = std::vector<armnn::BackendOptions>;
    NetworkOptions networkOptions;
    armnn::BackendOptions shapeInferenceMethodOption("ShapeInferenceMethod",
                                                    {
                                                            { "InferAndValidate", true }
                                                    });
 
    networkOptions.push_back(shapeInferenceMethodOption);
 
    // Create armnn::INetwork
    m_Data.m_Network = armnn::INetwork::Create(networkOptions);
 
    // add operations to it
    // track which layer outputs each operand
    VLOG(DRIVER) << "ModelToINetworkTransformer::Convert(): m_OutputSlotForOperand";
    m_Data.m_OutputSlotForOperand = std::vector<armnn::IOutputSlot*>(m_Model.main.operands.size(), nullptr);
    try
    {
        VLOG(DRIVER) << "ModelToINetworkTransformer::Convert(): for m_Model.inputIndexes.size()";
        for (uint32_t i = 0; i < m_Model.main.inputIndexes.size(); i++)
        {
            VLOG(DRIVER) << "ModelToINetworkTransformer::Convert(): m_Model.inputIndexes[i]";
            // inputs in android nn are represented by operands
            uint32_t inputIndex = m_Model.main.inputIndexes[i];
            VLOG(DRIVER) << "ModelToINetworkTransformer::Convert(): m_Model.operands[inputIndex]";
            const Operand& operand = m_Model.main.operands[inputIndex];
            VLOG(DRIVER) << "ModelToINetworkTransformer::Convert(): GetTensorInfoForOperand(operand)";
 
            const armnn::TensorInfo& tensor = GetTensorInfoForOperand(operand);
            const std::string layerName = "Input_" + std::to_string(i);
            VLOG(DRIVER) << "ModelToINetworkTransformer::Convert(): m_Data.m_Network->AddInputLayer(...)";
            armnn::IConnectableLayer* layer = m_Data.m_Network->AddInputLayer(i, layerName.c_str());
 
            VLOG(DRIVER) << "ModelToINetworkTransformer::Convert(): layer->GetOutputSlot(0)";
            armnn::IOutputSlot& outputSlot = layer->GetOutputSlot(0);
            VLOG(DRIVER) << "ModelToINetworkTransformer::Convert(): outputSlot.SetTensorInfo(...)";
            outputSlot.SetTensorInfo(GetTensorInfoForOperand(operand));
 
            VLOG(DRIVER) << "ModelToINetworkTransformer::Convert(): store for later layers";
            // store for later layers
            m_Data.m_OutputSlotForOperand[inputIndex] = &outputSlot;
        }
    }
    catch (UnsupportedOperand<OperandType>& e)
    {
        VLOG(DRIVER) <<  __func__ << "Operand type: " <<  e.m_type << " is not supported in ArmnnDriver";
        m_ConversionResult = ConversionResult::UnsupportedFeature;
    }
    catch (const armnn::InvalidArgumentException& e)
    {
        Fail("%s: Failed to convert input operand to TensorShape: %s", __func__, e.what());
        m_ConversionResult = ConversionResult::UnsupportedFeature;
    }
    bool UnsupportedDynamicOperation = false;
    for (uint32_t operationIdx = 0; operationIdx < m_Model.main.operations.size(); operationIdx++)
    {
        const auto& operation = m_Model.main.operations[operationIdx];
 
        bool ok = true;
        if (m_ForcedUnsupportedOperations.find(operationIdx) != m_ForcedUnsupportedOperations.end())
        {
            Fail("%s: Operation at index %i has been forced to be unsupported.", __func__, operationIdx);
            ok = false;
        }
 
        if (ok)
        {
            try
            {
                ok = Converter::ConvertOperation(operation, m_Model, m_Data);
            }
            catch (UnsupportedOperand<OperandType>& e)
            {
                VLOG(DRIVER) << __func__ << "Operation type: " << e.m_type << "is not supported in ArmnnDriver";
                ok = false;
            }
            catch (const armnn::InvalidArgumentException& e)
            {
                Fail("%s: Failed to convert operation in %s", __func__, e.what());
                ok = false;
            }
        }
 
        // Store whether this operation was successfully converted.
        m_OperationSupported.emplace(operationIdx, ok);
 
        // Any single operation failing will fail the entire conversion.
        // We still need to continue and check the other ones.
        if (!ok)
        {
            if (m_Data.m_DynamicInputsEncountered)
            {
                Fail("%s: The unsupported operation at index %i has dynamic inputs.", __func__, operationIdx);
                UnsupportedDynamicOperation = true;
            }
 
            m_ConversionResult = ConversionResult::UnsupportedFeature;
        }
        m_Data.m_DynamicInputsEncountered = false;
    }
 
    // Due to the NNAPI partitioner not supporting partition boundaries of unknown size,
    // any operations who's outputs connect to an unsupported operation with with dynamic inputs
    // will cause a failure.
 
    // The simplest solution to this problem is to not support any operations in a model containing
    // an unsupported operation with with dynamic inputs.
    if (UnsupportedDynamicOperation)
    {
        Fail("%s: Unsupported operation with dynamic inputs found. Retroactively setting all operations to unsupported",
             __func__);
        for (auto& operation : m_OperationSupported)
        {
            operation.second = false;
        }
    }
 
    try
    {
        if (m_ConversionResult == ConversionResult::Success)
        {
            for (uint32_t i = 0; i < m_Model.main.outputIndexes.size(); i++)
            {
                // outputs in android nn are represented by operands
                uint32_t outputIndex = m_Model.main.outputIndexes[i];
                const auto& operand = m_Model.main.operands[outputIndex];
                const armnn::TensorInfo& tensor = GetTensorInfoForOperand(operand);
                const std::string layerName = "Output_" + std::to_string(i);
                armnn::IConnectableLayer* layer = m_Data.m_Network->AddOutputLayer(i, layerName.c_str());
 
                assert(m_Data.m_OutputSlotForOperand[outputIndex]);
                m_Data.m_OutputSlotForOperand[outputIndex]->Connect(layer->GetInputSlot(0));
            }
        }
    }
    catch (const armnn::InvalidArgumentException& e)
    {
        Fail("%s: Failed to convert output operand to TensorShape: %s", __func__, e.what());
        m_ConversionResult = ConversionResult::UnsupportedFeature;
    }
}
 
bool ModelToINetworkTransformer::IsOperationSupported(uint32_t operationIndex) const
{
    std::map<uint32_t, bool>::const_iterator it = m_OperationSupported.find(operationIndex);
    assert(it != m_OperationSupported.end());
    return it->second;
}
 
} // armnn_driver