armnn::optimizations::pad_fold Namespace Reference

Classes
class	FoldPadIntoConvolution2dImpl
class	FoldPadIntoDepthwiseConvolution2dImpl
class	FoldPadIntoPooling2dImpl

Functions
float	GetZeroElement (const TensorInfo &tensorInfo)
float	GetLowestElement (const TensorInfo &tensorInfo)
bool	IsNeutralElement (const Convolution2dDescriptor &, const TensorInfo &tensorInfo, const float tensorValue)
bool	IsNeutralElement (const DepthwiseConvolution2dDescriptor &, const TensorInfo &tensorInfo, const float tensorValue)
bool	IsNeutralElement (const Pooling2dDescriptor &descriptor, const TensorInfo &tensorInfo, const float tensorValue)
bool	IsPooling2dPadded (const Pooling2dDescriptor &poolDescriptor)
template<typename Descriptor >
bool	TryFoldPadIntoLayer2d (const PadDescriptor &padDescriptor, Descriptor &layerDescriptor, const TensorInfo &tensorInfo)
bool	TryFoldPadIntoLayer2d (const PadDescriptor &padDescriptor, Pooling2dDescriptor &poolDescriptor, const TensorInfo &tensorInfo, bool isBackendOptimization=false)
template<typename Layer2dT >
Layer2dT *	FoldPadIntoLayer2dImpl (Graph &graph, InputSlot &connection)

Function Documentation

FoldPadIntoLayer2dImpl()

Layer2dT* armnn::optimizations::pad_fold::FoldPadIntoLayer2dImpl	(	Graph &	graph,
		InputSlot &	connection
	)

Definition at line 144 of file FoldPadIntoLayer2d.hpp.

{
    PadLayer& padLayer = *PolymorphicDowncast<PadLayer*>(&connection.GetConnectedOutputSlot()->GetOwningLayer());
    Layer2dT& layer2d = *PolymorphicDowncast<Layer2dT*>(&connection.GetOwningLayer());
 
    const PadDescriptor& padDescriptor = padLayer.GetParameters();
    auto newLayer2dDescriptor = layer2d.GetParameters();
 
    if (!TryFoldPadIntoLayer2d(padDescriptor, newLayer2dDescriptor, padLayer.GetOutputSlot().GetTensorInfo()))
    {
        return nullptr;
    }
 
    // Workaround an issue in the compute library. The conv2d algorithm that the
    // compute library is choosing is not handling the 1x1 filter case when
    // the padding size >= filter size
    if (layer2d.GetType() == armnn::LayerType::Convolution2d)
    {
        // Get filter width and height
        armnnUtils::DataLayoutIndexed dataLayoutIndex(newLayer2dDescriptor.m_DataLayout);
        const TensorShape& filterShape = layer2d.GetInputSlot(1).GetTensorInfo().GetShape();
        unsigned int filterWidth       = filterShape[dataLayoutIndex.GetWidthIndex()];
        unsigned int filterHeight      = filterShape[dataLayoutIndex.GetHeightIndex()];
        // Calculate total padding and check conditions
        auto horizontalPadding = newLayer2dDescriptor.m_PadLeft + newLayer2dDescriptor.m_PadRight;
        auto verticalPadding   = newLayer2dDescriptor.m_PadTop  + newLayer2dDescriptor.m_PadBottom;
        if ((filterWidth == 1) && (horizontalPadding >= filterWidth))
        {
            return nullptr;
        }
        else if ((filterHeight == 1) && (verticalPadding >= filterHeight))
        {
            return nullptr;
        }
    }
 
    // Save original parent output slot of the pad layer
    OutputSlot& parentSlot = *padLayer.GetInputSlot(0).GetConnectedOutputSlot();
 
    // Insert new layer2d layer between the pad layer and its parent layer.
    const std::string name = std::string("folded-") + padLayer.GetName() + "-into-" + layer2d.GetName();
    auto& newLayer2d = *graph.InsertNewLayer<Layer2dT>(padLayer.GetInputSlot(0), newLayer2dDescriptor, name.c_str());
 
    newLayer2d.GetOutputSlot().MoveAllConnections(parentSlot);
    // Start at 1 to connect only weights and bias
    for (unsigned int i = 1; i < layer2d.GetNumInputSlots(); ++i)
    {
        if (layer2d.GetInputSlot(i).GetConnectedOutputSlot() != nullptr)
        {
            Layer& tgtLayer = layer2d.GetInputSlot(i).GetConnectedOutputSlot()->GetOwningLayer();
            // Remove old connection and connect to new layer2d
            tgtLayer.GetOutputSlot(0).Disconnect(layer2d.GetInputSlot(i));
            tgtLayer.GetOutputSlot(0).Connect(newLayer2d.GetInputSlot(i));
        }
    }
 
    // Moves connections in old layer2d layer output to new layer.
    // Old layer2d layer will be removed as it's left unconnected.
    // Pad layer will be removed if left unconnected.
    layer2d.GetOutputSlot().MoveAllConnections(newLayer2d.GetOutputSlot());
 
    return &newLayer2d;
}

