ArmNN
 22.05.01
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 <armnn/backends/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 306 of file OptimizerTests.cpp.

References armnn::Activation, armnn::Addition, Graph::AddLayer(), ILayerSupport::anchors, ARMNN_ASSERT, armnn::AssignBackends(), armnn::Average, armnn::BackendRegistryInstance(), Layer::BackendSelectionHint(), Graph::begin(), ILayerSupport::beta, armnn::Bilinear, Graph::cbegin(), Graph::cend(), CheckSequence(), OutputSlot::Connect(), armnn::ConvertFp16ToFp32, armnn::ConvertFp32ToFp16, INetwork::Create(), ILayerSupport::descriptor, Graph::end(), armnn::Exclude, armnn::Float16, armnn::Float32, armnn::Floor, ILayerSupport::gamma, 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, ILayerSupport::input1, 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, ConstantLayer::m_LayerOutput, 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, Convolution2dLayer::m_Weight, armnn::MakeOptimizations(), ILayerSupport::mean, armnn::NCHW, armnn::NHWC, armnn::Output, ILayerSupport::paramsInfo, Optimizer::Pass(), armnn::QAsymmU8, OutputHandler::SetTensorInfo(), OutputSlot::SetTensorInfo(), armnn::Signed32, and ILayerSupport::weights.

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