ArmNN
 21.08
Functions
DetectionPostProcessTestImpl.hpp File Reference
#include <ResolveType.hpp>
#include <armnn/Types.hpp>
#include <backendsCommon/TensorHandle.hpp>
#include <armnn/backends/IBackendInternal.hpp>
#include <backendsCommon/WorkloadFactory.hpp>
#include <backendsCommon/test/TensorCopyUtils.hpp>
#include <backendsCommon/test/WorkloadFactoryHelper.hpp>
#include <backendsCommon/test/WorkloadTestUtils.hpp>
#include <test/TensorHelpers.hpp>
#include <doctest/doctest.h>

Go to the source code of this file.

Functions

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)
 
template<armnn::DataType QuantizedType, typename RawType = armnn::ResolveType<QuantizedType>>
void QuantizeData (RawType *quant, const float *dequant, const armnn::TensorInfo &info)
 
template<typename FactoryType >
void DetectionPostProcessRegularNmsFloatTest ()
 
template<typename FactoryType , armnn::DataType QuantizedType, typename RawType = armnn::ResolveType<QuantizedType>>
void DetectionPostProcessRegularNmsQuantizedTest ()
 
template<typename FactoryType >
void DetectionPostProcessFastNmsFloatTest ()
 
template<typename FactoryType , armnn::DataType QuantizedType, typename RawType = armnn::ResolveType<QuantizedType>>
void DetectionPostProcessFastNmsQuantizedTest ()
 

Function Documentation

◆ DetectionPostProcessFastNmsFloatTest()

void DetectionPostProcessFastNmsFloatTest ( )

Definition at line 322 of file DetectionPostProcessTestImpl.hpp.

References armnn::Float32.

323 {
324  return DetectionPostProcessImpl<FactoryType, armnn::DataType::Float32>(
325  armnn::TensorInfo(TestData::s_BoxEncodingsShape, armnn::DataType::Float32),
326  armnn::TensorInfo(TestData::s_ScoresShape, armnn::DataType::Float32),
327  armnn::TensorInfo(TestData::s_AnchorsShape, armnn::DataType::Float32),
328  TestData::s_BoxEncodings,
329  TestData::s_Scores,
330  TestData::s_Anchors,
331  FastNmsExpectedResults::s_DetectionBoxes,
332  FastNmsExpectedResults::s_DetectionClasses,
333  FastNmsExpectedResults::s_DetectionScores,
334  FastNmsExpectedResults::s_NumDetections,
335  false);
336 }

◆ DetectionPostProcessFastNmsQuantizedTest()

void DetectionPostProcessFastNmsQuantizedTest ( )

Definition at line 341 of file DetectionPostProcessTestImpl.hpp.

References TensorInfo::SetQuantizationOffset(), and TensorInfo::SetQuantizationScale().

342 {
343  armnn::TensorInfo boxEncodingsInfo(TestData::s_BoxEncodingsShape, QuantizedType);
344  armnn::TensorInfo scoresInfo(TestData::s_ScoresShape, QuantizedType);
345  armnn::TensorInfo anchorsInfo(TestData::s_AnchorsShape, QuantizedType);
346 
347  boxEncodingsInfo.SetQuantizationScale(TestData::s_BoxEncodingsQuantData.first);
348  boxEncodingsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);
349 
350  scoresInfo.SetQuantizationScale(TestData::s_ScoresQuantData.first);
351  scoresInfo.SetQuantizationOffset(TestData::s_ScoresQuantData.second);
352 
353  anchorsInfo.SetQuantizationScale(TestData::s_AnchorsQuantData.first);
354  anchorsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);
355 
356  std::vector<RawType> boxEncodingsData(TestData::s_BoxEncodingsShape.GetNumElements());
357  QuantizeData<QuantizedType>(boxEncodingsData.data(),
358  TestData::s_BoxEncodings.data(),
359  boxEncodingsInfo);
360 
361  std::vector<RawType> scoresData(TestData::s_ScoresShape.GetNumElements());
362  QuantizeData<QuantizedType>(scoresData.data(),
363  TestData::s_Scores.data(),
364  scoresInfo);
365 
366  std::vector<RawType> anchorsData(TestData::s_AnchorsShape.GetNumElements());
367  QuantizeData<QuantizedType>(anchorsData.data(),
368  TestData::s_Anchors.data(),
369  anchorsInfo);
370 
371  return DetectionPostProcessImpl<FactoryType, QuantizedType>(
372  boxEncodingsInfo,
373  scoresInfo,
374  anchorsInfo,
375  boxEncodingsData,
376  scoresData,
377  anchorsData,
378  FastNmsExpectedResults::s_DetectionBoxes,
379  FastNmsExpectedResults::s_DetectionClasses,
380  FastNmsExpectedResults::s_DetectionScores,
381  FastNmsExpectedResults::s_NumDetections,
382  false);
383 }

