梯度寻优

上接凸优化基础

扩展：机器学习中的几个概念的关系

2.1 逐次逼近法

使用主元消去法求解线性方程组 \(Ax = b\) 相信大家都不陌生，但是对于 \(A\) 的阶数很大且零元素很多的大型稀疏矩阵方程组，使用主元消去法求解将会是一个很大的挑战。鉴于此，逐次逼近法 (或称为迭代法^[1]) 提供了解决策略。

下面我们来看看迭代法的具体操作:

首先将 \(Ax=b\) 改写为 \(x = Bx + f\), 使用公式:

\[x^{k+1} = Bx^k + f \]

其中 \(k\) 为迭代次数 \((k=0, 1, 2, \cdots)\)。

若 \(\displaystyle\lim_{k \to \infty} x^k\) 存在 (记作 \(x^*\))，称此迭代法收敛。显然 \(x^*\) 就是方程组的解，否则称此迭代法发散。

2.1.1 研究数列的收敛性

引入误差向量：

\[\epsilon^{k+1} = x^{k+1} - x^* \]

我们可以得到

\[\epsilon^{k+1} = (Bx^k + f) - (Bx^* + f) = B\epsilon^k = B^k\epsilon^0 \]

故而，要研究数列 \(\{x^k\}\) 的收敛性，只需要研究 \(\displaystyle\lim_{k \to \infty} \epsilon^k = 0\) 或 \(\displaystyle\lim_{k \to \infty} B^k = 0\) 满足的条件。

下面以 Numpy 的形式呈现迭代的过程与结果：

2.1.2 消元法

import numpy as np # 载入矩阵运算库
A = np.array([[8, -3, 2], [4, 11, -1], [6, 3, 12]])
b = np.array([[20], [33], [36]])
result = np.linalg.solve(A, b)
print('x\n',result)

x
 [[3.]
 [2.]
 [1.]]

将 \(Ax = b\) 转换为：\(x^{k+1}=B x^k+f\)

B = np.array([[0.0, 3.0 / 8.0, -2.0 / 8.0], 
              [-4.0 / 11.0, 0.0, 1.0 / 11.0],
              [-6.0 / 12.0, -3.0 / 12.0, 0.0]])
f = np.array([[20.0 / 8.0], [33.0 / 11.0], [36.0 / 12.0]])

m, n = B.shape

error = 1e-7  # 误差阈值
steps = 100  # 迭代次数
xk = np.zeros((m, 1))  # 初始化 xk = 0
errorlist = []  # 记录逐次逼近的误差列表
for k in range(steps):
    xk_1 = xk  # 上一次的 xk
    xk = np.dot(B, xk) + f  # 本次 xk
    errorlist.append(np.linalg.norm(xk - xk_1))  # 计算并存储误差
    if errorlist[-1] < error:  # 判断误差是否小于阈值
        print('终止迭代数：', k + 1)  # 输出迭代次数
        break
print(xk)  # 输出计算结果

终止迭代数： 18
[[2.99999998]
 [2.00000003]
 [1.00000003]]

2.1.3 绘制误差收敛散点图

from matplotlib import pyplot as plt


def drawScatter(plt, mydata, size=20, color='blue', mrkr='o'):
    m, n = mydata.shape
    if m > n and m > 2:
        plt.scatter(mydata.T[0], mydata.T[1], s=size, c=color, marker=mrkr)
    else:
        plt.scatter(mydata[0], mydata[1], s=size, c=color, marker=mrkr)


matpts = np.zeros((2, k + 1))
matpts[0] = np.linspace(1, k + 1, k + 1)
matpts[1] = np.array(errorlist)
drawScatter(plt, matpts)
plt.show()