ArmNN
 21.02
Public Member Functions | List of all members
QuantizerStrategy Class Reference

#include <QuantizerStrategy.hpp>

Inheritance diagram for QuantizerStrategy:
IStrategy

Public Member Functions

 QuantizerStrategy (const RangeTracker &rangeTracker, const IQuantizationScheme *quantizationScheme, bool preserveType)
 
 ~QuantizerStrategy ()=default
 
void ExecuteStrategy (const armnn::IConnectableLayer *layer, const BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id) override
 
INetworkPtr RetrieveFinalNetwork ()
 Extract the quantized network. More...
 
- Public Member Functions inherited from IStrategy
virtual void FinishStrategy ()
 

Additional Inherited Members

- Protected Member Functions inherited from IStrategy
 IStrategy ()
 
virtual ~IStrategy ()
 

Detailed Description

Definition at line 15 of file QuantizerStrategy.hpp.

Constructor & Destructor Documentation

◆ QuantizerStrategy()

QuantizerStrategy ( const RangeTracker &  rangeTracker,
const IQuantizationScheme *  quantizationScheme,
bool  preserveType 
)

Definition at line 12 of file QuantizerStrategy.cpp.

References ARMNN_ASSERT, ARMNN_ASSERT_MSG, armnn::Boolean, OutputSlot::CalculateIndexOnOwner(), IQuantizationScheme::ComputeScheme(), IOutputSlot::Connect(), InputSlot::GetConnectedOutputSlot(), IQuantizationScheme::GetDataType(), TensorInfo::GetDataType(), IConnectableLayer::GetGuid(), Layer::GetGuid(), BaseTensor< MemoryType >::GetInfo(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetNumInputSlots(), IConnectableLayer::GetOutputSlot(), OutputSlot::GetOwningLayer(), TensorInfo::GetQuantizationScale(), RangeTracker::GetRange(), OutputSlot::GetTensorInfo(), armnn::info, armnn::numeric_cast(), IOutputSlot::SetTensorInfo(), armnn::Signed32, armnn::Signed64, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

15  : m_Ranges(rangeTracker)
16  , m_QuantizedNetwork(INetwork::Create())
17  , m_QuantizationScheme(quantizationScheme)
18  , m_PreserveType(preserveType)
19 {
20 }
armnn::INetwork::Create
static INetworkPtr Create(NetworkOptions networkOptions={})
Definition: Network.cpp:510

◆ ~QuantizerStrategy()

~QuantizerStrategy ( )
default

Member Function Documentation

◆ ExecuteStrategy()

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

Implements IStrategy.

Definition at line 118 of file QuantizerStrategy.cpp.

References armnn::Activation, armnn::Addition, armnn::ArgMinMax, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::Bilinear, armnn::Comparison, armnn::Concat, IOutputSlot::Connect(), armnn::Constant, armnn::Convolution2d, armnn::CreateQuantizedConst(), armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::ElementwiseUnary, armnn::Fill, armnn::Float16, armnn::Float32, armnn::FullyConnected, IInputSlot::GetConnection(), TensorInfo::GetDataType(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IConnectableLayer::GetType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::info, armnn::Input, armnn::InstanceNormalization, armnn::LogSoftmax, ResizeBilinearDescriptor::m_DataLayout, ResizeDescriptor::m_DataLayout, ResizeDescriptor::m_Method, ResizeBilinearDescriptor::m_TargetHeight, ResizeDescriptor::m_TargetHeight, ResizeBilinearDescriptor::m_TargetWidth, ResizeDescriptor::m_TargetWidth, armnn::Mean, armnn::Multiplication, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::Pooling2d, armnn::Prelu, armnn::Reshape, armnn::Resize, IOutputSlot::SetTensorInfo(), armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::Stack, armnn::StridedSlice, armnn::Subtraction, armnn::Transpose, and armnn::TransposeConvolution2d.

123 {
124  IgnoreUnused(id);
125 
126  IConnectableLayer* newLayer;
127 
128  switch (layer->GetType())
129  {
130  case armnn::LayerType::Addition :
131  {
132  newLayer = m_QuantizedNetwork->AddAdditionLayer(name);
133  break;
134  }
135  case armnn::LayerType::Activation :
136  {
137  const ActivationDescriptor& activationDescriptor = static_cast<const ActivationDescriptor&>(descriptor);
138  newLayer = m_QuantizedNetwork->AddActivationLayer(activationDescriptor, name);
139  break;
140  }
141  case armnn::LayerType::ArgMinMax :
142  {
143  ArgMinMaxDescriptor argMinMaxDescriptor = static_cast<const ArgMinMaxDescriptor&>(descriptor);
144  newLayer = m_QuantizedNetwork->AddArgMinMaxLayer(argMinMaxDescriptor, name);
145  break;
146  }
147  case armnn::LayerType::BatchNormalization :
148  {
149 
150  BatchNormalizationDescriptor batchNormalizationDescriptor =
151  static_cast<const BatchNormalizationDescriptor&>(descriptor);
152  std::vector<uint8_t> meanBacking;
153  ConstTensor qMean = CreateQuantizedConst(constants[0], meanBacking);
154 
155  std::vector<uint8_t> varianceBacking;
156  ConstTensor qVariance = CreateQuantizedConst(constants[1], varianceBacking);
157 
158  std::vector<uint8_t> betaBacking;
159  ConstTensor qBeta = CreateQuantizedConst(constants[2], betaBacking);
160 
161  std::vector<uint8_t> gammaBacking;
162  ConstTensor qGamma = CreateQuantizedConst(constants[3], gammaBacking);
163 
164  newLayer = m_QuantizedNetwork->AddBatchNormalizationLayer(batchNormalizationDescriptor,
165  qMean,
166  qVariance,
167  qBeta,
168  qGamma,
169  name);
170  break;
171  }
172  case armnn::LayerType::BatchToSpaceNd :
173  {
174  BatchToSpaceNdDescriptor batchToSpaceNdDescriptor =
175  static_cast<const BatchToSpaceNdDescriptor&>(descriptor);
176 
177  newLayer = m_QuantizedNetwork->AddBatchToSpaceNdLayer(batchToSpaceNdDescriptor, name);
178  break;
179  }
180  case armnn::LayerType::Comparison :
181  {
182  ComparisonDescriptor comparisonDescriptor =static_cast<const ComparisonDescriptor&>(descriptor);
183  newLayer = m_QuantizedNetwork->AddComparisonLayer(comparisonDescriptor, name);
184  break;
185  }
186  case armnn::LayerType::Concat :
187  {
188  OriginsDescriptor originsDescriptor = static_cast<const OriginsDescriptor&>(descriptor);
189  newLayer = m_QuantizedNetwork->AddConcatLayer(originsDescriptor, name);
190  break;
191  }
192  case armnn::LayerType::Constant :
193  {
194  std::vector<uint8_t> inputBacking;
195  ConstTensor qInput = CreateQuantizedConst(constants[0], inputBacking);
196 
197  newLayer = m_QuantizedNetwork->AddConstantLayer(qInput, name);
198  break;
199  }
200  case armnn::LayerType::Convolution2d :
201  {
202  const armnn::Optional<ConstTensor> biases = constants.size() == 1 ?
203  armnn::Optional<ConstTensor>{} :
204  armnn::Optional<ConstTensor>(constants[1]);
205 
206  std::vector<uint8_t> weightsBacking;
207  ConstTensor qWeights = CreateQuantizedConst(constants[0], weightsBacking);
208  Optional<ConstTensor> optionalQBiases;
209  std::vector<int32_t> biasesBacking;
210 
211  if (biases.has_value())
212  {
213  ConstTensor qBiases = CreateQuantizedBias(layer, qWeights, biases, biasesBacking);
214  optionalQBiases = Optional<ConstTensor>(qBiases);
215  }
216  Convolution2dDescriptor convolution2dDescriptor = static_cast<const Convolution2dDescriptor&>(descriptor);
217 
218  newLayer = m_QuantizedNetwork->AddConvolution2dLayer(convolution2dDescriptor,
219  qWeights,
220  optionalQBiases,
221  name);
222  break;
223  }
224  case armnn::LayerType::DepthToSpace :
225  {
226  DepthToSpaceDescriptor depthToSpaceDescriptor = static_cast<const DepthToSpaceDescriptor&>(descriptor);
227 
228  newLayer = m_QuantizedNetwork->AddDepthToSpaceLayer(depthToSpaceDescriptor, name);
229  break;
230  }
231  case armnn::LayerType::DepthwiseConvolution2d :
232  {
233  DepthwiseConvolution2dDescriptor depthwiseConvolution2dDescriptor =
234  static_cast<const DepthwiseConvolution2dDescriptor&>(descriptor);
235 
236  const armnn::Optional<ConstTensor> biases = constants.size() == 1 ?
237  armnn::Optional<ConstTensor>{} :
238  armnn::Optional<ConstTensor>(constants[1]);
239 
240  std::vector<uint8_t> weightsBacking;
241  ConstTensor qWeights = CreateQuantizedConst(constants[0], weightsBacking);
242  Optional<ConstTensor> optionalQBiases;
243  std::vector<int32_t> biasesBacking;
244 
245  if (biases.has_value())
246  {
247  ConstTensor qBiases = CreateQuantizedBias(layer, qWeights, biases, biasesBacking);
248  optionalQBiases = Optional<ConstTensor>(qBiases);
249  }
250 
251  newLayer = m_QuantizedNetwork->AddDepthwiseConvolution2dLayer(
252  depthwiseConvolution2dDescriptor,
253  qWeights,
254  optionalQBiases,
255  name);
256  break;
257  }
258  case armnn::LayerType::ElementwiseUnary :
259  {
260  ElementwiseUnaryDescriptor elementwiseUnaryDescriptor =
261  static_cast<const ElementwiseUnaryDescriptor&>(descriptor);
262 
263  newLayer = m_QuantizedNetwork->AddElementwiseUnaryLayer(elementwiseUnaryDescriptor, name);
264  break;
265  }
266  case armnn::LayerType::Fill :
267  {
268  FillDescriptor fillDescriptor = static_cast<const FillDescriptor&>(descriptor);
269 
270  newLayer = m_QuantizedNetwork->AddFillLayer(fillDescriptor, name);
271  break;
272  }
273  case armnn::LayerType::FullyConnected :
274  {
275  FullyConnectedDescriptor fullyConnectedDescriptor =
276  static_cast<const FullyConnectedDescriptor&>(descriptor);
277 
278  const armnn::Optional<ConstTensor> biases = constants.size() == 1 ?
279  armnn::Optional<ConstTensor>{} :
280  armnn::Optional<ConstTensor>(constants[1]);
281 
282  std::vector<uint8_t> weightsBacking;
283  ConstTensor qWeights = CreateQuantizedConst(constants[0], weightsBacking);
284  Optional<ConstTensor> optionalQBiases;
285  std::vector<int32_t> biasesBacking;
286 
287  if (biases.has_value())
288  {
289  ConstTensor qBiases = CreateQuantizedBias(layer, qWeights, biases, biasesBacking);
290  optionalQBiases = Optional<ConstTensor>(qBiases);
291  }
292 
293  newLayer = m_QuantizedNetwork->AddFullyConnectedLayer(fullyConnectedDescriptor,
294  qWeights,
295  optionalQBiases,
296  name);
297  break;
298  }
299  case armnn::LayerType::Input :
300  {
301  const DataType dataType = layer->GetOutputSlot(0).GetTensorInfo().GetDataType();
302  IConnectableLayer* inputLayer = m_QuantizedNetwork->AddInputLayer(id, name);
303 
304  if (m_PreserveType && (dataType == DataType::Float32 || dataType == DataType::Float16))
305  {
306  IConnectableLayer* quantizeLayer = m_QuantizedNetwork->AddQuantizeLayer();
307  inputLayer->GetOutputSlot(0).Connect(quantizeLayer->GetInputSlot(0));
308  inputLayer->GetOutputSlot(0).SetTensorInfo(layer->GetOutputSlot(0).GetTensorInfo());
309  RecordLayer(layer, quantizeLayer);
310  return;
311  }
312  else
313  {
314  RecordLayer(layer, inputLayer);
315  return;
316  }
317  }
318  case armnn::LayerType::InstanceNormalization :
319  {
320  InstanceNormalizationDescriptor instanceNormalizationDescriptor =
321  static_cast<const InstanceNormalizationDescriptor&>(descriptor);
322 
323  newLayer =
324  m_QuantizedNetwork->AddInstanceNormalizationLayer(instanceNormalizationDescriptor, name);
325  break;
326  }
327  case armnn::LayerType::LogSoftmax :
328  {
329  LogSoftmaxDescriptor logSoftmaxDescriptor = static_cast<const LogSoftmaxDescriptor&>(descriptor);
330 
331  newLayer = m_QuantizedNetwork->AddLogSoftmaxLayer(logSoftmaxDescriptor, name);
332  break;
333  }
334  case armnn::LayerType::Mean :
335  {
336  MeanDescriptor meanDescriptor = static_cast<const MeanDescriptor&>(descriptor);
337 
338  newLayer = m_QuantizedNetwork->AddMeanLayer(meanDescriptor, name);
339  break;
340  }
341  case armnn::LayerType::Multiplication :
342  {
343  newLayer = m_QuantizedNetwork->AddMultiplicationLayer(name);
344  break;
345  }
346  case armnn::LayerType::Normalization :
347  {
348  NormalizationDescriptor normalizationDescriptor = static_cast<const NormalizationDescriptor&>(descriptor);
349 
350  newLayer = m_QuantizedNetwork->AddNormalizationLayer(normalizationDescriptor, name);
351  break;
352  }
353  case armnn::LayerType::Output :
354  {
355  const TensorInfo& info = layer->GetInputSlot(0).GetConnection()->GetTensorInfo();
356  const DataType& dataType = info.GetDataType();
357  newLayer = m_QuantizedNetwork->AddOutputLayer(id, name);
358 
359  if (m_PreserveType && (dataType == DataType::Float32 || dataType == DataType::Float16))
360  {
361  IConnectableLayer* dequantizeLayer = m_QuantizedNetwork->AddDequantizeLayer();
362  RecordLayer(layer, dequantizeLayer);
363  SetQuantizedInputConnections(layer, dequantizeLayer);
364  dequantizeLayer->GetOutputSlot(0).Connect(newLayer->GetInputSlot(0));
365  dequantizeLayer->GetOutputSlot(0).SetTensorInfo(info);
366  return;
367  }
368  else
369  {
370  break;
371  }
372  }
373  case armnn::LayerType::Pad :
374  {
375  PadDescriptor padDescriptor = static_cast<const PadDescriptor&>(descriptor);
376 
377  newLayer = m_QuantizedNetwork->AddPadLayer(padDescriptor, name);
378  break;
379  }
380  case armnn::LayerType::Permute :
381  {
382  PermuteDescriptor permuteDescriptor = static_cast<const PermuteDescriptor&>(descriptor);
383 
384  newLayer = m_QuantizedNetwork->AddPermuteLayer(permuteDescriptor, name);
385  break;
386  }
387  case armnn::LayerType::Pooling2d :
388  {
389  Pooling2dDescriptor pooling2dDescriptor = static_cast<const Pooling2dDescriptor&>(descriptor);
390 
391  newLayer = m_QuantizedNetwork->AddPooling2dLayer(pooling2dDescriptor, name);
392  break;
393  }
394  case armnn::LayerType::Prelu :
395  {
396  newLayer = m_QuantizedNetwork->AddPreluLayer(name);
397  break;
398  }
399  case armnn::LayerType::Reshape :
400  {
401  ReshapeDescriptor reshapeDescriptor = static_cast<const ReshapeDescriptor&>(descriptor);
402 
403  newLayer = m_QuantizedNetwork->AddReshapeLayer(reshapeDescriptor, name);
404  break;
405  }
406  case armnn::LayerType::Resize :
407  {
408 
409  ResizeBilinearDescriptor resizeBilinearDescriptor =
410  static_cast<const ResizeBilinearDescriptor&>(descriptor);
411 
412  ResizeDescriptor resizeDescriptor;
413  resizeDescriptor.m_Method = ResizeMethod::Bilinear;
414  resizeDescriptor.m_TargetWidth = resizeBilinearDescriptor.m_TargetWidth;
415  resizeDescriptor.m_TargetHeight = resizeBilinearDescriptor.m_TargetHeight;
416  resizeDescriptor.m_DataLayout = resizeBilinearDescriptor.m_DataLayout;
417 
418  newLayer = m_QuantizedNetwork->AddResizeLayer(resizeDescriptor, name);
419  break;
420  }
421  case armnn::LayerType::Slice :
422  {
423  SliceDescriptor sliceDescriptor = static_cast<const SliceDescriptor&>(descriptor);
424 
425  newLayer = m_QuantizedNetwork->AddSliceLayer(sliceDescriptor, name);
426  break;
427  }
428  case armnn::LayerType::Softmax :
429  {
430  SoftmaxDescriptor softmaxDescriptor = static_cast<const SoftmaxDescriptor&>(descriptor);
431 
432  newLayer = m_QuantizedNetwork->AddSoftmaxLayer(softmaxDescriptor, name);
433  break;
434  }
435  case armnn::LayerType::SpaceToBatchNd :
436  {
437  SpaceToBatchNdDescriptor spaceToBatchNdDescriptor =
438  static_cast<const SpaceToBatchNdDescriptor&>(descriptor);
439 
440  newLayer = m_QuantizedNetwork->AddSpaceToBatchNdLayer(spaceToBatchNdDescriptor, name);
441  break;
442  }
443  case armnn::LayerType::SpaceToDepth :
444  {
445  SpaceToDepthDescriptor spaceToDepthDescriptor = static_cast<const SpaceToDepthDescriptor&>(descriptor);
446  newLayer = m_QuantizedNetwork->AddSpaceToDepthLayer(spaceToDepthDescriptor, name);
447  break;
448  }
449  case armnn::LayerType::Splitter :
450  {
451  SplitterDescriptor splitterDescriptor = static_cast<const SplitterDescriptor&>(descriptor);
452  newLayer = m_QuantizedNetwork->AddSplitterLayer(splitterDescriptor, name);
453  break;
454  }
455  case armnn::LayerType::Stack :
456  {
457  StackDescriptor stackDescriptor = static_cast<const StackDescriptor&>(descriptor);
458 
459  newLayer = m_QuantizedNetwork->AddStackLayer(stackDescriptor, name);
460  break;
461  }
462  case armnn::LayerType::StridedSlice :
463  {
464  StridedSliceDescriptor stridedSliceDescriptor = static_cast<const StridedSliceDescriptor&>(descriptor);
465 
466  newLayer = m_QuantizedNetwork->AddStridedSliceLayer(stridedSliceDescriptor, name);
467  break;
468  }
469  case armnn::LayerType::Subtraction :
470  {
471  newLayer = m_QuantizedNetwork->AddSubtractionLayer( name);
472  break;
473  }
474  case armnn::LayerType::TransposeConvolution2d :
475  {
476 
477  const armnn::Optional<ConstTensor> biases = constants.size() == 1 ?
478  armnn::Optional<ConstTensor>{} :
479  armnn::Optional<ConstTensor>(constants[1]);
480  // quantize weights
481  std::vector<uint8_t> weightsBacking;
482  ConstTensor qWeights = CreateQuantizedConst(constants[0], weightsBacking);
483 
484  // quantize biases
485  std::vector<int32_t> biasesBacking;
486  Optional<ConstTensor> optionalQBiases;
487  if (biases.has_value())
488  {
489  ConstTensor qBiases = CreateQuantizedBias(layer, qWeights, biases, biasesBacking);
490  optionalQBiases = Optional<ConstTensor>(qBiases);
491  }
492 
493  TransposeConvolution2dDescriptor transposeConvolution2dDescriptor =
494  static_cast<const TransposeConvolution2dDescriptor&>(descriptor);
495 
496  newLayer = m_QuantizedNetwork->AddTransposeConvolution2dLayer(transposeConvolution2dDescriptor,
497  qWeights,
498  optionalQBiases,
499  name);
500  break;
501  }
502  case armnn::LayerType::Transpose :
503  {
504  TransposeDescriptor transposeDescriptor = static_cast<const TransposeDescriptor&>(descriptor);
505 
506  newLayer = m_QuantizedNetwork->AddTransposeLayer(transposeDescriptor, name);
507  break;
508  }
509  default:
510  {
511  throw UnimplementedException("Unimplemented layer encountered");
512  }
513  }
514  RecordLayer(layer, newLayer);
515  SetQuantizedInputConnections(layer, newLayer);
516 }
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::DataType
DataType
Definition: Types.hpp:32
armnn::TensorInfo::GetDataType
DataType GetDataType() const
Definition: Tensor.hpp:194
armnn::OptionalBase::has_value
bool has_value() const noexcept
Definition: Optional.hpp:53
armnn::IConnectableLayer::GetType
virtual LayerType GetType() const =0
Returns the armnn::LayerType of this layer.
armnn::LogSoftmaxDescriptor
SoftmaxDescriptor LogSoftmaxDescriptor
A LogSoftmaxDescriptor for the LogSoftmaxLayer.
Definition: Descriptors.hpp:158
armnn::IConnectableLayer::GetInputSlot
virtual const IInputSlot & GetInputSlot(unsigned int index) const =0
Get a const input slot handle by slot index.
armnn::IInputSlot::GetConnection
virtual const IOutputSlot * GetConnection() const =0
armnn::IOutputSlot::GetTensorInfo
virtual const TensorInfo & GetTensorInfo() const =0
armnn::IConnectableLayer::GetOutputSlot
virtual const IOutputSlot & GetOutputSlot(unsigned int index) const =0
Get the const output slot handle by slot index.
armnn::CreateQuantizedConst
ConstTensor CreateQuantizedConst(const ConstTensor &tensor, std::vector< uint8_t > &backing)
Definition: NetworkQuantizerUtils.cpp:15
armnn::DepthToSpaceDescriptor
SpaceToDepthDescriptor DepthToSpaceDescriptor
A DepthToSpaceDescriptor for the DepthToSpaceLayer.
Definition: Descriptors.hpp:908
armnn::SplitterDescriptor
ViewsDescriptor SplitterDescriptor
Definition: DescriptorsFwd.hpp:57

◆ RetrieveFinalNetwork()

INetworkPtr RetrieveFinalNetwork ( )
inline

Extract the quantized network.

Definition at line 31 of file QuantizerStrategy.hpp.

31 { return std::move(m_QuantizedNetwork); }
The documentation for this class was generated from the following files: