笔记2深度学习梯度和梯度法

妖狐艹你老母 2022-11-01 05:29 198阅读 0赞

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

## 函数实现 ##

对于一个函数f(x0,x1)=x0的平方+x1的平方  
**偏导数可以这样实现：**

def function_2(x):
     return x[0]**2 + x[1]**2
     #或者return np.sum(x**2)+

**梯度可以这样实现:**

def _numerical_gradient_no_batch(f, x):
        h = 1e-4 # 0.0001
        grad = np.zeros_like(x)
        
        for idx in range(x.size):
            tmp_val = x[idx]
            x[idx] = float(tmp_val) + h
            fxh1 = f(x) # f(x+h)
            
            x[idx] = tmp_val - h 
            fxh2 = f(x) # f(x-h)
            grad[idx] = (fxh1 - fxh2) / (2*h)
            
            x[idx] = tmp_val # 还原值
            
        return grad

def numerical\_gradient(f, X):参数f为函数，x为NumPy数组，该函数对NumPy数组X的各个元素求数值微分  
现在用它来求（3，4）处的梯度:

numerical_gradient(function_2,np.array([3.0,4.0])

梯度指示的方向是各点处函数值减小最多的方向。

## 梯度法 ##

机器学习主要任务是在学习时寻找最优参数，神经网也必须在学习时找到最优参数（权重和偏置）这里的最优参数是损失函数取最小值时的函数，通过巧妙地使用梯度来寻找函数最小值的方法就是梯度法。  
函数的极小值最小值以及被称为鞍点的地方梯度为0.  
通过不断沿着梯度方向前进，逐渐减小函数值过程就是梯度法，寻找最小值的梯度法称为梯度下降法，寻找最大值的梯度法称为梯度上升法。一般，神经网络（深度学习)中，梯度法主要是梯度下降法。

### python实现梯度下降法： ###

import numpy as np
    import matplotlib.pylab as plt
    
    
    def _numerical_gradient_no_batch(f, x):
        h = 1e-4  # 0.0001
        grad = np.zeros_like(x)
    
        for idx in range(x.size):
            tmp_val = x[idx]
            x[idx] = float(tmp_val) + h
            fxh1 = f(x)  # f(x+h)
    
            x[idx] = tmp_val - h
            fxh2 = f(x)  # f(x-h)
            grad[idx] = (fxh1 - fxh2) / (2 * h)
    
            x[idx] = tmp_val  # 还原值
    
        return grad
    
    
    def numerical_gradient(f, X):
        if X.ndim == 1: #ndim返回的是数组的维度，返回的只有一个数，该数即表示数组的维度。
            return _numerical_gradient_no_batch(f, X)
        else:
            grad = np.zeros_like(X)
    
            for idx, x in enumerate(X):
                grad[idx] = _numerical_gradient_no_batch(f, x)
    
            return grad
    
    
    def gradient_descent(f, init_x, lr=0.01, step_num=100):
        x = init_x
        x_history = []
    
        for i in range(step_num):
            x_history.append( x.copy() )
    
            grad = numerical_gradient(f, x)
            x -= lr * grad
    
        return x, np.array(x_history)
    
    
    def function_2(x):
        return x[0]**2 + x[1]**2
    
    init_x = np.array([-3.0, 4.0])
    
    lr = 0.1
    step_num = 20
    x, x_history = gradient_descent(function_2, init_x, lr=lr, step_num=step_num)
    
    plt.plot( [-5, 5], [0,0], '--b')
    plt.plot( [0,0], [-5, 5], '--b')
    plt.plot(x_history[:,0], x_history[:,1], 'o')
    
    plt.xlim(-3.5, 3.5)
    plt.ylim(-4.5, 4.5)
    plt.xlabel("X0")
    plt.ylabel("X1")
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70]  
init\_x = np.array(\[-3.0, 4.0\]) ：设置初始值为(-3,4) 最终寻找的结果很接近0  
def gradient\_descent(f, init\_x, lr=0.01, step\_num=100):  
第二个参数是初始值，第三个参数是学习率，第四个是梯度法的重复次数，使用这个函数求函数的极小值，顺利的话还可以求最小值  
其中lr过小或者过大都会无法得到好的结果  
当lr为10：  
lr![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 1]  
当lr为1e-8:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 2]  
像学习率这样的参数成为**超参数**。相对于神经网络的权重参数是通过训练数据和学习算法自动获得的，学习率这样的超参数则是\*\*人工设定的，\*\*一般超参数需要尝试多个值，以便找到一种可以使学习顺利进行的设定。

## 神经网络的梯度 ##

这里的梯度是指损失函数关于权重参数的梯度.  
神经网络的学习的实现使用的是前面介绍过的mini-batch学习，即从训练数据中随机选择一部分数据（称为mini-batch），再以这些mini-batch为对象，使用梯度法更新参数的过程  
common.functions.py:

