深度神经网络中的局部响应归一化LRN简介及实现

电玩女神 2023-01-04 10:30 155阅读 0赞

Alex、Hinton等人在2012年的NIPS论文《ImageNet Classification with Deep Convolutional Neural Networks》中将LRN应用于深度神经网络中(AlexNet)。论文见：[http://www.cs.toronto.edu/~hinton/absps/imagenet.pdf][http_www.cs.toronto.edu_hinton_absps_imagenet.pdf] ，截图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg_size_16_color_FFFFFF_t_70][]

公式解释：

![a\_\{x,y\}^\{i\}][a_x_y_i]：ReLU处理后的神经元，作为LRN的输入；

![b\_\{x,y\}^\{i\}][b_x_y_i]：LRN的输出，LRN处理后的神经元；

N：kernal总数或通道数；

k、n、![\\alpha][alpha]、![\\beta][beta]：为常量，是超参数，k类似于bias，n对应于Caffe中的local\_size，在论文中这几个值分别为2、5、![10^\{-4\}][10_-4]、0.75。

LRN(Local Response Normalization)：局部响应归一化，此层实现了” lateral inhibition”(侧抑制)，通过对局部输入区域进行归一化来执行一种”侧抑制”。在AlexNet中，处理ReLU神经元时，LRN很有用，因为ReLU的响应结果是无界的，可以非常大，所以需要归一化。当处理具有无限激活(unbounded activation)的神经元时(如ReLU)，可以通过LRN对其归一化(normalize)，因为它允许检测具有大神经元响应的高频特征(high-frequency features)，同时衰减局部周围(local neighborhood)均匀大(uniformly large)的响应。它是一种正则化类型。一般应用在激活、池化后进行的一种处理方法。该层的输出维数始终等于输入维数。

在神经生物学有一个概念叫做侧抑制(lateral inhibition)，指的是被激活的神经元抑制相邻的神经元。归一化的目的是”抑制”，局部响应归一化就是借鉴侧抑制的思想来实现局部抑制。LRN层模仿生物神经系统的侧抑制机制，对局部神经元的活动创建竞争机制，使得其中响应比较大的值变得相对更大，并抑制其它反馈较小的神经元，增强了模型泛化能力。

后来研究者发现LRN起不到太大作用，LRN的作用已被正则化技术(regularization techniques,例如dropout and batch normalization)、更好的初始化和训练方法所取代。

在Caffe的caffe.proto中，LRN参数内容如下：分为通道间归一化(local\_size\*1\*1)和通道内归一化(1\*local\_size\*local\_size)

// Message that stores parameters used by LRNLayer
    message LRNParameter {
      optional uint32 local_size = 1 [default = 5];
      optional float alpha = 2 [default = 1.];
      optional float beta = 3 [default = 0.75];
      enum NormRegion {
        ACROSS_CHANNELS = 0;
        WITHIN_CHANNEL = 1;
      }
      optional NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
      optional float k = 5 [default = 1.];
      enum Engine {
        DEFAULT = 0;
        CAFFE = 1;
        CUDNN = 2;
      }
      optional Engine engine = 6 [default = DEFAULT];
    }

各参数介绍见：[http://caffe.berkeleyvision.org/tutorial/layers/lrn.html][http_caffe.berkeleyvision.org_tutorial_layers_lrn.html]

注：以上内容主要来自网络整理。

以下是实现的测试代码，仅实现通道间归一化，包括C++和tensorflow：

tensorflow的实现如下：

import tensorflow as tf
    import numpy as np
    x = np.array([i for i in range(1, 33)]).reshape([2, 2, 2, 4])
    y = tf.nn.lrn(input=x, depth_radius=2, bias=1, alpha=1, beta=0.75)
    print("input:\n", x)
    print("output:\n", y)

C++代码实现如下：

lrn.hpp:

#ifndef FBC_NN_LRN_HPP_
    #define FBC_NN_LRN_HPP_
    
    namespace ANN {
    
    enum class NormRegion {
    		ACROSS_CHANNEL = 0,
    		WITHIN_CHANNEL
    };
    
    template<typename T = float>
    class LRN {
    public:
    	LRN() = default;
    	LRN(unsigned int local_size, T alpha, T beta, T bias, NormRegion norm_region) :
    		local_size_(local_size), alpha_(alpha), beta_(beta), bias_(bias), norm_region_(norm_region) {}
    	int run(const T* input, int batch, int channel, int height, int width, T* output) const;
    
    private:
    	int across_channel(const T* input, int batch, int channel, int height, int width, T* output) const;
    	int within_channel(const T* input, int batch, int channel, int height, int width, T* output) const;
    
    	unsigned int local_size_ = 5; // n
    	T alpha_ = 1.;
    	T beta_ = 0.75;
    	T bias_ = 1.; // k
    	NormRegion norm_region_ = NormRegion::ACROSS_CHANNEL;
    };
    
    } // namespace ANN
    
    #endif // FBC_NN_LRN_HPP_

lrn.cpp:

#include "lrn.hpp"
    #include <algorithm>
    #include <cmath>
    
    namespace ANN {
    
    template<typename T>
    int LRN<T>::run(const T* input, int batch, int channel, int height, int width, T* output) const
    {
    	if (norm_region_ == NormRegion::ACROSS_CHANNEL)
    		return across_channel(input, batch, channel, height, width, output);
    	else
    		return within_channel(input, batch, channel, height, width, output);
    }
    
    template<typename T>
    int LRN<T>::across_channel(const T* input, int batch, int channel, int height, int width, T* output) const
    {
    	int size = channel * height * width;
    
    	for (int p = 0; p < batch; ++p) {
    		const T* in = input + size * p;
    		T* out = output + size * p;
    
    		// N = channel; n = local_size_; k = bias_
    		for (int i = 0; i < channel; ++i) {
    			for (int y = 0; y < height; ++y) {
    				for (int x = 0; x < width; ++x) {
    					T tmp = 0;
    					for (int j = std::max(0, static_cast<int>(i - local_size_ / 2)); j <= std::min(channel - 1, static_cast<int>(i + local_size_ / 2)); ++j) {
    						tmp += std::pow(in[j * height * width + width * y + x], 2);
    					}
    					out[i * height * width + width * y + x] = in[i * height * width + width * y + x] / std::pow(bias_ + alpha_ * tmp, beta_);
    				}
    			}
    		}
    	}
    
    	return 0;
    }
    
    template<typename T>
    int LRN<T>::within_channel(const T* input, int batch, int channel, int height, int width, T* output) const
    {
    	fprintf(stderr, "not implemented\n");
    	return -1;
    }
    
    template class LRN<float>;
    
    } // namespace ANN

test\_lrn.cpp:

int test_lrn()
    {
    	int batch = 2, channel = 4, height = 2, width = 2;
    	std::vector<float> input{ 1., 5., 9., 13., 2., 6., 10., 14., 3., 7., 11., 15., 4., 8., 12., 16.,
    			17., 21., 25., 29., 18., 22., 26., 30., 19., 23., 27., 31., 20., 24., 28., 32.};
    	CHECK(batch * channel * height * width == input.size());
    
    	std::unique_ptr<float[]> output(new float[input.size()]);
    	ANN::LRN<> lrn;
    	lrn.run(input.data(), batch, channel, height, width, output.get());
    
    	auto print = [height, width](const float* data, int length) {
    		int size = height * width;
    		for (int i = 0; i < length / size; ++i) {
    			const float* p = data + i * size;
    
    			for (int j = 0; j < size; ++j) {
    				fprintf(stdout, "  %f", p[j]);
    			}
    
    			fprintf(stdout, "\n");
    		}
    	};
    
    	fprintf(stdout, "input:\n"); print(input.data(), input.size());
    	fprintf(stdout, "output:\n"); print(output.get(), input.size());
    
    	return 0;
    }

执行结果如下图所示：由结果可知，C++实现与tensorflow一致

tensorflow执行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg_size_16_color_FFFFFF_t_70 1][]

C++执行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg_size_16_color_FFFFFF_t_70 2][]

GitHub：[https://github.com/fengbingchun/NN\_Test][https_github.com_fengbingchun_NN_Test]

[http_www.cs.toronto.edu_hinton_absps_imagenet.pdf]: http://www.cs.toronto.edu/~hinton/absps/imagenet.pdf
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg_size_16_color_FFFFFF_t_70]: /images/20221119/cf4c8ac0de09481597c32af802050e4a.png
[a_x_y_i]: https://private.codecogs.com/gif.latex?a_%7Bx%2Cy%7D%5E%7Bi%7D
[b_x_y_i]: https://private.codecogs.com/gif.latex?b_%7Bx%2Cy%7D%5E%7Bi%7D
[alpha]: https://private.codecogs.com/gif.latex?%5Calpha
[beta]: https://private.codecogs.com/gif.latex?%5Cbeta
[10_-4]: https://private.codecogs.com/gif.latex?10%5E%7B-4%7D
[http_caffe.berkeleyvision.org_tutorial_layers_lrn.html]: http://caffe.berkeleyvision.org/tutorial/layers/lrn.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2021010917042926.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210109170718930.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg==,size_16,color_FFFFFF,t_70
[https_github.com_fengbingchun_NN_Test]: https://github.com/fengbingchun/NN_Test