◆ DetectionPostProcessImpl()

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 
)

Definition at line 141 of file DetectionPostProcessTestImpl.hpp.

References AllocateAndCopyDataToITensorHandle(), CompareTensors(), CopyDataFromITensorHandle(), CopyDataToITensorHandle(), armnn::Float32, ProfilerManager::GetInstance(), QueueDescriptorWithParameters< LayerDescriptor >::m_Parameters, DetectionPostProcessDescriptor::m_UseRegularNms, and ProfilerManager::RegisterProfiler().

152 {
153  std::unique_ptr<armnn::IProfiler> profiler = std::make_unique<armnn::IProfiler>();
154  armnn::ProfilerManager::GetInstance().RegisterProfiler(profiler.get());
155 
156  auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
157  FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);
158  auto tensorHandleFactory = WorkloadFactoryHelper<FactoryType>::GetTensorHandleFactory(memoryManager);
159 
160  armnn::TensorInfo detectionBoxesInfo({ 1, 3, 4 }, armnn::DataType::Float32);
161  armnn::TensorInfo detectionClassesInfo({ 1, 3 }, armnn::DataType::Float32);
162  armnn::TensorInfo detectionScoresInfo({ 1, 3 }, armnn::DataType::Float32);
163  armnn::TensorInfo numDetectionInfo({ 1 }, armnn::DataType::Float32);
164 
165  std::vector<float> actualDetectionBoxesOutput(detectionBoxesInfo.GetNumElements());
166  std::vector<float> actualDetectionClassesOutput(detectionClassesInfo.GetNumElements());
167  std::vector<float> actualDetectionScoresOutput(detectionScoresInfo.GetNumElements());
168  std::vector<float> actualNumDetectionOutput(numDetectionInfo.GetNumElements());
169 
170  auto boxedHandle = tensorHandleFactory.CreateTensorHandle(boxEncodingsInfo);
171  auto scoreshandle = tensorHandleFactory.CreateTensorHandle(scoresInfo);
172  auto anchorsHandle = tensorHandleFactory.CreateTensorHandle(anchorsInfo);
173  auto outputBoxesHandle = tensorHandleFactory.CreateTensorHandle(detectionBoxesInfo);
174  auto classesHandle = tensorHandleFactory.CreateTensorHandle(detectionClassesInfo);
175  auto outputScoresHandle = tensorHandleFactory.CreateTensorHandle(detectionScoresInfo);
176  auto numDetectionHandle = tensorHandleFactory.CreateTensorHandle(numDetectionInfo);
177 
178  armnn::ScopedTensorHandle anchorsTensor(anchorsInfo);
179  AllocateAndCopyDataToITensorHandle(&anchorsTensor, anchorsData.data());
180 
181  armnn::DetectionPostProcessQueueDescriptor data;
182  data.m_Parameters.m_UseRegularNms = useRegularNms;
183  data.m_Parameters.m_MaxDetections = 3;
184  data.m_Parameters.m_MaxClassesPerDetection = 1;
185  data.m_Parameters.m_DetectionsPerClass =1;
186  data.m_Parameters.m_NmsScoreThreshold = 0.0;
187  data.m_Parameters.m_NmsIouThreshold = 0.5;
188  data.m_Parameters.m_NumClasses = 2;
189  data.m_Parameters.m_ScaleY = 10.0;
190  data.m_Parameters.m_ScaleX = 10.0;
191  data.m_Parameters.m_ScaleH = 5.0;
192  data.m_Parameters.m_ScaleW = 5.0;
193  data.m_Anchors = &anchorsTensor;
194 
195  armnn::WorkloadInfo info;
196  AddInputToWorkload(data, info, boxEncodingsInfo, boxedHandle.get());
197  AddInputToWorkload(data, info, scoresInfo, scoreshandle.get());
198  AddOutputToWorkload(data, info, detectionBoxesInfo, outputBoxesHandle.get());
199  AddOutputToWorkload(data, info, detectionClassesInfo, classesHandle.get());
200  AddOutputToWorkload(data, info, detectionScoresInfo, outputScoresHandle.get());
201  AddOutputToWorkload(data, info, numDetectionInfo, numDetectionHandle.get());
202 
203  std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateDetectionPostProcess(data, info);
204 
205  boxedHandle->Allocate();
206  scoreshandle->Allocate();
207  outputBoxesHandle->Allocate();
208  classesHandle->Allocate();
209  outputScoresHandle->Allocate();
210  numDetectionHandle->Allocate();
211 
212  CopyDataToITensorHandle(boxedHandle.get(), boxEncodingsData.data());
213  CopyDataToITensorHandle(scoreshandle.get(), scoresData.data());
214 
215  workload->Execute();
216 
217  CopyDataFromITensorHandle(actualDetectionBoxesOutput.data(), outputBoxesHandle.get());
218  CopyDataFromITensorHandle(actualDetectionClassesOutput.data(), classesHandle.get());
219  CopyDataFromITensorHandle(actualDetectionScoresOutput.data(), outputScoresHandle.get());
220  CopyDataFromITensorHandle(actualNumDetectionOutput.data(), numDetectionHandle.get());
221 
222  auto result = CompareTensors(actualDetectionBoxesOutput,
223  expectedDetectionBoxes,
224  outputBoxesHandle->GetShape(),
225  detectionBoxesInfo.GetShape());
226  CHECK_MESSAGE(result.m_Result, result.m_Message.str());
227 
228  result = CompareTensors(actualDetectionClassesOutput,
229  expectedDetectionClasses,
230  classesHandle->GetShape(),
231  detectionClassesInfo.GetShape());
232  CHECK_MESSAGE(result.m_Result, result.m_Message.str());
233 
234  result = CompareTensors(actualDetectionScoresOutput,
235  expectedDetectionScores,
236  outputScoresHandle->GetShape(),
237  detectionScoresInfo.GetShape());
238  CHECK_MESSAGE(result.m_Result, result.m_Message.str());
239 
240  result = CompareTensors(actualNumDetectionOutput,
241  expectedNumDetections,
242  numDetectionHandle->GetShape(),
243  numDetectionInfo.GetShape());
244  CHECK_MESSAGE(result.m_Result, result.m_Message.str());
245 }
armnn::DetectionPostProcessQueueDescriptor
Definition: WorkloadData.hpp:238
armnn::ProfilerManager::GetInstance
static ProfilerManager & GetInstance()
Definition: Profiling.cpp:526
CompareTensors
armnn::PredicateResult CompareTensors(const std::vector< T > &actualData, const std::vector< T > &expectedData, const armnn::TensorShape &actualShape, const armnn::TensorShape &expectedShape, bool compareBoolean=false, bool isDynamic=false)
Definition: TensorHelpers.hpp:73
AllocateAndCopyDataToITensorHandle
void AllocateAndCopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
Definition: TensorCopyUtils.cpp:19
armnn::DetectionPostProcessDescriptor::m_UseRegularNms
bool m_UseRegularNms
Use Regular NMS.
Definition: Descriptors.hpp:567
CopyDataFromITensorHandle
void CopyDataFromITensorHandle(void *memory, const armnn::ITensorHandle *tensorHandle)
Definition: TensorCopyUtils.cpp:14
armnn::ProfilerManager::RegisterProfiler
void RegisterProfiler(IProfiler *profiler)
Definition: Profiling.cpp:533
armnn::WorkloadInfo
Contains information about TensorInfos of a layer.
Definition: WorkloadInfo.hpp:16
CopyDataToITensorHandle
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
Definition: TensorCopyUtils.cpp:9