import numpy as np
    
    
    def identity_function(x):
        return x
    
    
    def step_function(x):
        return np.array(x > 0, dtype=np.int)
    
    
    def sigmoid(x):
        return 1 / (1 + np.exp(-x))    
    
    
    def sigmoid_grad(x):
        return (1.0 - sigmoid(x)) * sigmoid(x)
        
    
    def relu(x):
        return np.maximum(0, x)
    
    
    def relu_grad(x):
        grad = np.zeros(x)
        grad[x>=0] = 1
        return grad
        
    
    def softmax(x):
        if x.ndim == 2:
            x = x.T
            x = x - np.max(x, axis=0)
            y = np.exp(x) / np.sum(np.exp(x), axis=0)
            return y.T 
    
        x = x - np.max(x) # 溢出对策
        return np.exp(x) / np.sum(np.exp(x))
    
    
    def mean_squared_error(y, t):
        return 0.5 * np.sum((y-t)**2)
    
    
    def cross_entropy_error(y, t):
        if y.ndim == 1:
            t = t.reshape(1, t.size)
            y = y.reshape(1, y.size)
            
        # 监督数据是one-hot-vector的情况下，转换为正确解标签的索引
        if t.size == y.size:
            t = t.argmax(axis=1)
                 
        batch_size = y.shape[0]
        return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size
    
    
    def softmax_loss(X, t):
        y = softmax(X)
        return cross_entropy_error(y, t)

common.gradient.py:

import numpy as np
    
    def _numerical_gradient_1d(f, x):
        h = 1e-4 # 0.0001
        grad = np.zeros_like(x)
        
        for idx in range(x.size):
            tmp_val = x[idx]
            x[idx] = float(tmp_val) + h
            fxh1 = f(x) # f(x+h)
            
            x[idx] = tmp_val - h 
            fxh2 = f(x) # f(x-h)
            grad[idx] = (fxh1 - fxh2) / (2*h)
            
            x[idx] = tmp_val # 还原值
            
        return grad
    
    
    def numerical_gradient_2d(f, X):
        if X.ndim == 1:
            return _numerical_gradient_1d(f, X)
        else:
            grad = np.zeros_like(X)
            
            for idx, x in enumerate(X):
                grad[idx] = _numerical_gradient_1d(f, x)
            
            return grad
    
    
    def numerical_gradient(f, x):
        h = 1e-4 # 0.0001
        grad = np.zeros_like(x)
        
        it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
        while not it.finished:
            idx = it.multi_index
            tmp_val = x[idx]
            x[idx] = float(tmp_val) + h
            fxh1 = f(x) # f(x+h)
            
            x[idx] = tmp_val - h 
            fxh2 = f(x) # f(x-h)
            grad[idx] = (fxh1 - fxh2) / (2*h)
            
            x[idx] = tmp_val # 还原值
            it.iternext()   
            
        return grad

enumerate函数:

> > > list(enumerate(seasons))  
> > > \[(0, ‘Spring’), (1, ‘Summer’), (2, ‘Fall’), (3, ‘Winter’)\]

实现一个二层神经网络的类:

from common.functions import *
    from common.gradient import numerical_gradient
    
    
    class TwoLayerNet:
    
        def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
            # 初始化权重 
            self.params = { }
            self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
            self.params['b1'] = np.zeros(hidden_size)
            self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
            self.params['b2'] = np.zeros(output_size)
    
        def predict(self, x): #进行识别（推理） 参数X是图像数据
            W1, W2 = self.params['W1'], self.params['W2']
            b1, b2 = self.params['b1'], self.params['b2']
        
            a1 = np.dot(x, W1) + b1
            z1 = sigmoid(a1)
            a2 = np.dot(z1, W2) + b2
            y = softmax(a2)
            
            return y
            
        # x:输入数据, t:监督数据
        def loss(self, x, t): #计算损失函数的值x是图像数据，t是正确解标签
            y = self.predict(x)
            
            return cross_entropy_error(y, t)
        
        def accuracy(self, x, t): #计算识别精度
            y = self.predict(x)
            y = np.argmax(y, axis=1)
            t = np.argmax(t, axis=1)
            
            accuracy = np.sum(y == t) / float(x.shape[0])
            return accuracy
            
        # x:输入数据, t:监督数据
        def numerical_gradient(self, x, t): #计算权重参数的梯度
            loss_W = lambda W: self.loss(x, t)
            
            grads = { }
            grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
            grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
            grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
            grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
            
            return grads
            
        def gradient(self, x, t):#计算权重参数的梯度 numerical_gradient的高速版 
            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)
            
            da1 = np.dot(dy, W2.T)
            dz1 = sigmoid_grad(a1) * da1
            grads['W1'] = np.dot(x.T, dz1)
            grads['b1'] = np.sum(dz1, axis=0)
    
            return grads

params\[‘W1’\]:第一层的权重  
params\[‘b1’\] 第一层的偏置  
grads ：保存梯度的字典型变量（numerical\_gradient的返回值）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70]: /images/20221024/2d51a232c62a408bbb1d99b1a87b81fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 1]: /images/20221024/32d0493a215849e0ae1a06182054d61e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 2]: /images/20221024/c02e2693f4f74dd8bc80850950cef2c3.png