人工智能-作业3：例题程序复现 PyTorch版

人工智能-作业3：例题程序复现 PyTorch版 1.使用pytorch复现课上例题

运行代码：

import torch

x1, x2 = torch.Tensor([0.5]), torch.Tensor([0.3])
y1, y2 = torch.Tensor([0.23]), torch.Tensor([-0.07])
print("=====输入值：x1, x2；真实输出值：y1, y2=====")
print(x1, x2, y1, y2)
w1, w2, w3, w4, w5, w6, w7, w8 = torch.Tensor([0.2]), torch.Tensor([-0.4]), torch.Tensor([0.5]), torch.Tensor(
    [0.6]), torch.Tensor([0.1]), torch.Tensor([-0.5]), torch.Tensor([-0.3]), torch.Tensor([0.8])  # 权重初始值
w1.requires_grad = True
w2.requires_grad = True
w3.requires_grad = True
w4.requires_grad = True
w5.requires_grad = True
w6.requires_grad = True
w7.requires_grad = True
w8.requires_grad = True


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


def forward_propagate(x1, x2):
    in_h1 = w1 * x1 + w3 * x2
    out_h1 = sigmoid(in_h1)  # out_h1 = torch.sigmoid(in_h1)
    in_h2 = w2 * x1 + w4 * x2
    out_h2 = sigmoid(in_h2)  # out_h2 = torch.sigmoid(in_h2)

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

    print("正向计算：o1 ,o2")
    print(out_o1.data, out_o2.data)

    return out_o1, out_o2


def loss_fuction(x1, x2, y1, y2):  # 损失函数
    y1_pred, y2_pred = forward_propagate(x1, x2)  # 前向传播
    loss = (1 / 2) * (y1_pred - y1) ** 2 + (1 / 2) * (y2_pred - y2) ** 2  # 考虑 ： t.nn.MSELoss()
    print("损失函数（均方误差）：", loss.item())
    return loss


def update_w(w1, w2, w3, w4, w5, w6, w7, w8):
    # 步长
    step = 1
    w1.data = w1.data - step * w1.grad.data
    w2.data = w2.data - step * w2.grad.data
    w3.data = w3.data - step * w3.grad.data
    w4.data = w4.data - step * w4.grad.data
    w5.data = w5.data - step * w5.grad.data
    w6.data = w6.data - step * w6.grad.data
    w7.data = w7.data - step * w7.grad.data
    w8.data = w8.data - step * w8.grad.data
    w1.grad.data.zero_()  # 注意：将w中所有梯度清零
    w2.grad.data.zero_()
    w3.grad.data.zero_()
    w4.grad.data.zero_()
    w5.grad.data.zero_()
    w6.grad.data.zero_()
    w7.grad.data.zero_()
    w8.grad.data.zero_()
    return w1, w2, w3, w4, w5, w6, w7, w8


if __name__ == "__main__":

    print("=====更新前的权值=====")
    print(w1.data, w2.data, w3.data, w4.data, w5.data, w6.data, w7.data, w8.data)

    for i in range(1):
        print("=====第" + str(i) + "轮=====")
        L = loss_fuction(x1, x2, y1, y2)  # 前向传播，求 Loss，构建计算图
        L.backward()  # 自动求梯度，不需要人工编程实现。反向传播，求出计算图中所有梯度存入w中
        print("\tgrad W: ", round(w1.grad.item(), 2), round(w2.grad.item(), 2), round(w3.grad.item(), 2),
              round(w4.grad.item(), 2), round(w5.grad.item(), 2), round(w6.grad.item(), 2), round(w7.grad.item(), 2),
              round(w8.grad.item(), 2))
        w1, w2, w3, w4, w5, w6, w7, w8 = update_w(w1, w2, w3, w4, w5, w6, w7, w8)

    print("更新后的权值")
    print(w1.data, w2.data, w3.data, w4.data, w5.data, w6.data, w7.data, w8.data)

运行结果：

2.对比【作业3】和【作业2】的程序，观察两种方法结果是否相同？如果不同，哪个正确？

作业三是正确的，作业二是自己手算的，作业三是调用的库函数

3.程序更新

