AI作业6-误差反向传播

1.梯度下降

梯度下降在机器学习应用十分广泛，在回归计算（线性回归，Logistic）中的目的都是通过迭代计算寻找到目标函数的最小值，或者收敛到最小值。

这么来说，梯度下降的概念有点过于抽象了。我们以具体的某一函数为样例来解释什么是梯度下降。我们以二次函数中的抛物线函数来作为样例，当一个抛物线函数它的开口向上，那么这个函数就存在且唯一的最低点，我们需要寻找这个函数的最低点，或者说这个函数映射的最小值。使用梯度下降的方法来求解，那么我们可以看成，在抛物线上的一点，每次都向着函数映射值降低的方向移动，而每次又以移动过后的点为基准，继续向着函数映射值降低的方向移动，直到这个点移动到了整个函数的最低点。那么这个过程就叫做是梯度下降，当然，如果我们寻找一个开口向下的抛物线函数最高点，那么这种方法就叫做梯度上升。

那么什么是梯度呢？在不同函数中它的定义有所不同，在单变量函数中，梯度就是函数的微分值，代表函数在其某个点上切线的斜率。在多变量函数中，梯度则就是一个向量，其向量所指的方向就是在某一确定点下降（上升）最快的方向。

2.反向传播

反向传播算法是目前用来训练人工神经网络的最常用且有效的算法。在人工神经网络算法在实际运行过程中，一般分为输入层、隐藏层、和输入层三类，当算法输出结果和目标结果出现误差时，算法会对误差值进行计算，然后通过反向传播将数值传回至隐藏层，通过修改相关参数进行调整，并再次通过算法计算获取输出结果，通过不断重复该过程，得到与预期相符的结果。总的来说，反向传播算法可以让人工神经网络在推断过程中，不断通过调整重复运算，使得结果更加接近目标预期。

3.计算图

计算图是一种表示计算过程的图形模型，它由节点（表示变量或操作）和边（表示它们之间的数据流）组成。计算图可以帮助我们理解和优化复杂的数学公式和计算过程。在机器学习中，计算图被广泛应用于自动微分和优化算法的实现中。

4.使用Numpy编程实现

"""
import numpy as np
import matplotlib.pyplot as plt


def sigmoid(z):
    a = 1 / (1 + np.exp(-z))
    return a


def forward_propagate(x1, x2, y1, y2, w1, w2, w3, w4, w5, w6, w7, w8): # 正向传播
    in_h1 = w1 * x1 + w3 * x2
    out_h1 = sigmoid(in_h1)
    in_h2 = w2 * x1 + w4 * x2
    out_h2 = sigmoid(in_h2)

    in_o1 = w5 * out_h1 + w7 * out_h2
    out_o1 = sigmoid(in_o1)
    in_o2 = w6 * out_h1 + w8 * out_h2
    out_o2 = sigmoid(in_o2)

    error = (1 / 2) * (out_o1 - y1) ** 2 + (1 / 2) * (out_o2 - y2) ** 2

    return out_o1, out_o2, out_h1, out_h2, error


def back_propagate(out_o1, out_o2, out_h1, out_h2):    # 反向传播
    d_o1 = out_o1 - y1
    d_o2 = out_o2 - y2

    d_w5 = d_o1 * out_o1 * (1 - out_o1) * out_h1
    d_w7 = d_o1 * out_o1 * (1 - out_o1) * out_h2
    d_w6 = d_o2 * out_o2 * (1 - out_o2) * out_h1
    d_w8 = d_o2 * out_o2 * (1 - out_o2) * out_h2

    d_w1 = (d_w5 + d_w6) * out_h1 * (1 - out_h1) * x1
    d_w3 = (d_w5 + d_w6) * out_h1 * (1 - out_h1) * x2
    d_w2 = (d_w7 + d_w8) * out_h2 * (1 - out_h2) * x1
    d_w4 = (d_w7 + d_w8) * out_h2 * (1 - out_h2) * x2

    return d_w1, d_w2, d_w3, d_w4, d_w5, d_w6, d_w7, d_w8


def update_w(step,w1, w2, w3, w4, w5, w6, w7, w8):    #梯度下降，更新权值
    w1 = w1 - step * d_w1
    w2 = w2 - step * d_w2
    w3 = w3 - step * d_w3
    w4 = w4 - step * d_w4
    w5 = w5 - step * d_w5
    w6 = w6 - step * d_w6
    w7 = w7 - step * d_w7
    w8 = w8 - step * d_w8
    return w1, w2, w3, w4, w5, w6, w7, w8


if __name__ == "__main__":
    w1, w2, w3, w4, w5, w6, w7, w8 = 0.2, -0.4, 0.5, 0.6, 0.1, -0.5, -0.3, 0.8 # 可以给随机值，为配合PPT，给的指定值
    x1, x2 = 0.5, 0.3   # 输入值
    y1, y2 = 0.23, -0.07 # 正数可以准确收敛；负数不行。why? 因为用sigmoid输出，y1, y2 在 （0,1）范围内。
    N = 10             # 迭代次数
    step = 10           # 步长

    print("输入值：x1, x2；",x1, x2, "输出值：y1, y2:", y1, y2)
    eli = []
    lli = []
    for i in range(N):
        print("=====第" + str(i) + "轮=====")
        # 正向传播
        out_o1, out_o2, out_h1, out_h2, error = forward_propagate(x1, x2, y1, y2, w1, w2, w3, w4, w5, w6, w7, w8)
        print("正向传播:", round(out_o1, 5), round(out_o2, 5))
        print("损失函数：", round(error, 2))
        # 反向传播
        d_w1, d_w2, d_w3, d_w4, d_w5, d_w6, d_w7, d_w8 = back_propagate(out_o1, out_o2, out_h1, out_h2)
        # 梯度下降，更新权值
        w1, w2, w3, w4, w5, w6, w7, w8 = update_w(step,w1, w2, w3, w4, w5, w6, w7, w8)
        eli.append(i)
        lli.append(error)


    plt.plot(eli, lli)
    plt.ylabel('Loss')
    plt.xlabel('w')
    plt.show()

5.使用PyTorch的Backward（）编程实现

import torch

# 定义sigmoid函数
def sigmoid(x):
    return 1 / (1 + torch.exp(-x))

# 定义均方误差损失函数
def mse_loss(y_pred, y_true):
    return ((y_pred - y_true) ** 2).mean()

# 输入值
x = torch.tensor([0.5, 0.3])

# 目标输出值
y_true = torch.tensor([0.23, -0.07])

# 初始化权值
w1 = torch.tensor([0.2, -0.4, 0.5, 0.6])
w2 = torch.tensor([0.1, -0.5, -0.3, 0.8])

# 前向传播
h1 = sigmoid(torch.dot(x, w1))
h2 = sigmoid(torch.dot(x, w2))
y_pred = torch.tensor([h1, h2])

# 计算损失
loss = mse_loss(y_pred, y_true)

# 反向传播
loss.backward()

# 输出梯度
print("dL/dh1 = ", w1 * h1 * (1 - h1) * 2 * (y_pred[0] - y_true[0]))
print("dL/dh2 = ", w2 * h2 * (1 - h2) * 2 * (y_pred[1] - y_true[1]))
print("dL/dw1 = ", x * w1 * h1 * (1 - h1) * 2 * (y_pred[0] - y_true[0]))
print("dL/dw2 = ", x * w2 * h2 * (1 - h2) * 2 * (y_pred[1] - y_true[1]))