Gradient Decent 梯度下降算法
梯度下降算法原理
本文主要简略介绍梯度下降算法的原理。梯度下降就像在一个山谷中行走,不断迈出在当前位置下降最快的那一步,直到找到一个最低点也就是收敛点,当然这个点可能是局部最优解而非全局最优解。
平方误差代价函数
我们假设有一个共包含 m 个样本的训练集
{
x
i
,
y
i
}
,
i
=
1
,
2
,
.
.
.
,
m
\{x^i,y^i\},i=1,2,...,m
{xi,yi},i=1,2,...,m,x和y的关系如下图所示:
我们假设 h(x)是拟合出的关于x和y关系的曲线,如果y是连续的则为回归问题,如果y是离散的则为分类问题。 函数
h
(
x
)
h(x)
h(x)如下所示,其中
θ
\theta
θ为参数:
h
θ
(
x
)
=
θ
0
+
θ
1
×
x
+
.
.
.
h_\theta(x)=\theta_0+\theta_1\times x+...
hθ(x)=θ0+θ1×x+...
则平方误差代价函数为:
J
(
θ
0
,
θ
1
,
.
.
.
)
=
1
2
m
∑
i
=
1
m
(
h
θ
(
x
i
)
−
y
i
)
2
T
a
s
k
=
m
i
n
i
z
e
(
J
)
J(\theta_0,\theta_1,...)=\frac{1}{2m} \sum^m_{i=1}(h_\theta(x^i)-y^i)^2\\ Task=minize(J)
J(θ0,θ1,...)=2m1i=1∑m(hθ(xi)−yi)2Task=minize(J)
梯度下降算法所要做的就是将
J
(
θ
0
,
θ
1
,
.
.
.
)
J(\theta_0,\theta_1,...)
J(θ0,θ1,...)最小化,使假设函数
h
(
x
)
h(x)
h(x)尽可能拟合真实情况。
进行偏微分计算不断更新参数
在初始化了参数
θ
\theta
θ 之后,接下来进行偏微分计算不断 同步更新
θ
\theta
θ,此处要注意是同步更新,不能将更新了
θ
0
\theta_0
θ0 后的
J
J
J 代入对
θ
1
\theta_1
θ1 的更新计算中。假设学习速度(learning rate)为
α
\alpha
α,学习速度的大小选取要适当,过大容易错过收敛点,过小则需要迭代太多次,更新参数的过程如下:
t
e
m
p
j
=
θ
j
−
α
∂
∂
θ
j
J
(
θ
0
,
θ
1
,
.
.
.
)
θ
j
=
t
e
m
p
j
temp_j = \theta_j-\alpha\frac{\partial}{\partial \theta_j}J(\theta_0,\theta_1,...)\\ \theta_j=temp_j
tempj=θj−α∂θj∂J(θ0,θ1,...)θj=tempj
越接近局部最优解时,
∂
∂
θ
j
J
(
θ
0
,
θ
1
,
.
.
.
)
\frac{\partial}{\partial \theta_j}J(\theta_0,\theta_1,...)
∂θj∂J(θ0,θ1,...) 的值越小,不断重复这个更新参数的过程直至收敛,这时得到的
h
θ
(
x
)
h_\theta(x)
hθ(x) 即为拟合效果较好的函数。
梯度下降代码(Python)
本文代码主要参考了博客梯度下降算法原理讲解——机器学习,代码编写过程中,将所有的公式都转换为矩阵的形式,python中矩阵计算比较方便,同时也会使代码更简洁。
预测函数
h
(
x
)
h(x)
h(x) 转化为如下形式:
h
Θ
(
x
)
=
Θ
0
+
Θ
1
×
x
+
.
.
.
h_\Theta(x)=\Theta_0+\Theta_1\times x+...
hΘ(x)=Θ0+Θ1×x+...
假设
θ
\theta
θ 有两个,为了便于进行矩阵化,给每一个点x增加一维,这一维的值固定为1,这一维将会乘到
Θ
0
\Theta_0
Θ0上。则
x
0
i
x_0^i
x0i 与
Θ
0
\Theta_0
Θ0 相乘后仍为
Θ
0
\Theta_0
Θ0,
x
1
i
x_1^i
x1i 为原来的
x
i
x^i
xi。这样就方便我们统一矩阵化的计算:
(
x
1
i
,
y
i
)
−
>
(
x
0
i
,
x
1
i
,
y
i
)
h
Θ
(
x
)
=
Θ
×
X
(x_1^i,y^i)->(x_0^i,x_1^i,y^i)\\ h_\Theta(x)=\Theta\times X
(x1i,yi)−>(x0i,x1i,yi)hΘ(x)=Θ×X
代价函数和梯度(偏微分计算)转化为如下形式:
J
(
Θ
)
=
1
2
m
(
h
Θ
(
x
)
−
Y
)
T
(
h
Θ
(
x
)
−
Y
)
∇
J
(
Θ
)
=
1
m
X
T
(
h
Θ
(
x
)
−
Y
)
J(\Theta)=\frac{1}{2m}( h_\Theta(x)-Y)^T( h_\Theta(x)-Y)\\ \nabla J(\Theta)=\frac{1}{m}X^T(h_\Theta(x)-Y)\\
J(Θ)=2m1(hΘ(x)−Y)T(hΘ(x)−Y)∇J(Θ)=m1XT(hΘ(x)−Y)
Python代码如下:
from numpy import *
# 数据集大小 即20个数据点
m = 20
# x的坐标以及对应的矩阵
X0 = ones((m, 1)) # 生成一个m行1列的向量,也就是x0,全是1
X1 = arange(1, m+1).reshape(m, 1) # 生成一个m行1列的向量,也就是x1,从1到m
X = hstack((X0, X1)) # 按照列堆叠形成数组,其实就是样本数据
# 对应的y坐标
Y = array([
3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
11, 13, 13, 16, 17, 18, 17, 19, 21
]).reshape(m, 1) # m行1列
# 学习速度
alpha = 0.01
# 定义代价函数J
def cost_function(theta, X, Y):
# h = X*\Theta
diff = dot(X, theta) - Y # dot() 数组需要像矩阵那样相乘,就需要用到dot()
return (1/(2*m)) * dot(diff.transpose(), diff)# h的转置和h相乘
# 定义代价函数对应的梯度函数(偏微分计算)
def gradient_function(theta, X, Y):
diff = dot(X, theta) - Y
return (1/m) * dot(X.transpose(), diff)
# 梯度下降迭代
def gradient_descent(X, Y, alpha):
# reshape成2行1列说明是两个\theta参数,如果\theta参数需要更多此处需要更改
theta = array([1, 1]).reshape(2, 1)
gradient = gradient_function(theta, X, Y)
while not all(abs(gradient) <= 1e-5): # 当梯度小于1e-5时,停止迭代
theta = theta - alpha * gradient
gradient = gradient_function(theta, X, Y)
return theta
optimal = gradient_descent(X, Y, alpha)
print('optimal:', optimal)
print('cost function:', cost_function(optimal, X, Y)[0][0])
# 根据数据画出对应的图像
def plot(X, Y, theta):
import matplotlib.pyplot as plt
ax = plt.subplot(111) # 图像为一行一列分布在第一块
ax.scatter(X, Y, s=30, c="red", marker="s")
plt.xlabel("X")
plt.ylabel("Y")
x = arange(0, 21, 0.1) # x的范围
y = theta[0] + theta[1]*x
ax.plot(x, y)
plt.show()
plot(X1, Y, optimal)