PyTorch 深度学习实践 第4讲 反向传播

B站--刘二大人《PyTorch深度学习实践》完结合集  4.反向传播

 PPT 链接：网盘          提取码：cxe4

1.反向传播 

反向传播：面对复杂网络，解析式数量过多，无法表达，思考是否有算法可就网络看成图，在图上找关系 

如果不加入非线性函数的话，会被合并同类项

举例 x=2，w=3

蓝色线：前向传播过程

红色线：反向传播过程---梯度

练习1： 

 

练习2：

 

2.tensor in pytorch

tensor：数据类型，存储图中的数值，可以保存各类数据

             data：w，存储权重

              grad：损失函数对权重的导数

#实现步骤：
#1.构建数据集
#2.定义权重
#3.定义模型
#4.定义损失



import torch

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


## 定义权重w，w为一个张量Tensor，初始值为1
w = torch.tensor([1.0])
# True表示需要计算w的梯度
w.requires_grad = True



##定义模型
def forward(x):
    # 由于w是一个tensor，x会先转换成tensor再计算，所以forward(x)也是一个张量
    #x,w进行数乘
    return x * w

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

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)    # 前馈过程——计算损失
                     # 反向传播，求出从loss处到w所需要的梯度值，存储在w中
        l.backward()    #求出之前计算过的计算图的梯度
                        #backward之后计算图被释放
                        #下次前向传播，重新构建计算图

                       
        print('\t grad: ', x, y, w.grad.item())
                     # print(w.grad.data, w.grad, w.item(), w.data)
        
        w.data = w - 0.01 * w.grad.data
                            # 梯度下降——更新权重
                            # 使用tensor直接计算会产生计算图，
                            #  直接用w.grad计算会产生计算图，
                            # 用w.grad.data计算，只更新数值，不用建立新的计算图模型 
          
          #sum+=l,是对计算图相加         
          # item()将w的梯度转换成标量
          # sum+=l.item()，转换为数值相加

        w.grad.data.zero_()
                            # 将当前计算完保存下来的的梯度值清0，下次用新的Loss计算新的梯度
    print("progress: ", epoch, l.item())
print("Predict(after training)", 4, forward(4).item())

练习3：

 

import torch

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


## 定义权重w，w为一个张量Tensor，初始值为1
w1 = torch.tensor([1.0])
w2 = torch.tensor([1.0])
b = torch.tensor([1.0])

# True表示需要计算w的梯度
w1.requires_grad = True
w2.requires_grad = True
b.requires_grad = True

##定义模型
def forward(x):
    
    return (x**2) * w1+ x * w2 + b

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

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()                         
        print('\t grad: ', x, y, w1.grad.item(),w2.grad.item(),b.grad.item())  
        
        w1.data = w1 - 0.01 * w1.grad.data  
        w2.data = w2 - 0.01 * w2.grad.data  
        b.data = b - 0.01 * b.grad.data  
        
        w1.grad.data.zero_()
        w2.grad.data.zero_()
        b.grad.data.zero_()
                            
    print("progress: ", epoch, l.item())
print("Predict(after training)", 4, forward(4).item())
print("w1:", w1.data.item(), "\nw2", w2.data.item(), "\nb:", b.data.item())

参考链接：

pytorch 深度学习实践 第4讲 反向传播