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 };
49 auto input = MakeTensor<float, 4>(inputTensorInfo, std::vector<float>({
61 uint32_t normSize = 3;
63 std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo);
64 std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo);
68 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
69 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
81 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, &refHandle);
83 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateNormalization(data, info);
85 inputHandle->Allocate();
86 outputHandle->Allocate();
90 ExecuteWorkload(*workload, memoryManager);
106 float divisor[inputNum];
107 for(
int i = 0; i < armnn::numeric_cast<int>(inputNum); i++)
109 float accumulatedScale = input[i][0][0][0]*input[i][0][0][0] +
110 input[i][0][0][1]*input[i][0][0][1] +
111 input[i][0][1][0]*input[i][0][1][0] +
112 input[i][0][1][1]*input[i][0][1][1];
113 divisor[i] = powf((kappa + accumulatedScale * alpha), beta);
115 ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo,
116 std::vector<float>({input[0][0][0][0]/divisor[0],
117 input[0][0][0][1]/divisor[0],
118 input[0][0][1][0]/divisor[0],
119 input[0][0][1][1]/divisor[0],
120 input[1][0][0][0]/divisor[1],
121 input[1][0][0][1]/divisor[1],
122 input[1][0][1][0]/divisor[1],
123 input[1][0][1][1]/divisor[1]}));
133 std::vector<float> outputVector;
134 for (
int n = 0; n < armnn::numeric_cast<int>(inputNum); ++n)
136 for (
int h = 0; h < armnn::numeric_cast<int>(inputHeight); ++h)
138 for (
int w = 0; w < armnn::numeric_cast<int>(inputWidth); ++w)
140 float accumulatedScale = input[n][0][h][w]*input[n][0][h][w];
141 float scale = powf((kappa + accumulatedScale * alpha), -beta);
142 outputVector.push_back(input[n][0][h][w] * scale);
146 ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo, outputVector);
152 "only Across and Within are supported");
161 "only LocalBrightness is supported");
175 const unsigned int inputHeight = 2;
176 const unsigned int inputWidth = 2;
177 const unsigned int inputChannels = 1;
178 const unsigned int inputNum = 2;
180 unsigned int outputHeight = inputHeight;
181 unsigned int outputWidth = inputWidth;
182 unsigned int outputChannels = inputChannels;
183 unsigned int outputNum = inputNum;
185 unsigned int inputShape[] = { inputNum, inputHeight, inputWidth, inputChannels };
186 unsigned int outputShape[] = { outputNum, outputHeight, outputWidth, outputChannels };
193 auto input = MakeTensor<float, 4>(inputTensorInfo, std::vector<float>({
205 uint32_t normSize = 3;
207 std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo);
208 std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo);
212 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
213 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
225 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, &refHandle);
227 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateNormalization(data, info);
229 inputHandle->Allocate();
230 outputHandle->Allocate();
234 ExecuteWorkload(*workload, memoryManager);
246 std::vector<float> expectedOutput{ 0.5f, 0.400000006f, 0.300000012f, 0.235294119f,
247 0.192307696f, 0.16216217f, 0.140000001f, 0.123076923f };
248 ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo, expectedOutput);
254 "Only Cross-map is supported for NHWC layout");
263 "only LocalBrightness is supported");
279 constexpr
unsigned int inputNum = 5;
280 constexpr
unsigned int inputChannels = 3;
281 constexpr
unsigned int inputHeight = 32;
282 constexpr
unsigned int inputWidth = 24;
284 constexpr
unsigned int outputNum = inputNum;
285 constexpr
unsigned int outputChannels = inputChannels;
286 constexpr
unsigned int outputHeight = inputHeight;
287 constexpr
unsigned int outputWidth = inputWidth;
292 unsigned int inputShape[] = {inputNum, inputChannels, inputHeight, inputWidth};
293 unsigned int outputShape[] = {outputNum, outputChannels, outputHeight, outputWidth};
300 auto input = MakeRandomTensor<float, 4>(inputTensorInfo, 111234);
302 constexpr
float alpha = 1.f;
303 constexpr
float beta = 1.f;
304 constexpr
float kappa = 1.f;
305 constexpr uint32_t normSize = 5;
307 std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.
CreateTensorHandle(inputTensorInfo);
308 std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.
CreateTensorHandle(outputTensorInfo);
312 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
313 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
321 std::unique_ptr<armnn::ITensorHandle> outputHandleRef = refTensorHandleFactory.
CreateTensorHandle(outputTensorInfo);
322 std::unique_ptr<armnn::ITensorHandle> inputHandleRef = refTensorHandleFactory.
CreateTensorHandle(inputTensorInfo);
326 SetWorkloadInput(refData, refInfo, 0, inputTensorInfo, inputHandleRef.get());
327 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, outputHandleRef.get());
331 const size_t reasonIfUnsupportedMaxLen = 255;
332 char reasonIfUnsupported[reasonIfUnsupportedMaxLen+1];
334 reasonIfUnsupported, reasonIfUnsupportedMaxLen);
340 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateNormalization(data, info);
341 std::unique_ptr<armnn::IWorkload> workloadRef = refWorkloadFactory.
CreateNormalization(refData, refInfo);
343 outputHandleRef->Allocate();
344 inputHandleRef->Allocate();
346 inputHandle->Allocate();
347 outputHandle->Allocate();
352 ExecuteWorkload(*workload, memoryManager);
354 workloadRef->Execute();
371 return SimpleNormalizationTestImpl(workloadFactory, memoryManager, tensorHandleFactory, normChannel, normMethod);
381 return SimpleNormalizationTestImpl(workloadFactory, memoryManager, tensorHandleFactory, normChannel, normMethod);
391 return SimpleNormalizationNhwcTestImpl(
392 workloadFactory, memoryManager, tensorHandleFactory, normChannel, normMethod);
404 return CompareNormalizationTestImpl(
405 workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory,
406 normChannel, normMethod);
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.
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
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.
Contains information about inputs and outputs to 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.
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)