◆ DetectionPostProcessRegularNmsFloatTest()

void DetectionPostProcessRegularNmsFloatTest ( )

Definition at line 258 of file DetectionPostProcessTestImpl.hpp.

References armnn::Float32.

259 {
260  return DetectionPostProcessImpl<FactoryType, armnn::DataType::Float32>(
261  armnn::TensorInfo(TestData::s_BoxEncodingsShape, armnn::DataType::Float32),
262  armnn::TensorInfo(TestData::s_ScoresShape, armnn::DataType::Float32),
263  armnn::TensorInfo(TestData::s_AnchorsShape, armnn::DataType::Float32),
264  TestData::s_BoxEncodings,
265  TestData::s_Scores,
266  TestData::s_Anchors,
267  RegularNmsExpectedResults::s_DetectionBoxes,
268  RegularNmsExpectedResults::s_DetectionClasses,
269  RegularNmsExpectedResults::s_DetectionScores,
270  RegularNmsExpectedResults::s_NumDetections,
271  true);
272 }

◆ DetectionPostProcessRegularNmsQuantizedTest()

void DetectionPostProcessRegularNmsQuantizedTest ( )

Definition at line 277 of file DetectionPostProcessTestImpl.hpp.

References TensorInfo::SetQuantizationOffset(), and TensorInfo::SetQuantizationScale().

