From 6940dd720ebb6b3d1df8ca203ab696daefe58189 Mon Sep 17 00:00:00 2001 From: Jim Flynn Date: Fri, 20 Mar 2020 12:25:56 +0000 Subject: renamed Documentation folder 20.02 and added .nojekyll file Signed-off-by: Jim Flynn --- 20.02/_l2_normalization_test_impl_8cpp.xhtml | 716 +++++++++++++++++++++++++++ 1 file changed, 716 insertions(+) create mode 100644 20.02/_l2_normalization_test_impl_8cpp.xhtml (limited to '20.02/_l2_normalization_test_impl_8cpp.xhtml') diff --git a/20.02/_l2_normalization_test_impl_8cpp.xhtml b/20.02/_l2_normalization_test_impl_8cpp.xhtml new file mode 100644 index 0000000000..749a1a28b7 --- /dev/null +++ b/20.02/_l2_normalization_test_impl_8cpp.xhtml @@ -0,0 +1,716 @@ + + + + + + + + + + + + + +ArmNN: src/backends/backendsCommon/test/layerTests/L2NormalizationTestImpl.cpp File Reference + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  20.02 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Functions
+
+
L2NormalizationTestImpl.cpp File Reference
+
+
+
#include "L2NormalizationTestImpl.hpp"
+#include <QuantizeHelper.hpp>
+#include <ResolveType.hpp>
+#include <armnnUtils/TensorUtils.hpp>
+#include <armnnUtils/Permute.hpp>
+#include <backendsCommon/test/TensorCopyUtils.hpp>
+#include <backendsCommon/test/WorkloadTestUtils.hpp>
+#include <test/TensorHelpers.hpp>
+
+

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

