动手实现深度学习（9）：第四篇：optimization的实现

 

 

传送门： https://www.cnblogs.com/greentomlee/p/12314064.html

github: Leezhen2014: https://github.com/Leezhen2014/python_deep_learning

 

六 optimization的实现

神经网络的学习目的是找到使得损失函数的值尽可能小的参数，这个寻找最优参数的过程称为最优化（optimization）。本章会介绍4中优化函数，给出实现代码和测例。

测例方面，首先会用函数做测试，观察是否可以逼近极小值；然后会用mnist数据集做测试观察是否能够收敛。

所测试的函数公式如下：

 

6.1 随机梯度下降（stochastic gradient descent, SGD）的实现

在前几篇两篇中一直使用同一种的方法修改权重。这种方法为了寻找最优参数，将参数的梯度（导数）作为依据，根据参数的梯度，就知道梯度的方向，并沿着梯度的方向更新参数。通过不断的更新迭代上述步骤，从而逐渐接近最优参数。这个过程称为随机梯度下降（stochastic gradient descent, SGD），前面几篇的训练中一直使用的是SGD。SGD的数学表达式如下：

虽然实现简单，也能得到优化参数。但是SGD有很多缺点, 比较明显的一个就是梯度的方向并没有指向最小值的方向,有可能得到的最优解是局部最优解。

因此我们还应该实现其他的优化参数的方法。 不过在此之前，需要对程序做修改，之前代码的耦合性很高，先把SGD独立抽出来，写成一个class,代码如下。

class SGD:

    """梯度下降（Stochastic Gradient Descent）"""

    def __init__(self, lr=0.01):
        self.lr = lr

    def update(self, params, grads):
        for key in params.keys():
            params[key] -= self.lr * grads[key]

 

PS: 2/3里面均是采用SGD寻找最优参数，我们也可以从代码中找到，优化代码结构。

在第3篇的mnist数据集训练手写体：

def gradient(self, x, t):
    # forward
    dout=self.loss(x, t)

    # backward
    # dout = 1
    dout = self.lastLayer.backward(dout)

    layers = list(self.layers.values())
    layers.reverse()
    for layer in layers:
        dout = layer.backward(dout)

    # 更新
    grads = {}
    grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
    grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

    return grads

 

第二篇里的2.4节，mnist数据集训练手写体：

 

def gradient(self, x, t):
    W1, W2 = self.params['W1'], self.params['W2']
    b1, b2 = self.params['b1'], self.params['b2']
    grads = {}

    batch_num = x.shape[0]

    # forward
    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, W2) + b2
    y = softmax(a2)

    # backward
    dy = (y - t) / batch_num
    grads['W2'] = np.dot(z1.T, dy)
    grads['b2'] = np.sum(dy, axis=0)

    dz1 = np.dot(dy, W2.T)
    da1 = sigmoid_grad(a1) * dz1
    grads['W1'] = np.dot(x.T, da1)
    grads['b1'] = np.sum(da1, axis=0)

    return grads

测试SGD:

与之前测试梯度的方法类似：给出一个函数公式，求它的梯度。但这次会将每次梯度下降的点绘制出来。

# coding: utf-8
import numpy as np

import matplotlib.pyplot as plt
from collections import OrderedDict
from src.common.optimizer import *


def f(x, y):
    return x**2 / 20.0 + y**2


def df(x, y):
    return x / 10.0, 2.0*y

init_pos = (-7.0, 2.0)
params = {}
params['x'], params['y'] = init_pos[0], init_pos[1]
grads = {}
grads['x'], grads['y'] = 0, 0


optimizer= SGD(lr=0.95)
# optimizer=Momentum(lr=0.1)
# optimizer=AdaGrad(lr=1.5)
# optimizer= Adam(lr=0.3)
# optimizer=RMSprop()



x_history = []
y_history = []
params['x'], params['y'] = init_pos[0], init_pos[1]

for i in range(30):
    x_history.append(params['x'])
    y_history.append(params['y'])

    grads['x'], grads['y'] = df(params['x'], params['y'])
    optimizer.update(params, grads)


x = np.arange(-10, 10, 0.01)
y = np.arange(-5, 5, 0.01)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

mask = Z > 7
Z[mask] = 0

plt.plot(x_history, y_history, 'o-', color="red")
plt.contour(X, Y, Z)
plt.ylim(-10, 10)
plt.xlim(-10, 10)
plt.plot(0, 0, '+')
    # colorbar()
    # spring()
plt.title("Momentum")
plt.xlabel("x")
plt.ylabel("y")

plt.show()

6.2 Momentum的实现

针对SGD的缺点，添加动量v，对应物理上的速度。这样公式类似于物理上的瞬时速度的公式，对应物理上的阻力。

是加速度，一般是常量0.9

class Momentum:

    """添加动量后的 SGD"""

    def __init__(self, lr=0.01, momentum=0.9):
        self.lr = lr
        self.momentum = momentum
        self.v = None

    def update(self, params, grads):
        if self.v is None:
            self.v = {}
            for key, val in params.items():
                self.v[key] = np.zeros_like(val)

        for key in params.keys():
            self.v[key] = self.momentum*self.v[key] - self.lr*grads[key]
            params[key] += self.v[key]

