ArmNN
 20.02
Functions
DetectionPostProcessTestImpl.hpp File Reference
#include <ResolveType.hpp>
#include <armnn/Types.hpp>
#include <backendsCommon/CpuTensorHandle.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>

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 308 of file DetectionPostProcessTestImpl.hpp.

References armnn::Float32.

309 {
310  return DetectionPostProcessImpl<FactoryType, armnn::DataType::Float32>(
311  armnn::TensorInfo(TestData::s_BoxEncodingsShape, armnn::DataType::Float32),
312  armnn::TensorInfo(TestData::s_ScoresShape, armnn::DataType::Float32),
313  armnn::TensorInfo(TestData::s_AnchorsShape, armnn::DataType::Float32),
314  TestData::s_BoxEncodings,
315  TestData::s_Scores,
316  TestData::s_Anchors,
317  FastNmsExpectedResults::s_DetectionBoxes,
318  FastNmsExpectedResults::s_DetectionClasses,
319  FastNmsExpectedResults::s_DetectionScores,
320  FastNmsExpectedResults::s_NumDetections,
321  false);
322 }

◆ DetectionPostProcessFastNmsQuantizedTest()

void DetectionPostProcessFastNmsQuantizedTest ( )

Definition at line 327 of file DetectionPostProcessTestImpl.hpp.

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

Referenced by BOOST_AUTO_TEST_CASE().

328 {
329  armnn::TensorInfo boxEncodingsInfo(TestData::s_BoxEncodingsShape, QuantizedType);
330  armnn::TensorInfo scoresInfo(TestData::s_ScoresShape, QuantizedType);
331  armnn::TensorInfo anchorsInfo(TestData::s_AnchorsShape, QuantizedType);
332 
333  boxEncodingsInfo.SetQuantizationScale(TestData::s_BoxEncodingsQuantData.first);
334  boxEncodingsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);
335 
336  scoresInfo.SetQuantizationScale(TestData::s_ScoresQuantData.first);
337  scoresInfo.SetQuantizationOffset(TestData::s_ScoresQuantData.second);
338 
339  anchorsInfo.SetQuantizationScale(TestData::s_AnchorsQuantData.first);
340  anchorsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);
341 
342  std::vector<RawType> boxEncodingsData(TestData::s_BoxEncodingsShape.GetNumElements());
343  QuantizeData<QuantizedType>(boxEncodingsData.data(),
344  TestData::s_BoxEncodings.data(),
345  boxEncodingsInfo);
346 
347  std::vector<RawType> scoresData(TestData::s_ScoresShape.GetNumElements());
348  QuantizeData<QuantizedType>(scoresData.data(),
349  TestData::s_Scores.data(),
350  scoresInfo);
351 
352  std::vector<RawType> anchorsData(TestData::s_AnchorsShape.GetNumElements());
353  QuantizeData<QuantizedType>(anchorsData.data(),
354  TestData::s_Anchors.data(),
355  anchorsInfo);
356 
357  return DetectionPostProcessImpl<FactoryType, QuantizedType>(
358  boxEncodingsInfo,
359  scoresInfo,
360  anchorsInfo,
361  boxEncodingsData,
362  scoresData,
363  anchorsData,
364  FastNmsExpectedResults::s_DetectionBoxes,
365  FastNmsExpectedResults::s_DetectionClasses,
366  FastNmsExpectedResults::s_DetectionScores,
367  FastNmsExpectedResults::s_NumDetections,
368  false);
369 }
anchorsInfo
armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32)
armnn::TensorInfo::SetQuantizationScale
void SetQuantizationScale(float scale)
Definition: Tensor.cpp:259
scoresInfo
armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32)
armnn::TensorInfo::SetQuantizationOffset
void SetQuantizationOffset(int32_t offset)
Definition: Tensor.cpp:275

◆ 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 139 of file DetectionPostProcessTestImpl.hpp.

References AllocateAndCopyDataToITensorHandle(), anchors(), anchorsInfo, boxEncodings(), CompareTensors(), CopyDataFromITensorHandle(), CopyDataToITensorHandle(), armnn::Float32, ProfilerManager::GetInstance(), DetectionPostProcessQueueDescriptor::m_Anchors, DetectionPostProcessDescriptor::m_DetectionsPerClass, DetectionPostProcessDescriptor::m_MaxClassesPerDetection, DetectionPostProcessDescriptor::m_MaxDetections, DetectionPostProcessDescriptor::m_NmsIouThreshold, DetectionPostProcessDescriptor::m_NmsScoreThreshold, DetectionPostProcessDescriptor::m_NumClasses, QueueDescriptorWithParameters< LayerDescriptor >::m_Parameters, DetectionPostProcessDescriptor::m_ScaleH, DetectionPostProcessDescriptor::m_ScaleW, DetectionPostProcessDescriptor::m_ScaleX, DetectionPostProcessDescriptor::m_ScaleY, DetectionPostProcessDescriptor::m_UseRegularNms, ProfilerManager::RegisterProfiler(), scores(), and scoresInfo.