References OutputSlot::Connect(), armnn::Convolution2d, OutputSlot::Disconnect(), InputSlot::GetConnectedOutputSlot(), DataLayoutIndexed::GetHeightIndex(), Layer::GetInputSlot(), Layer::GetName(), Layer::GetOutputSlot(), InputSlot::GetOwningLayer(), OutputSlot::GetOwningLayer(), LayerWithParameters< Parameters >::GetParameters(), OutputSlot::GetTensorInfo(), DataLayoutIndexed::GetWidthIndex(), Graph::InsertNewLayer(), and TryFoldPadIntoLayer2d().

GetLowestElement()

float armnn::optimizations::pad_fold::GetLowestElement ( const TensorInfo &  tensorInfo )

inline

Definition at line 26 of file FoldPadIntoLayer2d.hpp.

{
    constexpr float negativeInfinity = -std::numeric_limits<float>::infinity();
    const float scale = tensorInfo.GetQuantizationScale();
    const int32_t offset = tensorInfo.GetQuantizationOffset();
 
    switch (tensorInfo.GetDataType())
    {
        case DataType::Float16:
            return armnnUtils::SelectiveQuantize<armnn::Half>(negativeInfinity, scale, offset);
        case DataType::Float32:
            return armnnUtils::SelectiveQuantize<float>(negativeInfinity, scale, offset);
        case DataType::QAsymmU8:
            return armnnUtils::SelectiveQuantize<uint8_t>(negativeInfinity, scale, offset);
        case DataType::QSymmS16:
            return armnnUtils::SelectiveQuantize<int16_t>(negativeInfinity, scale, offset);
        case DataType::QSymmS8:
            // Fall-through
        case DataType::QAsymmS8:
            return armnnUtils::SelectiveQuantize<int8_t>(negativeInfinity, scale, offset);
        case DataType::BFloat16:
            return armnnUtils::SelectiveQuantize<armnn::BFloat16>(negativeInfinity, scale, offset);
        default:
        {
            ARMNN_ASSERT_MSG(false, "Unsupported DataType");
            return NAN;
        }
    }
}

References ARMNN_ASSERT_MSG, armnn::BFloat16, armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by IsNeutralElement().

GetZeroElement()

float armnn::optimizations::pad_fold::GetZeroElement ( const TensorInfo &  tensorInfo )

inline

Definition at line 21 of file FoldPadIntoLayer2d.hpp.

{
    return static_cast<float>(tensorInfo.IsQuantized() ? tensorInfo.GetQuantizationOffset() : 0);
}

References TensorInfo::GetQuantizationOffset(), and TensorInfo::IsQuantized().

Referenced by IsNeutralElement().

IsNeutralElement() [1/3]

bool armnn::optimizations::pad_fold::IsNeutralElement ( const Convolution2dDescriptor &  , const TensorInfo &  tensorInfo, const float  tensorValue  )

inline

Definition at line 56 of file FoldPadIntoLayer2d.hpp.

{
    return tensorValue == GetZeroElement(tensorInfo);
}

References GetZeroElement().

Referenced by TryFoldPadIntoLayer2d().

IsNeutralElement() [2/3]

bool armnn::optimizations::pad_fold::IsNeutralElement ( const DepthwiseConvolution2dDescriptor &  , const TensorInfo &  tensorInfo, const float  tensorValue  )

inline

Definition at line 61 of file FoldPadIntoLayer2d.hpp.

{
    return tensorValue == GetZeroElement(tensorInfo);
}

References GetZeroElement().

IsNeutralElement() [3/3]

bool armnn::optimizations::pad_fold::IsNeutralElement ( const Pooling2dDescriptor &  descriptor, const TensorInfo &  tensorInfo, const float  tensorValue  )

inline

Definition at line 68 of file FoldPadIntoLayer2d.hpp.

{
    return (descriptor.m_PoolType == PoolingAlgorithm::Max)
        ? tensorValue <= GetLowestElement(tensorInfo)
        : tensorValue == GetZeroElement(tensorInfo);
}

