Pytorch深度学习实践笔记4

🎬个人简介：一个全栈工程师的升级之路！
📋个人专栏：pytorch深度学习
🎀CSDN主页发狂的小花
🌄人生秘诀：学习的本质就是极致重复!

视频来自【b站刘二大人】

1 反向传播

Back propagation （BP），训练神经网络的目标是优化代价函数cost，使得cost找到以一个全局或者局部最优值。让cost尽可能的接近0，这样得到的weights和bias是最好的，由于需要不断的调整参数让cost收敛，cost在梯度的相反反向下降最快，所以提出了BP算法，就是来计算weights和bias的梯度（偏导数的，加速训练时的收敛速度，避免无效的训练。
反向传播求梯度用到了链式求导，很好理解，高中就学习过了。

反向传播的优点：尽力用一次前向传播和一次反向传播，就同时计算出所有参数的偏导数。 反向传播计算量和前向传播差不多，并且有效利用前向传播过程中的计算结果，前向传播的主要计算量在权重矩阵和input vector的乘法计算，反向传播则主要是矩阵和input vector 的转置的乘法计

2 链式求导

神经网络反向传播理解_反向传播的作用-CSDN博客

3 计算图

计算图可以减轻网络构建的难度，以前需要为每一个神经网络写反向传播算法。
（1）计算图为有向无环图
（2）Pytorch为动态计算图，Tensorflow为静态计算图，后来也改进支持动态计算图
（3）Pytorch的动态计算图，为了节约内存，一轮迭代完后计算图就被在内存释放，因此每次都需要构建新的计算图，计算图代表程序中变量之间的关系
（4）pytorch计算图中，只有两种元素：数据（Tensor）和运算。tensor可以分为两种：叶子节点和非叶子节点。使用backward()函数反向传播计算tensor的梯度时，并不计算所有tensor的梯度，而是只计算满足这几个条件的tensor的梯度：1.类型为叶子节点、2.requires_grad=True、3.依赖该tensor的所有tensor的requires_grad=True。
自己定义的tensor中，requires_grad属性默认是False，而神经网络中的权重w的tensor中requires_grad属性默认为True。
（5）autograd包提供Tensor所有操作的自动求导方法。
torch.Tensor是这个包里面最重要的类。如果设置了requires_grad为True，那么它开始追踪所有在它上面的操作。当你完成了计算，可以使用调用backward()，回自动计算所有的梯度。然后这个tensor的梯度会被自动累积到grad属性上。

pytorch计算图_pytorch 计算图-CSDN博客

Pytorch快速入门系列---（二）动态计算图、自动微分、torch.nn模块_pytorch计算图训练-CSDN博客

blog.csdn.net/qq_42681787/article/details/129394170编辑

4 tensor

Tensor 中指定需要计算梯度，requires_grad = True

w是Tensor(张量类型)，Tensor中包含data和grad，data和grad也是Tensor。grad初始为None，调用l.backward()方法后w.grad为Tensor，故更新w.data时需使用w.grad.data。如果w需要计算梯度，那构建的计算图中，跟w相关的tensor都默认需要计算梯度。
调用backward()会将所有的需要计算梯度的都求出来，存储待对应的w.grad.data中。

torch.tensor() 和 torch.Tensor()：

【PyTorch】Tensor和tensor的区别_pytorch tensor tensor-CSDN博客

torch.FloatTensor和torch.Tensor、torch.tensor-CSDN博客

torch.FloatTensor()

5 代码

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

# SGD随机梯度下降

x_data = np.arange(1.0,200.0,1.0)
y_data = np.arange(2.0,400.0,2.0)

def forward(x,w):
    return x * w

def loss(x,y_true,w):
    y_pred = forward(x,w)

    return (y_pred-y_true)**2

w = torch.Tensor([1.0])
w.requires_grad = True

lr = 0.00001

epoch_list = []
loss_list = []

print("Before train 4: ",forward(torch.Tensor([400.]),w).data.item())
for epoch in range(100):
    seed = np.random.choice(range(len(x_data)))

    loss_val = loss(x_data[seed],y_data[seed],w)
    loss_val.backward()
    w.data -= lr*w.grad.data
    w.grad.data.zero_()
    
    print("epoch: ",epoch," loss: ",loss_val.data.item()," w: ",w.data.item())
    epoch_list.append(epoch)
    loss_list.append(loss_val.data.item())
    if (loss_val < 1e-7):
        break
print("After train 4: ",forward(torch.Tensor([400.]),w).data.item())

plt.plot(epoch_list,loss_list)
plt.xlabel("epoch")
plt.ylabel("loss")
plt.savefig("./data/pytorch3.png")

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

# 假设 3 * x^2 + 2 * x + 2 
x_data = [1.0,2.0,3.0]
y_data = [7.0,18.0,35.0]

def forward(x,w1,w2,b):
    return (w1 * x **2 + w2 *x +b)

def loss(x,y_true,w1,w2,b):
    y_pred = forward(x,w1,w2,b)

    return (y_pred-y_true)**2

w1 = torch.Tensor([1.0])#初始权值
w1.requires_grad = True#计算梯度，默认是不计算的
w2 = torch.Tensor([1.0])
w2.requires_grad = True
b = torch.Tensor([1.0])
b.requires_grad = True

lr = 0.001

epoch_list = []
loss_list = []

print("Before train 4: ",forward(torch.Tensor([4.]),w1,w2,b).data.item())
for epoch in range(10000):
    seed = np.random.choice(range(len(x_data)))

    loss_val = loss(x_data[seed],y_data[seed],w1,w2,b)
    loss_val.backward()
    w1.data -= lr*w1.grad.data
    w2.data -= lr*w2.grad.data
    b.data -= lr*b.grad.data
    w1.grad.data.zero_()
    w2.grad.data.zero_()
    b.grad.data.zero_()
    
    print("epoch: ",epoch," loss: ",loss_val.data.item()," w1: ",w1.data.item()," w2: ",w2.data.item()," b: ",b.data.item())
    epoch_list.append(epoch)
    loss_list.append(loss_val.data.item())
    if (loss_val < 1e-7):
        break
print("After train 4: ",forward(torch.Tensor([4.]),w1,w2,b).data.item())

plt.plot(epoch_list,loss_list)
plt.xlabel("epoch")
plt.ylabel("loss")
plt.savefig("./data/pytorch3_1.png")