代码测试：

参考资料：

https://tensorflow.google.cn/api_docs/cc/class/tensorflow/ops/apply-momentum?hl=en

 

6.3 AdaGrad

AdaGrad又称为学习率衰减。在神经网络的训练过程中，学习率的设置很重要，如果学习设置过小，导致学习的时间很长；学习率过大导致不能收敛。

针对以上的这种情况，有人提出了learning rate decay的方法：可以让学习率一开始比较大，随着训练的次数增加，学习率不断减少。AdaGrad（Adaptive Grad）会对每个元素的学习率进行适当的调整。AdaGrad的数学表达式如下：

 

表示损失函数关于的梯度；

 

表示学习率

由于保存了以前所有梯度值的平方和，所以在更新参数的时候需要对除以才可以。这样一来，参数元素中变动较大的元素的学习率会降低。可以看做按照参数的元素进行学习率的衰减，使得变动较大的参数的学习率减小。

AdaGrad会记录所有梯度的平方和，然后在减去对应的梯度的权重，因此学习越深入，更新的幅度会越小。

class AdaGrad:

    """AdaGrad的实现"""

    def __init__(self, lr=0.01):
        self.lr = lr
        self.h = None

    def update(self, params, grads):
        if self.h is None:
            self.h = {}
            for key, val in params.items():
                self.h[key] = np.zeros_like(val)

        for key in params.keys():
            self.h[key] += grads[key] * grads[key] """求平方和，平方和中包含了每个元素 """
            params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)

测试代码：

参考资料：

https://tensorflow.google.cn/api_docs/python/tf/keras/optimizers/Adagrad?hl=en

https://tensorflow.google.cn/api_docs/cc/class/tensorflow/ops/apply-adagrad?hl=en

 

6.5 RMSProp的实现

从公式上看AdaGrad会迭代更新权重，这意味着会记录过去所有的平方和。可能会存在学习越深入更新的幅度会越小，甚至到最后几乎为0的情况。从上图可以看出确实出现了这种情况。

RMSProp可以改善这种情况。

RMSProp不是将过去的所有梯度都一视同仁的相加，而是逐渐的遗忘过去的梯度。

这里的代码实现就不给出了；， 具体可以从github上获取：

 

6.4 adam的实现

这里给出一个博客园大佬对adam的介绍和说明， 我就没有必要再赘述了： https://www.cnblogs.com/yifdu25/p/8183587.html

 

Adam的思路是将adaGrad和momnentum结合在一起。论文中Adam会设置3个参数：学习率，一次动量系数,二次动量系数。

 

 

class Adam:

    """
    Adam (http://arxiv.org/abs/1412.6980v8)
    """

    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.iter = 0
        self.m = None
        self.v = None

    def update(self, params, grads):
        if self.m is None:
            self.m, self.v = {}, {}
            for key, val in params.items():
                self.m[key] = np.zeros_like(val)
                self.v[key] = np.zeros_like(val)

        self.iter += 1
        lr_t = self.lr * np.sqrt(1.0 - self.beta2**self.iter) / (1.0 - self.beta1**self.iter)

        for key in params.keys():
            #self.m[key] = self.beta1*self.m[key] + (1-self.beta1)*grads[key]
            #self.v[key] = self.beta2*self.v[key] + (1-self.beta2)*(grads[key]**2)
            self.m[key] += (1 - self.beta1) * (grads[key] - self.m[key])
            self.v[key] += (1 - self.beta2) * (grads[key]**2 - self.v[key])

            params[key] -= lr_t * self.m[key] / (np.sqrt(self.v[key]) + 1e-7)

测试代码：

参考资料：

https://tensorflow.google.cn/api_docs/python/tf/keras/optimizers/Adam?hl=en

 

6.5 构造神经网络

 

# -*- coding: utf-8 -*-
# @File  : multi_layer.py
# @Author: lizhen
# @Date  : 2020/2/4
# @Desc  : 多层神经网络

import numpy as np
from collections import OrderedDict
from src.common.layers import Sigmoid,Relu,Affine,SoftmaxWithLoss
from src.common.gradient import numerical_gradient