References GetLowestElement(), GetZeroElement(), Pooling2dDescriptor::m_PoolType, and armnn::Max.

IsPooling2dPadded()

bool armnn::optimizations::pad_fold::IsPooling2dPadded ( const Pooling2dDescriptor &  poolDescriptor )

inline

Definition at line 76 of file FoldPadIntoLayer2d.hpp.

{
    const auto poolingPadValues = std::make_tuple(poolDescriptor.m_PadLeft, poolDescriptor.m_PadRight,
                                                  poolDescriptor.m_PadTop, poolDescriptor.m_PadBottom);
    if (poolingPadValues != std::make_tuple(0U, 0U, 0U, 0U))
    {
        return true;
    }
    return false;
}

References Pooling2dDescriptor::m_PadBottom, Pooling2dDescriptor::m_PadLeft, Pooling2dDescriptor::m_PadRight, and Pooling2dDescriptor::m_PadTop.

Referenced by TryFoldPadIntoLayer2d().

TryFoldPadIntoLayer2d() [1/2]

bool armnn::optimizations::pad_fold::TryFoldPadIntoLayer2d	(	const PadDescriptor &	padDescriptor,
		Descriptor &	layerDescriptor,
		const TensorInfo &	tensorInfo
	)

Definition at line 88 of file FoldPadIntoLayer2d.hpp.

{
    armnnUtils::DataLayoutIndexed layout = armnnUtils::DataLayoutIndexed(layerDescriptor.m_DataLayout);
    constexpr unsigned int batchIndex = 0;
 
    constexpr auto noPad = std::make_pair(0U, 0U);
 
    if ((!IsNeutralElement(layerDescriptor, tensorInfo, padDescriptor.m_PadValue)) ||
        (padDescriptor.m_PadList[batchIndex] != noPad) || (padDescriptor.m_PadList[layout.GetChannelsIndex()] != noPad))
    {
        return false;
    }
 
    const auto& padList = padDescriptor.m_PadList;
 
    // In Convolution2dDescriptor/Pooling2dDescriptor, padLeft and padRight are defined as paddings
    // on width dimension whereas padTop and padBottom - paddings on height dimension, so updating
    // these according to data layout
    layerDescriptor.m_PadLeft += padList[layout.GetWidthIndex()].first;
    layerDescriptor.m_PadRight += padList[layout.GetWidthIndex()].second;
    layerDescriptor.m_PadTop += padList[layout.GetHeightIndex()].first;
    layerDescriptor.m_PadBottom += padList[layout.GetHeightIndex()].second;
 
    return true;
}

References DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), DataLayoutIndexed::GetWidthIndex(), IsNeutralElement(), PadDescriptor::m_PadList, and PadDescriptor::m_PadValue.

Referenced by FoldPadIntoLayer2dImpl(), RefBackend::OptimizeSubgraphView(), and ClBackend::OptimizeSubgraphView().

TryFoldPadIntoLayer2d() [2/2]

bool armnn::optimizations::pad_fold::TryFoldPadIntoLayer2d ( const PadDescriptor &  padDescriptor, Pooling2dDescriptor &  poolDescriptor, const TensorInfo &  tensorInfo, bool  isBackendOptimization = false  )

inline

Definition at line 115 of file FoldPadIntoLayer2d.hpp.

{
    // Cannot fold Average or L2 pooling if padding exists and the padding method is Exclude.
    if (poolDescriptor.m_PoolType != PoolingAlgorithm::Max &&
        IsPooling2dPadded(poolDescriptor) &&
        poolDescriptor.m_PaddingMethod == PaddingMethod::Exclude)
    {
        return false;
    }
 
    // Cannot fold Average pooling if data type is quantized and layout is NHWC in Neon backend.
    // Therefore, this specific case will become a backend specific optimization.
    if  (!isBackendOptimization &&
         tensorInfo.IsQuantized() &&
         poolDescriptor.m_PoolType == PoolingAlgorithm::Average &&
         poolDescriptor.m_DataLayout == DataLayout::NHWC)
    {
        return false;
    }
 
    poolDescriptor.m_PaddingMethod = PaddingMethod::IgnoreValue;
 
    return TryFoldPadIntoLayer2d<Pooling2dDescriptor>(padDescriptor, poolDescriptor, tensorInfo);
}

References armnn::Average, armnn::Exclude, armnn::IgnoreValue, IsPooling2dPadded(), TensorInfo::IsQuantized(), Pooling2dDescriptor::m_DataLayout, Pooling2dDescriptor::m_PaddingMethod, Pooling2dDescriptor::m_PoolType, armnn::Max, and armnn::NHWC.