src/backends/backendsCommon/test/layerTests/DetectionPostProcessTestImpl.hpp - ml/armnn - Gitiles

 //
 // Copyright © 2017 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 #pragma once

 #include <ResolveType.hpp>

 #include <armnn/Types.hpp>

 #include <armnn/backends/TensorHandle.hpp>
 #include <armnn/backends/IBackendInternal.hpp>
 #include <armnn/backends/WorkloadFactory.hpp>

 #include <armnnTestUtils/TensorCopyUtils.hpp>
 #include <backendsCommon/test/WorkloadFactoryHelper.hpp>
 #include <armnnTestUtils/WorkloadTestUtils.hpp>

 #include <armnnTestUtils/TensorHelpers.hpp>

 #include <doctest/doctest.h>

 namespace
 {

 using FloatData = std::vector<float>;
 using QuantData = std::pair<float, int32_t>;

 struct TestData
 {
     static const armnn::TensorShape s_BoxEncodingsShape;
     static const armnn::TensorShape s_ScoresShape;
     static const armnn::TensorShape s_AnchorsShape;

     static const QuantData s_BoxEncodingsQuantData;
     static const QuantData s_ScoresQuantData;
     static const QuantData s_AnchorsQuantData;

     static const FloatData s_BoxEncodings;
     static const FloatData s_Scores;
     static const FloatData s_Anchors;
 };

 struct RegularNmsExpectedResults
 {
     static const FloatData s_DetectionBoxes;
     static const FloatData s_DetectionScores;
     static const FloatData s_DetectionClasses;
     static const FloatData s_NumDetections;
 };

 struct FastNmsExpectedResults
 {
     static const FloatData s_DetectionBoxes;
     static const FloatData s_DetectionScores;
     static const FloatData s_DetectionClasses;
     static const FloatData s_NumDetections;
 };

 const armnn::TensorShape TestData::s_BoxEncodingsShape = { 1, 6, 4 };
 const armnn::TensorShape TestData::s_ScoresShape       = { 1, 6, 3 };
 const armnn::TensorShape TestData::s_AnchorsShape      = { 6, 4 };

 const QuantData TestData::s_BoxEncodingsQuantData = { 1.00f, 1 };
 const QuantData TestData::s_ScoresQuantData       = { 0.01f, 0 };
 const QuantData TestData::s_AnchorsQuantData      = { 0.50f, 0 };

 const FloatData TestData::s_BoxEncodings =
 {
     0.0f,  0.0f, 0.0f, 0.0f,
     0.0f,  1.0f, 0.0f, 0.0f,
     0.0f, -1.0f, 0.0f, 0.0f,
     0.0f,  0.0f, 0.0f, 0.0f,
     0.0f,  1.0f, 0.0f, 0.0f,
     0.0f,  0.0f, 0.0f, 0.0f
 };

 const FloatData TestData::s_Scores =
 {
     0.0f, 0.90f, 0.80f,
     0.0f, 0.75f, 0.72f,
     0.0f, 0.60f, 0.50f,
     0.0f, 0.93f, 0.95f,
     0.0f, 0.50f, 0.40f,
     0.0f, 0.30f, 0.20f
 };

 const FloatData TestData::s_Anchors =
 {
     0.5f,   0.5f, 1.0f, 1.0f,
     0.5f,   0.5f, 1.0f, 1.0f,
     0.5f,   0.5f, 1.0f, 1.0f,
     0.5f,  10.5f, 1.0f, 1.0f,
     0.5f,  10.5f, 1.0f, 1.0f,
     0.5f, 100.5f, 1.0f, 1.0f
 };

 const FloatData RegularNmsExpectedResults::s_DetectionBoxes =
 {
     0.0f, 10.0f, 1.0f, 11.0f,
     0.0f, 10.0f, 1.0f, 11.0f,
     0.0f,  0.0f, 0.0f,  0.0f
 };

 const FloatData RegularNmsExpectedResults::s_DetectionScores =
 {
     0.95f, 0.93f, 0.0f
 };

 const FloatData RegularNmsExpectedResults::s_DetectionClasses =
 {
     1.0f, 0.0f, 0.0f
 };

 const FloatData RegularNmsExpectedResults::s_NumDetections = { 2.0f };

 const FloatData FastNmsExpectedResults::s_DetectionBoxes =
 {
     0.0f,  10.0f, 1.0f,  11.0f,
     0.0f,   0.0f, 1.0f,   1.0f,
     0.0f, 100.0f, 1.0f, 101.0f
 };

 const FloatData FastNmsExpectedResults::s_DetectionScores =
 {
     0.95f, 0.9f, 0.3f
 };

 const FloatData FastNmsExpectedResults::s_DetectionClasses =
 {
     1.0f, 0.0f, 0.0f
 };

 const FloatData FastNmsExpectedResults::s_NumDetections = { 3.0f };

 } // anonymous namespace

 template<typename FactoryType,
          armnn::DataType ArmnnType,
          typename T = armnn::ResolveType<ArmnnType>>
 void DetectionPostProcessImpl(const armnn::TensorInfo& boxEncodingsInfo,
                               const armnn::TensorInfo& scoresInfo,
                               const armnn::TensorInfo& anchorsInfo,
                               const std::vector<T>& boxEncodingsData,
                               const std::vector<T>& scoresData,
                               const std::vector<T>& anchorsData,
                               const std::vector<float>& expectedDetectionBoxes,
                               const std::vector<float>& expectedDetectionClasses,
                               const std::vector<float>& expectedDetectionScores,
                               const std::vector<float>& expectedNumDetections,
                               bool useRegularNms)
 {
     std::unique_ptr<armnn::IProfiler> profiler = std::make_unique<armnn::IProfiler>();
     armnn::ProfilerManager::GetInstance().RegisterProfiler(profiler.get());

     auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
     FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);
     auto tensorHandleFactory = WorkloadFactoryHelper<FactoryType>::GetTensorHandleFactory(memoryManager);

     armnn::TensorInfo detectionBoxesInfo({ 1, 3, 4 }, armnn::DataType::Float32);
     armnn::TensorInfo detectionClassesInfo({ 1, 3 }, armnn::DataType::Float32);
     armnn::TensorInfo detectionScoresInfo({ 1, 3 }, armnn::DataType::Float32);
     armnn::TensorInfo numDetectionInfo({ 1 }, armnn::DataType::Float32);

     std::vector<float> actualDetectionBoxesOutput(detectionBoxesInfo.GetNumElements());
     std::vector<float> actualDetectionClassesOutput(detectionClassesInfo.GetNumElements());
     std::vector<float> actualDetectionScoresOutput(detectionScoresInfo.GetNumElements());
     std::vector<float> actualNumDetectionOutput(numDetectionInfo.GetNumElements());

     auto boxedHandle = tensorHandleFactory.CreateTensorHandle(boxEncodingsInfo);
     auto scoreshandle = tensorHandleFactory.CreateTensorHandle(scoresInfo);
     auto anchorsHandle = tensorHandleFactory.CreateTensorHandle(anchorsInfo);
     auto outputBoxesHandle = tensorHandleFactory.CreateTensorHandle(detectionBoxesInfo);
     auto classesHandle = tensorHandleFactory.CreateTensorHandle(detectionClassesInfo);
     auto outputScoresHandle = tensorHandleFactory.CreateTensorHandle(detectionScoresInfo);
     auto numDetectionHandle = tensorHandleFactory.CreateTensorHandle(numDetectionInfo);

     armnn::ScopedTensorHandle anchorsTensor(anchorsInfo);
     AllocateAndCopyDataToITensorHandle(&anchorsTensor, anchorsData.data());

     armnn::DetectionPostProcessQueueDescriptor data;
     data.m_Parameters.m_UseRegularNms = useRegularNms;
     data.m_Parameters.m_MaxDetections = 3;
     data.m_Parameters.m_MaxClassesPerDetection = 1;
     data.m_Parameters.m_DetectionsPerClass =1;
     data.m_Parameters.m_NmsScoreThreshold = 0.0;
     data.m_Parameters.m_NmsIouThreshold = 0.5;
     data.m_Parameters.m_NumClasses = 2;
     data.m_Parameters.m_ScaleY = 10.0;
     data.m_Parameters.m_ScaleX = 10.0;
     data.m_Parameters.m_ScaleH = 5.0;
     data.m_Parameters.m_ScaleW = 5.0;
     data.m_Anchors = &anchorsTensor;

     armnn::WorkloadInfo info;
     AddInputToWorkload(data,  info, boxEncodingsInfo, boxedHandle.get());
     AddInputToWorkload(data,  info, scoresInfo, scoreshandle.get());
     AddOutputToWorkload(data, info, detectionBoxesInfo, outputBoxesHandle.get());
     AddOutputToWorkload(data, info, detectionClassesInfo, classesHandle.get());
     AddOutputToWorkload(data, info, detectionScoresInfo, outputScoresHandle.get());
     AddOutputToWorkload(data, info, numDetectionInfo, numDetectionHandle.get());

     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateWorkload(armnn::LayerType::DetectionPostProcess,
                                                                                 data,
                                                                                 info);

     boxedHandle->Allocate();
     scoreshandle->Allocate();
     outputBoxesHandle->Allocate();
     classesHandle->Allocate();
     outputScoresHandle->Allocate();
     numDetectionHandle->Allocate();

     CopyDataToITensorHandle(boxedHandle.get(), boxEncodingsData.data());
     CopyDataToITensorHandle(scoreshandle.get(), scoresData.data());

     workload->Execute();

     CopyDataFromITensorHandle(actualDetectionBoxesOutput.data(), outputBoxesHandle.get());
     CopyDataFromITensorHandle(actualDetectionClassesOutput.data(), classesHandle.get());
     CopyDataFromITensorHandle(actualDetectionScoresOutput.data(), outputScoresHandle.get());
     CopyDataFromITensorHandle(actualNumDetectionOutput.data(), numDetectionHandle.get());

     auto result = CompareTensors(actualDetectionBoxesOutput,
                                  expectedDetectionBoxes,
                                  outputBoxesHandle->GetShape(),
                                  detectionBoxesInfo.GetShape());
     CHECK_MESSAGE(result.m_Result, result.m_Message.str());

     result = CompareTensors(actualDetectionClassesOutput,
                             expectedDetectionClasses,
                             classesHandle->GetShape(),
                             detectionClassesInfo.GetShape());
     CHECK_MESSAGE(result.m_Result, result.m_Message.str());

     result = CompareTensors(actualDetectionScoresOutput,
                             expectedDetectionScores,
                             outputScoresHandle->GetShape(),
                             detectionScoresInfo.GetShape());
     CHECK_MESSAGE(result.m_Result, result.m_Message.str());

     result = CompareTensors(actualNumDetectionOutput,
                             expectedNumDetections,
                             numDetectionHandle->GetShape(),
                             numDetectionInfo.GetShape());
     CHECK_MESSAGE(result.m_Result, result.m_Message.str());
 }

 template<armnn::DataType QuantizedType, typename RawType = armnn::ResolveType<QuantizedType>>
 void QuantizeData(RawType* quant, const float* dequant, const armnn::TensorInfo& info)
 {
     for (size_t i = 0; i < info.GetNumElements(); i++)
     {
         quant[i] = armnn::Quantize<RawType>(
             dequant[i], info.GetQuantizationScale(), info.GetQuantizationOffset());
     }
 }

 template<typename FactoryType>
 void DetectionPostProcessRegularNmsFloatTest()
 {
     return DetectionPostProcessImpl<FactoryType, armnn::DataType::Float32>(
         armnn::TensorInfo(TestData::s_BoxEncodingsShape, armnn::DataType::Float32),
         armnn::TensorInfo(TestData::s_ScoresShape, armnn::DataType::Float32),
         armnn::TensorInfo(TestData::s_AnchorsShape, armnn::DataType::Float32),
         TestData::s_BoxEncodings,
         TestData::s_Scores,
         TestData::s_Anchors,
         RegularNmsExpectedResults::s_DetectionBoxes,
         RegularNmsExpectedResults::s_DetectionClasses,
         RegularNmsExpectedResults::s_DetectionScores,
         RegularNmsExpectedResults::s_NumDetections,
         true);
 }

 template<typename FactoryType,
          armnn::DataType QuantizedType,
          typename RawType = armnn::ResolveType<QuantizedType>>
 void DetectionPostProcessRegularNmsQuantizedTest()
 {
     armnn::TensorInfo boxEncodingsInfo(TestData::s_BoxEncodingsShape, QuantizedType);
     armnn::TensorInfo scoresInfo(TestData::s_ScoresShape, QuantizedType);
     armnn::TensorInfo anchorsInfo(TestData::s_AnchorsShape, QuantizedType);

     boxEncodingsInfo.SetQuantizationScale(TestData::s_BoxEncodingsQuantData.first);
     boxEncodingsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);

     scoresInfo.SetQuantizationScale(TestData::s_ScoresQuantData.first);
     scoresInfo.SetQuantizationOffset(TestData::s_ScoresQuantData.second);

     anchorsInfo.SetQuantizationScale(TestData::s_AnchorsQuantData.first);
     anchorsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);

     std::vector<RawType> boxEncodingsData(TestData::s_BoxEncodingsShape.GetNumElements());
     QuantizeData<QuantizedType>(boxEncodingsData.data(),
                                 TestData::s_BoxEncodings.data(),
                                 boxEncodingsInfo);

     std::vector<RawType> scoresData(TestData::s_ScoresShape.GetNumElements());
     QuantizeData<QuantizedType>(scoresData.data(),
                                 TestData::s_Scores.data(),
                                 scoresInfo);

     std::vector<RawType> anchorsData(TestData::s_AnchorsShape.GetNumElements());
     QuantizeData<QuantizedType>(anchorsData.data(),
                                 TestData::s_Anchors.data(),
                                 anchorsInfo);

     return DetectionPostProcessImpl<FactoryType, QuantizedType>(
         boxEncodingsInfo,
         scoresInfo,
         anchorsInfo,
         boxEncodingsData,
         scoresData,
         anchorsData,
         RegularNmsExpectedResults::s_DetectionBoxes,
         RegularNmsExpectedResults::s_DetectionClasses,
         RegularNmsExpectedResults::s_DetectionScores,
         RegularNmsExpectedResults::s_NumDetections,
         true);
 }

 template<typename FactoryType>
 void DetectionPostProcessFastNmsFloatTest()
 {
     return DetectionPostProcessImpl<FactoryType, armnn::DataType::Float32>(
         armnn::TensorInfo(TestData::s_BoxEncodingsShape, armnn::DataType::Float32),
         armnn::TensorInfo(TestData::s_ScoresShape, armnn::DataType::Float32),
         armnn::TensorInfo(TestData::s_AnchorsShape, armnn::DataType::Float32),
         TestData::s_BoxEncodings,
         TestData::s_Scores,
         TestData::s_Anchors,
         FastNmsExpectedResults::s_DetectionBoxes,
         FastNmsExpectedResults::s_DetectionClasses,
         FastNmsExpectedResults::s_DetectionScores,
         FastNmsExpectedResults::s_NumDetections,
         false);
 }

 template<typename FactoryType,
          armnn::DataType QuantizedType,
          typename RawType = armnn::ResolveType<QuantizedType>>
 void DetectionPostProcessFastNmsQuantizedTest()
 {
     armnn::TensorInfo boxEncodingsInfo(TestData::s_BoxEncodingsShape, QuantizedType);
     armnn::TensorInfo scoresInfo(TestData::s_ScoresShape, QuantizedType);
     armnn::TensorInfo anchorsInfo(TestData::s_AnchorsShape, QuantizedType);

     boxEncodingsInfo.SetQuantizationScale(TestData::s_BoxEncodingsQuantData.first);
     boxEncodingsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);

     scoresInfo.SetQuantizationScale(TestData::s_ScoresQuantData.first);
     scoresInfo.SetQuantizationOffset(TestData::s_ScoresQuantData.second);

     anchorsInfo.SetQuantizationScale(TestData::s_AnchorsQuantData.first);
     anchorsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);

     std::vector<RawType> boxEncodingsData(TestData::s_BoxEncodingsShape.GetNumElements());
     QuantizeData<QuantizedType>(boxEncodingsData.data(),
                                 TestData::s_BoxEncodings.data(),
                                 boxEncodingsInfo);

     std::vector<RawType> scoresData(TestData::s_ScoresShape.GetNumElements());
     QuantizeData<QuantizedType>(scoresData.data(),
                                 TestData::s_Scores.data(),
                                 scoresInfo);

     std::vector<RawType> anchorsData(TestData::s_AnchorsShape.GetNumElements());
     QuantizeData<QuantizedType>(anchorsData.data(),
                                 TestData::s_Anchors.data(),
                                 anchorsInfo);

     return DetectionPostProcessImpl<FactoryType, QuantizedType>(
         boxEncodingsInfo,
         scoresInfo,
         anchorsInfo,
         boxEncodingsData,
         scoresData,
         anchorsData,
         FastNmsExpectedResults::s_DetectionBoxes,
         FastNmsExpectedResults::s_DetectionClasses,
         FastNmsExpectedResults::s_DetectionScores,
         FastNmsExpectedResults::s_NumDetections,
         false);
 }
	//
	// Copyright © 2017 Arm Ltd. All rights reserved.
	// SPDX-License-Identifier: MIT
	//
	#pragma once

	#include <ResolveType.hpp>

	#include <armnn/Types.hpp>

	#include <armnn/backends/TensorHandle.hpp>
	#include <armnn/backends/IBackendInternal.hpp>
	#include <armnn/backends/WorkloadFactory.hpp>

	#include <armnnTestUtils/TensorCopyUtils.hpp>
	#include <backendsCommon/test/WorkloadFactoryHelper.hpp>
	#include <armnnTestUtils/WorkloadTestUtils.hpp>

	#include <armnnTestUtils/TensorHelpers.hpp>

	#include <doctest/doctest.h>

	namespace
	{

	using FloatData = std::vector<float>;
	using QuantData = std::pair<float, int32_t>;

	struct TestData
	{
	static const armnn::TensorShape s_BoxEncodingsShape;
	static const armnn::TensorShape s_ScoresShape;
	static const armnn::TensorShape s_AnchorsShape;

	static const QuantData s_BoxEncodingsQuantData;
	static const QuantData s_ScoresQuantData;
	static const QuantData s_AnchorsQuantData;

	static const FloatData s_BoxEncodings;
	static const FloatData s_Scores;
	static const FloatData s_Anchors;
	};

	struct RegularNmsExpectedResults
	{
	static const FloatData s_DetectionBoxes;
	static const FloatData s_DetectionScores;
	static const FloatData s_DetectionClasses;
	static const FloatData s_NumDetections;
	};

	struct FastNmsExpectedResults
	{
	static const FloatData s_DetectionBoxes;
	static const FloatData s_DetectionScores;
	static const FloatData s_DetectionClasses;
	static const FloatData s_NumDetections;
	};

	const armnn::TensorShape TestData::s_BoxEncodingsShape = { 1, 6, 4 };
	const armnn::TensorShape TestData::s_ScoresShape = { 1, 6, 3 };
	const armnn::TensorShape TestData::s_AnchorsShape = { 6, 4 };

	const QuantData TestData::s_BoxEncodingsQuantData = { 1.00f, 1 };
	const QuantData TestData::s_ScoresQuantData = { 0.01f, 0 };
	const QuantData TestData::s_AnchorsQuantData = { 0.50f, 0 };

	const FloatData TestData::s_BoxEncodings =
	{
	0.0f, 0.0f, 0.0f, 0.0f,
	0.0f, 1.0f, 0.0f, 0.0f,
	0.0f, -1.0f, 0.0f, 0.0f,
	0.0f, 0.0f, 0.0f, 0.0f,
	0.0f, 1.0f, 0.0f, 0.0f,
	0.0f, 0.0f, 0.0f, 0.0f
	};

	const FloatData TestData::s_Scores =
	{
	0.0f, 0.90f, 0.80f,
	0.0f, 0.75f, 0.72f,
	0.0f, 0.60f, 0.50f,
	0.0f, 0.93f, 0.95f,
	0.0f, 0.50f, 0.40f,
	0.0f, 0.30f, 0.20f
	};

	const FloatData TestData::s_Anchors =
	{
	0.5f, 0.5f, 1.0f, 1.0f,
	0.5f, 0.5f, 1.0f, 1.0f,
	0.5f, 0.5f, 1.0f, 1.0f,
	0.5f, 10.5f, 1.0f, 1.0f,
	0.5f, 10.5f, 1.0f, 1.0f,
	0.5f, 100.5f, 1.0f, 1.0f
	};

	const FloatData RegularNmsExpectedResults::s_DetectionBoxes =
	{
	0.0f, 10.0f, 1.0f, 11.0f,
	0.0f, 10.0f, 1.0f, 11.0f,
	0.0f, 0.0f, 0.0f, 0.0f
	};

	const FloatData RegularNmsExpectedResults::s_DetectionScores =
	{
	0.95f, 0.93f, 0.0f
	};

	const FloatData RegularNmsExpectedResults::s_DetectionClasses =
	{
	1.0f, 0.0f, 0.0f
	};

	const FloatData RegularNmsExpectedResults::s_NumDetections = { 2.0f };

	const FloatData FastNmsExpectedResults::s_DetectionBoxes =
	{
	0.0f, 10.0f, 1.0f, 11.0f,
	0.0f, 0.0f, 1.0f, 1.0f,
	0.0f, 100.0f, 1.0f, 101.0f
	};

	const FloatData FastNmsExpectedResults::s_DetectionScores =
	{
	0.95f, 0.9f, 0.3f
	};

	const FloatData FastNmsExpectedResults::s_DetectionClasses =
	{
	1.0f, 0.0f, 0.0f
	};

	const FloatData FastNmsExpectedResults::s_NumDetections = { 3.0f };

	} // anonymous namespace

	template<typename FactoryType,
	armnn::DataType ArmnnType,
	typename T = armnn::ResolveType<ArmnnType>>
	void DetectionPostProcessImpl(const armnn::TensorInfo& boxEncodingsInfo,
	const armnn::TensorInfo& scoresInfo,
	const armnn::TensorInfo& anchorsInfo,
	const std::vector<T>& boxEncodingsData,
	const std::vector<T>& scoresData,
	const std::vector<T>& anchorsData,
	const std::vector<float>& expectedDetectionBoxes,
	const std::vector<float>& expectedDetectionClasses,
	const std::vector<float>& expectedDetectionScores,
	const std::vector<float>& expectedNumDetections,
	bool useRegularNms)
	{
	std::unique_ptr<armnn::IProfiler> profiler = std::make_unique<armnn::IProfiler>();
	armnn::ProfilerManager::GetInstance().RegisterProfiler(profiler.get());

	auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
	FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);
	auto tensorHandleFactory = WorkloadFactoryHelper<FactoryType>::GetTensorHandleFactory(memoryManager);

	armnn::TensorInfo detectionBoxesInfo({ 1, 3, 4 }, armnn::DataType::Float32);
	armnn::TensorInfo detectionClassesInfo({ 1, 3 }, armnn::DataType::Float32);
	armnn::TensorInfo detectionScoresInfo({ 1, 3 }, armnn::DataType::Float32);
	armnn::TensorInfo numDetectionInfo({ 1 }, armnn::DataType::Float32);

	std::vector<float> actualDetectionBoxesOutput(detectionBoxesInfo.GetNumElements());
	std::vector<float> actualDetectionClassesOutput(detectionClassesInfo.GetNumElements());
	std::vector<float> actualDetectionScoresOutput(detectionScoresInfo.GetNumElements());
	std::vector<float> actualNumDetectionOutput(numDetectionInfo.GetNumElements());

	auto boxedHandle = tensorHandleFactory.CreateTensorHandle(boxEncodingsInfo);
	auto scoreshandle = tensorHandleFactory.CreateTensorHandle(scoresInfo);
	auto anchorsHandle = tensorHandleFactory.CreateTensorHandle(anchorsInfo);
	auto outputBoxesHandle = tensorHandleFactory.CreateTensorHandle(detectionBoxesInfo);
	auto classesHandle = tensorHandleFactory.CreateTensorHandle(detectionClassesInfo);
	auto outputScoresHandle = tensorHandleFactory.CreateTensorHandle(detectionScoresInfo);
	auto numDetectionHandle = tensorHandleFactory.CreateTensorHandle(numDetectionInfo);

	armnn::ScopedTensorHandle anchorsTensor(anchorsInfo);
	AllocateAndCopyDataToITensorHandle(&anchorsTensor, anchorsData.data());

	armnn::DetectionPostProcessQueueDescriptor data;
	data.m_Parameters.m_UseRegularNms = useRegularNms;
	data.m_Parameters.m_MaxDetections = 3;
	data.m_Parameters.m_MaxClassesPerDetection = 1;
	data.m_Parameters.m_DetectionsPerClass =1;
	data.m_Parameters.m_NmsScoreThreshold = 0.0;
	data.m_Parameters.m_NmsIouThreshold = 0.5;
	data.m_Parameters.m_NumClasses = 2;
	data.m_Parameters.m_ScaleY = 10.0;
	data.m_Parameters.m_ScaleX = 10.0;
	data.m_Parameters.m_ScaleH = 5.0;
	data.m_Parameters.m_ScaleW = 5.0;
	data.m_Anchors = &anchorsTensor;

	armnn::WorkloadInfo info;
	AddInputToWorkload(data, info, boxEncodingsInfo, boxedHandle.get());
	AddInputToWorkload(data, info, scoresInfo, scoreshandle.get());
	AddOutputToWorkload(data, info, detectionBoxesInfo, outputBoxesHandle.get());
	AddOutputToWorkload(data, info, detectionClassesInfo, classesHandle.get());
	AddOutputToWorkload(data, info, detectionScoresInfo, outputScoresHandle.get());
	AddOutputToWorkload(data, info, numDetectionInfo, numDetectionHandle.get());

	std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateWorkload(armnn::LayerType::DetectionPostProcess,
	data,
	info);

	boxedHandle->Allocate();
	scoreshandle->Allocate();
	outputBoxesHandle->Allocate();
	classesHandle->Allocate();
	outputScoresHandle->Allocate();
	numDetectionHandle->Allocate();

	CopyDataToITensorHandle(boxedHandle.get(), boxEncodingsData.data());
	CopyDataToITensorHandle(scoreshandle.get(), scoresData.data());

	workload->Execute();

	CopyDataFromITensorHandle(actualDetectionBoxesOutput.data(), outputBoxesHandle.get());
	CopyDataFromITensorHandle(actualDetectionClassesOutput.data(), classesHandle.get());
	CopyDataFromITensorHandle(actualDetectionScoresOutput.data(), outputScoresHandle.get());
	CopyDataFromITensorHandle(actualNumDetectionOutput.data(), numDetectionHandle.get());

	auto result = CompareTensors(actualDetectionBoxesOutput,
	expectedDetectionBoxes,
	outputBoxesHandle->GetShape(),
	detectionBoxesInfo.GetShape());
	CHECK_MESSAGE(result.m_Result, result.m_Message.str());

	result = CompareTensors(actualDetectionClassesOutput,
	expectedDetectionClasses,
	classesHandle->GetShape(),
	detectionClassesInfo.GetShape());
	CHECK_MESSAGE(result.m_Result, result.m_Message.str());

	result = CompareTensors(actualDetectionScoresOutput,
	expectedDetectionScores,
	outputScoresHandle->GetShape(),
	detectionScoresInfo.GetShape());
	CHECK_MESSAGE(result.m_Result, result.m_Message.str());

	result = CompareTensors(actualNumDetectionOutput,
	expectedNumDetections,
	numDetectionHandle->GetShape(),
	numDetectionInfo.GetShape());
	CHECK_MESSAGE(result.m_Result, result.m_Message.str());
	}

	template<armnn::DataType QuantizedType, typename RawType = armnn::ResolveType<QuantizedType>>
	void QuantizeData(RawType* quant, const float* dequant, const armnn::TensorInfo& info)
	{
	for (size_t i = 0; i < info.GetNumElements(); i++)
	{
	quant[i] = armnn::Quantize<RawType>(
	dequant[i], info.GetQuantizationScale(), info.GetQuantizationOffset());
	}
	}

	template<typename FactoryType>
	void DetectionPostProcessRegularNmsFloatTest()
	{
	return DetectionPostProcessImpl<FactoryType, armnn::DataType::Float32>(
	armnn::TensorInfo(TestData::s_BoxEncodingsShape, armnn::DataType::Float32),
	armnn::TensorInfo(TestData::s_ScoresShape, armnn::DataType::Float32),
	armnn::TensorInfo(TestData::s_AnchorsShape, armnn::DataType::Float32),
	TestData::s_BoxEncodings,
	TestData::s_Scores,
	TestData::s_Anchors,
	RegularNmsExpectedResults::s_DetectionBoxes,
	RegularNmsExpectedResults::s_DetectionClasses,
	RegularNmsExpectedResults::s_DetectionScores,
	RegularNmsExpectedResults::s_NumDetections,
	true);
	}

	template<typename FactoryType,
	armnn::DataType QuantizedType,
	typename RawType = armnn::ResolveType<QuantizedType>>
	void DetectionPostProcessRegularNmsQuantizedTest()
	{
	armnn::TensorInfo boxEncodingsInfo(TestData::s_BoxEncodingsShape, QuantizedType);
	armnn::TensorInfo scoresInfo(TestData::s_ScoresShape, QuantizedType);
	armnn::TensorInfo anchorsInfo(TestData::s_AnchorsShape, QuantizedType);

	boxEncodingsInfo.SetQuantizationScale(TestData::s_BoxEncodingsQuantData.first);
	boxEncodingsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);

	scoresInfo.SetQuantizationScale(TestData::s_ScoresQuantData.first);
	scoresInfo.SetQuantizationOffset(TestData::s_ScoresQuantData.second);

	anchorsInfo.SetQuantizationScale(TestData::s_AnchorsQuantData.first);
	anchorsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);

	std::vector<RawType> boxEncodingsData(TestData::s_BoxEncodingsShape.GetNumElements());
	QuantizeData<QuantizedType>(boxEncodingsData.data(),
	TestData::s_BoxEncodings.data(),
	boxEncodingsInfo);

	std::vector<RawType> scoresData(TestData::s_ScoresShape.GetNumElements());
	QuantizeData<QuantizedType>(scoresData.data(),
	TestData::s_Scores.data(),
	scoresInfo);

	std::vector<RawType> anchorsData(TestData::s_AnchorsShape.GetNumElements());
	QuantizeData<QuantizedType>(anchorsData.data(),
	TestData::s_Anchors.data(),
	anchorsInfo);

	return DetectionPostProcessImpl<FactoryType, QuantizedType>(
	boxEncodingsInfo,
	scoresInfo,
	anchorsInfo,
	boxEncodingsData,
	scoresData,
	anchorsData,
	RegularNmsExpectedResults::s_DetectionBoxes,
	RegularNmsExpectedResults::s_DetectionClasses,
	RegularNmsExpectedResults::s_DetectionScores,
	RegularNmsExpectedResults::s_NumDetections,
	true);
	}

	template<typename FactoryType>
	void DetectionPostProcessFastNmsFloatTest()
	{
	return DetectionPostProcessImpl<FactoryType, armnn::DataType::Float32>(
	armnn::TensorInfo(TestData::s_BoxEncodingsShape, armnn::DataType::Float32),
	armnn::TensorInfo(TestData::s_ScoresShape, armnn::DataType::Float32),
	armnn::TensorInfo(TestData::s_AnchorsShape, armnn::DataType::Float32),
	TestData::s_BoxEncodings,
	TestData::s_Scores,
	TestData::s_Anchors,
	FastNmsExpectedResults::s_DetectionBoxes,
	FastNmsExpectedResults::s_DetectionClasses,
	FastNmsExpectedResults::s_DetectionScores,
	FastNmsExpectedResults::s_NumDetections,
	false);
	}

	template<typename FactoryType,
	armnn::DataType QuantizedType,
	typename RawType = armnn::ResolveType<QuantizedType>>
	void DetectionPostProcessFastNmsQuantizedTest()
	{
	armnn::TensorInfo boxEncodingsInfo(TestData::s_BoxEncodingsShape, QuantizedType);
	armnn::TensorInfo scoresInfo(TestData::s_ScoresShape, QuantizedType);
	armnn::TensorInfo anchorsInfo(TestData::s_AnchorsShape, QuantizedType);

	boxEncodingsInfo.SetQuantizationScale(TestData::s_BoxEncodingsQuantData.first);
	boxEncodingsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);

	scoresInfo.SetQuantizationScale(TestData::s_ScoresQuantData.first);
	scoresInfo.SetQuantizationOffset(TestData::s_ScoresQuantData.second);

	anchorsInfo.SetQuantizationScale(TestData::s_AnchorsQuantData.first);
	anchorsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);

	std::vector<RawType> boxEncodingsData(TestData::s_BoxEncodingsShape.GetNumElements());
	QuantizeData<QuantizedType>(boxEncodingsData.data(),
	TestData::s_BoxEncodings.data(),
	boxEncodingsInfo);

	std::vector<RawType> scoresData(TestData::s_ScoresShape.GetNumElements());
	QuantizeData<QuantizedType>(scoresData.data(),
	TestData::s_Scores.data(),
	scoresInfo);

	std::vector<RawType> anchorsData(TestData::s_AnchorsShape.GetNumElements());
	QuantizeData<QuantizedType>(anchorsData.data(),
	TestData::s_Anchors.data(),
	anchorsInfo);

	return DetectionPostProcessImpl<FactoryType, QuantizedType>(
	boxEncodingsInfo,
	scoresInfo,
	anchorsInfo,
	boxEncodingsData,
	scoresData,
	anchorsData,
	FastNmsExpectedResults::s_DetectionBoxes,
	FastNmsExpectedResults::s_DetectionClasses,
	FastNmsExpectedResults::s_DetectionScores,
	FastNmsExpectedResults::s_NumDetections,
	false);
	}