31 const unsigned int inputHeight = 2;
32 const unsigned int inputWidth = 2;
33 const unsigned int inputChannels = 1;
34 const unsigned int inputNum = 2;
36 unsigned int outputHeight = inputHeight;
37 unsigned int outputWidth = inputWidth;
38 unsigned int outputChannels = inputChannels;
39 unsigned int outputNum = inputNum;
41 unsigned int inputShape[] = { inputNum, inputChannels, inputHeight, inputWidth };
42 unsigned int outputShape[] = { outputNum, outputChannels, outputHeight, outputWidth };
47 std::vector<float> input =
57 std::vector<float> actualOutput(outputTensorInfo.GetNumElements());
58 std::vector<float> expectedOutput(outputTensorInfo.GetNumElements());
63 uint32_t normSize = 3;
65 std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.
CreateTensorHandle(inputTensorInfo);
66 std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.
CreateTensorHandle(outputTensorInfo);
70 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
71 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
83 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, &refHandle);
85 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateNormalization(data, info);
87 inputHandle->Allocate();
88 outputHandle->Allocate();
92 ExecuteWorkload(*workload, memoryManager);
108 float divisor[inputNum];
110 float accumulatedScale1 = 0.0f;
111 for (
size_t i = 0; i < input.size()/2; ++i)
113 accumulatedScale1 += input[i]*input[i];
116 float accumulatedScale2 = 0.0f;
117 for (
size_t i = input.size()/2; i < input.size(); ++i)
119 accumulatedScale2 += input[i]*input[i];
122 divisor[0] = powf((kappa + accumulatedScale1 * alpha), beta);
123 divisor[1] = powf((kappa + accumulatedScale2 * alpha), beta);
125 std::vector<float> output;
126 unsigned int divisorIndex = 0;
127 for (
size_t i = 0; i < input.size(); ++i)
129 if (i == input.size()/2)
133 output.emplace_back(input[i]/divisor[divisorIndex]);
136 expectedOutput = output;
146 std::vector<float> outputVector;
148 for (
unsigned int i = 0; i < input.size(); ++i)
150 float accumulatedScale = input[i]*input[i];
151 float scale = powf((kappa + accumulatedScale * alpha), -beta);
152 outputVector.push_back(input[i] * scale);
154 expectedOutput = outputVector;
160 "only Across and Within are supported");
169 "only LocalBrightness is supported");
175 outputHandle->GetShape(),
176 outputTensorInfo.GetShape());
186 const unsigned int inputHeight = 2;
187 const unsigned int inputWidth = 2;
188 const unsigned int inputChannels = 1;
189 const unsigned int inputNum = 2;
191 unsigned int outputHeight = inputHeight;
192 unsigned int outputWidth = inputWidth;
193 unsigned int outputChannels = inputChannels;
194 unsigned int outputNum = inputNum;
196 unsigned int inputShape[] = { inputNum, inputHeight, inputWidth, inputChannels };
197 unsigned int outputShape[] = { outputNum, outputHeight, outputWidth, outputChannels };
202 std::vector<float> input =
212 std::vector<float> actualOutput(outputTensorInfo.GetNumElements());
213 std::vector<float> expectedOutput(outputTensorInfo.GetNumElements());
218 uint32_t normSize = 3;
220 std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.
CreateTensorHandle(inputTensorInfo);
221 std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.
CreateTensorHandle(outputTensorInfo);
225 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
226 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
238 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, &refHandle);
240 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateNormalization(data, info);
242 inputHandle->Allocate();
243 outputHandle->Allocate();
247 ExecuteWorkload(*workload, memoryManager);
259 expectedOutput = { 0.5f, 0.400000006f, 0.300000012f, 0.235294119f,
260 0.192307696f, 0.16216217f, 0.140000001f, 0.123076923f };
266 "Only Cross-map is supported for NHWC layout");
275 "only LocalBrightness is supported");
281 outputHandle->GetShape(),
282 outputTensorInfo.GetShape());
294 constexpr
unsigned int inputNum = 5;
295 constexpr
unsigned int inputChannels = 3;
296 constexpr
unsigned int inputHeight = 32;
297 constexpr
unsigned int inputWidth = 24;
299 constexpr
unsigned int outputNum = inputNum;
300 constexpr
unsigned int outputChannels = inputChannels;
301 constexpr
unsigned int outputHeight = inputHeight;
302 constexpr
unsigned int outputWidth = inputWidth;
307 unsigned int inputShape[] = {inputNum, inputChannels, inputHeight, inputWidth};
308 unsigned int outputShape[] = {outputNum, outputChannels, outputHeight, outputWidth};
315 auto input = MakeRandomTensor<float>(inputTensorInfo, 111234);
317 std::vector<float> actualOutput(outputTensorInfo.
GetNumElements());
318 std::vector<float> expectedOutput(outputTensorInfo.
GetNumElements());
320 constexpr
float alpha = 1.f;
321 constexpr
float beta = 1.f;
322 constexpr
float kappa = 1.f;
323 constexpr uint32_t normSize = 5;
325 std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.
CreateTensorHandle(inputTensorInfo);
326 std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.
CreateTensorHandle(outputTensorInfo);
330 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
331 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
339 std::unique_ptr<armnn::ITensorHandle> outputHandleRef = refTensorHandleFactory.
CreateTensorHandle(outputTensorInfo);
340 std::unique_ptr<armnn::ITensorHandle> inputHandleRef = refTensorHandleFactory.
CreateTensorHandle(inputTensorInfo);
344 SetWorkloadInput(refData, refInfo, 0, inputTensorInfo, inputHandleRef.get());
345 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, outputHandleRef.get());
349 const size_t reasonIfUnsupportedMaxLen = 255;
350 char reasonIfUnsupported[reasonIfUnsupportedMaxLen+1];
352 reasonIfUnsupported, reasonIfUnsupportedMaxLen);
353 if (!ret.m_Supported)
358 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateNormalization(data, info);
359 std::unique_ptr<armnn::IWorkload> workloadRef = refWorkloadFactory.
CreateNormalization(refData, refInfo);
361 outputHandleRef->Allocate();
362 inputHandleRef->Allocate();
364 inputHandle->Allocate();
365 outputHandle->Allocate();
370 ExecuteWorkload(*workload, memoryManager);
372 workloadRef->Execute();
376 ret.m_ActualData = actualOutput;
389 const unsigned int inputHeight = 1;
390 const unsigned int inputWidth = 2;
391 const unsigned int inputChannels = 3;
392 const unsigned int inputNum = 2;
394 unsigned int outputHeight = inputHeight;
395 unsigned int outputWidth = inputWidth;
396 unsigned int outputChannels = inputChannels;
397 unsigned int outputNum = inputNum;
399 unsigned int inputShape[] = { inputNum, inputHeight, inputWidth, inputChannels };
400 unsigned int outputShape[] = { outputNum, outputHeight, outputWidth, outputChannels };
405 std::vector<float> input =
408 -2.1f, 2.6f, 1.7f, 1.2f, -1.0f, 0.7f,
410 -2.1f, 2.6f, 1.7f, 1.2f, -1.0f, 0.7f,
413 std::vector<float> actualOutput(outputTensorInfo.
GetNumElements());
414 std::vector<float> expectedOutput(outputTensorInfo.
GetNumElements());
419 uint32_t normSize = 5;
421 std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.
CreateTensorHandle(inputTensorInfo);
422 std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.
CreateTensorHandle(outputTensorInfo);
426 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
427 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
439 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, &refHandle);
441 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateNormalization(data, info);
443 inputHandle->Allocate();
444 outputHandle->Allocate();
448 ExecuteWorkload(*workload, memoryManager);
460 expectedOutput = { -0.259993f, 0.321897f, 0.210471f, 0.263625f, -0.219687f, 0.153781f,
461 -0.259993f, 0.321897f, 0.210471f, 0.263625f, -0.219687f, 0.153781f, };
467 "only Across and Within are supported");
476 "only LocalBrightness is supported");
482 outputHandle->GetShape(),
495 return SimpleNormalizationTestImpl(workloadFactory, memoryManager, tensorHandleFactory, normChannel, normMethod);
505 return SimpleNormalizationTestImpl(workloadFactory, memoryManager, tensorHandleFactory, normChannel, normMethod);
515 return SimpleNormalizationNhwcTestImpl(
516 workloadFactory, memoryManager, tensorHandleFactory, normChannel, normMethod);
528 return CompareNormalizationTestImpl(
529 workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory,
530 normChannel, normMethod);
540 return AcrossChannelNormalizationTestImpl(workloadFactory,
virtual const BackendId & GetBackendId() const =0
LayerTestResult< float, 4 > CompareNormalizationTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::ITensorHandleFactory &refTensorHandleFactory, armnn::NormalizationAlgorithmChannel normChannel, armnn::NormalizationAlgorithmMethod normMethod)
float m_K
Kappa value used for the across channel normalization equation.
const TensorShape & GetShape() const
float m_Alpha
Alpha value for the normalization equation.
NormalizationAlgorithmChannel
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
bool IsNormalizationSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
void IgnoreUnused(Ts &&...)
LayerDescriptor m_Parameters
NormalizationAlgorithmMethod m_NormMethodType
Normalization method algorithm to use (LocalBrightness, LocalContrast).
LayerTestResult< float, 4 > SimpleNormalizationAcrossNhwcTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
std::shared_ptr< IMemoryManager > IMemoryManagerSharedPtr
std::vector< T > m_ExpectedData
virtual std::unique_ptr< IWorkload > CreateNormalization(const NormalizationQueueDescriptor &descriptor, const WorkloadInfo &info) const
void CopyDataFromITensorHandle(void *memory, const armnn::ITensorHandle *tensorHandle)
LayerTestResult< float, 4 > SimpleNormalizationAcrossTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
NormalizationAlgorithmChannel m_NormChannelType
Normalization channel algorithm to use (Across, Within).
Jarret 2009: Local Contrast Normalization.
LayerTestResult< float, 4 > AcrossChannelNormalizationTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Contains information about TensorInfos of a layer.
Krichevsky 2012: Local Brightness Normalization.
NormalizationAlgorithmMethod
virtual std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo) const =0
float m_Beta
Beta value for the normalization equation.
LayerTestResult< float, 4 > SimpleNormalizationWithinTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
uint32_t m_NormSize
Depth radius value.
unsigned int GetNumElements() const
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)