150 {
151  std::unique_ptr<armnn::Profiler> profiler = std::make_unique<armnn::Profiler>();
152  armnn::ProfilerManager::GetInstance().RegisterProfiler(profiler.get());
153 
154  auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
155  FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);
156 
157  auto boxEncodings = MakeTensor<T, 3>(boxEncodingsInfo, boxEncodingsData);
158  auto scores = MakeTensor<T, 3>(scoresInfo, scoresData);
159  auto anchors = MakeTensor<T, 2>(anchorsInfo, anchorsData);
160 
161  armnn::TensorInfo detectionBoxesInfo({ 1, 3, 4 }, armnn::DataType::Float32);
162  armnn::TensorInfo detectionScoresInfo({ 1, 3 }, armnn::DataType::Float32);
163  armnn::TensorInfo detectionClassesInfo({ 1, 3 }, armnn::DataType::Float32);
164  armnn::TensorInfo numDetectionInfo({ 1 }, armnn::DataType::Float32);
165 
166  LayerTestResult<float, 3> detectionBoxesResult(detectionBoxesInfo);
167  detectionBoxesResult.outputExpected = MakeTensor<float, 3>(detectionBoxesInfo, expectedDetectionBoxes);
168  LayerTestResult<float, 2> detectionClassesResult(detectionClassesInfo);
169  detectionClassesResult.outputExpected = MakeTensor<float, 2>(detectionClassesInfo, expectedDetectionClasses);
170  LayerTestResult<float, 2> detectionScoresResult(detectionScoresInfo);
171  detectionScoresResult.outputExpected = MakeTensor<float, 2>(detectionScoresInfo, expectedDetectionScores);
172  LayerTestResult<float, 1> numDetectionsResult(numDetectionInfo);
173  numDetectionsResult.outputExpected = MakeTensor<float, 1>(numDetectionInfo, expectedNumDetections);
174 
175  std::unique_ptr<armnn::ITensorHandle> boxedHandle = workloadFactory.CreateTensorHandle(boxEncodingsInfo);
176  std::unique_ptr<armnn::ITensorHandle> scoreshandle = workloadFactory.CreateTensorHandle(scoresInfo);
177  std::unique_ptr<armnn::ITensorHandle> anchorsHandle = workloadFactory.CreateTensorHandle(anchorsInfo);
178  std::unique_ptr<armnn::ITensorHandle> outputBoxesHandle = workloadFactory.CreateTensorHandle(detectionBoxesInfo);
179  std::unique_ptr<armnn::ITensorHandle> classesHandle = workloadFactory.CreateTensorHandle(detectionClassesInfo);
180  std::unique_ptr<armnn::ITensorHandle> outputScoresHandle = workloadFactory.CreateTensorHandle(detectionScoresInfo);
181  std::unique_ptr<armnn::ITensorHandle> numDetectionHandle = workloadFactory.CreateTensorHandle(numDetectionInfo);
182 
183  armnn::ScopedCpuTensorHandle anchorsTensor(anchorsInfo);
184  AllocateAndCopyDataToITensorHandle(&anchorsTensor, &anchors[0][0]);
185 
186  armnn::DetectionPostProcessQueueDescriptor data;
187  data.m_Parameters.m_UseRegularNms = useRegularNms;
188  data.m_Parameters.m_MaxDetections = 3;
189  data.m_Parameters.m_MaxClassesPerDetection = 1;
190  data.m_Parameters.m_DetectionsPerClass =1;
191  data.m_Parameters.m_NmsScoreThreshold = 0.0;
192  data.m_Parameters.m_NmsIouThreshold = 0.5;
193  data.m_Parameters.m_NumClasses = 2;
194  data.m_Parameters.m_ScaleY = 10.0;
195  data.m_Parameters.m_ScaleX = 10.0;
196  data.m_Parameters.m_ScaleH = 5.0;
197  data.m_Parameters.m_ScaleW = 5.0;
198  data.m_Anchors = &anchorsTensor;
199 
200  armnn::WorkloadInfo info;
201  AddInputToWorkload(data, info, boxEncodingsInfo, boxedHandle.get());
202  AddInputToWorkload(data, info, scoresInfo, scoreshandle.get());
203  AddOutputToWorkload(data, info, detectionBoxesInfo, outputBoxesHandle.get());
204  AddOutputToWorkload(data, info, detectionClassesInfo, classesHandle.get());
205  AddOutputToWorkload(data, info, detectionScoresInfo, outputScoresHandle.get());
206  AddOutputToWorkload(data, info, numDetectionInfo, numDetectionHandle.get());
207 
208  std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateDetectionPostProcess(data, info);
209 
210  boxedHandle->Allocate();
211  scoreshandle->Allocate();
212  outputBoxesHandle->Allocate();
213  classesHandle->Allocate();
214  outputScoresHandle->Allocate();
215  numDetectionHandle->Allocate();
216 
217  CopyDataToITensorHandle(boxedHandle.get(), boxEncodings.origin());
218  CopyDataToITensorHandle(scoreshandle.get(), scores.origin());
219 
220  workload->Execute();
221 
222  CopyDataFromITensorHandle(detectionBoxesResult.output.origin(), outputBoxesHandle.get());
223  CopyDataFromITensorHandle(detectionClassesResult.output.origin(), classesHandle.get());
224  CopyDataFromITensorHandle(detectionScoresResult.output.origin(), outputScoresHandle.get());
225  CopyDataFromITensorHandle(numDetectionsResult.output.origin(), numDetectionHandle.get());
226 
227  BOOST_TEST(CompareTensors(detectionBoxesResult.output, detectionBoxesResult.outputExpected));
228  BOOST_TEST(CompareTensors(detectionClassesResult.output, detectionClassesResult.outputExpected));
229  BOOST_TEST(CompareTensors(detectionScoresResult.output, detectionScoresResult.outputExpected));
230  BOOST_TEST(CompareTensors(numDetectionsResult.output, numDetectionsResult.outputExpected));
231 }
armnn::DetectionPostProcessDescriptor::m_ScaleW
float m_ScaleW
Center size encoding scale weight.
Definition: Descriptors.hpp:545
armnn::DetectionPostProcessQueueDescriptor
Definition: WorkloadData.hpp:197
armnn::ProfilerManager::RegisterProfiler
void RegisterProfiler(Profiler *profiler)
Definition: Profiling.cpp:494
armnn::ProfilerManager::GetInstance
static ProfilerManager & GetInstance()
Definition: Profiling.cpp:487
armnn::DetectionPostProcessDescriptor::m_ScaleX
float m_ScaleX
Center size encoding scale x.
Definition: Descriptors.hpp:541
CompareTensors
boost::test_tools::predicate_result CompareTensors(const boost::multi_array< T, n > &a, const boost::multi_array< T, n > &b, bool compareBoolean=false)
Definition: TensorHelpers.hpp:75
armnn::DetectionPostProcessDescriptor::m_DetectionsPerClass
uint32_t m_DetectionsPerClass
Detections per classes, used in Regular NMS.
Definition: Descriptors.hpp:531
anchorsInfo
armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32)
boxEncodings
std::vector< float > 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 })
armnn::DetectionPostProcessDescriptor::m_MaxClassesPerDetection
uint32_t m_MaxClassesPerDetection
Maximum numbers of classes per detection, used in Fast NMS.
Definition: Descriptors.hpp:529
armnn::DetectionPostProcessDescriptor::m_MaxDetections
uint32_t m_MaxDetections
Maximum numbers of detections.
Definition: Descriptors.hpp:527
armnn::DetectionPostProcessDescriptor::m_NmsIouThreshold
float m_NmsIouThreshold
Intersection over union threshold.
Definition: Descriptors.hpp:535
armnn::DetectionPostProcessDescriptor::m_NumClasses
uint32_t m_NumClasses
Number of classes.
Definition: Descriptors.hpp:537
armnn::DetectionPostProcessQueueDescriptor::m_Anchors
const ConstCpuTensorHandle * m_Anchors
Definition: WorkloadData.hpp:204
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:539
CopyDataFromITensorHandle
void CopyDataFromITensorHandle(void *memory, const armnn::ITensorHandle *tensorHandle)
Definition: TensorCopyUtils.cpp:14
armnn::DetectionPostProcessDescriptor::m_ScaleH
float m_ScaleH
Center size encoding scale height.
Definition: Descriptors.hpp:547
scores
std::vector< float > scores({ 0.0f, 0.9f, 0.8f, 0.0f, 0.75f, 0.72f, 0.0f, 0.6f, 0.5f, 0.0f, 0.93f, 0.95f, 0.0f, 0.5f, 0.4f, 0.0f, 0.3f, 0.2f })
FactoryType
ClWorkloadFactory FactoryType
Definition: ClLayerTests.cpp:31
scoresInfo
armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32)
armnn::WorkloadInfo
Contains information about inputs and outputs to a layer.
Definition: WorkloadInfo.hpp:16
armnn::DetectionPostProcessDescriptor::m_ScaleY
float m_ScaleY
Center size encoding scale y.
Definition: Descriptors.hpp:543
armnn::DetectionPostProcessDescriptor::m_NmsScoreThreshold
float m_NmsScoreThreshold
NMS score threshold.
Definition: Descriptors.hpp:533
CopyDataToITensorHandle
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
Definition: TensorCopyUtils.cpp:9
anchors
std::vector< float > 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 })

