Pytorch与视觉竞赛入门

最新推荐文章于 2024-07-18 20:02:41 发布

pandachu

最新推荐文章于 2024-07-18 20:02:41 发布

阅读量1k

点赞数

文章标签： pytorch 人工智能 python

本文链接：https://blog.csdn.net/pandachu/article/details/121315673

版权

打卡内容Coggle 30 Days of ML（21年11月）

任务1：PyTorch张量计算与Numpy的转换

1. 配置环境,参考本人另一篇文章https://blog.csdn.net/pandachu/article/details/121590603
2. 学习Pytorch的基础语法，实现如下代码

任务2：梯度计算和梯度下降过程

1.学习自动求梯度原理
2. 学习随机梯度下降原理(SGD)

随机梯度下降在计算下降最快的方向时时随机选一个数据进行计算，而不是扫描全部训练数据集，这样就加快了迭代速度。随机梯度下降并不是沿着J(θ)下降最快的方向收敛，而是震荡的方式趋向极小点

3. 使用numpy创建一个y=10*x+4+noise(0,1)的数据, 其中x是0到100的范围，以0.01进行等差数列, 定义w和b，并使用随机梯度下降，完成回归拟合.
3.1 首先定义初始数据x,y,noise，然后根据这些拟合出w，b

import torch

device = torch.device("cuda:0")
x = torch.linspace(0, 100, 10000, device=device, dtype=torch.float)
noise=torch.rand(10000, device=device, dtype=torch.float)
y = 10 * x + 4.0 + noise

3.2 初步使用tensor的前向反向传播解题

w = torch.randn((), device=device, dtype=torch.float)
b = torch.randn((), device=device, dtype=torch.float)
learning_rate = 1e-8
for t in range(50000):

    y_pred = w * x + b                         #前向传递，计算y的预测值
    loss = (y_pred - y).pow(2).sum().item()    #损失函数

    grad_y_pred = 2.0 * (y_pred - y)           #反向传递，计算w，b相对于损失的梯度
    grad_b = grad_y_pred.sum()
    grad_w = (grad_y_pred * x).sum()
    b -= learning_rate * grad_b                #使用梯度下降更新权重
    w -= learning_rate * grad_w
    
print(w.item(),b.item())

初始学习率设小一点，要不然loss出现nan, 该方法循环了5万次才得到较好的结果，

w,b 分别为10.004472732543945 4.203275680541992

3.3 使用Autograd求解

w = torch.randn((), device=device, dtype=torch.float, requires_grad=True)
b = torch.randn((), device=device, dtype=torch.float, requires_grad=True)
learning_rate = 1e-8
for k in range(50000):
    y_pred = w * x + b
    loss = (y_pred - y).pow(2).sum()
    loss.backward()
    
    with torch.no_grad():
        w -= learning_rate * w.grad
        b -= learning_rate * b.grad
        w.grad = None
        b.grad = None
print(w.item(),b.item())

w,b 分别为10.004472732543945 4.203275680541992

3.4 使用nn包

class Polynomial(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.w = torch.nn.Parameter(torch.randn(()))
        self.b = torch.nn.Parameter(torch.randn(()))
    def forward(self, x):
        return self.b + self.w * x

model = Polynomial()
loss_fn = torch.nn.MSELoss(reduction='sum')
optimizer = torch.optim.SGD(model.parameters(), lr=1e-8)
for t in range(50000):
    y_pred = model(x)
    loss = loss_fn(y_pred, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

w，b的结果为 10.00623893737793 和4.085504531860352，可以看出使用SGD对结果有益处。

任务3：PyTorch全连接层原理和使用

1.学习全连接网络，参考文章
2.在pytorch中使用矩阵乘法实现全连接层
3.使用nn.Linear层

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

model = MyModel()                                          #实例化模型
optimizer = torch.optim.SGD(model.parameters(),lr=1e-6)    #实例化优化器
loss_fn = nn.MSELoss()                                     #实例化损失函数

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