机器学习入门：偏导数、梯度概念与梯度下降法详解
机器学习入门：偏导数、梯度概念与梯度下降法详解
机器学习中的优化问题常常涉及到函数的最小化或最大化。梯度下降法是一种常用的优化算法，它通过计算梯度来寻找函数的最小值。本文将从偏导数和梯度的概念出发，详细介绍梯度下降法的原理和实现，并通过Python代码示例帮助读者理解这一重要概念。
1. 偏导数概念
对于一个具有多个变量的函数，求导数时需要明确是对哪个变量求导。例如，对于式（4.6）而言，它有两个变量(x_0)和(x_1)。在这种情况下，我们把对多个变量的函数求导数称为求偏导数。用数学式表示的话，可以写成：
[
\frac{\partial f}{\partial x_0} \quad \text{和} \quad \frac{\partial f}{\partial x_1}
]
分别表示对(x_0)和(x_1)的偏导数。
2. 梯度概念
当需要同时计算多个变量的偏导数时，可以将这些偏导数汇总成一个向量，这个向量被称为梯度（gradient）。例如，对于函数(f(x_0, x_1))，其梯度可以表示为：
[
\nabla f = \begin{bmatrix}
\frac{\partial f}{\partial x_0} \
\frac{\partial f}{\partial x_1}
\end{bmatrix}
]
下面是一个计算梯度的Python代码示例：
import numpy as np
def numerical_gradient(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 function(x):
return np.sum(x ** 2)
if __name__ == "__main__":
print(numerical_gradient(function, np.array([3.0, 4.0]))) # [6. 8.]
print(numerical_gradient(function, np.array([0.0, 2.0]))) # [0. 4.]
为了更直观地理解梯度，我们可以将其图形化显示：
import numpy as np
import matplotlib.pylab as plt
from mpl_toolkits.mplot3d import Axes3D
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:
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 function_2(x):
if x.ndim == 1:
return np.sum(x**2)
else:
return np.sum(x**2, axis=1)
def tangent_line(f, x):
d = numerical_gradient(f, x)
print(d)
y = f(x) - d*x
return lambda t: d*t + y
if __name__ == '__main__':
x0 = np.arange(-2, 2.5, 0.25)
x1 = np.arange(-2, 2.5, 0.25)
X, Y = np.meshgrid(x0, x1)
X = X.flatten()
Y = Y.flatten()
grad = numerical_gradient(function_2, np.array([X, Y]) )
plt.figure()
plt.quiver(X, Y, -grad[0], -grad[1], angles="xy",headwidth=5,scale=30,color="#666666")
plt.xlim([-2, 2])
plt.ylim([-2, 2])
plt.xlabel('x0')
plt.ylabel('x1')
plt.grid()
plt.legend()
plt.draw()
plt.show()
显示结果：
从图中可以看出，梯度指向函数(f(x_0, x_1))的“最低处”（最小值），就像指南针一样，所有的箭头都指向同一点。其次，我们发现离“最低处”越远，箭头越大。梯度会指向各点处的函数值降低的方向。更严格地讲，梯度指示的方向是各点处的函数值减小最多的方向。因此，无法保证梯度所指的方向就是函数的最小值或者真正应该前进的方向。实际上，在复杂的函数中，梯度指示的方向基本上都不是函数值最小处。
3. 梯度下降法
虽然梯度的方向并不一定指向最小值，但沿着它的方向能够最大限度地减小函数的值。因此，在寻找函数的最小值（或者尽可能小的值）的位置的任务中，要以梯度的信息为线索，决定前进的方向。
函数的取值从当前位置沿着梯度方向前进一定距离，然后在新的地方重新求梯度，再沿着新梯度方向前进，如此反复，不断地沿梯度方向前进。像这样，通过不断地沿梯度方向前进，逐渐减小函数值的过程就是梯度法（gradient method）。
梯度法是解决机器学习中最优化问题的常用方法，特别是在神经网络的学习中经常被使用。根据目的是寻找最小值还是最大值，梯度法的叫法有所不同。严格地讲，寻找最小值的梯度法称为梯度下降法（gradient descent method），寻找最大值的梯度法称为梯度上升法（gradient ascent method）。但是通过反转损失函数的符号，求最小值的问题和求最大值的问题会变成相同的问题，因此“下降”还是“上升”的差异本质上并不重要。
一般来说，神经网络（深度学习）中，梯度法主要是指梯度下降法。
用数学式来表示梯度下降法，如式（4.7）所示：
式（4.7）的(\eta)表示更新量，在神经网络的学习中，称为学习率（learning rate）。学习率决定在一次学习中，应该学习多少，以及在多大程度上更新参数。
式（4.7）是表示更新一次的式子，这个步骤会反复执行。也就是说，每一步都按式（4.7）更新变量的值，通过反复执行此步骤，逐渐减小函数值。
学习率需要事先确定为某个值，比如0.01 或0.001。一般而言，这个值过大或过小，都无法抵达一个“好的位置”。在神经网络的学习中，一般会一边改变学习率的值，一边确认学习是否正确进行了。
用代码实现梯度下降法：
import numpy as np
def numerical_gradient(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 function(x):
return np.sum(x ** 2)
def gradient_descent(f, init_x, lr=0.01, step_num=100):
x = init_x
for i in range(step_num):
grad = numerical_gradient(f, x)
x -= lr * grad
return x
if __name__ == "__main__":
init_x = np.array([-3.0, 4.0])
print(gradient_descent(function, init_x=init_x, lr=0.1, step_num=100))
输出结果：
[-6.11110793e-10 8.14814391e-10]
这里，设初始值为(-3.0, 4.0)，开始使用梯度法寻找最小值。最终的结果是(-6.1e-10, 8.1e-10)，非常接近(0，0)。实际上，真的最小值就是(0，0)，所以说通过梯度法我们基本得到了正确结果。
对于梯度下降函数：
def gradient_descent(f, init_x, lr=0.01, step_num=100):
- (f)是要进行最优化的函数；
- (init_x)是初始值，(lr)是学习率(learning rate)；
- (step_num)是梯度法的重复次数；
- (numerical_gradient(f,x))会求函数的梯度，用该梯度乘以学习率得到的值进行更新操作，由(step_num)指定重复的次数。
下图表示梯度更新的过程：
下面再来看看学习率过大或者过小的例子：
- 学习率过大 (lr=10.0)
init_x = np.array([-3.0, 4.0])
print(gradient_descent(function, init_x=init_x, lr=10.0, step_num=100))
输出结果是：
[-2.58983747e+13 -1.29524862e+12]
- 学习率过小 (lr=1e-10)
init_x = np.array([-3.0, 4.0])
print(gradient_descent(function, init_x=init_x, lr=1e-10, step_num=100))
输出结果：
[-2.99999994 3.99999992]
实验结果表明，学习率过大的话，会发散成一个很大的值；反过来，学习率过小的话，基本上没怎么更新就结束了。
也就是说，设定合适的学习率是一个很重要的问题。
像学习率这样的参数称为超参数。这是一种和神经网络的参数（权重和偏置）性质不同的参数。相对于神经网络的权重参数是通过训练数据和学习算法自动获得的，学习率这样的超参数则是人工设定的。一般来说，超参数需要尝试多个值，以便找到一种可以使学习顺利进行的设定。
参考：《深度学习入门：基于Python的理论与实现》