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

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.0001grad = np.zeros_like(x)for idx in range(x.size):tmp_val = x[idx]x[idx] = float(tmp_val) + hfxh1 = 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 pltdef _numerical_gradient_no_batch(f, x):h = 1e-4  # 0.0001grad = np.zeros_like(x)for idx in range(x.size):tmp_val = x[idx]x[idx] = float(tmp_val) + hfxh1 = f(x)  # f(x+h)x[idx] = tmp_val - hfxh2 = f(x)  # f(x-h)grad[idx] = (fxh1 - fxh2) / (2 * h)x[idx] = tmp_val  # 还原值return graddef 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 graddef gradient_descent(f, init_x, lr=0.01, step_num=100):x = init_xx_history = []for i in range(step_num):x_history.append( x.copy() )grad = numerical_gradient(f, x)x -= lr * gradreturn x, np.array(x_history)def function_2(x):return x[0]**2 + x[1]**2init_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()

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
当lr为1e-8:

像学习率这样的参数成为超参数。相对于神经网络的权重参数是通过训练数据和学习算法自动获得的，学习率这样的超参数则是**人工设定的，**一般超参数需要尝试多个值，以便找到一种可以使学习顺利进行的设定。

神经网络的梯度

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

import numpy as npdef identity_function(x):return xdef 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] = 1return graddef softmax(x):if x.ndim == 2:x = x.Tx = 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_sizedef softmax_loss(X, t):y = softmax(X)return cross_entropy_error(y, t)

common.gradient.py:

import numpy as npdef _numerical_gradient_1d(f, x):h = 1e-4 # 0.0001grad = np.zeros_like(x)for idx in range(x.size):tmp_val = x[idx]x[idx] = float(tmp_val) + hfxh1 = 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 graddef 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 graddef numerical_gradient(f, x):h = 1e-4 # 0.0001grad = np.zeros_like(x)it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])while not it.finished:idx = it.multi_indextmp_val = x[idx]x[idx] = float(tmp_val) + hfxh1 = 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_gradientclass 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) + b1z1 = sigmoid(a1)a2 = np.dot(z1, W2) + b2y = 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 gradsdef 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]# forwarda1 = np.dot(x, W1) + b1z1 = sigmoid(a1)a2 = np.dot(z1, W2) + b2y = softmax(a2)# backwarddy = (y - t) / batch_numgrads['W2'] = np.dot(z1.T, dy)grads['b2'] = np.sum(dy, axis=0)da1 = np.dot(dy, W2.T)dz1 = sigmoid_grad(a1) * da1grads['W1'] = np.dot(x.T, dz1)grads['b1'] = np.sum(dz1, axis=0)return grads

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