278 {
279  armnn::TensorInfo boxEncodingsInfo(TestData::s_BoxEncodingsShape, QuantizedType);
280  armnn::TensorInfo scoresInfo(TestData::s_ScoresShape, QuantizedType);
281  armnn::TensorInfo anchorsInfo(TestData::s_AnchorsShape, QuantizedType);
282 
283  boxEncodingsInfo.SetQuantizationScale(TestData::s_BoxEncodingsQuantData.first);
284  boxEncodingsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);
285 
286  scoresInfo.SetQuantizationScale(TestData::s_ScoresQuantData.first);
287  scoresInfo.SetQuantizationOffset(TestData::s_ScoresQuantData.second);
288 
289  anchorsInfo.SetQuantizationScale(TestData::s_AnchorsQuantData.first);
290  anchorsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);
291 
292  std::vector<RawType> boxEncodingsData(TestData::s_BoxEncodingsShape.GetNumElements());
293  QuantizeData<QuantizedType>(boxEncodingsData.data(),
294  TestData::s_BoxEncodings.data(),
295  boxEncodingsInfo);
296 
297  std::vector<RawType> scoresData(TestData::s_ScoresShape.GetNumElements());
298  QuantizeData<QuantizedType>(scoresData.data(),
299  TestData::s_Scores.data(),
300  scoresInfo);
301 
302  std::vector<RawType> anchorsData(TestData::s_AnchorsShape.GetNumElements());
303  QuantizeData<QuantizedType>(anchorsData.data(),
304  TestData::s_Anchors.data(),
305  anchorsInfo);
306 
307  return DetectionPostProcessImpl<FactoryType, QuantizedType>(
308  boxEncodingsInfo,
309  scoresInfo,
310  anchorsInfo,
311  boxEncodingsData,
312  scoresData,
313  anchorsData,
314  RegularNmsExpectedResults::s_DetectionBoxes,
315  RegularNmsExpectedResults::s_DetectionClasses,
316  RegularNmsExpectedResults::s_DetectionScores,
317  RegularNmsExpectedResults::s_NumDetections,
318  true);
319 }

◆ QuantizeData()

void QuantizeData ( RawType *  quant,
const float *  dequant,
const armnn::TensorInfo &  info 
)

Definition at line 248 of file DetectionPostProcessTestImpl.hpp.

References TensorInfo::GetNumElements(), TensorInfo::GetQuantizationOffset(), and TensorInfo::GetQuantizationScale().

Referenced by TEST_SUITE().

249 {
250  for (size_t i = 0; i < info.GetNumElements(); i++)
251  {
252  quant[i] = armnn::Quantize<RawType>(
253  dequant[i], info.GetQuantizationScale(), info.GetQuantizationOffset());
254  }
255 }
armnn::TensorInfo::GetQuantizationOffset
int32_t GetQuantizationOffset() const
Definition: Tensor.cpp:480
armnn::TensorInfo::GetQuantizationScale
float GetQuantizationScale() const
Definition: Tensor.cpp:463
armnn::TensorInfo::GetNumElements
unsigned int GetNumElements() const
Definition: Tensor.hpp:196