ArmNN
 21.11
Functions
OptimizerTests.cpp File Reference
#include "TestUtils.hpp"
#include <BackendSettings.hpp>
#include <Graph.hpp>
#include <Network.hpp>
#include <Optimizer.hpp>
#include <armnn/BackendHelper.hpp>
#include <armnn/BackendRegistry.hpp>
#include <armnn/INetwork.hpp>
#include <armnn/StrategyBase.hpp>
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <armnn/backends/IBackendInternal.hpp>
#include <backendsCommon/LayerSupportBase.hpp>
#include <backendsCommon/TensorHandle.hpp>
#include <doctest/doctest.h>

Go to the source code of this file.

Functions

 TEST_SUITE ("Optimizer")
 

Function Documentation

◆ TEST_SUITE()

TEST_SUITE ( "Optimizer"  )

Definition at line 283 of file OptimizerTests.cpp.

References armnn::Activation, armnn::Addition, Graph::AddLayer(), ARMNN_ASSERT, armnn::AssignBackends(), armnn::Average, armnn::BackendRegistryInstance(), Layer::BackendSelectionHint(), Graph::begin(), armnn::Bilinear, Graph::cbegin(), Graph::cend(), CheckSequence(), OutputSlot::Connect(), armnn::ConvertFp16ToFp32, armnn::ConvertFp32ToFp16, INetwork::Create(), Graph::end(), armnn::Exclude, armnn::Float16, armnn::Float32, armnn::Floor, armnn::GetCapability(), TensorInfo::GetDataType(), Layer::GetDataType(), OptimizedNetworkImpl::GetGraph(), Layer::GetInputSlot(), armnn::GetLayerTypeAsCString(), Layer::GetNameStr(), Graph::GetNumLayers(), Layer::GetOutputHandler(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), IConnectableLayer::GetType(), Layer::GetType(), armnn::HasCapability(), armnn::IgnoreUnused(), Graph::InferTensorInfos(), armnn::info, armnn::Input, armnn::InsertConvertFp16ToFp32LayersBefore(), armnn::InsertConvertFp32ToFp16LayersAfter(), OptimizationResult::IsOk(), armnn::Linear, DetectionPostProcessLayer::m_Anchors, Convolution2dDescriptor::m_BiasEnabled, DepthwiseConvolution2dDescriptor::m_BiasEnabled, Pooling2dDescriptor::m_DataLayout, Convolution2dDescriptor::m_DataLayout, DepthwiseConvolution2dDescriptor::m_DataLayout, BatchNormalizationDescriptor::m_DataLayout, ResizeDescriptor::m_DataLayout, ActivationDescriptor::m_Function, DetectionPostProcessDescriptor::m_MaxDetections, ResizeDescriptor::m_Method, Pooling2dDescriptor::m_PadBottom, Pooling2dDescriptor::m_PaddingMethod, Pooling2dDescriptor::m_PadLeft, Pooling2dDescriptor::m_PadRight, Pooling2dDescriptor::m_PadTop, Pooling2dDescriptor::m_PoolHeight, Pooling2dDescriptor::m_PoolType, Pooling2dDescriptor::m_PoolWidth, Pooling2dDescriptor::m_StrideX, Convolution2dDescriptor::m_StrideX, DepthwiseConvolution2dDescriptor::m_StrideX, Pooling2dDescriptor::m_StrideY, Convolution2dDescriptor::m_StrideY, DepthwiseConvolution2dDescriptor::m_StrideY, ResizeDescriptor::m_TargetHeight, ResizeDescriptor::m_TargetWidth, DepthwiseConvolution2dLayer::m_Weight, Convolution2dLayer::m_Weight, armnn::MakeOptimizations(), armnn::NCHW, armnn::NHWC, armnn::Output, Optimizer::Pass(), armnn::QAsymmU8, OutputHandler::SetTensorInfo(), OutputSlot::SetTensorInfo(), and armnn::Signed32.

