一、参数更新策略
1.SGD
也就是随机梯度下降，最简单的更新形式是沿着负梯度方向改变参数（因为梯度指向的是上升方向，但是我们通常希望最小化损失函数）。假设有一个参数向量x及其梯度dx，那么最简单的更新的形式是：
x += - learning_rate * dx
其中learning_rate是一个超参数，表示的是更新的幅度。这是一个重要的参数，lr过大可能会出现loss异常的情况，过小会使训练时间过长，后面也会介绍lr参数更新的一些trick。
2. Momentum
又被成为动量法，我觉得很多地方对这个方法并没有说清楚，我个人简单的理解是，在更新梯度的时候，我们要注意保留之前的梯度的信息，可以相信，一个梯度一直朝下减小的函数，一般不会遇到突然向左减小，所以加上动量以后，就可以处理这种情况，这个如果知道共轭点的话（不确定是不是这么叫的，也就是一个梯度下降的时候，向下一直减小，但是左右一直变化幅度很大的情况），就知道momentum的强大了。
def sgd_momentum(w, dw, config=None):
"""
Performs stochastic gradient descent with momentum.
config format:
- learning_rate: Scalar learning rate.
- momentum: Scalar between 0 and 1 giving the momentum value.
Setting momentum = 0 reduces to sgd.
- velocity: A numpy array of the same shape as w and dw used to store a moving
average of the gradients.
"""
if config is None: config = {}
config.setdefault(‘learning_rate‘, 1e-2)
config.setdefault(‘momentum‘, 0.9)
v = config.get(‘velocity‘, np.zeros_like(w))
next_w = None
v = config[‘momentum‘] * v - config[‘learning_rate‘] * dw
next_w = w + v
config[‘velocity‘] = v
return next_w, config
3.Nestero
这个是动量法的进阶版，既然我们要用之前梯度的信息，那么为什么不在更新当前梯度的时候，直接取最后的方向呢。
x_ahead = x + mu * v # 计算dx_ahead(在x_ahead处的梯度，而不是在x处的梯度) v = mu * v - learning_rate * dx_ahead x += v
在实际编程的时候，我们采用的是下面的方法，因为这样就可以和之前的代码统一起来了 ，因为一般来说我们只有dx：
v_prev = v # 存储备份 v = mu * v - learning_rate * dx # 速度更新保持不变 x += -mu * v_prev + (1 + mu) * v # 位置更新变了形式
为什么可以这样做？据说只要根据X_ahead=x+mu*v应该是可以换算的，但是我试了一下...没推出来.我怀疑只是实际使用的时候效果相似，不一定推出来，因为你不可能去计算dx_ahead的..
4.RMSProp and Adam
这两个是学习速率的更新策略
def rmsprop(x, dx, config=None):
"""
Uses the RMSProp update rule, which uses a moving average of squared gradient
values to set adaptive per-parameter learning rates.
config format:
- learning_rate: Scalar learning rate.
- decay_rate: Scalar between 0 and 1 giving the decay rate for the squared
gradient cache.
- epsilon: Small scalar used for smoothing to avoid dividing by zero.
- cache: Moving average of second moments of gradients.
"""
if config is None: config = {}
config.setdefault(‘learning_rate‘, 1e-2)
config.setdefault(‘decay_rate‘, 0.99)
config.setdefault(‘epsilon‘, 1e-8)
config.setdefault(‘cache‘, np.zeros_like(x))
next_x = None
cache = config[‘cache‘]
decay_rate = config[‘decay_rate‘]
learning_rate = config[‘learning_rate‘]
epsilon = config[‘epsilon‘]
cache = decay_rate * cache + (1 - decay_rate) * (dx**2) #用一种更为平滑的方式更新lr，注意到这里是累加的，因为越往后惩罚项越大，lr越小
x += - learning_rate * dx / (np.sqrt(cache) + epsilon)
config[‘cache‘] = cache
next_x = x
return next_x, config
def adam(x, dx, config=None):
"""
Uses the Adam update rule, which incorporates moving averages of both the
gradient and its square and a bias correction term.
config format:
- learning_rate: Scalar learning rate.
- beta1: Decay rate for moving average of first moment of gradient.
- beta2: Decay rate for moving average of second moment of gradient.
- epsilon: Small scalar used for smoothing to avoid dividing by zero.
- m: Moving average of gradient.
- v: Moving average of squared gradient.
- t: Iteration number.
"""
if config is None: config = {}
config.setdefault(‘learning_rate‘, 1e-3)
config.setdefault(‘beta1‘, 0.9)
config.setdefault(‘beta2‘, 0.999)
config.setdefault(‘epsilon‘, 1e-8)
config.setdefault(‘m‘, np.zeros_like(x))
config.setdefault(‘v‘, np.zeros_like(x))
config.setdefault(‘t‘, 0)
next_x = None
m = config[‘m‘]
v = config[‘v‘]
beta1 = config[‘beta1‘]
beta2 = config[‘beta2‘]
learning_rate = config[‘learning_rate‘]
epsilon = config[‘epsilon‘]
t = config[‘t‘]
t += 1
m = beta1 * m + (1 - beta1) * dx
v = beta2 * v + (1 - beta2) * (dx**2)
m_bias = m / (1 - beta1**t)
v_bias = v / (1 - beta2**t)
x += - learning_rate * m_bias / (np.sqrt(v_bias) + epsilon)
next_x = x
config[‘m‘] = m
config[‘v‘] = v
config[‘t‘] = t
return next_x, config
二、Batch Normalization
接下来要介绍两个在训练神经网络的时候，非常有用技巧，首先是batch normalization，简单的解释：在每次NN的输入的时候，我们都知道要进行数据预处理，一般是让数据是zero means和单位方差的，这样对于训练是有好处的，但当数据走过几层以后，就基本不可能还保持这个特性了，BN做的事情就是在每一层的开始，加上这个操作，但是有的数据可能会因此丢失了一些信息，所以再加上beta和gama来恢复原始数据，这里beta和gama是可学习的。
#BN参数的初始化
if self.use_batchnorm and i < len(hidden_dims):
self.params[‘gamma‘ + str(i+1)] = np.ones((1, layers_dims[i+1]))
self.params[‘beta‘ + str(i+1)] = np.zeros((1, layers_dims[i+1]))
BN的的关键是前向传播，后向传播以及实际使用的。
按照上面推导出来的公式，即可进行BN层的构建：
def batchnorm_forward(x, gamma, beta, bn_param):
mode = bn_param[‘mode‘] #因为train和test是两种不同的方法
eps = bn_param.get(‘eps‘, 1e-5)
momentum = bn_param.get(‘momentum‘, 0.9)
N, D = x.shape
running_mean = bn_param.get(‘running_mean‘, np.zeros(D, dtype=x.dtype))
running_var = bn_param.get(‘running_var‘, np.zeros(D, dtype=x.dtype))
out, cache = None, None
if mode == ‘train‘:
sample_mean = np.mean(x, axis=0, keepdims=True) # [1,D]
sample_var = np.var(x, axis=0, keepdims=True) # [1,D]
x_normalized = (x - sample_mean) / np.sqrt(sample_var + eps) # [N,D]
out = gamma * x_normalized + beta
cache = (x_normalized, gamma, beta, sample_mean, sample_var, x, eps)
running_mean = momentum * running_mean + (1 - momentum) * sample_mean #通过moument得到最终的running_mean和running_var
running_var = momentum * running_var + (1 - momentum) * sample_var
elif mode == ‘test‘:
x_normalized = (x - running_mean) / np.sqrt(running_var + eps) #test的时候如何通过BN层
out = gamma * x_normalized + beta
else:
raise ValueError(‘Invalid forward batchnorm mode "%s"‘ % mode)
# Store the updated running means back into bn_param
bn_param[‘running_mean‘] = running_mean
bn_param[‘running_var‘] = running_var
return out, cache
def batchnorm_backward(dout, cache):
dx, dgamma, dbeta = None, None, None
x_normalized, gamma, beta, sample_mean, sample_var, x, eps = cache
N, D = x.shape
dx_normalized = dout * gamma # [N,D]
x_mu = x - sample_mean # [N,D]
sample_std_inv = 1.0 / np.sqrt(sample_var + eps) # [1,D]
dsample_var = -0.5 * np.sum(dx_normalized * x_mu, axis=0, keepdims=True) * sample_std_inv**3
dsample_mean = -1.0 * np.sum(dx_normalized * sample_std_inv, axis=0, keepdims=True) - \
2.0 * dsample_var * np.mean(x_mu, axis=0, keepdims=True)
dx1 = dx_normalized * sample_std_inv
dx2 = 2.0/N * dsample_var * x_mu
dx = dx1 + dx2 + 1.0/N * dsample_mean
dgamma = np.sum(dout * x_normalized, axis=0, keepdims=True)
dbeta = np.sum(dout, axis=0, keepdims=True)
return dx, dgamma, dbeta
Batch Normalization解决的一个重要问题就是梯度饱和，配合Relu可以说基本解决了梯度饱和的问题。
三、Dropout
dropout是非常好理解的，就是在训练的时候以一定的概率来去每层的神经元，如下图所示：
个人理解：每次训练进行deoptout的操作，可以防止过拟合，为什么呢，因为每次训练的模型都长的不一样，但是他们的参数实际上是共享的，可以简单的理解为是个bagging的操作，众所周知..bagging在machine learning中是防止过拟合的神器，每次限制神经元的数量也防止过大的神经网络对数据集的过拟合。
还可以理解为dropout是一个正则化的操作，他在每次训练的时候，强行让一些feature为0，这样提高了网络的稀疏表达能力
def dropout_forward(x, dropout_param):
p, mode = dropout_param[‘p‘], dropout_param[‘mode‘]
if ‘seed‘ in dropout_param:
np.random.seed(dropout_param[‘seed‘])
mask = None
out = None
if mode == ‘train‘:
mask = (np.random.rand(*x.shape) < p) / p #注意这里除以了一个P，这样在test的输出的时候，维持原样即可
out = x * mask
elif mode == ‘test‘:
out = x
cache = (dropout_param, mask)
out = out.astype(x.dtype, copy=False)
return out, cache
def dropout_backward(dout, cache):
dropout_param, mask = cache
mode = dropout_param[‘mode‘]
dx = None
if mode == ‘train‘:
dx = dout * mask
elif mode == ‘test‘:
dx = dout
return dx
四、总结
总的来说，很多trick都是在train model的时候很有用，不过向BN已经逐渐要被替代和取消了，所以说明实时的follow最新的会议是多么的重要......然后，一些推导之后还是要在自己做一做，预备在后面复习cs231n的讲义的时候做一遍推导。
时间： 2024-11-08 06:44:45