下面展示一些 内联代码片。

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 * w5 / out_h1 + d_w6 * w6 / out_h1) * out_h1 * (1 - out_h1) * x1
    d_w3 = (d_w5 * w5 / out_h1 + d_w6 * w6 / out_h1) * out_h1 * (1 - out_h1) * x2
    d_w2 = (d_w7 * w7 / out_h2 + d_w8 * w8 / out_h2) * out_h2 * (1 - out_h2) * x1
    d_w4 = (d_w7 * w7 / out_h2 + d_w8 * w8 / out_h2) * 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 = 1         # 迭代次数
    step = 1           # 步长

    print("输入值：x1, x2；",x1, x2, "输出值：y1, y2:", y1, y2)
    print("更新前的权值")
    print(w1, w2, w3, w4, w5, w6, w7, w8)

    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, 4))
        # 反向传播
        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)
        print("\tgrad W: ", round(d_w1, 2), round(d_w2, 2),round(d_w3, 2),round(d_w4, 2),round(d_w5, 2),round(d_w6, 2),round(d_w7,2),
              round(d_w8, 2))
        # 梯度下降，更新权值
        w1, w2, w3, w4, w5, w6, w7, w8 = update_w(step,w1, w2, w3, w4, w5, w6, w7, w8)
        print("更新后的权值")
        print(round(w1,4), round(w2,4),round(w3,4),round(w4,4),round(w5,4),round(w6,4),round(w7,4),round(w8,4))
        eli.append(i)
        lli.append(error)


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

4.对比【作业2】与【作业3】的反向传播的实现方法。总结并陈述

作业二中的方法通过手动计算，几乎每个过程都要自己算；作业三直接采用的张量Tensor，求Loss，构建计算图，通过backword()函数自动求梯度。自己算可能出错，能用库函数尽量用库函数，不仅代码写的简单，也保证了正确性。

5.激活函数Sigmoid用PyTorch自带函数torch.sigmoid()，观察、总结并陈述

在数据挖掘和分析中，专业人员经常使用sigmoid函数，因为它更容易解释和实现。它是一个非线性函数。当我们将权值从神经网络的输入层传递到隐含层时，我们希望我们的模型能够捕获数据中呈现的所有非线性;因此，建议在神经网络的隐层中使用sigmoid函数。非线性函数有助于泛化数据集。用非线性函数计算函数的梯度比较容易。

sigmoid函数是一种特殊的非线性激活函数。sigmoid函数的输出总是限制在0和1之内;因此，它主要用于执行基于分类的任务。sigmoid函数的局限性之一是它可能会陷入局部极小值。这样做的好处是，它提供了属于这类的可能性。下面是它的方程。
————————————————
版权声明：本文为CSDN博主「wh嘻嘻」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45297133/article/details/124695838

Sigmoid函数的导数是其本身的函数，即f′(x)=f(x)[1−f(x)]，因此Sigmoid函数在反向传播的求导中起到了重要作用。

6.激活函数Sigmoid改变为Relu，观察、总结并陈述

ReLU函数是目前比较火的一个激活函数,函数公式：，函数图像如下

相比sigmod函数与tanh函数有以下几个优点

1)克服梯度消失的问题

2）加快训练速度

注：正因为克服了梯度消失问题，训练才会快

缺点：

1）输入负数，则完全不激活，ReLU函数无法继续运行。

2）ReLU函数输出要么是0，要么是正数，也就是ReLU函数不是以0为中心的函数

深度学习中最大的问题是梯度消失问题，使用tanh、sigmod等饱和激活函数情况下特别严重（神经网络在进行方向误差传播时，各个层都要乘以激活函数的一阶导数，梯度每传递一层就会衰减一层，网络层数较多时，梯度G就会不停衰减直到消失），使得训练网络收敛越来越慢，而ReLU函数凭借其线性、非饱和的形式，训练速度则快很多。

原函数：

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


def forward_propagate(x1, x2):
    in_h1 = w1 * x1 + w3 * x2
    out_h1 = sigmoid(in_h1)  # out_h1 = torch.sigmoid(in_h1)
    in_h2 = w2 * x1 + w4 * x2
    out_h2 = sigmoid(in_h2)  # out_h2 = torch.sigmoid(in_h2)

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

    print("正向计算：o1 ,o2")
    print(out_o1.data, out_o2.data)

    return out_o1, out_o2

更改后：

def forward_propagate(x1, x2):
    in_h1 = w1 * x1 + w3 * x2
    out_h1 = torch.relu(in_h1)
    in_h2 = w2 * x1 + w4 * x2
    out_h2 = torch.relu(in_h2)


    in_o1 = w5 * out_h1 + w7 * out_h2
    out_o1 = torch.relu(in_o1)
    in_o2 = w6 * out_h1 + w8 * out_h2
    out_o2 = torch.relu(in_o2)

    print("正向计算：o1 ,o2")
    print(out_o1.data, out_o2.data)

    return out_o1, out_o2