class MultiLayerNet:

    def __init__(self, input_size, hidden_size_list, output_size,
                 activation='relu', weight_init_std='relu', weight_decay_lambda=0):
        '''
        全连接的神经网络
        :param input_size: 输入大小，784
        :param hidden_size_list: 隐含层的大小（e.g. [100, 100, 100]）
        :param output_size: 输出层的大小，10
        :param activation: 激活函数 'relu' or 'sigmoid'
        :param weight_init_std: 数据做标准化（e.g. 0.01）
        :param weight_decay_lambda: 权值衰减系数
        '''
        self.input_size = input_size
        self.output_size = output_size
        self.hidden_size_list = hidden_size_list
        self.hidden_layer_num = len(hidden_size_list)
        self.weight_decay_lambda = weight_decay_lambda
        self.params = {}

        # 初始化权重
        self.__init_weight(weight_init_std)

        # 激活层
        activation_layer = {'sigmoid': Sigmoid, 'relu': Relu}
        self.layers = OrderedDict()
        for idx in range(1, self.hidden_layer_num+1):
            self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)],
                                                      self.params['b' + str(idx)])
            self.layers['Activation_function' + str(idx)] = activation_layer[activation]()

        idx = self.hidden_layer_num + 1
        self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)],
            self.params['b' + str(idx)])

        self.last_layer = SoftmaxWithLoss()

    def __init_weight(self, weight_init_std):
        """
        初始化权重
        :param weight_init_std: 指定权重使用的标准差，{'relu','He','Sigmoid','xavier'}
        weight_init_std 可以使用的输入
        :return:
        """

        all_size_list = [self.input_size] + self.hidden_size_list + [self.output_size]
        for idx in range(1, len(all_size_list)):
            scale = weight_init_std
            if str(weight_init_std).lower() in ('relu', 'he'):# 使用relu的情况
                scale = np.sqrt(2.0 / all_size_list[idx - 1])
            elif str(weight_init_std).lower() in ('sigmoid', 'xavier'):
                scale = np.sqrt(1.0 / all_size_list[idx - 1])  # 使用sigmoid的情况

            self.params['W' + str(idx)] = scale * np.random.randn(all_size_list[idx-1], all_size_list[idx])
            self.params['b' + str(idx)] = np.zeros(all_size_list[idx])

    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)

        return x

    def loss(self, x, t):
        """
        损失函数
        :param x: 输入数据
        :param t: 标签数据
        :return: 损失值
        """

        y = self.predict(x)

        weight_decay = 0
        for idx in range(1, self.hidden_layer_num + 2):
            W = self.params['W' + str(idx)]
            weight_decay += 0.5 * self.weight_decay_lambda * np.sum(W ** 2)

        return self.last_layer.forward(y, t) + weight_decay

    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        if t.ndim != 1 : t = np.argmax(t, axis=1)

        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy

    def numerical_gradient(self, x, t):
        '''
        求数值微分
        :param x: 输入的数据
        :param t: 标签数据
        :return:  返回每一层的梯度
        '''

        loss_W = lambda W: self.loss(x, t)

        grads = {}
        for idx in range(1, self.hidden_layer_num+2):
            grads['W' + str(idx)] = numerical_gradient(loss_W, self.params['W' + str(idx)])
            grads['b' + str(idx)] = numerical_gradient(loss_W, self.params['b' + str(idx)])

        return grads

    def gradient(self, x, t):
        '''
        寻找每层的梯度
        :param x: 输入数据
        :param t: 标签
        :return:返回每层的梯度变量
        '''
        # forward
        self.loss(x, t)

        # backward
        dout = 1
        dout = self.last_layer.backward(dout)

        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)


        grads = {}
        for idx in range(1, self.hidden_layer_num+2):
            grads['W' + str(idx)] = self.layers['Affine' + str(idx)].dW + self.weight_decay_lambda * self.layers['Affine' + str(idx)].W
            grads['b' + str(idx)] = self.layers['Affine' + str(idx)].db

        return grads

 

6.6 opt的对比（基于mnist数据集）

P.S：这里面把RMSprop也放进来做参考了。

 

# coding: utf-8
#  opt的对比（基于mnist数据集）

import matplotlib.pyplot as plt
from src.datasets.mnist import load_mnist
from src.common.util import smooth_curve
from src.common.multi_layer_net import MultiLayerNet
from src.common.optimizer import *


# 0:MNIST数据集
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)

train_size = x_train.shape[0]
batch_size = 128
max_iterations = 2000


# 1:设置优化器
optimizers = {}
optimizers['SGD'] = SGD()
optimizers['Momentum'] = Momentum()
optimizers['AdaGrad'] = AdaGrad()
optimizers['Adam'] = Adam()
optimizers['RMSprop'] = RMSprop()

networks = {}
train_loss = {}
for key in optimizers.keys():
    networks[key] = MultiLayerNet(
        input_size=784, hidden_size_list=[100, 100, 100, 100],
        output_size=10)
    train_loss[key] = []


# 2:训练：
for i in range(max_iterations):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]

    for key in optimizers.keys():
        grads = networks[key].gradient(x_batch, t_batch)
        optimizers[key].update(networks[key].params, grads)

        loss = networks[key].loss(x_batch, t_batch)
        train_loss[key].append(loss)

    if i % 100 == 0:
        print( "===========" + "iteration:" + str(i) + "===========")
        for key in optimizers.keys():
            loss = networks[key].loss(x_batch, t_batch)
            print(key + ":" + str(loss))


# 3.绘图
markers = {"SGD": "o", "Momentum": "x", "AdaGrad": "s", "Adam": "D","RMSprop":"^"}
x = np.arange(max_iterations)
for key in optimizers.keys():
    plt.plot(x, smooth_curve(train_loss[key]), marker=markers[key], markevery=100, label=key)
plt.xlabel("iterations")
plt.ylabel("loss")
plt.ylim(0, 1)
plt.legend()
plt.show()

4.6 总结

在网上找到了一些资料：

https://www.cnblogs.com/itmorn/p/11123789.html#ct2