ArmNN
 24.08
ExpOperator.cpp File Reference
#include "ExpOperator.hpp"
#include "TosaTableUtils.hpp"
Include dependency graph for ExpOperator.cpp:

Go to the source code of this file.

Functions

TosaSerializationBasicBlock * ConvertExpOperator (const Layer *layer, const std::vector< const TensorInfo * > &inputs, const std::vector< const TensorInfo * > &outputs, const ElementwiseUnaryDescriptor *unaryDescriptor)
 

Function Documentation

◆ ConvertExpOperator()

TosaSerializationBasicBlock* ConvertExpOperator ( const Layer layer,
const std::vector< const TensorInfo * > &  inputs,
const std::vector< const TensorInfo * > &  outputs,
const ElementwiseUnaryDescriptor unaryDescriptor 
)

Definition at line 13 of file ExpOperator.cpp.

17 {
18  if (unaryDescriptor->m_Operation != UnaryOperation::Exp)
19  {
20  throw armnn::Exception("ConvertExpOperator: Unsupported elementwise unary operation in descriptor.");
21  }
22 
23  std::string inputName = std::string("input_");
24  std::string outputName = std::string("output0_");
25  std::string blockName = std::string("Op_EXP_block_") + GetUniqueTosaMappingID();
26 
27  // If a layer is present then the block will be used for execution, so input and output names need to be determined
28  // using the previous and following layers so the graph is connected correctly. For validation this doesn't matter.
29  if(layer != nullptr)
30  {
31  inputName = GenerateUniqueInputName(layer->GetInputSlot(0));
32  outputName = GenerateUniqueOutputName(*layer);
33  }
34 
35  std::vector<TosaSerializationTensor*> tensors;
36  std::vector<TosaSerializationOperator*> operators;
37 
38  float input_scale = inputs[0]->GetQuantizationScale();
39  float output_scale = outputs[0]->GetQuantizationScale();
40  int32_t input_zp = inputs[0]->GetQuantizationOffset();
41  int32_t output_zp = outputs[0]->GetQuantizationOffset();
42  DataType inputDType = inputs[0]->GetDataType();
43  if (inputDType == DataType::QAsymmS8 ||
44  inputDType == DataType::QSymmS8)
45  {
46  auto exp_func = [](float x) -> float { return std::exp(x); };
47  TosaTableAttribute attribute(
48  getTosaConst8bitTable(input_scale, input_zp, output_scale, output_zp, exp_func));
49  operators.push_back(new TosaSerializationOperator(tosa::Op_TABLE,
50  Attribute_TableAttribute,
51  &attribute,
52  {inputName},
53  {outputName}));
54  }
55  else if (inputDType == DataType::QSymmS16)
56  {
57  throw Exception("ConvertExpOperator() unsupported int 16 not implemented yet.");
58  // The following generates the table, tosa attribute and operator for int16 exponential.
59  // However, running the int16 EXP EndToEnd test causes incorrect output values.
60  // At the time of writing the EXP operator there is no requirment for int16 support.
61  // Points to enable int16 in the future:
62  // - TOSA specifies EXP int16 input must have int32 output
63  // - We potentially need a rescale after the int32 EXP output to convert back to int16.
64  /*
65  auto exp_func = [](float x) -> float { return std::exp(x); };
66  TosaTableAttribute attribute(
67  getTosaConst16bitTable<float>(input_scale, input_zp, output_scale, output_zp, exp_func));
68  operators.push_back(new TosaSerializationOperator(tosa::Op_TABLE,
69  Attribute_TableAttribute,
70  &attribute,
71  {inputName},
72  {outputName}));
73  */
74  }
75  else if (inputDType == DataType::Signed32 ||
76  inputDType == DataType::Signed64)
77  {
78  throw Exception(
79  "ConvertExpOperator() unsupported int 32. Only int 8 and int 16 quantized types are supported.");
80  }
81  // Floating point EXP operator
82  else
83  {
84  operators.push_back(new TosaSerializationOperator(tosa::Op_EXP,
85  Attribute_NONE,
86  nullptr,
87  {inputName},
88  {outputName}));
89  }
90 
91  // Only add input tensor if connected layer is an input layer.
92  // As intermediate or constant tensors will be created separately.
93  // There also can't be duplicate tensor.
94  if(inputName.find("input_") != std::string::npos)
95  {
96  std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputs[0]->GetShape());
97  DType inputDType0 = ArmNNToDType(inputDType);
98  tensors.push_back(new TosaSerializationTensor(inputName, inputShape0, inputDType0, {}));
99  }
100 
101  std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
102 
103  // Re-enable below line for int16 EXP support which requires int32 output in TOSA and remove second line.
104  // DType outputDType0 =
105  // (inputDType == DataType::QSymmS16) ? DType::DType_INT32 : ArmNNToDType(outputs[0]->GetDataType());
106  DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
107 
108  tensors.push_back(new TosaSerializationTensor(outputName, outputShape0, outputDType0, {}));
109 
110  // operatorInputNames/operatorOutputNames ends up being the same as
111  // blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
112  return new TosaSerializationBasicBlock(blockName, // name
113  mainName, // region name
114  operators, // operators
115  tensors, // tensors
116  {inputName}, // inputs
117  {outputName}); // outputs
118 }

References GenerateUniqueInputName(), GenerateUniqueOutputName(), Layer::GetInputSlot(), getTosaConst8bitTable(), GetTosaTensorShape(), GetUniqueTosaMappingID(), and ElementwiseUnaryDescriptor::m_Operation.

Referenced by GetTosaMapping().

getTosaConst8bitTable
std::vector< int16_t > getTosaConst8bitTable(float input_scale, int32_t input_zp, float output_scale, int32_t output_zp, std::function< float(float)> func)
Definition: TosaTableUtils.hpp:19
GenerateUniqueOutputName
std::string GenerateUniqueOutputName(const Layer &layer, uint32_t layerSlot=0)
Definition: TosaOperatorUtils.hpp:120
armnn::Layer::GetInputSlot
const InputSlot & GetInputSlot(unsigned int index) const override
Get a const input slot handle by slot index.
Definition: Layer.hpp:337
mainName
const std::string mainName
Definition: TosaOperatorUtils.hpp:19
ArmNNToDType
DType ArmNNToDType(const DataType &type)
Definition: TosaOperatorUtils.hpp:22
armnn::DataType
DataType
Definition: Types.hpp:48
armnn::Exception
Base class for all ArmNN exceptions so that users can filter to just those.
Definition: Exceptions.hpp:46
armnn::ElementwiseUnaryDescriptor::m_Operation
UnaryOperation m_Operation
Specifies the elementwiseUnary operation to execute.
Definition: Descriptors.hpp:145
GetTosaTensorShape
std::vector< int32_t > GetTosaTensorShape(const TensorShape &shape)
Definition: TosaOperatorUtils.hpp:79
GenerateUniqueInputName
std::string GenerateUniqueInputName(const armnn::InputSlot &slot)
Definition: TosaOperatorUtils.hpp:109
GetUniqueTosaMappingID
std::string GetUniqueTosaMappingID()
Definition: TosaOperatorUtils.hpp:138