27 boost::ignore_unused(memoryManager);
28 const unsigned int inputHeight = 2;
29 const unsigned int inputWidth = 2;
30 const unsigned int inputChannels = 1;
31 const unsigned int inputNum = 2;
33 unsigned int outputHeight = inputHeight;
34 unsigned int outputWidth = inputWidth;
35 unsigned int outputChannels = inputChannels;
36 unsigned int outputNum = inputNum;
38 unsigned int inputShape[] = { inputNum, inputChannels, inputHeight, inputWidth };
39 unsigned int outputShape[] = { outputNum, outputChannels, outputHeight, outputWidth };
46 auto input = MakeTensor<float, 4>(inputTensorInfo, std::vector<float>({
58 uint32_t normSize = 3;
60 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
61 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
65 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
66 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
78 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, &refHandle);
80 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateNormalization(data, info);
82 inputHandle->Allocate();
83 outputHandle->Allocate();
87 ExecuteWorkload(*workload, memoryManager);
103 float divisor[inputNum];
104 for(
int i = 0; i < boost::numeric_cast<int>(inputNum); i++)
106 float accumulatedScale = input[i][0][0][0]*input[i][0][0][0] +
107 input[i][0][0][1]*input[i][0][0][1] +
108 input[i][0][1][0]*input[i][0][1][0] +
109 input[i][0][1][1]*input[i][0][1][1];
110 divisor[i] = powf((kappa + accumulatedScale * alpha), beta);
112 ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo,
113 std::vector<float>({input[0][0][0][0]/divisor[0],
114 input[0][0][0][1]/divisor[0],
115 input[0][0][1][0]/divisor[0],
116 input[0][0][1][1]/divisor[0],
117 input[1][0][0][0]/divisor[1],
118 input[1][0][0][1]/divisor[1],
119 input[1][0][1][0]/divisor[1],
120 input[1][0][1][1]/divisor[1]}));
130 std::vector<float> outputVector;
131 for (
int n = 0; n < boost::numeric_cast<int>(inputNum); ++n)
133 for (
int h = 0; h < boost::numeric_cast<int>(inputHeight); ++h)
135 for (
int w = 0; w < boost::numeric_cast<int>(inputWidth); ++w)
137 float accumulatedScale = input[n][0][h][w]*input[n][0][h][w];
138 float scale = powf((kappa + accumulatedScale * alpha), -beta);
139 outputVector.push_back(input[n][0][h][w] * scale);
143 ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo, outputVector);
149 "only Across and Within are supported");
158 "only LocalBrightness is supported");
171 const unsigned int inputHeight = 2;
172 const unsigned int inputWidth = 2;
173 const unsigned int inputChannels = 1;
174 const unsigned int inputNum = 2;
176 unsigned int outputHeight = inputHeight;
177 unsigned int outputWidth = inputWidth;
178 unsigned int outputChannels = inputChannels;
179 unsigned int outputNum = inputNum;
181 unsigned int inputShape[] = { inputNum, inputHeight, inputWidth, inputChannels };
182 unsigned int outputShape[] = { outputNum, outputHeight, outputWidth, outputChannels };
189 auto input = MakeTensor<float, 4>(inputTensorInfo, std::vector<float>({
201 uint32_t normSize = 3;
203 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
204 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
208 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
209 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
221 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, &refHandle);
223 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateNormalization(data, info);
225 inputHandle->Allocate();
226 outputHandle->Allocate();
230 ExecuteWorkload(*workload, memoryManager);
242 std::vector<float> expectedOutput{ 0.5f, 0.400000006f, 0.300000012f, 0.235294119f,
243 0.192307696f, 0.16216217f, 0.140000001f, 0.123076923f };
244 ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo, expectedOutput);
250 "Only Cross-map is supported for NHWC layout");
259 "only LocalBrightness is supported");
273 constexpr
unsigned int inputNum = 5;
274 constexpr
unsigned int inputChannels = 3;
275 constexpr
unsigned int inputHeight = 32;
276 constexpr
unsigned int inputWidth = 24;
278 constexpr
unsigned int outputNum = inputNum;
279 constexpr
unsigned int outputChannels = inputChannels;
280 constexpr
unsigned int outputHeight = inputHeight;
281 constexpr
unsigned int outputWidth = inputWidth;
286 unsigned int inputShape[] = {inputNum, inputChannels, inputHeight, inputWidth};
287 unsigned int outputShape[] = {outputNum, outputChannels, outputHeight, outputWidth};
294 auto input = MakeRandomTensor<float, 4>(inputTensorInfo, 111234);
296 constexpr
float alpha = 1.f;
297 constexpr
float beta = 1.f;
298 constexpr
float kappa = 1.f;
299 constexpr uint32_t normSize = 5;
301 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfo);
302 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
306 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
307 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
315 std::unique_ptr<armnn::ITensorHandle> outputHandleRef = refWorkloadFactory.
CreateTensorHandle(outputTensorInfo);
316 std::unique_ptr<armnn::ITensorHandle> inputHandleRef = refWorkloadFactory.
CreateTensorHandle(inputTensorInfo);
320 SetWorkloadInput(refData, refInfo, 0, inputTensorInfo, inputHandleRef.get());
321 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, outputHandleRef.get());
325 const size_t reasonIfUnsupportedMaxLen = 255;
326 char reasonIfUnsupported[reasonIfUnsupportedMaxLen+1];
328 reasonIfUnsupported, reasonIfUnsupportedMaxLen);
334 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateNormalization(data, info);
335 std::unique_ptr<armnn::IWorkload> workloadRef = refWorkloadFactory.
CreateNormalization(refData, refInfo);
337 outputHandleRef->Allocate();
338 inputHandleRef->Allocate();
340 inputHandle->Allocate();
341 outputHandle->Allocate();
346 ExecuteWorkload(*workload, memoryManager);
348 workloadRef->Execute();
364 return SimpleNormalizationTestImpl(workloadFactory, memoryManager, normChannel, normMethod);
373 return SimpleNormalizationTestImpl(workloadFactory, memoryManager, normChannel, normMethod);
382 return SimpleNormalizationNhwcTestImpl(workloadFactory, memoryManager, normChannel, normMethod);
392 return CompareNormalizationTestImpl(workloadFactory, memoryManager, refWorkloadFactory, normChannel, normMethod);
float m_Alpha
Alpha value for the normalization equation.
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
LayerTestResult< float, 4 > SimpleNormalizationAcrossNhwcTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
virtual std::unique_ptr< IWorkload > CreateNormalization(const NormalizationQueueDescriptor &descriptor, const WorkloadInfo &info) const
LayerTestResult< float, 4 > SimpleNormalizationAcrossTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerDescriptor m_Parameters
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
virtual std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo, const bool IsMemoryManaged=true) const =0
void CopyDataFromITensorHandle(void *memory, const armnn::ITensorHandle *tensorHandle)
std::shared_ptr< IMemoryManager > IMemoryManagerSharedPtr
virtual const BackendId & GetBackendId() const =0
Krichevsky 2012: Local Brightness Normalization.
Jarret 2009: Local Contrast Normalization.
uint32_t m_NormSize
Depth radius value.
float m_Beta
Beta value for the normalization equation.
LayerTestResult< float, 4 > CompareNormalizationTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, armnn::NormalizationAlgorithmChannel normChannel, armnn::NormalizationAlgorithmMethod normMethod)
NormalizationAlgorithmMethod
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.
NormalizationAlgorithmMethod m_NormMethodType
Normalization method algorithm to use (LocalBrightness, LocalContrast).
float m_K
Kappa value used for the across channel normalization equation.
NormalizationAlgorithmChannel
NormalizationAlgorithmChannel m_NormChannelType
Normalization channel algorithm to use (Across, Within).
LayerTestResult< float, 4 > SimpleNormalizationWithinTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)