7.损失函数MSE用PyTorch自带函数 t.nn.MSELoss()替代，观察、总结并陈述

MSELoss均方误差，是预测值与真实值之差的平方和的平均值

	loss_func = torch.nn.MSELoss() #自带函数
    y_pred = torch.cat((y1_pred, y2_pred), dim=0) 
    y = torch.cat((y1, y2), dim=0)  
    loss = loss_func(y_pred, y) 

nn.MSELoss()参数介绍

(1)如果 reduction = ‘none’，直接返回向量形式的 loss
(2)如果 reduction ≠ ‘none’，那么 loss 返回的是标量
a)如果 reduction=‘mean’，返回 loss.mean(); 注意：默认情况下， reduction=‘mean’
b)如果 reduction=‘sum’，返回 loss.sum();

8.损失函数MSE改变为交叉熵，观察、总结并陈述。

def loss_fuction(x1, x2, y1, y2): 
    y1_pred, y2_pred = forward_propagate(x1, x2) 
    loss_func = torch.nn.CrossEntropyLoss() # 创建交叉熵损失函数
    y_pred = torch.stack([y1_pred, y2_pred], dim=1) 
    y = torch.stack([y1, y2], dim=1)
    loss = loss_func(y_pred, y) # 计算
    print("损失函数（均方误差）：", loss.item())
    return loss

1、均值平方差（MSE）：指参数估计值与参数真实值之差平方的期望值。

在神经网络计算时，预测值要与真实值控制在同样的数据分布内，假设将预测值经过Sigmoid激活函数得到取值范围在0_{1之间，那么真实值也归一化到0}1之间。

2、交叉熵：预测输入样本属于某一类的概率。

其中y代表真实值分类（0或1），a代表预测值，交叉熵值越小，预测结果越准。

9.改变步长，训练次数，观察、总结并陈述。

=====第999轮=====
正向计算：o1 ,o2
tensor([0.2296]) tensor([0.0098])
损失函数（均方误差）： 0.003185197012498975
	grad W:  -0.0 -0.0 -0.0 -0.0 -0.0 0.0 -0.0 0.0
更新后的权值
tensor([1.6515]) tensor([0.1770]) tensor([1.3709]) tensor([0.9462]) tensor([-0.7798]) tensor([-4.2741]) tensor([-1.0236]) tensor([-2.1999])

=====第999轮=====
正向计算：o1 ,o2
tensor([0.2299]) tensor([0.0020])
损失函数（均方误差）： 0.002591301454231143
	grad W:  -0.0 -0.0 -0.0 -0.0 -0.0 0.0 -0.0 0.0
更新后的权值
tensor([2.0871]) tensor([0.5032]) tensor([1.6323]) tensor([1.1419]) tensor([-0.7079]) tensor([-5.2478]) tensor([-0.9722]) tensor([-2.9524])

=====第999轮=====
正向计算：o1 ,o2
tensor([0.2389]) tensor([0.0001])
损失函数（均方误差）： 0.0024988993536680937
	grad W:  -0.0 -0.0 -0.0 -0.0 0.0 0.0 0.0 0.0
更新后的权值
tensor([1.1752]) tensor([-1.9685]) tensor([1.0851]) tensor([-0.3411]) tensor([-0.9945]) tensor([-10.1541]) tensor([-2.1901]) tensor([-7.0080])
 

10.权值w1-w8初始值换为随机数，对比【作业2】指定权值结果，观察、总结并陈述。

随机生成权值：

w1, w2, w3, w4, w5, w6, w7, w8 = torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1)  # 权重初始值

观测结果，前后存在差别，但大部分参数改变不大。

11.全面总结反向传播原理和编码实现，认真写心得体会。

反向传播算法是训练神经网络的经典算法，是深度学习的最重要的基础，适合于多层神经元网络的一种学习算法，它建立在梯度下降法的基础上，通过迭代的方法求出目标损失函数(loss function)的近似最小值。

在参数选择时，只通过直觉无法判断怎样选取最优参数。我个人选择多次选取相近数据，逐步找到规律。反向传播不同于一般的数学规律，必须要反复尝试。