armnn::optimizations::pad_fold Namespace Reference

Classes
class	FoldPadIntoConvolution2dImpl
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 Pooling2dDescriptor &descriptor, const TensorInfo &tensorInfo, const float tensorValue)
template<typename Descriptor >
bool	TryFoldPadIntoLayer2d (const PadDescriptor &padDescriptor, Descriptor &layerDescriptor, const TensorInfo &tensorInfo)
bool	TryFoldPadIntoLayer2d (const PadDescriptor &padDescriptor, Pooling2dDescriptor &poolDescriptor, const TensorInfo &tensorInfo)
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 122 of file FoldPadIntoLayer2d.hpp.

References InputSlot::GetConnectedOutputSlot(), Layer::GetInputSlot(), Layer::GetName(), Layer::GetOutputSlot(), InputSlot::GetOwningLayer(), OutputSlot::GetOwningLayer(), LayerWithParameters< Parameters >::GetParameters(), OutputSlot::GetTensorInfo(), Graph::InsertNewLayer(), and TryFoldPadIntoLayer2d().

{
    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;
    }

    // Save original parent output slot of the pad layer
    OutputSlot& parentSlot = *padLayer.GetInputSlot(0).GetConnectedOutputSlot();

    // Insert new layer2d layer between the pad layer an 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());

    // Reconnect the pad layer with its original parent.
    newLayer2d.GetOutputSlot().MoveAllConnections(parentSlot);

    // 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;
}

GetLowestElement()

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

inline

Definition at line 26 of file FoldPadIntoLayer2d.hpp.

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().

{
    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;
        }
    }
}

GetZeroElement()

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

inline

Definition at line 21 of file FoldPadIntoLayer2d.hpp.

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

Referenced by IsNeutralElement().

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

IsNeutralElement() [1/2]

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

inline

Definition at line 56 of file FoldPadIntoLayer2d.hpp.

References GetZeroElement().

Referenced by TryFoldPadIntoLayer2d().

{
    return tensorValue == GetZeroElement(tensorInfo);
}

IsNeutralElement() [2/2]

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

inline

Definition at line 61 of file FoldPadIntoLayer2d.hpp.

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

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

TryFoldPadIntoLayer2d() [1/2]

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

Definition at line 70 of file FoldPadIntoLayer2d.hpp.

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

Referenced by FoldPadIntoLayer2dImpl().

{
    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;
}

TryFoldPadIntoLayer2d() [2/2]

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

inline

Definition at line 97 of file FoldPadIntoLayer2d.hpp.

References armnn::Exclude, armnn::IgnoreValue, Pooling2dDescriptor::m_PadBottom, Pooling2dDescriptor::m_PaddingMethod, Pooling2dDescriptor::m_PadLeft, Pooling2dDescriptor::m_PadRight, Pooling2dDescriptor::m_PadTop, Pooling2dDescriptor::m_PoolType, and armnn::Max.

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

    // We cannot fold Average or L2 pooling if there's is already padding and that padding method is Exclude.
    if (poolDescriptor.m_PoolType != PoolingAlgorithm::Max) // PoolingAlgorithm::Average or PoolingAlgorithm::L2
    {
        if ((poolHasPadding) && (poolDescriptor.m_PaddingMethod == PaddingMethod::Exclude))
        {
            return false;
        }
    }
    poolDescriptor.m_PaddingMethod = PaddingMethod::IgnoreValue;

    return TryFoldPadIntoLayer2d<Pooling2dDescriptor>(padDescriptor, poolDescriptor, tensorInfo);
}