patch/21.02/_elementwise_base_layer_8cpp_source.xhtml

 //
 // Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //

 #include "ElementwiseBaseLayer.hpp"

 #include "InternalTypes.hpp"
 #include "armnn/Exceptions.hpp"
 #include <armnn/TypesUtils.hpp>
 #include <armnn/utility/Assert.hpp>

 namespace armnn
 {

 ElementwiseBaseLayer::ElementwiseBaseLayer(unsigned int numInputSlots, unsigned int numOutputSlots,
                                            LayerType type, const char* name)
     : Layer(numInputSlots, numOutputSlots, type, name)
 {
 }

 std::vector<TensorShape> ElementwiseBaseLayer::InferOutputShapes(const std::vector<TensorShape>& inputShapes) const
 {
     ARMNN_ASSERT(inputShapes.size() == 2);
     TensorShape input0 = inputShapes[0];
     TensorShape input1 = inputShapes[1];

     if (m_ShapeInferenceMethod == ShapeInferenceMethod::ValidateOnly)
     {
         ARMNN_ASSERT(input0.GetNumDimensions() == input1.GetNumDimensions());
     }
     else if (m_ShapeInferenceMethod == ShapeInferenceMethod::InferAndValidate &&
              inputShapes[0].GetNumDimensions() < inputShapes[1].GetNumDimensions())
     {
         input1 = inputShapes[0];
         input0 = inputShapes[1];
     }

     unsigned int numDims = input0.GetNumDimensions();
     unsigned int shiftedDims = input0.GetNumDimensions() - input1.GetNumDimensions();

     // Get the max of the inputs.
     std::vector<unsigned int> dims(numDims);
     for (unsigned int i = shiftedDims; i < numDims; i++)
     {
         unsigned int dim0 = input0[i];
         unsigned int dim1 = input1[i - shiftedDims];

 #if !NDEBUG
         // Validate inputs are broadcast compatible.
         ARMNN_ASSERT_MSG(dim0 == dim1 || dim0 == 1 || dim1 == 1,
                          "Dimensions should either match or one should be of size 1.");
 #endif

         dims[i] = std::max(dim0, dim1);
     }

     // Fill in the rest of the shifted dimensions.
     for (unsigned int i = 0; i < shiftedDims; i++)
     {
         dims[i] = input0[i];
     }

     return std::vector<TensorShape>({ TensorShape(numDims, dims.data()) });
 }

 void ElementwiseBaseLayer::ValidateTensorShapesFromInputs()
 {
     VerifyLayerConnections(2, CHECK_LOCATION());

     const TensorShape& outputShape = GetOutputSlot(0).GetTensorInfo().GetShape();

     VerifyShapeInferenceType(outputShape, m_ShapeInferenceMethod);

     auto inferredShapes = InferOutputShapes({
         GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape(),
         GetInputSlot(1).GetConnection()->GetTensorInfo().GetShape()
     });

     ARMNN_ASSERT(inferredShapes.size() == 1);

     ValidateAndCopyShape(outputShape, inferredShapes[0], m_ShapeInferenceMethod, GetLayerTypeAsCString(GetType()));
 }

 void ElementwiseBaseLayer::ExecuteStrategy(IStrategy& strategy) const
 {
     strategy.ExecuteStrategy(this, BaseDescriptor(), {}, GetName());
 }

 } // namespace armnn
armnn::TensorInfo::GetShape
const TensorShape & GetShape() const
Definition: Tensor.hpp:187

+armnn::ElementwiseBaseLayer::InferOutputShapes
std::vector< TensorShape > InferOutputShapes(const std::vector< TensorShape > &inputShapes) const override
By default returns inputShapes if the number of inputs are equal to number of outputs, otherwise infers the output shapes from given input shapes and layer properties.
Definition: ElementwiseBaseLayer.cpp:22

+armnn::IStrategy::ExecuteStrategy
virtual void ExecuteStrategy(const armnn::IConnectableLayer *layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id=0)=0

