刘二大人的pytorch深度学习实践（四）

反向传播

思路：
①数据集x,y
②初始化w权重是个torch的张量，记得([1.0])；声明w.requires_grad = True 意思是我声明我要计算梯度,因为默认是不计算梯度的。
③定义预测函数、损失函数，注意：这里不用定义梯度函数了，因为我们前面声明了w.requires_grad = True ，待会直接调用一个w.grad即可。
④开始迭代100次，
使用l = loss(x,y) l.backward()这两行是计算loss函数，并构建计算图。
输出w.grad.item()，
并更新权重w.data = w.data - 0.01 * w.grad.data
梯度即使清零w.grad.data.zero_()
输出每个zip后的最后一次损失函数
注意：反向传播，不用一点点计算梯度，直接声明True后、l = loss(x,y) l.backward()调用梯度w.grad即可。这样计算不用那么麻烦

看了别的博主的.item,.data后，我自己也输出了这两个东西和各自的类型。
想法：因为Data：w、Grad：梯度函数都是Tensor类型，所以，我们在forward()函数后x*w也是Tensor类型，那么要写成输出w.grad.item()和w.grad.data，才能把他们当做值使用，.item()和.data不能构建计算图，而Tensor可以构建计算图。就比如l.backward()构建了计算图。

# 体会a.data的类型，虽然还是Tensor，但是a.data研究可以当做值处理了，不会构建计算图。
import torch
a = torch.tensor([1.0])
a.requires_grad = True # 或者 a.requires_grad_()
print(a)
print(a.data)
print(a.item())

print(a.type())             # a的类型是tensor
print(a.data.type())        # a.data的类型是tensor
print(type(a.item())

注意：
不同点：.data返回的是一个tensor，而.item()返回的是一个具体的数值。
相同点：.data和.item()都可以当做值处理，都不能构建计算图。参考博客

import torch

# 数据集
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

# w初始化
w = torch.Tensor([1.0])
w.requires_grad = True     # 意思是我声明我要计算梯度


# 预测函数
def forward(x):
    return x*w


# 定义损失函数
def loss(x,y):
    y_pred = forward(x)
    return (y_pred - y) ** 2


# 这里的forward(4).item()的原因，
# 因为w是Tensor,x*w后，x自动类型转换成Tensor,结果也是Tensor，所以我们要用.item()或者.data转换成数值进行操作
print('predict (before training)',4,forward(4).item())

for epoch in range(100):
    for x,y in zip(x_data,y_data):
        l = loss(x,y)
        l.backward() #这两行是计算loss函数，并构建计算图
        print('\tgrad:',x,y,w.grad.item())
        w.data = w.data - 0.01 * w.grad.data  # 更新权重

        w.grad.data.zero_() # 梯度及时清零
    print('progress:',epoch,l.item()) # 这里是输出每个zip后的最后一次loss，而且这个loss也是每个zip产生的loss中最小的。

print('predict (after training)',4,forward(4).item())

课后作业

思路：
①y=w1x²+w2x+b和y=wx的步骤类似，主要区别是多了参数w2、b的定义和处理。
②参考博客说的蛮好的

import torch

x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

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

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


def loss(x,y): # 构建计算图
    y_pred = forward(x)
    return (y_pred-y)**2


print('Predict (before training)',4,forward(4))

for epoch in range(100):
    for x,y in zip(x_data,y_data):
        l = loss(x,y)
        l.backward()
        print('\tgrad:',x,y,w1.grad.item(),w2.grad.item(),b.grad.item())
        w1.data = w1.data - 0.01*w1.grad.data
        w2.data = w2.data - 0.01*w2.grad.data
        b.data = b.data - 0.01*b.grad.data
        w1.grad.data.zero_()
        w2.grad.data.zero_()
        b.grad.data.zero_()
    print('Epoch:',epoch,l.item())

print('Predict (after training)',4,forward(4).item())