批量归一化（BN：Batch Normalization：解决在训练过程中，中间层数据分布发生改变的问题，以防止梯度消失或爆炸、加快训练速度）
1、为什么输入数据需要归一化（Normalized Data）？
归一化后有什么好处呢？原因在于神经网络学习过程本质就是为了学习数据分布，一旦训练数据与测试数据的分布不同，那么网络的泛化能力也大大降低；另外一方面，一旦每批训练数据的分布各不相同(batch 梯度下降)，那么网络就要在每次迭代都去学习适应不同的分布，这样将会大大降低网络的训练速度，这也正是为什么我们需要对数据都要做一个归一化预处理的原因。
对于深度网络的训练是一个复杂的过程，只要网络的前面几层发生微小的改变，那么后面几层就会被累积放大下去。一旦网络某一层的输入数据的分布发生改变，那么这一层网络就需要去适应学习这个新的数据分布，所以如果训练过程中，训练数据的分布一直在发生变化，那么将会影响网络的训练速度。
2、BN训练
1）随机梯度下降法（SGD）对于训练深度网络简单高效，但是它有个毛病，就是需要我们人为的去选择参数，比如学习率、参数初始化、权重衰减系数、Drop out比例等。这些参数的选择对训练结果至关重要，以至于我们很多时间都浪费在这些的调参上。那么使用BN之后，你可以不需要那么刻意的慢慢调整参数。
2）神经网络一旦训练起来，那么参数就要发生更新，除了输入层的数据外(因为输入层数据，我们已经人为的为每个样本归一化)，后面网络每一层的输入数据分布是一直在发生变化的，因为在训练的时候，前面层训练参数的更新将导致后面层输入数据分布的变化。以网络第二层为例：网络的第二层输入，是由第一层的参数和input计算得到的，而第一层的参数在整个训练过程中一直在变化，因此必然会引起后面每一层输入数据分布的改变。我们把网络中间层在训练过程中，数据分布的改变称之为：“Internal Covariate Shift”。文章所提出的算法，就是要解决在训练过程中，中间层数据分布发生改变的情况，于是就有了Batch Normalization，这个算法的诞生。
3）BN的地位：与激活函数层、卷积层、全连接层、池化层一样，BN(Batch Normalization)也属于网络的一层。
4）BN的本质原理：在网络的每一层输入的时候，又插入了一个归一化层，也就是先做一个归一化处理（归一化至：均值0、方差为1），然后再进入网络的下一层。不过文献归一化层，可不像我们想象的那么简单，它是一个可学习、有参数（γ、β）的网络层。
3、BN的作用
1）改善流经网络的梯度
2）允许更大的学习率，大幅提高训练速度：
你可以选择比较大的初始学习率，让你的训练速度飙涨。以前还需要慢慢调整学习率，甚至在网络训练到一半的时候，还需要想着学习率进一步调小的比例选择多少比较合适，现在我们可以采用初始很大的学习率，然后学习率的衰减速度也很大，因为这个算法收敛很快。当然这个算法即使你选择了较小的学习率，也比以前的收敛速度快，因为它具有快速训练收敛的特性；
3）减少对初始化的强烈依赖
4）改善正则化策略：作为正则化的一种形式，轻微减少了对dropout的需求
你再也不用去理会过拟合中drop out、L2正则项参数的选择问题，采用BN算法后，你可以移除这两项了参数，或者可以选择更小的L2正则约束参数了，因为BN具有提高网络泛化能力的特性；
5）再也不需要使用使用局部响应归一化层了（局部响应归一化是Alexnet网络用到的方法，搞视觉的估计比较熟悉），因为BN本身就是一个归一化网络层；
6）可以把训练数据彻底打乱（防止每批训练的时候，某一个样本都经常被挑选到，文献说这个可以提高1%的精度）。
注：以上为学习过程，在测试时，均值和方差(mean/std)不基于小批量进行计算， 可取训练过程中的激活值的均值。
对于一个小白，从了解Batch Normalization（后面简称BN）到正确使用BN,可谓路漫漫兮。在此做一个记录。
网上搜索关于BN最多的就是原理推导，相关论文出处。
例如：
https://www.jianshu.com/p/0312e04e4e83
但是这个并不能帮助我们实际的使用，对于需要迅速用起来的伙伴帮助不大。我们工程师相信的是先用起来，再去研究原理！呵呵！
有一些文章介绍的BN层的实现，也有代码示例，但能顺利跑起来的寥寥。因为使用BN不像卷积层那样，写个层的实现就可以了。由于BN层会包含两个可训练参数以及两个不可训练参数，所以涉及到在train代码中如何保存的关键问题，以及在inference代码中如何加载的问题。有相关博客介绍到这一步了，很有帮助。
本以为别人都说这么明白了，抄一抄不是很容易的事情吗。可以上的代码是不能让你正确完成BN功能的。也不知是抄错了，还是别人漏掉了一些关键环节。总之你的moving_mean/moving_variance好像就是不太对。基本上中文网页很难在找到这个问题的解了。
现在你需要搜索的关键字可能要变成BN/参数保存/平均滑动等等了。还好tensorflow的github中有了线索：
https://github.com/tensorflow/tensorflow/issues/14809
https://github.com/tensorflow/tensorflow/issues/15250
可见有很多人确实无法正确使用BN功能，然而最有用的一个issues是：
https://github.com/tensorflow/tensorflow/issues/1122#issuecomment-280325584
在这里，我拼凑成了一个完整能用的BN功能代码，解决了我好久的痛苦，让我兴奋一下。
知识来源于网络，奉献给网络。不敢独享这一成果，再此分享给大家。
-----------------------------------------------------------------华丽的分割线----------------------------------------------------------------------------
整个BN功能的实现需要分三个部分：1.BN层实现；2.训练时更新和完成后保存；3.预测时加载。
1.BN层实现：
如果你接触了一段时间后，这里你至少应该知道BN的三种实现方式了，但是我只成功了其中的一种，希望其他朋友能够补充完善。
def bn_layer(x, scope, is_training, epsilon=0.001, decay=0.99, reuse=None):
"""
Performs a batch normalization layer
Args:
x: input tensor
scope: scope name
is_training: python boolean value
epsilon: the variance epsilon - a small float number to avoid dividing by 0
decay: the moving average decay
Returns:
The ops of a batch normalization layer
"""
with tf.variable_scope(scope, reuse=reuse):
shape = x.get_shape().as_list()
# gamma: a trainable scale factor
gamma = tf.get_variable(scope+"_gamma", shape[-1], initializer=tf.constant_initializer(1.0), trainable=True)
# beta: a trainable shift value
beta = tf.get_variable(scope+"_beta", shape[-1], initializer=tf.constant_initializer(0.0), trainable=True)
moving_avg = tf.get_variable(scope+"_moving_mean", shape[-1], initializer=tf.constant_initializer(0.0), trainable=False)
moving_var = tf.get_variable(scope+"_moving_variance", shape[-1], initializer=tf.constant_initializer(1.0), trainable=False)
if is_training:
# tf.nn.moments == Calculate the mean and the variance of the tensor x
avg, var = tf.nn.moments(x, np.arange(len(shape)-1), keep_dims=True)
avg=tf.reshape(avg, [avg.shape.as_list()[-1]])
var=tf.reshape(var, [var.shape.as_list()[-1]])
#update_moving_avg = moving_averages.assign_moving_average(moving_avg, avg, decay)
update_moving_avg=tf.assign(moving_avg, moving_avg*decay+avg*(1-decay))
#update_moving_var = moving_averages.assign_moving_average(moving_var, var, decay)
update_moving_var=tf.assign(moving_var, moving_var*decay+var*(1-decay))
control_inputs = [update_moving_avg, update_moving_var]
else:
avg = moving_avg
var = moving_var
control_inputs = []
with tf.control_dependencies(control_inputs):
output = tf.nn.batch_normalization(x, avg, var, offset=beta, scale=gamma, variance_epsilon=epsilon)
return output
def bn_layer_top(x, scope, is_training, epsilon=0.001, decay=0.99):
"""
Returns a batch normalization layer that automatically switch between train and test phases based on the
tensor is_training
Args:
x: input tensor
scope: scope name
is_training: boolean tensor or variable
epsilon: epsilon parameter - see batch_norm_layer
decay: epsilon parameter - see batch_norm_layer
Returns:
The correct batch normalization layer based on the value of is_training
"""
#assert isinstance(is_training, (ops.Tensor, variables.Variable)) and is_training.dtype == tf.bool
return tf.cond(
is_training,
lambda: bn_layer(x=x, scope=scope, epsilon=epsilon, decay=decay, is_training=True, reuse=None),
lambda: bn_layer(x=x, scope=scope, epsilon=epsilon, decay=decay, is_training=False, reuse=True),
)
这里的参数epsilon=0.001, decay=0.99可以自行调整。
2.训练时更新和完成后保存：
在训练的代码中增加如下代码:
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train = tf.train.AdamOptimizer(learning_rate=lr).minimize(cost)
这个是用于更新参数的。
var_list = tf.trainable_variables()
g_list = tf.global_variables()
bn_moving_vars = [gfor gin g_listif 'moving_mean' in g.name]
bn_moving_vars += [gfor gin g_listif 'moving_variance' in g.name]
var_list += bn_moving_vars
train_saver = tf.train.Saver(var_list=var_list)
这个是用于保存bn不可训练的参数。
3.预测时加载：
# get moving avg
var_list = tf.trainable_variables()
g_list = tf.global_variables()
bn_moving_vars = [gfor gin g_listif 'moving_mean' in g.name]
bn_moving_vars += [gfor gin g_listif 'moving_variance' in g.name]
var_list += bn_moving_vars
saver = tf.train.Saver(var_list=var_list)
ckpt_path =""
saver.restore(sess, ckpt_path)
这样就可以找到checkpoint中的参数了。
在tensorflow框架下添加正则化约束l1、l2的方法
tf.contrib.layers.l1_regularizer(scale, scope=None)
返回一个用来执行L1正则化的函数,函数的签名是func(weights).
参数:
- scale: 正则项的系数.
- scope: 可选的
scope name
tf.contrib.layers.l2_regularizer(scale, scope=None)
先看看tf.contrib.layers.l2_regularizer(weight_decay)都执行了什么：
import tensorflow as tf
sess=tf.Session()
weight_decay=0.1
tmp=tf.constant([0,1,2,3],dtype=tf.float32)
"""
l2_reg=tf.contrib.layers.l2_regularizer(weight_decay)
a=tf.get_variable("I_am_a",regularizer=l2_reg,initializer=tmp)
"""
#**上面代码的等价代码
a=tf.get_variable("I_am_a",initializer=tmp)
a2=tf.reduce_sum(a*a)*weight_decay/2;
a3=tf.get_variable(a.name.split(":")[0]+"/Regularizer/l2_regularizer",initializer=a2)
tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES,a2)
#**
sess.run(tf.global_variables_initializer())
keys = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
for key in keys:
print("%s : %s" %(key.name,sess.run(key)))
我们很容易可以模拟出tf.contrib.layers.l2_regularizer都做了什么，不过会让代码变丑。
以下比较完整实现L2 正则化。
import tensorflow as tf
sess=tf.Session()
weight_decay=0.1 #(1)定义weight_decay
l2_reg=tf.contrib.layers.l2_regularizer(weight_decay) #(2)定义l2_regularizer()
tmp=tf.constant([0,1,2,3],dtype=tf.float32)
a=tf.get_variable("I_am_a",regularizer=l2_reg,initializer=tmp) #(3)创建variable，l2_regularizer复制给regularizer参数。
#目测REXXX_LOSSES集合
#regularizer定义会将a加入REGULARIZATION_LOSSES集合
print("Global Set:")
keys = tf.get_collection("variables")
for key in keys:
print(key.name)
print("Regular Set:")
keys = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
for key in keys:
print(key.name)
print("--------------------")
sess.run(tf.global_variables_initializer())
print(sess.run(a))
reg_set=tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) #(4)则REGULARIAZTION_LOSSES集合会包含所有被weight_decay后的参数和，将其相加
l2_loss=tf.add_n(reg_set)
print("loss=%s" %(sess.run(l2_loss)))
"""
此处输出0.7,即:
weight_decay*sigmal(w*2)/2=0.1*(0*0+1*1+2*2+3*3)/2=0.7
其实代码自己写也很方便，用API看着比较正规。
在网络模型中，直接将l2_loss加入loss就好了。(loss变大，执行train自然会decay)
"""
回到顶部
二、添加正则化方法
a、原始办法
正则化常用到集合，下面是最原始的添加正则办法（直接在变量声明后将之添加进'losses'集合或tf.GraphKeys.LOESSES也行）：
import tensorflow as tf
import numpy as np
def get_weights(shape, lambd):
var = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(lambd)(var))
return var
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
batch_size = 8
layer_dimension = [2, 10, 10, 10, 1]
n_layers = len(layer_dimension)
cur_lay = x
in_dimension = layer_dimension[0]
for i in range(1, n_layers):
out_dimension = layer_dimension[i]
weights = get_weights([in_dimension, out_dimension], 0.001)
bias = tf.Variable(tf.constant(0.1, shape=[out_dimension]))
cur_lay = tf.nn.relu(tf.matmul(cur_lay, weights)+bias)
in_dimension = layer_dimension[i]
mess_loss = tf.reduce_mean(tf.square(y_-cur_lay))
tf.add_to_collection('losses', mess_loss)
loss = tf.add_n(tf.get_collection('losses'))
b、tf.contrib.layers.apply_regularization(regularizer, weights_list=None)
先看参数
- regularizer:就是我们上一步创建的正则化方法
- weights_list: 想要执行正则化方法的参数列表,如果为
None的话,就取GraphKeys.WEIGHTS中的weights.
函数返回一个标量Tensor,同时,这个标量Tensor也会保存到GraphKeys.REGULARIZATION_LOSSES中.这个Tensor保存了计算正则项损失的方法.
tensorflow中的Tensor是保存了计算这个值的路径(方法),当我们run的时候,tensorflow后端就通过路径计算出Tensor对应的值
现在,我们只需将这个正则项损失加到我们的损失函数上就可以了.
eg:
weight = tf.constant([[1.0, -2.0], [-3.0, 4.0]])
weight1 = tf.constant([[1.0, -2.0], [-3.0, 4.0]])
l2_reg=tf.contrib.layers.l2_regularizer(0.5)
with tf.Session() as sess:
# 输出为(|1|+|-2|+|-3|+|4|)*0.5=5
print(sess.run(tf.contrib.layers.apply_regularization(regularizer=l2_reg,weights_list=[weight,weight1])))
# 输出为(1²+(-2)²+(-3)²+4²)/2*0.5=7.5
# TensorFlow会将L2的正则化损失值除以2使得求导得到的结果更加简洁
print(sess.run(tf.contrib.layers.l2_regularizer(0.5)(weight)))
如果是自己手动定义
weight的话,需要手动将weight保存到GraphKeys.WEIGHTS中,但是如果使用layer的话,就不用这么麻烦了,别人已经帮你考虑好了.(最好自己验证一下tf.GraphKeys.WEIGHTS中是否包含了所有的weights,防止被坑)
c、使用slim
使用slim会简单很多：
with slim.arg_scope([slim.conv2d, slim.fully_connected],
activation_fn=tf.nn.relu,
weights_regularizer=slim.l2_regularizer(weight_decay)）：
pass
Python实现梯度下降法及算例分析以及可视化
代码和算例可以到博主github中下载：
https://github.com/Airuio/Implementing-the-method-of-gradient-descent-by-using-Python-
上一篇讲解了最原始的感知机算法，该算法的目的只为收敛，得到的往往不是基于样本的最佳解，梯度下降法以最小化损失函数为目标，得到的解比原始感知机算法一般更准确。
梯度下降法算法原理如下图所示：
基于以上原理来对权重系数和闵值进行更新即可得到最后的解。
原理实现可按如下代码操作：#实现梯度下降法：
import numpy as np
class AdalineGD(object):
def __init__(self,eta=0.01,n_iter=50): #定义超参数学习率和迭代次数
self.eta = eta
self.n_iter = n_iter
def fit(self,X,y): #定义权重系数w和损失函数cost
self.w_ = np.zeros(1+X.shape[1])
self.cost_ = []
for i in range(self.n_iter): #更新权重
output = self.net_input(X) #计算预测值
errors = (y - output) #统计误差
self.w_[1:] += self.eta*X.T.dot(errors)
self.w_[0] += self.eta * errors.sum()
cost = (errors**2).sum()/2.0 #损失函数
self.cost_.append(cost)
return self
def net_input(self,X):
return np.dot(X,self.w_[1:]) + self.w_[0]
def activation(self,X):
return self.net_input(X)
def predict(self, X):
return np.where(self.activation(X) >= 0.0, 1, -1)
以上算法即实现了梯度下降法更新权重参数。将该模块命名为Adaline_achieve，基于鸢尾花lirs数据集，我们进行算例的验证如下所示：
from Adaline_achieve import AdalineGD
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
df = pd.read_excel(io = 'lris.xlsx',header = None) #读取数据为Dataframe结构，没有表头行
y = df.iloc[0:100,4].values #取前100列数据，4列为标识
y = np.where(y == 'Iris-setosa', -1,1)
X = df.iloc[0:100,[0,2]].values #iloc为选取表格区域，此处取二维特征进行分类,values为返回不含索引的表
plt.scatter(X[:50,0],X[0:50,1],color = 'red',marker = 'o', label = 'setosa')
plt.scatter(X[50:100,0],X[50:100,1],color = 'blue',marker = 'x', label = 'versicolor')
plt.xlabel('petal lenth')
plt.ylabel('sepal lenth')
plt.legend(loc = 2) #画出标签以及标签的位置参数
plt.show() #出图
#以上六行与分类无关，仅仅是为了直观的感受两块数据的分布区域
fig,ax = plt.subplots(nrows = 1 , ncols = 2, figsize = (8,4))
'''
完成不同学习率下的分类的任务，进行结果展示
plt.subplots(nrows = 1 , ncols = 2, figsize = (8,4)中nrows表示几行图，ncols表示几列
figsize为图片大小。
'''
ada1 = AdalineGD(eta = 0.01,n_iter = 10).fit(X,y)
ax[0].plot(range(1,len(ada1.cost_) + 1), np.log10(ada1.cost_) , marker = 'o')
ax[0].set_xlabel('Epoches')
ax[0].set_ylabel('log(ada1.cost_)')
ax[0].set_title('Adaline - Learning rate 0.01')
ada2 = AdalineGD(eta = 0.0001,n_iter = 10).fit(X,y)
ax[1].plot(range(1,len(ada2.cost_) + 1), ada2.cost_ , marker = 'o')
ax[1].set_xlabel('Epoches')
ax[1].set_ylabel('ada1.cost_')
ax[1].set_title('Adaline - Learning rate 0.01')
plt.show()
'''
由以上得到的结果图可以看出，学习率过大会导致不收敛，过小会导致收敛速度慢
采用数据标准化、归一化的方法可以使得梯度下降法取得更好的效果
对同维度处的样本特征取均值和标准差，标准化后的值等于：
（原值-均值）/标准差，可以用numpy中的mean和std方法便捷的获得
'''
X_std = np.copy(X) #将样本特征归一化、标准化
X_std[:,0] = (X[:,0] - X[:,0].mean()) / X[:,0].std()
X_std[:,1] = (X[:,1] - X[:,1].mean()) / X[:,1].std()
ada = AdalineGD(eta = 0.01, n_iter = 15)
ada.fit(X_std,y)
def plot_decision_region(X,y,classifier,resolution = 0.02):
markers = ('s','x','o','~','v')
colors = ('red','blue','lightgreen','gray','cyan')
cmap = ListedColormap(colors[:len(np.unique(y))])
#画出界面
x1_min, x1max = X[:,0].min() - 1, X[:,0].max() + 1
x2_min, x2max = X[:,1].min() - 1, X[:,1].max() + 1
xx1,xx2 = np.meshgrid(np.arange(x1_min,x1max,resolution),
np.arange(x2_min,x2max,resolution)) #生成均匀网格点，
'''
meshgrid的作用是根据传入的两个一维数组参数生成两个数组元素的列表。如果第一个参数是xarray， 维度是xdimesion，第二个参数是yarray，维度是ydimesion。那么生成的第一个二维数组是以xarray为行，ydimesion行的向量；而第二个二维数组是以yarray的转置为列，xdimesion列的向量。
'''
Z = classifier.predict(X = np.array([xx1.ravel(),xx2.ravel()]).T)
Z = Z.reshape(xx1.shape)
#在全图上每一个点（间隔0.2）计算预测值，并返回1或-1
plt.contourf(xx1,xx2,Z,alpha = 0.5,cmap = cmap) #画出等高线并填充颜色
plt.xlim(xx1.min(),xx1.max())
plt.ylim(xx2.min(),xx2.max())
#画上分类后的样本
for idx,cl in enumerate(np.unique(y)):
plt.scatter(x=X[y==cl,0], y=X[y==cl,1],alpha=0.8,
c=cmap(idx),marker=markers[idx],label=cl)
plot_decision_region(X_std, y, classifier = ada) #展示分类结果
plt.xlabel('sepal lenth [nondimensional]')
plt.ylabel('petal lenth [nondimensional]')
plt.legend(loc = 2)
plt.show()
plt.plot(range(1,len(ada.cost_)+1),ada.cost_,marker = 'o') #展示损失函数误差收敛过程
plt.xlabel('Epoches')
plt.ylabel('ada1.cost_')
plt.show()
结果如下图所示：
标签：decay,调参,BN,var,l2,tf,moving From： https://blog.51cto.com/u_13206712/5928228