LayerTestResult< float, 4 > L2NormalizationDefaultEpsilonTest (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< float, 4 > L2NormalizationNonDefaultEpsilonTest (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< float, 4 > L2Normalization1dTest (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< int16_t, 4 > L2Normalization1dInt16Test (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< uint8_t, 4 > L2Normalization1dUint8Test (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< float, 4 > L2Normalization2dTest (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< int16_t, 4 > L2Normalization2dInt16Test (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< uint8_t, 4 > L2Normalization2dUint8Test (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< float, 2 > L2Normalization2dShapeTest (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
 
LayerTestResult< float, 4 > L2Normalization3dTest (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< int16_t, 4 > L2Normalization3dInt16Test (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< uint8_t, 4 > L2Normalization3dUint8Test (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< float, 4 > L2Normalization4dTest (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< int16_t, 4 > L2Normalization4dInt16Test (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
LayerTestResult< uint8_t, 4 > L2Normalization4dUint8Test (armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::DataLayout layout)
 
+

Function Documentation

+ +

◆ L2Normalization1dInt16Test()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<int16_t, 4> L2Normalization1dInt16Test (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 597 of file L2NormalizationTestImpl.cpp.

+
601 {
602  return L2Normalization1dTestCommon<armnn::DataType::QSymmS16>(
603  workloadFactory,
604  memoryManager,
605  1.f,
606  0,
607  1.f,
608  0,
609  layout);
610 }
+
+
+ +

◆ L2Normalization1dTest()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<float, 4> L2Normalization1dTest (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 582 of file L2NormalizationTestImpl.cpp.

+
586 {
587  return L2Normalization1dTestCommon<armnn::DataType::Float32>(
588  workloadFactory,
589  memoryManager,
590  0.f,
591  0,
592  0.f,
593  0,
594  layout);
595 }
+
+
+ +

◆ L2Normalization1dUint8Test()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<uint8_t, 4> L2Normalization1dUint8Test (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 612 of file L2NormalizationTestImpl.cpp.

+
616 {
617  return L2Normalization1dTestCommon<armnn::DataType::QAsymmU8>(
618  workloadFactory,
619  memoryManager,
620  1.f,
621  0,
622  1.f / 128,
623  128,
624  layout);
625 }
+
+
+ +

◆ L2Normalization2dInt16Test()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<int16_t, 4> L2Normalization2dInt16Test (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 642 of file L2NormalizationTestImpl.cpp.

+
646 {
647  return L2Normalization1dTestCommon<armnn::DataType::QSymmS16>(
648  workloadFactory,
649  memoryManager,
650  1.f,
651  0,
652  1.f,
653  0,
654  layout);
655 }
+
+
+ +

◆ L2Normalization2dShapeTest()

+ +
+
+ + + + + + + + + + + + + + + + + + +
LayerTestResult<float, 2> L2Normalization2dShapeTest (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager 
)
+
+ +

Definition at line 672 of file L2NormalizationTestImpl.cpp.

+ +

References CopyDataFromITensorHandle(), CopyDataToITensorHandle(), IWorkloadFactory::CreateL2Normalization(), IWorkloadFactory::CreateTensorHandle(), armnn::Float32, L2NormalizationDescriptor::m_DataLayout, L2NormalizationDescriptor::m_Eps, QueueDescriptorWithParameters< LayerDescriptor >::m_Parameters, and armnn::NHWC.

+
675 {
676  const armnn::DataLayout layout = armnn::DataLayout::NHWC;
677  const armnn::TensorShape inputOutputTensorShape = armnn::TensorShape({ 5, 2 });
678 
679  std::vector<float> inputData
680  {
681  1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f, 10.f
682  };
683  std::vector<float> expectedOutputData
684  {
685  1.0f * CalcInvL2Norm({ 1.0f, 2.0f }),
686  2.0f * CalcInvL2Norm({ 1.0f, 2.0f }),
687  3.0f * CalcInvL2Norm({ 3.0f, 4.0f }),
688  4.0f * CalcInvL2Norm({ 3.0f, 4.0f }),
689  5.0f * CalcInvL2Norm({ 5.0f, 6.0f }),
690  6.0f * CalcInvL2Norm({ 5.0f, 6.0f }),
691  7.0f * CalcInvL2Norm({ 7.0f, 8.0f }),
692  8.0f * CalcInvL2Norm({ 7.0f, 8.0f }),
693  9.0f * CalcInvL2Norm({ 9.0f, 10.0f }),
694  10.0f * CalcInvL2Norm({ 9.0f, 10.0f })
695  };
696 
697  const armnn::TensorInfo inputTensorInfo(inputOutputTensorShape, armnn::DataType::Float32, 0.f, 0);
698  const armnn::TensorInfo outputTensorInfo(inputOutputTensorShape, armnn::DataType::Float32, 0.f, 0);
699 
700  auto inputTensor = MakeTensor<float, 2>(inputTensorInfo, inputData);
701 
702  LayerTestResult<float, 2> result(outputTensorInfo);
703  result.outputExpected = MakeTensor<float, 2>(outputTensorInfo, expectedOutputData);
704 
705  std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
706  std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
707 
708  armnn::L2NormalizationQueueDescriptor descriptor;
709  descriptor.m_Parameters.m_Eps = 1e-12f;
710  descriptor.m_Parameters.m_DataLayout = layout;
711  armnn::WorkloadInfo info;
712 
713  AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
714  AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
715 
716  std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateL2Normalization(descriptor, info);
717 
718  inputHandle->Allocate();
719  outputHandle->Allocate();
720 
721  CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0]);
722 
723  workload->PostAllocationConfigure();
724  ExecuteWorkload(*workload, memoryManager);
725 
726  CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
727 
728  return result;
729 }
armnn::L2NormalizationDescriptor::m_Eps
float m_Eps
Used to avoid dividing by zero.
Definition: Descriptors.hpp:604
+
armnn::IWorkloadFactory::CreateL2Normalization
virtual std::unique_ptr< IWorkload > CreateL2Normalization(const L2NormalizationQueueDescriptor &descriptor, const WorkloadInfo &info) const
Definition: WorkloadFactory.cpp:1250
+
armnn::DataLayout
DataLayout
Definition: Types.hpp:49
+ + + +
armnn::L2NormalizationDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:606
+
CopyDataFromITensorHandle
void CopyDataFromITensorHandle(void *memory, const armnn::ITensorHandle *tensorHandle)
Definition: TensorCopyUtils.cpp:14
+
armnn::IWorkloadFactory::CreateTensorHandle
virtual std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo, const bool IsMemoryManaged=true) const =0
+ + + +
armnn::WorkloadInfo
Contains information about inputs and outputs to a layer.
Definition: WorkloadInfo.hpp:16
+ + +
CopyDataToITensorHandle
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
Definition: TensorCopyUtils.cpp:9
+
+
+
+ +

◆ L2Normalization2dTest()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<float, 4> L2Normalization2dTest (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 627 of file L2NormalizationTestImpl.cpp.

+
631 {
632  return L2Normalization2dTestCommon<armnn::DataType::Float32>(
633  workloadFactory,
634  memoryManager,
635  0.f,
636  0,
637  0.f,
638  0,
639  layout);
640 }
+
+
+ +

◆ L2Normalization2dUint8Test()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<uint8_t, 4> L2Normalization2dUint8Test (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 657 of file L2NormalizationTestImpl.cpp.

+
661 {
662  return L2Normalization1dTestCommon<armnn::DataType::QAsymmU8>(
663  workloadFactory,
664  memoryManager,
665  1.f,
666  0,
667  1.f / 128,
668  128,
669  layout);
670 }
+
+
+ +

◆ L2Normalization3dInt16Test()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<int16_t, 4> L2Normalization3dInt16Test (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 746 of file L2NormalizationTestImpl.cpp.

+
750 {
751  return L2Normalization1dTestCommon<armnn::DataType::QSymmS16>(
752  workloadFactory,
753  memoryManager,
754  1.f,
755  0,
756  1.f,
757  0,
758  layout);
759 }
+
+
+ +

◆ L2Normalization3dTest()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<float, 4> L2Normalization3dTest (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 731 of file L2NormalizationTestImpl.cpp.

+
735 {
736  return L2Normalization3dTestCommon<armnn::DataType::Float32>(
737  workloadFactory,
738  memoryManager,
739  0.f,
740  0,
741  0.f,
742  0,
743  layout);
744 }
+
+
+ +

◆ L2Normalization3dUint8Test()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<uint8_t, 4> L2Normalization3dUint8Test (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 761 of file L2NormalizationTestImpl.cpp.

+
765 {
766  return L2Normalization1dTestCommon<armnn::DataType::QAsymmU8>(
767  workloadFactory,
768  memoryManager,
769  1.f,
770  0,
771  1.f / 128,
772  128,
773  layout);
774 }
+
+
+ +

◆ L2Normalization4dInt16Test()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<int16_t, 4> L2Normalization4dInt16Test (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 791 of file L2NormalizationTestImpl.cpp.

+
795 {
796  return L2Normalization1dTestCommon<armnn::DataType::QSymmS16>(
797  workloadFactory,
798  memoryManager,
799  1.f,
800  0,
801  1.f,
802  0,
803  layout);
804 }
+
+
+ +

◆ L2Normalization4dTest()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<float, 4> L2Normalization4dTest (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 776 of file L2NormalizationTestImpl.cpp.

+
780 {
781  return L2Normalization4dTestCommon<armnn::DataType::Float32>(
782  workloadFactory,
783  memoryManager,
784  0.f,
785  0,
786  0.f,
787  0,
788  layout);
789 }
+
+
+ +

◆ L2Normalization4dUint8Test()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<uint8_t, 4> L2Normalization4dUint8Test (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 806 of file L2NormalizationTestImpl.cpp.

+
810 {
811  return L2Normalization1dTestCommon<armnn::DataType::QAsymmU8>(
812  workloadFactory,
813  memoryManager,
814  1.f,
815  0,
816  1.f / 128,
817  128,
818  layout);
819 }
+
+
+ +

◆ L2NormalizationDefaultEpsilonTest()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<float, 4> L2NormalizationDefaultEpsilonTest (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 547 of file L2NormalizationTestImpl.cpp.

+ +

References L2NormalizationDescriptor::m_Eps.

+
551 {
552  // Dummy descriptor to get the default value of epsilon.
553  armnn::L2NormalizationDescriptor descriptor;
554 
555  return L2NormalizationEpsilonTestCommon<armnn::DataType::Float32>(
556  workloadFactory,
557  memoryManager,
558  0.f,
559  0,
560  0.f,
561  0,
562  layout,
563  descriptor.m_Eps);
564 }
armnn::L2NormalizationDescriptor::m_Eps
float m_Eps
Used to avoid dividing by zero.
Definition: Descriptors.hpp:604
+
armnn::L2NormalizationDescriptor
A L2NormalizationDescriptor for the L2NormalizationLayer.
Definition: Descriptors.hpp:591
+
+
+
+ +

◆ L2NormalizationNonDefaultEpsilonTest()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
LayerTestResult<float, 4> L2NormalizationNonDefaultEpsilonTest (armnn::IWorkloadFactory & workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
const armnn::DataLayout layout 
)
+
+ +

Definition at line 566 of file L2NormalizationTestImpl.cpp.

+
570 {
571  return L2NormalizationEpsilonTestCommon<armnn::DataType::Float32>(
572  workloadFactory,
573  memoryManager,
574  0.f,
575  0,
576  0.f,
577  0,
578  layout,
579  1e-9f);
580 }
+
+
+
+
+ + + + -- cgit v1.2.1