284 {
285 using namespace armnn::optimizations;
286 
287 TEST_CASE("LSTMValidateTensorShapesFromInputsCIFGDisabledTest")
288 {
289  Graph graph;
290 
291  //Helper function creates graph containing LSTM layer with required input and output layers
292  CreateLSTMLayerHelper(graph, false);
293 
294  //This function used to call ValidateShapesFromInputs();
295  CHECK_NOTHROW(graph.InferTensorInfos());
296 }
297 
298 TEST_CASE("LSTMValidateTensorShapesFromInputsCIFGEnabledTest")
299 {
300  Graph graph;
301 
302  //Helper function creates graph containing LSTM layer with required input and output layers
303  CreateLSTMLayerHelper(graph, true);
304 
305  //This function used to call ValidateShapesFromInputs();
306  CHECK_NOTHROW(graph.InferTensorInfos());
307 }
308 
309 TEST_CASE("InsertConvertersTest")
310 {
311  const armnn::TensorInfo info({ 1, 5, 2, 3 }, armnn::DataType::Float16);
312 
313  armnn::Graph graph;
314 
315  armnn::LayerBindingId inputId = 0;
316 
317  armnn::Layer* head = graph.AddLayer<armnn::OutputLayer>(0, "output");
318 
319  head = graph.InsertNewLayer<armnn::AdditionLayer>(head->GetInputSlot(0), "");
320  head->GetOutputHandler().SetTensorInfo(info);
321 
322  graph.InsertNewLayer<armnn::InputLayer>(head->GetInputSlot(1), inputId++, "")
323  ->GetOutputHandler().SetTensorInfo(info);
324 
325  head = graph.InsertNewLayer<armnn::FloorLayer>(head->GetInputSlot(0), "");
326  head->GetOutputHandler().SetTensorInfo(info);
327 
328  head = graph.InsertNewLayer<armnn::MemCopyLayer>(head->GetInputSlot(0), "");
329  head->GetOutputHandler().SetTensorInfo(info);
330 
331  graph.InsertNewLayer<armnn::InputLayer>(head->GetInputSlot(0), inputId++, "")
332  ->GetOutputHandler().SetTensorInfo(info);
333 
334  // Check graph layer sequence before inserting convert layers
335  CHECK(CheckSequence(graph.cbegin(),
336  graph.cend(),
337  &IsLayerOfType<armnn::InputLayer>,
338  &IsLayerOfType<armnn::InputLayer>,
339  &IsLayerOfType<armnn::MemCopyLayer>,
340  &IsLayerOfType<armnn::FloorLayer>,
341  &IsLayerOfType<armnn::AdditionLayer>,
342  &IsLayerOfType<armnn::OutputLayer>));
343 
344  // Check layers have Float16 DataType
345  for (auto& layer : graph)
346  {
347  if(layer->GetType()==LayerType::Floor || layer->GetType() == LayerType::Addition)
348  {
349  ARMNN_ASSERT(layer->GetOutputSlot(0).GetTensorInfo().GetDataType() == DataType::Float16);
350  ARMNN_ASSERT(layer->GetDataType() == DataType::Float16);
351  }
352  }
353 
354  // Insert convert layers either side of unsupported layer
355  for (auto& layer : graph)
356  {
357  if(layer->GetType()==LayerType::Floor || layer->GetType() == LayerType::Addition)
358  {
359  InsertConvertFp16ToFp32LayersBefore(graph, *layer);
360  InsertConvertFp32ToFp16LayersAfter(graph, *layer);
361  }
362  }
363 
364  // Check layers have correct DataType after inserting convert layers
365  for (auto& layer : graph)
366  {
367  if (layer->GetType()==LayerType::Floor || layer->GetType() == LayerType::Addition)
368  {
369  ARMNN_ASSERT(layer->GetOutputSlot(0).GetTensorInfo().GetDataType() == DataType::Float32);
370  ARMNN_ASSERT(layer->GetDataType() == DataType::Float32);
371  }
372  else if (layer->GetType() == LayerType::ConvertFp16ToFp32)
373  {
374  ARMNN_ASSERT(layer->GetOutputSlot(0).GetTensorInfo().GetDataType() == DataType::Float32);
375  ARMNN_ASSERT(layer->GetDataType() == DataType::Float16);
376  }
377  else if (layer->GetType() == LayerType::ConvertFp32ToFp16)
378  {
379  ARMNN_ASSERT(layer->GetOutputSlot(0).GetTensorInfo().GetDataType() == DataType::Float16);
380  ARMNN_ASSERT(layer->GetDataType() == DataType::Float32);
381  }
382  }
383 
384  // Check sequence of layers after inserting convert layers
385  CHECK(CheckSequence(graph.cbegin(),
386  graph.cend(),
387  &IsLayerOfType<armnn::InputLayer>,
388  &IsLayerOfType<armnn::InputLayer>,
389  &IsLayerOfType<armnn::ConvertFp16ToFp32Layer>,
390  &IsLayerOfType<armnn::MemCopyLayer>,
391  &IsLayerOfType<armnn::ConvertFp16ToFp32Layer>,
392  &IsLayerOfType<armnn::FloorLayer>,
393  &IsLayerOfType<armnn::ConvertFp32ToFp16Layer>,
394  &IsLayerOfType<armnn::ConvertFp16ToFp32Layer>,
395  &IsLayerOfType<armnn::AdditionLayer>,
396  &IsLayerOfType<armnn::ConvertFp32ToFp16Layer>,
397  &IsLayerOfType<armnn::OutputLayer>));
398 }
399 
400 void CreateConvolution2dGraph(Graph &graph, const unsigned int* inputShape,
401  const unsigned int* weightsShape, const unsigned int* outputShape,
402  DataLayout dataLayout = DataLayout::NCHW)
403 {
404  armnn::TensorInfo inputInfo(4, inputShape, DataType::Float32);
405  armnn::TensorInfo outputInfo(4, outputShape, DataType::Float32);
406 
407  std::vector<float> weightsVector(90);
408  armnn::ConstTensor weights(
409  armnn::TensorInfo(4, weightsShape, armnn::DataType::Float32, 0.0f, 0, true),
410  weightsVector);
411 
412  Convolution2dDescriptor desc;
413  desc.m_BiasEnabled = false;
414  desc.m_StrideX = 1;
415  desc.m_StrideY = 1;
416  desc.m_DataLayout = dataLayout;
417 
418  Layer* input = graph.AddLayer<InputLayer>(0, "input");
419  input->GetOutputSlot().SetTensorInfo(inputInfo);
420 
421  Convolution2dLayer* layer = graph.AddLayer<Convolution2dLayer>(desc, "conv2d");
422  layer->m_Weight = std::make_unique<armnn::ScopedTensorHandle>(weights);
423  layer->GetOutputSlot().SetTensorInfo(outputInfo);
424 
425  Layer* output = graph.AddLayer<OutputLayer>(0, "output");
426  input->GetOutputSlot().Connect(layer->GetInputSlot(0));
427  layer->GetOutputSlot().Connect(output->GetInputSlot(0));
428 }
429 
430 TEST_CASE("Conv2dValidateTensorShapesFromInputs")
431 {
432  Graph graph;
433  const unsigned int inputShape[] = { 1, 3, 8, 16 };
434  const unsigned int weightsShape[] = { 2, 3, 5, 3 };
435  const unsigned int outputShape[] = { 1, 2, 4, 14 };
436  CreateConvolution2dGraph(graph, inputShape, weightsShape, outputShape);
437 
438  CHECK_NOTHROW(graph.InferTensorInfos());
439 }
440 
441 TEST_CASE("Conv2dValidateTensorShapesFromInputsNhwc")
442 {
443  Graph graph;
444  const unsigned int inputShape[] = { 1, 8, 16, 3 };
445  const unsigned int weightsShape[] = { 2, 5, 3, 3 };
446  const unsigned int outputShape[] = { 1, 4, 14, 2 };
447  CreateConvolution2dGraph(graph, inputShape, weightsShape, outputShape, DataLayout::NHWC);
448 
449  CHECK_NOTHROW(graph.InferTensorInfos());
450 }
451 
452 void CreateDepthwiseConvolution2dGraph(Graph &graph, const unsigned int* inputShape,
453  const unsigned int* weightsShape, const unsigned int* outputShape,
454  DataLayout dataLayout = DataLayout::NCHW)
455 {
456  armnn::TensorInfo inputInfo(4, inputShape, DataType::Float32);
457  armnn::TensorInfo outputInfo(4, outputShape, DataType::Float32);
458 
459  std::vector<float> weightsVector(18);
460  armnn::ConstTensor weights(
461  armnn::TensorInfo(4, weightsShape, armnn::DataType::Float32, 0.0f, 0, true),
462  weightsVector);
463 
464  DepthwiseConvolution2dDescriptor desc;
465  desc.m_BiasEnabled = false;
466  desc.m_StrideX = 1;
467  desc.m_StrideY = 1;
468  desc.m_DataLayout = dataLayout;
469 
470  Layer* input = graph.AddLayer<InputLayer>(0, "input");
471  input->GetOutputSlot().SetTensorInfo(inputInfo);
472 
473  DepthwiseConvolution2dLayer* layer = graph.AddLayer<DepthwiseConvolution2dLayer>(desc, "depthwiseConv2d");
474  layer->m_Weight = std::make_unique<armnn::ScopedTensorHandle>(weights);
475  layer->GetOutputSlot().SetTensorInfo(outputInfo);
476 
477  Layer* output = graph.AddLayer<OutputLayer>(0, "output");
478  input->GetOutputSlot().Connect(layer->GetInputSlot(0));
479  layer->GetOutputSlot().Connect(output->GetInputSlot(0));
480 }
481 
482 TEST_CASE("DepthwiseConv2dValidateTensorShapesFromInputs")
483 {
484  Graph graph;
485  const unsigned int inputShape[] = { 1, 2, 3, 3 };
486  const unsigned int weightsShape[] = { 1, 3, 3, 2 };
487  const unsigned int outputShape[] = { 1, 2, 1, 1 };
488  CreateDepthwiseConvolution2dGraph(graph, inputShape, weightsShape, outputShape);
489 
490  CHECK_NOTHROW(graph.InferTensorInfos());
491 }
492 
493 TEST_CASE("DepthwiseConv2dValidateTensorShapesFromInputsNhwc")
494 {
495  Graph graph;
496  const unsigned int inputShape[] = { 1, 3, 3, 2 };
497  const unsigned int weightsShape[] = { 1, 3, 3, 2 };
498  const unsigned int outputShape[] = { 1, 1, 1, 2 };
499  CreateDepthwiseConvolution2dGraph(graph, inputShape, weightsShape, outputShape, DataLayout::NHWC);
500 
501  CHECK_NOTHROW(graph.InferTensorInfos());
502 }
503 
504 void CreatePooling2dGraph(Graph& graph, const unsigned int* inputShape, const unsigned int* outputShape,
505  DataLayout dataLayout = DataLayout::NCHW)
506 {
507  armnn::TensorInfo inputInfo(4, inputShape, DataType::Float32);
508  armnn::TensorInfo outputInfo(4, outputShape, DataType::Float32);
509 
510  Pooling2dDescriptor desc;
511  desc.m_PoolType = armnn::PoolingAlgorithm::Average;
512  desc.m_PoolWidth = desc.m_PoolHeight = 100;
513  desc.m_StrideX = desc.m_StrideY = 5;
514  desc.m_PadLeft = 50;
515  desc.m_PadRight = 50;
516  desc.m_PadTop = 50;
517  desc.m_PadBottom = 50;
518  desc.m_PaddingMethod = armnn::PaddingMethod::Exclude;
519  desc.m_DataLayout = dataLayout;
520 
521  Layer* input = graph.AddLayer<InputLayer>(0, "input");
522  input->GetOutputSlot().SetTensorInfo(inputInfo);
523 
524  Pooling2dLayer* layer = graph.AddLayer<Pooling2dLayer>(desc, "pooling2d");
525  layer->GetOutputSlot().SetTensorInfo(outputInfo);
526 
527  Layer* output = graph.AddLayer<OutputLayer>(0, "output");
528  input->GetOutputSlot().Connect(layer->GetInputSlot(0));
529  layer->GetOutputSlot().Connect(output->GetInputSlot(0));
530 }
531 
532 TEST_CASE("Pooling2dValidateTensorShapesFromInputs")
533 {
534  Graph graph;
535  const unsigned int inputShape[] = { 5, 3, 52, 60 };
536  const unsigned int outputShape[] = { 5, 3, 11, 13 };
537  CreatePooling2dGraph(graph, inputShape, outputShape, DataLayout::NCHW);
538 
539  CHECK_NOTHROW(graph.InferTensorInfos());
540 }
541 
542 TEST_CASE("Pooling2dValidateTensorShapesFromInputsNhwc")
543 {
544  Graph graph;
545  const unsigned int inputShape[] = { 5, 52, 60, 3 };
546  const unsigned int outputShape[] = { 5, 11, 13, 3 };
547  CreatePooling2dGraph(graph, inputShape, outputShape, DataLayout::NHWC);
548 
549  CHECK_NOTHROW(graph.InferTensorInfos());
550 }
551 
552 void CreateResizeBilinearGraph(Graph& graph,
553  const unsigned int* inputShape,
554  const unsigned int* outputShape,
555  DataLayout dataLayout = DataLayout::NCHW)
556 {
557  TensorInfo inputInfo(4, inputShape, DataType::Float32);
558  TensorInfo outputInfo(4, outputShape, DataType::Float32);
559 
560  ResizeDescriptor desc;
561  desc.m_Method = ResizeMethod::Bilinear;
562  desc.m_TargetHeight = 3;
563  desc.m_TargetWidth = 4;
564  desc.m_DataLayout = dataLayout;
565 
566  Layer* input = graph.AddLayer<InputLayer>(0, "input");
567  input->GetOutputSlot().SetTensorInfo(inputInfo);
568 
569  ResizeLayer* layer = graph.AddLayer<ResizeLayer>(desc, "resizeBilinear");
570  layer->GetOutputSlot().SetTensorInfo(outputInfo);
571 
572  Layer* output = graph.AddLayer<OutputLayer>(0, "output");
573  input->GetOutputSlot().Connect(layer->GetInputSlot(0));
574  layer->GetOutputSlot().Connect(output->GetInputSlot(0));
575 }
576 
577 TEST_CASE("ResizeBilinearValidateTensorShapesFromInputs")
578 {
579  Graph graph;
580  const unsigned int inputShape[] = { 1, 2, 4, 5 };
581  const unsigned int outputShape[] = { 1, 2, 3, 4 };
582  CreateResizeBilinearGraph(graph, inputShape, outputShape);
583 
584  CHECK_NOTHROW(graph.InferTensorInfos());
585 }
586 
587 TEST_CASE("ResizeBilinearValidateTensorShapesFromInputsNhwc")
588 {
589  Graph graph;
590  const unsigned int inputShape[] = { 1, 4, 5, 2 };
591  const unsigned int outputShape[] = { 1, 3, 4, 2 };
592  CreateResizeBilinearGraph(graph, inputShape, outputShape, DataLayout::NHWC);
593 
594  CHECK_NOTHROW(graph.InferTensorInfos());
595 }
596 
597 void CreateGatherGraph(Graph& graph,
598  const armnn::TensorInfo& paramsInfo,
599  const armnn::TensorInfo& indicesInfo,
600  const armnn::TensorInfo& outputInfo)
601 {
602  Layer* input0 = graph.AddLayer<InputLayer>(0, "params");
603  input0->GetOutputSlot().SetTensorInfo(paramsInfo);
604 
605  Layer* input1 = graph.AddLayer<InputLayer>(1, "indices");
606  input1->GetOutputSlot().SetTensorInfo(indicesInfo);
607 
608  GatherDescriptor descriptor;
609  GatherLayer* layer = graph.AddLayer<GatherLayer>(descriptor, "gather");
610  layer->GetOutputSlot().SetTensorInfo(outputInfo);
611 
612  Layer* output = graph.AddLayer<OutputLayer>(0, "output");
613  input0->GetOutputSlot().Connect(layer->GetInputSlot(0));
614  input1->GetOutputSlot().Connect(layer->GetInputSlot(1));
615  layer->GetOutputSlot().Connect(output->GetInputSlot(0));
616 }
617 
618 TEST_CASE("GatherValidateTensorShapesFromInputs")
619 {
620  Graph graph;
621  armnn::TensorInfo paramsInfo({10, 5}, DataType::Float32);
622  armnn::TensorInfo indicesInfo({3}, DataType::Signed32);
623  armnn::TensorInfo outputInfo({3, 5}, DataType::Float32);
624 
625  CreateGatherGraph(graph, paramsInfo, indicesInfo, outputInfo);
626 
627  CHECK_NOTHROW(graph.InferTensorInfos());
628 }
629 
630 TEST_CASE("GatherValidateTensorShapesFromInputs1DParams")
631 {
632  Graph graph;
633  armnn::TensorInfo paramsInfo({8}, DataType::Float32);
634  armnn::TensorInfo indicesInfo({5}, DataType::Signed32);
635  armnn::TensorInfo outputInfo( {5}, DataType::Float32);
636 
637  CreateGatherGraph(graph, paramsInfo, indicesInfo, outputInfo);
638 
639  CHECK_NOTHROW(graph.InferTensorInfos());
640 }
641 
642 TEST_CASE("GatherValidateTensorShapesFromInputsMultiDimIndices")
643 {
644  Graph graph;
645  armnn::TensorInfo paramsInfo({3, 2, 5}, DataType::Float32);
646  armnn::TensorInfo indicesInfo({2, 2}, DataType::Signed32);
647  armnn::TensorInfo outputInfo({2, 2, 2, 5}, DataType::Float32);
648 
649  CreateGatherGraph(graph, paramsInfo, indicesInfo, outputInfo);
650 
651  CHECK_NOTHROW(graph.InferTensorInfos());
652 }
653 
654 TEST_CASE("DetectionPostProcessValidateTensorShapes")
655 {
656  Graph graph;
657  armnn::TensorInfo boxEncodingsInfo({1, 10, 4}, DataType::QAsymmU8);
658  armnn::TensorInfo scoresInfo({1, 10, 4}, DataType::QAsymmU8);
659  std::vector<uint8_t> anchorsVector(40);
660  armnn::ConstTensor anchors(armnn::TensorInfo({10, 4}, armnn::DataType::QAsymmU8, 0.0f, 0, true), anchorsVector);
661 
662  armnn::TensorInfo detectionBoxesInfo({1, 3, 4}, DataType::QAsymmU8);
663  armnn::TensorInfo detectionScoresInfo({1, 3}, DataType::QAsymmU8);
664  armnn::TensorInfo detectionClassesInfo({1, 3}, DataType::QAsymmU8);
665  armnn::TensorInfo numDetectionInfo({1}, DataType::QAsymmU8);
666 
667  Layer* input0 = graph.AddLayer<InputLayer>(0, "boxEncodings");
668  input0->GetOutputSlot().SetTensorInfo(boxEncodingsInfo);
669 
670  Layer* input1 = graph.AddLayer<InputLayer>(1, "score");
671  input1->GetOutputSlot().SetTensorInfo(scoresInfo);
672 
673  DetectionPostProcessDescriptor descriptor;
674  descriptor.m_MaxDetections = 3;
675 
676  DetectionPostProcessLayer* layer = graph.AddLayer<DetectionPostProcessLayer>(descriptor, "detectionPostProcess");
677  layer->m_Anchors = std::make_unique<armnn::ScopedTensorHandle>(anchors);
678  layer->GetOutputSlot(0).SetTensorInfo(detectionBoxesInfo);
679  layer->GetOutputSlot(1).SetTensorInfo(detectionScoresInfo);
680  layer->GetOutputSlot(2).SetTensorInfo(detectionClassesInfo);
681  layer->GetOutputSlot(3).SetTensorInfo(numDetectionInfo);
682 
683  input0->GetOutputSlot().Connect(layer->GetInputSlot(0));
684  input1->GetOutputSlot().Connect(layer->GetInputSlot(1));
685 
686  CHECK_NOTHROW(graph.InferTensorInfos());
687 }
688 
689 TEST_CASE("BackendCapabilityTest")
690 {
691  BackendId backendId = "MockBackend";
692 
693  armnn::BackendOptions::BackendOption nonConstWeights{"NonConstWeights", true};
694 
695  // MockBackend does not support the NonConstWeights capability
696  CHECK(!armnn::HasCapability(nonConstWeights, backendId));
697  CHECK(!armnn::HasCapability("NonConstWeights", backendId));
698 
699  // MockBackend does not support the AsyncExecution capability
700  CHECK(!armnn::GetCapability("AsyncExecution", backendId).has_value());
701 }
702 
703 TEST_CASE("BackendHintTest")
704 {
705  class TestBackendAssignment : public StrategyBase<NoThrowStrategy>
706  {
707  public:
708 
709  void ExecuteStrategy(const armnn::IConnectableLayer* layer,
710  const armnn::BaseDescriptor& descriptor,
711  const std::vector<armnn::ConstTensor>& constants,
712  const char* name,
713  const armnn::LayerBindingId id = 0) override
714  {
715  armnn::IgnoreUnused(descriptor, constants, id, name);
716  switch (layer->GetType())
717  {
718  case armnn::LayerType::Input:
719  {
720  auto inputLayer = PolymorphicDowncast<const InputLayer*>(layer);
721  const auto connectedLayerBackendId = inputLayer->GetOutputSlot(0).GetOwningLayer().GetBackendId();
722  CHECK((inputLayer->GetBackendId() == connectedLayerBackendId));
723  break;
724  }
725  case armnn::LayerType::Output:
726  {
727  auto outputLayer = PolymorphicDowncast<const OutputLayer*>(layer);
728  CHECK((outputLayer->GetBackendId() == "MockBackend"));
729  break;
730  }
731  case armnn::LayerType::Activation:
732  {
733  auto activation = PolymorphicDowncast<const ActivationLayer*>(layer);
734  CHECK((activation->GetBackendId() == "CustomBackend"));
735  break;
736  }
737  default:
738  {
739  m_DefaultStrategy.Apply(GetLayerTypeAsCString(layer->GetType()));
740  }
741  }
742  }
743  };
744 
745  struct CustomPolicy
746  {
747  static const BackendId& GetIdStatic()
748  {
749  static BackendId id = "CustomBackend";
750  return id;
751  }
752  };
753 
754  struct MockPolicy
755  {
756  static const BackendId& GetIdStatic()
757  {
758  static BackendId id = "MockBackend";
759  return id;
760  }
761  };
762 
763  auto& backendRegistry = BackendRegistryInstance();
764 
765  backendRegistry.Register("MockBackend", []() { return std::make_unique<MockBackend<MockPolicy>>(); });
766 
767  backendRegistry.Register("CustomBackend", []() { return std::make_unique<MockBackend<CustomPolicy>>(); });
768 
769  // Define the network
770  auto network = INetwork::Create();
771  ActivationDescriptor desc;
772  desc.m_Function = ActivationFunction::Linear;
773 
774  std::unique_ptr<Graph> graph = std::make_unique<Graph>();
775  auto input = graph->AddLayer<InputLayer>(0, "input");
776  auto act = graph->AddLayer<ActivationLayer>(desc, "activation");
777  auto output = graph->AddLayer<OutputLayer>(0, "output");
778 
779  BackendId customBackendId("CustomBackend");
780  act->BackendSelectionHint(customBackendId);
781 
782  input->GetOutputSlot(0).Connect(act->GetInputSlot(0));
783  act->GetOutputSlot(0).Connect(output->GetInputSlot(0));
784 
785  OptimizedNetworkImpl optNet(std::move(graph));
786 
787  // Get the optimized graph
788  Graph& optGraph = optNet.GetGraph();
789 
790  std::vector<BackendId> prefs{ "MockBackend", "CustomBackend" };
791 
792  BackendIdSet availableBackends = { "CustomBackend", "MockBackend" };
793  DeviceSpec spec(availableBackends);
794 
795  BackendSettings backendSettings(prefs, spec);
796 
797  // Assign an available backend to each layer
798  Graph::Iterator firstLayer = optGraph.begin();
799  Graph::Iterator lastLayer = optGraph.end();
800 
801  OptimizedNetworkImpl* optNetObjPtr = &optNet;
802  OptimizationResult res = AssignBackends(optNetObjPtr,
803  backendSettings,
804  firstLayer,
805  lastLayer,
806  EmptyOptional());
807 
808  CHECK(res.IsOk());
809 
810  TestBackendAssignment visitor;
811  for (auto it = firstLayer; it != lastLayer; ++it)
812  {
813  (*it)->ExecuteStrategy(visitor);
814  }
815  // Clean up the registry for the next test.
816  backendRegistry.Deregister("MockBackend");
817  backendRegistry.Deregister("CustomBackend");
818 }
819 
820 // Tests that OptimizeForExclusiveConnections works, fusing when needed, using BatchNorm fusing as example
821 TEST_CASE("OptimizeForExclusiveConnectionsFuseTest")
822 {
823  using namespace armnn;
824  // Define layers information
825  Convolution2dDescriptor convolution2dDescriptor;
826  convolution2dDescriptor.m_BiasEnabled = false;
827  convolution2dDescriptor.m_DataLayout = DataLayout::NHWC;
828  BatchNormalizationDescriptor batchNormDescriptor;
829  batchNormDescriptor.m_DataLayout = DataLayout::NHWC;
830 
831  const unsigned int inputDimensionSizes[] = { 1, 4, 4, 3 }; // NHWCin
832  const unsigned int weightsDimensionSizes[] = { 1, 2, 2, 3 }; // CoutHWCin
833  const unsigned int outputDimensionSizes[] = { 1, 3, 3, 1 }; // NHWCout
834  const unsigned int outputChannelSize[] = { outputDimensionSizes[3] }; // Cout
835 
836  TensorInfo inputInfo(4, inputDimensionSizes, DataType::Float32);
837  TensorInfo outputInfo(4, outputDimensionSizes, DataType::Float32);
838 
839  std::vector<float> weightsVector = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
840  ConstTensor weights(TensorInfo(4, weightsDimensionSizes, DataType::Float32, 0.0f, 0, true), weightsVector);
841 
842  std::vector<float> betaVector = { 0.1f };
843  std::vector<float> gammaVector = { 0.5f };
844  std::vector<float> meanVector = { 0 };
845  std::vector<float> varianceVector = { 1 };
846  ConstTensor beta(TensorInfo(1, outputChannelSize, DataType::Float32, 0.0f, 0, true), betaVector);
847  ConstTensor gamma(TensorInfo(1, outputChannelSize, DataType::Float32, 0.0f, 0, true), gammaVector);
848  ConstTensor mean(TensorInfo(1, outputChannelSize, DataType::Float32, 0.0f, 0, true), meanVector);
849  ConstTensor variance(TensorInfo(1, outputChannelSize, DataType::Float32, 0.0f, 0, true), varianceVector);
850 
851  // Define the network
852  Graph graph;
853  auto input = graph.AddLayer<InputLayer>(0, "input");
854  auto conv = graph.AddLayer<Convolution2dLayer>(convolution2dDescriptor, "convolution");
855  auto batchNorm = graph.AddLayer<BatchNormalizationLayer>(batchNormDescriptor, "batchNorm");
856  auto output = graph.AddLayer<OutputLayer>(0, "output");
857 
858  // Set layer information
859  input->GetOutputSlot().SetTensorInfo(inputInfo);
860  conv->GetOutputSlot().SetTensorInfo(outputInfo);
861  batchNorm->GetOutputSlot().SetTensorInfo(outputInfo);
862  conv->m_Weight = std::make_unique<ScopedTensorHandle>(weights);
863  batchNorm->m_Beta = std::make_unique<ScopedTensorHandle>(beta);
864  batchNorm->m_Gamma = std::make_unique<ScopedTensorHandle>(gamma);
865  batchNorm->m_Mean = std::make_unique<ScopedTensorHandle>(mean);
866  batchNorm->m_Variance = std::make_unique<ScopedTensorHandle>(variance);
867  if (convolution2dDescriptor.m_BiasEnabled)
868  {
869  std::vector<float> biasVector = { 11 };
870  ConstTensor bias(TensorInfo(1, outputChannelSize, DataType::Float32, 0.0f, 0, true), biasVector);
871  conv->m_Bias = std::make_unique<ScopedTensorHandle>(bias);
872  }
873 
874  // Connect layers
875  input->GetOutputSlot(0).Connect(conv->GetInputSlot(0));
876  conv->GetOutputSlot(0).Connect(batchNorm->GetInputSlot(0));
877  batchNorm->GetOutputSlot(0).Connect(output->GetInputSlot(0));
878 
879  CHECK(4 == graph.GetNumLayers());
880  CHECK(CheckSequence(graph.cbegin(), graph.cend(),
881  &IsLayerOfType<InputLayer>,
882  &IsLayerOfType<Convolution2dLayer>,
883  &IsLayerOfType<BatchNormalizationLayer>,
884  &IsLayerOfType<OutputLayer>));
885 
886  // Optimize graph
887  armnn::Optimizer::Pass(graph, MakeOptimizations(FuseBatchNormIntoConvolution2DFloat32()));
888 
889  auto checkFusedConv2d = [](const armnn::Layer* const layer) -> bool {
890  return IsLayerOfType<armnn::Convolution2dLayer>(layer) &&
891  (layer->GetNameStr() == "fused-batchNorm-into-convolution");
892  };
893 
894  CHECK(3 == graph.GetNumLayers());
895  CHECK(CheckSequence(graph.cbegin(), graph.cend(),
896  &IsLayerOfType<InputLayer>,
897  checkFusedConv2d,
898  &IsLayerOfType<OutputLayer>));
899 }
900 
901 // Tests that OptimizeForExclusiveConnections works, not fusing when not needed, using BatchNorm fusing as example
902 TEST_CASE("OptimizeForExclusiveConnectionsWithoutFuseTest")
903 {
904  // Define the network
905  Graph graph;
906  Convolution2dDescriptor convolution2dDescriptor;
907  BatchNormalizationDescriptor batchNormDescriptor;
908 
909  auto input = graph.AddLayer<InputLayer>(0, "input");
910  auto conv = graph.AddLayer<Convolution2dLayer>(convolution2dDescriptor, "convolution");
911  auto batchNorm = graph.AddLayer<BatchNormalizationLayer>(batchNormDescriptor, "batchNorm");
912  auto output = graph.AddLayer<OutputLayer>(0, "output");
913  auto output2 = graph.AddLayer<OutputLayer>(1, "output2");
914 
915  // Connect layers
916  input->GetOutputSlot(0).Connect(conv->GetInputSlot(0));
917  conv->GetOutputSlot(0).Connect(batchNorm->GetInputSlot(0));
918  batchNorm->GetOutputSlot(0).Connect(output->GetInputSlot(0));
919  conv->GetOutputSlot(0).Connect(output2->GetInputSlot(0));
920 
921  CHECK(5 == graph.GetNumLayers());
922  CHECK(CheckSequence(graph.cbegin(), graph.cend(),
923  &IsLayerOfType<armnn::InputLayer>,
924  &IsLayerOfType<armnn::Convolution2dLayer>,
925  &IsLayerOfType<armnn::BatchNormalizationLayer>,
926  &IsLayerOfType<armnn::OutputLayer>,
927  &IsLayerOfType<armnn::OutputLayer>));
928  // Optimize graph
929  armnn::Optimizer::Pass(graph, armnn::MakeOptimizations(FuseBatchNormIntoConvolution2DFloat32()));
930 
931  CHECK(5 == graph.GetNumLayers());
932  CHECK(CheckSequence(graph.cbegin(), graph.cend(),
933  &IsLayerOfType<armnn::InputLayer>,
934  &IsLayerOfType<armnn::Convolution2dLayer>,
935  &IsLayerOfType<armnn::BatchNormalizationLayer>,
936  &IsLayerOfType<armnn::OutputLayer>,
937  &IsLayerOfType<armnn::OutputLayer>));
938 }
939 } // Optimizer TestSuite
armnn::Graph::begin
Iterator begin()
Returns iterator pointing to the beginning of the list. Lowercase for range-based for loops...
Definition: Graph.hpp:165
armnn::Convolution2dDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:458
armnn::Convolution2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:460
armnn::AssignBackends
OptimizationResult AssignBackends(OptimizedNetworkImpl *optNetObjPtr, BackendSettings &backendSettings, Graph::Iterator &firstLayer, Graph::Iterator &lastLayer, Optional< std::vector< std::string > &> errMessages)
Definition: Network.cpp:906
armnn::HasCapability
bool HasCapability(const std::string &name, const BackendCapabilities &capabilities)
Convenience function to check if a capability exists in a BackendCapabilites struct.
Definition: BackendHelper.cpp:58
armnn::BatchNormalizationLayer
This layer represents a batch normalization operation.
Definition: BatchNormalizationLayer.hpp:15
armnn::IConnectableLayer
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
Definition: INetwork.hpp:61
armnn::Pooling2dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:363
armnn::InsertConvertFp32ToFp16LayersAfter
std::vector< ConvertFp32ToFp16Layer * > InsertConvertFp32ToFp16LayersAfter(Graph &graph, Layer &layer)
Definition: NetworkUtils.cpp:201
armnn::DepthwiseConvolution2dDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:581
armnn::DataLayout
DataLayout
Definition: Types.hpp:49
armnn::InsertConvertFp16ToFp32LayersBefore
std::vector< ConvertFp16ToFp32Layer * > InsertConvertFp16ToFp32LayersBefore(Graph &graph, Layer &layer, bool expectCorrectInputType)
Definition: NetworkUtils.cpp:129
armnn::Pooling2dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:357
armnn::MakeOptimizations
Optimizer::Optimizations MakeOptimizations(Args &&... args)
Definition: Optimizer.hpp:43
armnn::BackendIdSet
std::unordered_set< BackendId > BackendIdSet
Definition: BackendId.hpp:193
armnn::Layer::BackendSelectionHint
void BackendSelectionHint(Optional< BackendId > backend) final
Provide a hint for the optimizer as to which backend to prefer for this layer.
Definition: Layer.hpp:330
armnn::DepthwiseConvolution2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:583
armnn::GetCapability
Optional< const BackendOptions::BackendOption > GetCapability(const std::string &backendCapabilityName, const BackendCapabilities &capabilities)
Returns a BackendCapability if the backend lists the capability The BackendCapability must then be in...
Definition: BackendHelper.cpp:30
armnn::DepthwiseConvolution2dLayer
This layer represents a depthwise convolution 2d operation.
Definition: DepthwiseConvolution2dLayer.hpp:15
armnn::Graph::AddLayer
LayerT * AddLayer(Args &&... args)
Adds a new layer, of type LayerType, to the graph constructed with the arguments passed.
Definition: Graph.hpp:417
armnn::Pooling2dDescriptor::m_PoolWidth
uint32_t m_PoolWidth
Pooling width value.
Definition: Descriptors.hpp:365
armnn::Graph::cbegin
ConstIterator cbegin() const
Returns const iterator pointing to the beginning of the list. Lowercase for range-based for loops...
Definition: Graph.hpp:175
armnn::Convolution2dDescriptor
A Convolution2dDescriptor for the Convolution2dLayer.
Definition: Descriptors.hpp:412
armnn::OutputSlot::Connect
int Connect(InputSlot &destination)
Definition: Layer.cpp:83
armnn::ResizeDescriptor::m_Method
ResizeMethod m_Method
The Interpolation method to use (Bilinear, NearestNeighbor).
Definition: Descriptors.hpp:901
armnn::Optimizer::Pass
static void Pass(Graph &graph, const Optimizations &optimizations)
Definition: Optimizer.cpp:16
armnn::PaddingMethod::Exclude
The padding fields don&#39;t count and are ignored.
armnn::Pooling2dDescriptor::m_PaddingMethod
PaddingMethod m_PaddingMethod
The padding method to be used. (Exclude, IgnoreValue).
Definition: Descriptors.hpp:375
armnn::BatchNormalizationDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:716
armnn::optimizations::FuseBatchNormIntoConvolution2DFloat32
OptimizeForExclusiveConnection< Convolution2dLayer, BatchNormalizationLayer, FuseBatchNorm< Convolution2dLayer, armnn::DataType::Float32 > > FuseBatchNormIntoConvolution2DFloat32
Definition: FuseBatchNorm.hpp:178
armnn::Convolution2dLayer::m_Weight
std::shared_ptr< ConstTensorHandle > m_Weight
A unique pointer to store Weight values.
Definition: Convolution2dLayer.hpp:20
armnn::ActivationLayer
This layer represents an activation operation with the specified activation function.
Definition: ActivationLayer.hpp:12
armnn::BackendRegistryInstance
BackendRegistry & BackendRegistryInstance()
Definition: BackendRegistry.cpp:13
armnn::Pooling2dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:361
armnn::DetectionPostProcessLayer
This layer represents a detection postprocess operator.
Definition: DetectionPostProcessLayer.hpp:16
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::Graph::Iterator
LayerList::const_iterator Iterator
Definition: Graph.hpp:51
armnn::Pooling2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:369
armnn::LayerBindingId
int LayerBindingId
Type of identifiers for bindable layers (inputs, outputs).
Definition: Types.hpp:277
armnn::ResizeDescriptor
A ResizeBilinearDescriptor for the ResizeBilinearLayer.
Definition: Descriptors.hpp:874
armnn::BaseDescriptor
Base class for all descriptors.
Definition: Descriptors.hpp:22
armnn::StrategyBase
Strategy base class with empty implementations.
Definition: StrategyBase.hpp:27
armnn::Pooling2dDescriptor::m_PoolHeight
uint32_t m_PoolHeight
Pooling height value.
Definition: Descriptors.hpp:367
armnn::DetectionPostProcessDescriptor::m_MaxDetections
uint32_t m_MaxDetections
Maximum numbers of detections.
Definition: Descriptors.hpp:618
armnn::Layer::GetInputSlot
const InputSlot & GetInputSlot(unsigned int index) const override
Get a const input slot handle by slot index.
Definition: Layer.hpp:316
armnn::Convolution2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:450
armnn::DepthwiseConvolution2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:573
armnn::OutputLayer
A layer user-provided data can be bound to (e.g. inputs, outputs).
Definition: OutputLayer.hpp:13
armnn::GatherLayer
This layer represents a Gather operator.
Definition: GatherLayer.hpp:14
armnn::Pooling2dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:359
armnn::ConstTensor
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
Definition: Tensor.hpp:327
armnn::ResizeDescriptor::m_TargetWidth
uint32_t m_TargetWidth
Target width value.
Definition: Descriptors.hpp:896
armnn::GatherDescriptor
A GatherDescriptor for the GatherLayer.
Definition: Descriptors.hpp:817
armnn::MemCopyLayer
This layer represents a memory copy operation.
Definition: MemCopyLayer.hpp:13
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
armnn::ActivationDescriptor
An ActivationDescriptor for the ActivationLayer.
Definition: Descriptors.hpp:25
armnn::FloorLayer
This layer represents a floor operation.
Definition: FloorLayer.hpp:13
armnn::ResizeDescriptor::m_TargetHeight
uint32_t m_TargetHeight
Target height value.
Definition: Descriptors.hpp:898
armnn::Convolution2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:452
armnn::IConnectableLayer::GetType
virtual LayerType GetType() const =0
Returns the armnn::LayerType of this layer.
armnn::Pooling2dLayer
This layer represents a pooling 2d operation.
Definition: Pooling2dLayer.hpp:13
armnn::Pooling2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:377
armnn::AdditionLayer
This layer represents an addition operation.
Definition: AdditionLayer.hpp:13
armnn::OutputHandler::SetTensorInfo
void SetTensorInfo(const TensorInfo &tensorInfo)
Sets the TensorInfo used by this output handler.
Definition: OutputHandler.cpp:15
armnn::EmptyOptional
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
Definition: Optional.hpp:32
armnn::Pooling2dDescriptor::m_PoolType
PoolingAlgorithm m_PoolType
The pooling algorithm to use (Max. Average, L2).
Definition: Descriptors.hpp:355
armnn::DepthwiseConvolution2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:575
armnn::Graph::InferTensorInfos
void InferTensorInfos()
Definition: Graph.cpp:558
armnn::DepthwiseConvolution2dLayer::m_Weight
std::shared_ptr< ConstTensorHandle > m_Weight
A unique pointer to store Weight values.
Definition: DepthwiseConvolution2dLayer.hpp:19
armnn::Layer::GetOutputHandler
const OutputHandler & GetOutputHandler(unsigned int i=0) const
Definition: Layer.hpp:225
armnn::InputLayer
A layer user-provided data can be bound to (e.g. inputs, outputs).
Definition: InputLayer.hpp:13
armnn::Graph::end
Iterator end()
Returns iterator pointing to the end of the list. Lowercase for range-based for loops.
Definition: Graph.hpp:167
CheckSequence
bool CheckSequence(const armnn::Graph::ConstIterator first, const armnn::Graph::ConstIterator last)
Definition: TestUtils.hpp:21
armnn::OutputSlot::SetTensorInfo
void SetTensorInfo(const TensorInfo &tensorInfo) override
Definition: Layer.cpp:58
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::Graph::cend
ConstIterator cend() const
Returns const iterator pointing to the end of the list. Lowercase for range-based for loops...
Definition: Graph.hpp:177
armnn::Convolution2dLayer
This layer represents a convolution 2d operation.
Definition: Convolution2dLayer.hpp:15
armnn::Pooling2dDescriptor
A Pooling2dDescriptor for the Pooling2dLayer.
Definition: Descriptors.hpp:321
armnn::Graph::GetNumLayers
size_t GetNumLayers() const
Definition: Graph.hpp:194
armnn::ResizeDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:903
armnn::DetectionPostProcessDescriptor
Definition: Descriptors.hpp:586
armnn::DetectionPostProcessLayer::m_Anchors
std::shared_ptr< ConstTensorHandle > m_Anchors
A unique pointer to store Anchor values.
Definition: DetectionPostProcessLayer.hpp:20
armnn::INetwork::Create
static INetworkPtr Create(NetworkOptions networkOptions={})
Definition: Network.cpp:478
armnn::GetLayerTypeAsCString
const char * GetLayerTypeAsCString(LayerType type)
Definition: InternalTypes.cpp:13
armnn::ActivationDescriptor::m_Function
ActivationFunction m_Function
The activation function to use (Sigmoid, TanH, Linear, ReLu, BoundedReLu, SoftReLu, LeakyReLu, Abs, Sqrt, Square, Elu).
Definition: Descriptors.hpp:48
armnn::Pooling2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:371
armnn::DepthwiseConvolution2dDescriptor
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
Definition: Descriptors.hpp:535
armnn::BatchNormalizationDescriptor
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
Definition: Descriptors.hpp:701
armnn::ResizeLayer
This layer represents a resize operation.
Definition: ResizeLayer.hpp:13