◆ DetectionPostProcessRegularNmsFloatTest()

void DetectionPostProcessRegularNmsFloatTest ( )

Definition at line 244 of file DetectionPostProcessTestImpl.hpp.

References armnn::Float32.

245 {
246  return DetectionPostProcessImpl<FactoryType, armnn::DataType::Float32>(
247  armnn::TensorInfo(TestData::s_BoxEncodingsShape, armnn::DataType::Float32),
248  armnn::TensorInfo(TestData::s_ScoresShape, armnn::DataType::Float32),
249  armnn::TensorInfo(TestData::s_AnchorsShape, armnn::DataType::Float32),
250  TestData::s_BoxEncodings,
251  TestData::s_Scores,
252  TestData::s_Anchors,
253  RegularNmsExpectedResults::s_DetectionBoxes,
254  RegularNmsExpectedResults::s_DetectionClasses,
255  RegularNmsExpectedResults::s_DetectionScores,
256  RegularNmsExpectedResults::s_NumDetections,
257  true);
258 }

◆ DetectionPostProcessRegularNmsQuantizedTest()

void DetectionPostProcessRegularNmsQuantizedTest ( )

Definition at line 263 of file DetectionPostProcessTestImpl.hpp.

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

Referenced by BOOST_AUTO_TEST_CASE().

