patch/21.02/_layers_fwd_8hpp_source.xhtml

 //
 // Copyright © 2017 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 #pragma once

 #include "InternalTypes.hpp"

 #include "layers/ActivationLayer.hpp"
 #include "layers/AdditionLayer.hpp"
 #include "layers/ArgMinMaxLayer.hpp"
 #include "layers/BatchNormalizationLayer.hpp"
 #include "layers/BatchToSpaceNdLayer.hpp"
 #include "layers/ComparisonLayer.hpp"
 #include "layers/ConcatLayer.hpp"
 #include "layers/ConstantLayer.hpp"
 #include "layers/ConvertBf16ToFp32Layer.hpp"
 #include "layers/ConvertFp16ToFp32Layer.hpp"
 #include "layers/ConvertFp32ToBf16Layer.hpp"
 #include "layers/ConvertFp32ToFp16Layer.hpp"
 #include "layers/Convolution2dLayer.hpp"
 #include "layers/DebugLayer.hpp"
 #include "layers/DepthToSpaceLayer.hpp"
 #include "layers/DepthwiseConvolution2dLayer.hpp"
 #include "layers/DequantizeLayer.hpp"
 #include "layers/DetectionPostProcessLayer.hpp"
 #include "layers/DivisionLayer.hpp"
 #include "layers/ElementwiseUnaryLayer.hpp"
 #include "layers/FakeQuantizationLayer.hpp"
 #include "layers/FillLayer.hpp"
 #include "layers/FloorLayer.hpp"
 #include "layers/FullyConnectedLayer.hpp"
 #include "layers/GatherLayer.hpp"
 #include "layers/InputLayer.hpp"
 #include "layers/InstanceNormalizationLayer.hpp"
 #include "layers/L2NormalizationLayer.hpp"
 #include "layers/LogicalBinaryLayer.hpp"
 #include "layers/LogSoftmaxLayer.hpp"
 #include "layers/LstmLayer.hpp"
 #include "layers/MapLayer.hpp"
 #include "layers/MaximumLayer.hpp"
 #include "layers/MeanLayer.hpp"
 #include "layers/MemCopyLayer.hpp"
 #include "layers/MemImportLayer.hpp"
 #include "layers/MergeLayer.hpp"
 #include "layers/MinimumLayer.hpp"
 #include "layers/MultiplicationLayer.hpp"
 #include "layers/NormalizationLayer.hpp"
 #include "layers/OutputLayer.hpp"
 #include "layers/PadLayer.hpp"
 #include "layers/PermuteLayer.hpp"
 #include "layers/Pooling2dLayer.hpp"
 #include "layers/PreCompiledLayer.hpp"
 #include "layers/PreluLayer.hpp"
 #include "layers/QuantizeLayer.hpp"
 #include "layers/QLstmLayer.hpp"
 #include "layers/QuantizedLstmLayer.hpp"
 #include "layers/RankLayer.hpp"
 #include "layers/ReduceLayer.hpp"
 #include "layers/ReshapeLayer.hpp"
 #include "layers/ResizeLayer.hpp"
 #include "layers/SliceLayer.hpp"
 #include "layers/SoftmaxLayer.hpp"
 #include "layers/SpaceToBatchNdLayer.hpp"
 #include "layers/SpaceToDepthLayer.hpp"
 #include "layers/SplitterLayer.hpp"
 #include "layers/StackLayer.hpp"
 #include "layers/StandInLayer.hpp"
 #include "layers/StridedSliceLayer.hpp"
 #include "layers/SubtractionLayer.hpp"
 #include "layers/SwitchLayer.hpp"
 #include "layers/TransposeConvolution2dLayer.hpp"
 #include "layers/TransposeLayer.hpp"
 #include "layers/UnmapLayer.hpp"

 namespace armnn
 {

 template <LayerType Type>
 struct LayerTypeOfImpl;

 template <LayerType Type>
 using LayerTypeOf = typename LayerTypeOfImpl<Type>::Type;

 template <typename T>
 constexpr LayerType LayerEnumOf(const T* = nullptr);

 #define DECLARE_LAYER_IMPL(_, LayerName)                     \
     class LayerName##Layer;                                  \
     template <>                                              \
     struct LayerTypeOfImpl<LayerType::_##LayerName>          \
     {                                                        \
         using Type = LayerName##Layer;                       \
     };                                                       \
     template <>                                              \
     constexpr LayerType LayerEnumOf(const LayerName##Layer*) \
     {                                                        \
         return LayerType::_##LayerName;                      \
     }

 #define DECLARE_LAYER(LayerName) DECLARE_LAYER_IMPL(, LayerName)

 DECLARE_LAYER(Activation)
 DECLARE_LAYER(Addition)
 DECLARE_LAYER(ArgMinMax)
 DECLARE_LAYER(BatchNormalization)
 DECLARE_LAYER(BatchToSpaceNd)
 DECLARE_LAYER(Comparison)
 DECLARE_LAYER(Concat)
 DECLARE_LAYER(Constant)
 DECLARE_LAYER(ConvertBf16ToFp32)
 DECLARE_LAYER(ConvertFp16ToFp32)
 DECLARE_LAYER(ConvertFp32ToBf16)
 DECLARE_LAYER(ConvertFp32ToFp16)
 DECLARE_LAYER(Convolution2d)
 DECLARE_LAYER(Debug)
 DECLARE_LAYER(DepthToSpace)
 DECLARE_LAYER(DepthwiseConvolution2d)
 DECLARE_LAYER(Dequantize)
 DECLARE_LAYER(DetectionPostProcess)
 DECLARE_LAYER(Division)
 DECLARE_LAYER(ElementwiseUnary)
 DECLARE_LAYER(FakeQuantization)
 DECLARE_LAYER(Fill)
 DECLARE_LAYER(Floor)
 DECLARE_LAYER(FullyConnected)
 DECLARE_LAYER(Gather)
 DECLARE_LAYER(Input)
 DECLARE_LAYER(InstanceNormalization)
 DECLARE_LAYER(L2Normalization)
 DECLARE_LAYER(LogicalBinary)
 DECLARE_LAYER(LogSoftmax)
 DECLARE_LAYER(Lstm)
 DECLARE_LAYER(Map)
 DECLARE_LAYER(Maximum)
 DECLARE_LAYER(Mean)
 DECLARE_LAYER(MemCopy)
 DECLARE_LAYER(MemImport)
 DECLARE_LAYER(Merge)
 DECLARE_LAYER(Minimum)
 DECLARE_LAYER(Multiplication)
 DECLARE_LAYER(Normalization)
 DECLARE_LAYER(Output)
 DECLARE_LAYER(Pad)
 DECLARE_LAYER(Permute)
 DECLARE_LAYER(Pooling2d)
 DECLARE_LAYER(PreCompiled)
 DECLARE_LAYER(Prelu)
 DECLARE_LAYER(Quantize)
 DECLARE_LAYER(QLstm)
 DECLARE_LAYER(QuantizedLstm)
 DECLARE_LAYER(Rank)
 DECLARE_LAYER(Reduce)
 DECLARE_LAYER(Reshape)
 DECLARE_LAYER(Resize)
 DECLARE_LAYER(Slice)
 DECLARE_LAYER(Softmax)
 DECLARE_LAYER(SpaceToBatchNd)
 DECLARE_LAYER(SpaceToDepth)
 DECLARE_LAYER(Splitter)
 DECLARE_LAYER(Stack)
 DECLARE_LAYER(StandIn)
 DECLARE_LAYER(StridedSlice)
 DECLARE_LAYER(Subtraction)
 DECLARE_LAYER(Switch)
 DECLARE_LAYER(Transpose)
 DECLARE_LAYER(TransposeConvolution2d)
 DECLARE_LAYER(Unmap)

 }
GatherLayer.hpp

+armnn::LayerEnumOf
constexpr LayerType LayerEnumOf(const T *=nullptr)

+armnn::Dequantize
float Dequantize(QuantizedType value, float scale, int32_t offset)
Dequantize an 8-bit data type into a floating point data type.
Definition: TypesUtils.cpp:46

+DepthToSpaceLayer.hpp

+armnn::Slice
void Slice(const TensorInfo &inputInfo, const SliceDescriptor &descriptor, const void *inputData, void *outputData, unsigned int dataTypeSize)
Definition: Slice.cpp:14

+SplitterLayer.hpp

+MapLayer.hpp

+LogicalBinaryLayer.hpp

+armnn::LayerTypeOf
typename LayerTypeOfImpl< Type >::Type LayerTypeOf
Definition: LayersFwd.hpp:83

+Pooling2dLayer.hpp

+ActivationLayer.hpp

+PermuteLayer.hpp

+armnn::Fill
void Fill(Encoder< float > &output, const TensorShape &desiredOutputShape, const float value)
Creates a tensor and fills it with a scalar value.
Definition: Fill.cpp:13

+armnn::Reduce
void Reduce(const TensorInfo &inputInfo, const TensorInfo &outputInfo, Decoder< float > &input, Encoder< float > &output, const std::vector< uint32_t > axis, const ReduceOperation reduceOperation)
Definition: Reduce.cpp:71

+MinimumLayer.hpp

+StandInLayer.hpp

+InstanceNormalizationLayer.hpp

+AdditionLayer.hpp

+ComparisonLayer.hpp

+SliceLayer.hpp

+FloorLayer.hpp

+DebugLayer.hpp

+armnnUtils::Transpose
void Transpose(const armnn::TensorShape &dstShape, const armnn::PermutationVector &mappings, const void *src, void *dst, size_t dataTypeSize)
Definition: Transpose.cpp:120

+armnn::DepthToSpace
void DepthToSpace(const TensorInfo &inputInfo, const DepthToSpaceDescriptor &descriptor, const void *inputData, void *outputData, unsigned int dataTypeSize)
Definition: DepthToSpace.cpp:18

+armnn::ArgMinMax
void ArgMinMax(Decoder< float > &in, OUT *out, const TensorInfo &inputTensorInfo, const TensorInfo &outputTensorInfo, ArgMinMaxFunction function, int axis)
Definition: ArgMinMax.cpp:16

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

+SwitchLayer.hpp

+BatchToSpaceNdLayer.hpp

+MultiplicationLayer.hpp

+armnn::FakeQuantization
void FakeQuantization(const float *inputData, float *outputData, uint32_t numElements, float min, float max)
Definition: RefFakeQuantizationFloat32Workload.cpp:17

+QLstmLayer.hpp

+ReshapeLayer.hpp

+InternalTypes.hpp

+ArgMinMaxLayer.hpp

+armnn::FullyConnected
void FullyConnected(const TensorShape &rInputShape, Decoder< float > &rInputDecoder, const TensorShape &rOutputShape, Encoder< float > &rOutputEncoder, const TensorShape &rWeightsShape, Decoder< float > &rWeightDecoder, Decoder< float > &rBiasDecoder, const bool biasEnabled, const unsigned int K, const bool transposeWeights)
Performs a matrix multiplication and optionally adds a bias.
Definition: FullyConnected.cpp:13

+OutputLayer.hpp

+ConstantLayer.hpp

+PadLayer.hpp

+armnn::Stack
void Stack(const StackQueueDescriptor &data, std::vector< std::unique_ptr< Decoder< float >>> &inputs, Encoder< float > &output)
Definition: Stack.cpp:12

+MergeLayer.hpp

+ElementwiseUnaryLayer.hpp

+DetectionPostProcessLayer.hpp

+NormalizationLayer.hpp

+PreluLayer.hpp

+armnnUtils::Permute
void Permute(const armnn::TensorShape &dstShape, const armnn::PermutationVector &mappings, const void *src, void *dst, size_t dataTypeSize)
Definition: Permute.cpp:131

+UnmapLayer.hpp

+armnn::DetectionPostProcess
void DetectionPostProcess(const TensorInfo &boxEncodingsInfo, const TensorInfo &scoresInfo, const TensorInfo &anchorsInfo, const TensorInfo &detectionBoxesInfo, const TensorInfo &detectionClassesInfo, const TensorInfo &detectionScoresInfo, const TensorInfo &numDetectionsInfo, const DetectionPostProcessDescriptor &desc, Decoder< float > &boxEncodings, Decoder< float > &scores, Decoder< float > &anchors, float *detectionBoxes, float *detectionClasses, float *detectionScores, float *numDetections)
Definition: DetectionPostProcess.cpp:140

+DivisionLayer.hpp

+MemCopyLayer.hpp

+MeanLayer.hpp

+armnn::Gather
void Gather(const TensorInfo &paramsInfo, const TensorInfo &indicesInfo, const TensorInfo &outputInfo, Decoder< float > &params, const int32_t *indices, Encoder< float > &output, const int32_t axis)
Definition: Gather.cpp:17

+RankLayer.hpp

+QuantizedLstmLayer.hpp

+armnn::LayerTypeOfImpl
Definition: LayersFwd.hpp:80

+armnn::Debug
void Debug(const TensorInfo &inputInfo, const T *inputData, LayerGuid guid, const std::string &layerName, unsigned int slotIndex)
Definition: Debug.cpp:18

+Convolution2dLayer.hpp

+armnn::Activation
float Activation(float in, ActivationFunction function, float a, float b)
Definition: Activation.cpp:13

+LogSoftmaxLayer.hpp

+armnn::Quantize
QuantizedType Quantize(float value, float scale, int32_t offset)
Quantize a floating point data type into an 8-bit data type.
Definition: TypesUtils.cpp:30

+ReduceLayer.hpp

+InputLayer.hpp

+armnn::LogSoftmax
void LogSoftmax(Decoder< float > &input, Encoder< float > &output, const TensorInfo &inputInfo, const LogSoftmaxDescriptor &descriptor)
Definition: LogSoftmax.cpp:29

+DepthwiseConvolution2dLayer.hpp

+SoftmaxLayer.hpp

+armnn::SpaceToBatchNd
void SpaceToBatchNd(const TensorInfo &inputInfo, const TensorInfo &outputInfo, const SpaceToBatchNdDescriptor &params, Decoder< float > &inputData, Encoder< float > &outputData)
Definition: SpaceToBatchNd.cpp:34

+StridedSliceLayer.hpp

+TransposeConvolution2dLayer.hpp

+ConvertBf16ToFp32Layer.hpp

+FakeQuantizationLayer.hpp

+BatchNormalizationLayer.hpp

+ResizeLayer.hpp

+PreCompiledLayer.hpp

+ConcatLayer.hpp

+QuantizeLayer.hpp

+ConvertFp32ToBf16Layer.hpp

+SpaceToBatchNdLayer.hpp

+armnn::StridedSlice
void StridedSlice(const TensorInfo &inputInfo, const StridedSliceDescriptor &params, const void *inputData, void *outputData, unsigned int dataTypeSize)
Definition: StridedSlice.cpp:90

+DECLARE_LAYER
#define DECLARE_LAYER(LayerName)
Definition: LayersFwd.hpp:101

+MaximumLayer.hpp

+SubtractionLayer.hpp

+L2NormalizationLayer.hpp

+ConvertFp32ToFp16Layer.hpp

+FullyConnectedLayer.hpp

+LstmLayer.hpp

+armnn::SpaceToDepth
void SpaceToDepth(const TensorInfo &inputInfo, const TensorInfo &outputInfo, const SpaceToDepthDescriptor &params, Decoder< float > &inputData, Encoder< float > &outputData)
Definition: SpaceToDepth.cpp:36

+DequantizeLayer.hpp

+armnn::BatchToSpaceNd
void BatchToSpaceNd(const DataLayoutIndexed &dataLayout, const TensorInfo &inputTensorInfo, const TensorInfo &outputTensorInfo, const std::vector< unsigned int > &blockShape, const std::vector< std::pair< unsigned int, unsigned int >> &cropsData, Decoder< float > &inputDecoder, Encoder< float > &outputEncoder)
Definition: BatchToSpaceNd.cpp:35

+armnn::Pad
void Pad(const TensorInfo &inputInfo, const TensorInfo &outputInfo, const PadQueueDescriptor &data)
Definition: Pad.cpp:39

+ConvertFp16ToFp32Layer.hpp

+armnn::Pooling2d
void Pooling2d(Decoder< float > &rInputDecoder, Encoder< float > &rOutputEncoder, const TensorInfo &inputInfo, const TensorInfo &outputInfo, const Pooling2dDescriptor &params)
Computes the Pooling2d operation.
Definition: Pooling2d.cpp:142

+TransposeLayer.hpp

+MemImportLayer.hpp

+FillLayer.hpp

+armnn::Splitter
void Splitter(const SplitterQueueDescriptor &data)
Definition: Splitter.hpp:17

+armnn::Softmax
void Softmax(Decoder< float > &in, Encoder< float > &out, const TensorInfo &inputTensorInfo, float beta, int axis)
Computes the softmax function on some inputs, into outputs, with a shape given by tensorInfo...
Definition: Softmax.cpp:17

+SpaceToDepthLayer.hpp

+armnn::Resize
void Resize(Decoder< float > &in, const TensorInfo &inputInfo, Encoder< float > &out, const TensorInfo &outputInfo, DataLayoutIndexed dataLayout, armnn::ResizeMethod resizeMethod, bool alignCorners, bool halfPixelCenters)
Definition: Resize.cpp:65

+StackLayer.hpp

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

+