+armnn::Layer::VerifyShapeInferenceType
void VerifyShapeInferenceType(const TensorShape &outputShape, ShapeInferenceMethod shapeInferenceMethod)
Definition: Layer.cpp:432

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

+armnn::TensorShape
Definition: Tensor.hpp:20

+armnn::InputSlot::GetConnection
const IOutputSlot * GetConnection() const override
Definition: Layer.hpp:199

+InternalTypes.hpp

+armnn::Layer::ValidateAndCopyShape
void ValidateAndCopyShape(const TensorShape &outputShape, const TensorShape &inferredShape, const ShapeInferenceMethod shapeInferenceMethod, const std::string &layerName, const unsigned int outputSlotIndex=0)
Definition: Layer.cpp:392

+armnn::BaseDescriptor
Base class for all descriptors.
Definition: Descriptors.hpp:22

+armnn::IStrategy
Definition: IStrategy.hpp:13

+armnn::Layer::VerifyLayerConnections
void VerifyLayerConnections(unsigned int expectedConnections, const CheckLocation &location) const
Definition: Layer.cpp:348

+armnn::Layer::GetInputSlot
const InputSlot & GetInputSlot(unsigned int index) const override
Get a const input slot handle by slot index.
Definition: Layer.hpp:316

+TypesUtils.hpp

+ARMNN_ASSERT_MSG
#define ARMNN_ASSERT_MSG(COND, MSG)
Definition: Assert.hpp:15

+armnn::ShapeInferenceMethod::ValidateOnly
Validate all output shapes.

+armnn::Layer::GetType
LayerType GetType() const override
Returns the armnn::LayerType of this layer.
Definition: Layer.hpp:265

+ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14

+CHECK_LOCATION
#define CHECK_LOCATION()
Definition: Exceptions.hpp:197

+Assert.hpp

+armnn::ElementwiseBaseLayer::ElementwiseBaseLayer
ElementwiseBaseLayer(unsigned int numInputSlots, unsigned int numOutputSlots, LayerType type, const char *name)
Definition: ElementwiseBaseLayer.cpp:16

+Exceptions.hpp

+armnn::TensorShape::GetNumDimensions
unsigned int GetNumDimensions() const
Function that returns the tensor rank.
Definition: Tensor.cpp:174

+armnn::Layer::GetOutputSlot
const OutputSlot & GetOutputSlot(unsigned int index=0) const override
Get the const output slot handle by slot index.
Definition: Layer.hpp:318

+armnn::ShapeInferenceMethod::InferAndValidate
Infer missing output shapes and validate all output shapes.

+armnn::IOutputSlot::GetTensorInfo
virtual const TensorInfo & GetTensorInfo() const =0

+armnn::Layer::GetName
const char * GetName() const override
Returns the name of the layer.
Definition: Layer.hpp:311

+ElementwiseBaseLayer.hpp

+armnn::ElementwiseBaseLayer::ExecuteStrategy
void ExecuteStrategy(IStrategy &strategy) const override
Apply a visitor to this layer.
Definition: ElementwiseBaseLayer.cpp:85

+armnn::OutputSlot::GetTensorInfo
const TensorInfo & GetTensorInfo() const override
Definition: Layer.cpp:63

+armnn::GetLayerTypeAsCString
const char * GetLayerTypeAsCString(LayerType type)
Definition: InternalTypes.cpp:13

+armnn::ElementwiseBaseLayer::ValidateTensorShapesFromInputs
void ValidateTensorShapesFromInputs() override
Check if the input tensor shape(s) will lead to a valid configuration of the element wise operation...
Definition: ElementwiseBaseLayer.cpp:67

+armnn::Layer::m_ShapeInferenceMethod
ShapeInferenceMethod m_ShapeInferenceMethod
Definition: Layer.hpp:408

+armnn::Layer
Definition: Layer.hpp:210

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

+