264 {
265  armnn::TensorInfo boxEncodingsInfo(TestData::s_BoxEncodingsShape, QuantizedType);
266  armnn::TensorInfo scoresInfo(TestData::s_ScoresShape, QuantizedType);
267  armnn::TensorInfo anchorsInfo(TestData::s_AnchorsShape, QuantizedType);
268 
269  boxEncodingsInfo.SetQuantizationScale(TestData::s_BoxEncodingsQuantData.first);
270  boxEncodingsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);
271 
272  scoresInfo.SetQuantizationScale(TestData::s_ScoresQuantData.first);
273  scoresInfo.SetQuantizationOffset(TestData::s_ScoresQuantData.second);
274 
275  anchorsInfo.SetQuantizationScale(TestData::s_AnchorsQuantData.first);
276  anchorsInfo.SetQuantizationOffset(TestData::s_BoxEncodingsQuantData.second);
277 
278  std::vector<RawType> boxEncodingsData(TestData::s_BoxEncodingsShape.GetNumElements());
279  QuantizeData<QuantizedType>(boxEncodingsData.data(),
280  TestData::s_BoxEncodings.data(),
281  boxEncodingsInfo);
282 
283  std::vector<RawType> scoresData(TestData::s_ScoresShape.GetNumElements());
284  QuantizeData<QuantizedType>(scoresData.data(),
285  TestData::s_Scores.data(),
286  scoresInfo);
287 
288  std::vector<RawType> anchorsData(TestData::s_AnchorsShape.GetNumElements());
289  QuantizeData<QuantizedType>(anchorsData.data(),
290  TestData::s_Anchors.data(),
291  anchorsInfo);
292 
293  return DetectionPostProcessImpl<FactoryType, QuantizedType>(
294  boxEncodingsInfo,
295  scoresInfo,
296  anchorsInfo,
297  boxEncodingsData,
298  scoresData,
299  anchorsData,
300  RegularNmsExpectedResults::s_DetectionBoxes,
301  RegularNmsExpectedResults::s_DetectionClasses,
302  RegularNmsExpectedResults::s_DetectionScores,
303  RegularNmsExpectedResults::s_NumDetections,
304  true);
305 }
anchorsInfo
armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32)
armnn::TensorInfo::SetQuantizationScale
void SetQuantizationScale(float scale)
Definition: Tensor.cpp:259
scoresInfo
armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32)
armnn::TensorInfo::SetQuantizationOffset
void SetQuantizationOffset(int32_t offset)
Definition: Tensor.cpp:275

◆ QuantizeData()

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

Definition at line 234 of file DetectionPostProcessTestImpl.hpp.

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

235 {
236  for (size_t i = 0; i < info.GetNumElements(); i++)
237  {
238  quant[i] = armnn::Quantize<RawType>(
239  dequant[i], info.GetQuantizationScale(), info.GetQuantizationOffset());
240  }
241 }
armnn::TensorInfo::GetQuantizationOffset
int32_t GetQuantizationOffset() const
Definition: Tensor.cpp:264
armnn::TensorInfo::GetQuantizationScale
float GetQuantizationScale() const
Definition: Tensor.cpp:247
armnn::TensorInfo::GetNumElements
unsigned int GetNumElements() const
Definition: Tensor.hpp:93