我的Pytorch框架学习二阶段

---

date: 2025-02-20 17:09:48
tags: pytorch

一，梯度下降和反向传播及计算方法，线性回归的实现

1.梯度：向量，值是导数，方向是变化最快的方向
更新参数w ：w = w-α▽w
链式法则：把复杂的函数用更小的变量去表示包含x的部分
2.反向传播：先计算最后一层的偏导，之后再计算倒数第二层···

3.线性回归实现代码大致过程

#更新  w=w-$w

import torch
import numpy as np
from matplotlib import pyplot as plt
x=torch.ones(2,2,requires_grad=True) #不设置x的值，默认为None
print(x)
y=x+2
print(y)
z=y*y*3
print(z)
out=z.mean()  #均值
print(out)
#综上，若x的属性requires_grad=True，每次计算都修改grad_fn属性，用来记录做过的操作
a=torch.randn(2,2)
a.requires_grad_(True)  #实现就地修改

with torch.no_grad():
    c=(a*a).sum()  #此时在打印发现c没有gard_fn

out.backward()   #计算梯度
print(x.grad)    #获取x的梯度
print(x.data)   #仅仅获取数据
x.detach().numpy()     #如果requires_grad=True是不能转换的，要用该方法脱离


##########################################################################################################
#手动实现线性回归   假设模型是y=wx+b        使用y=3x+0.8
x1=torch.rand([500,1])
y_true=3*x1+0.8
learning_rate=0.01
w=torch.rand([1,1],requires_grad=True)
b=torch.rand(1,requires_grad=True,dtype=torch.float32)

for i in range(200000000):     #循环，反向传播更新参数
    y_predict = torch.matmul(x1, w) + b
    loss=(y_predict-y_true).pow(2).mean()
     #反向传播前把梯度质为0
    if w.grad is not None:
        w.grad.data.zero_()
    if b.grad is not None:
        b.grad.data.zero_()
    loss.backward()
    w.data = w.data - learning_rate*w.grad
    b.data = w.data - learning_rate*b.grad
    print("w,b,loss",w.item(),b.item(),loss.item())


plt.figure(figsize=(20,8))#华图演练
plt.scatter(x1.numpy().reshape(-1),y_true.numpy().reshape(-1))
y_predict=torch.matmul(x1,w)+b
plt.plot(x1.numpy().reshape(-1),y_predict.detach().numpy().reshape(-1))
#plt.show()
#更快实现nn.model方法
from torch import nn
class Lr(nn.Module):
    def __init__(self):
        super(Lr,self).__init__()#继承父类init参数
        self.linear=nn.Linear(1,1)#nn.Linear是torch预定好的线性模型

    def forward(self,x):
        out1=self.linear(x)
        return out

#优化器（optimizer）
optimizer=optim.SGD(model.parameters(D))

4.pytorch实现线性回归完需要pytorch通过api完成模型和训练
我们需要构造模型，反向传播，
构造模型：
计算梯度：loss.backward()
optimizer.step() 参数的更新
训练的过程：梯度置为0
调用模型得到预测值
调用loss函数，得到损失
loss.backward() 进行梯度计算
optimizer.step()
、
、
、以下为大概实现代码

torch

import torch.nn as nn
from torch import optim
import time

#定义一个device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel,self).__init__()
        self.lr = nn.Linear(1,1)

    def forward(self, x):  #x [500,1]  ---> y_predict :[500,1]
        return self.lr(x)

#0 准备数据
x = torch.rand([500,1]).to(device)
y_true = 3*x + 0.8
# print(y_true)

#1. 实例化模型
model = MyModel().to(device)
#2. 实例化优化器
optimizer = optim.Adam(model.parameters(),lr=0.1)
#3. 实例化损失函数
loss_fn = nn.MSELoss()

t0 = time.time()
for i in range(500):
    #4. 梯度置为0
    optimizer.zero_grad()
    #5. 调用模型得到预测值
    y_predict = model(x)
    #6. 通过损失函数，计算得到损失
    loss = loss_fn(y_predict,y_true)
    #7. 反向传播，计算梯度
    loss.backward()
    #8. 更新参数
    optimizer.step()

    

for param in model.parameters():
    print(param.item())

print("total cost time:",time.time()-t0) #1.3463990688323975

二，优化算法的相关了解

1.梯度下降：把所有的数据传入模型，计算平均梯度，更新参数，缺点：慢
2. 随机梯度下降：选一条数据进行参数的更新。缺点：容易受到噪声数据的影响
3. 批梯度下降：每次选择一波数据进行参数的更新。缺点：梯度的变化幅度可能会很大，在最小值附件徘徊
4. 动量法：把历史的梯度考虑进去。更新参数时候使用梯度=历史梯度的指数加权平均
5. adagrad : 更新参数的时候，使用自适应的学习率，= 学习率/历史梯度的平方
6. rmsprop：使用自适应的学习率，= 学习率/历史梯度的平方的指数加权平均