02 Pytorch代码实践之【线性回归】

最新推荐文章于 2023-05-28 13:29:55 发布
最新推荐文章于 2023-05-28 13:29:55 发布
阅读量248 收藏
点赞数
分类专栏： pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32939413/article/details/108761680
版权 
import torch
import matplotlib.pyplot as plt
# 准备数据
x = torch.Tensor([1.4, 5, 11, 16, 21])
y = torch.Tensor([14.4, 29.6, 62, 85.5, 113.4])
# 绘制散点图
plt.scatter(x.numpy(), y.numpy())
plt.show()

简单的线性回归

import torch
import matplotlib.pyplot as plt

# 生成矩阵X[5,2]
def Produce_X(x):
    x0 = torch.ones(x.numpy().size)
    X = torch.stack((x, x0), dim=1)
    return X


x = torch.Tensor([1.4, 5, 11, 16, 21])
y = torch.Tensor([14.4, 29.6, 62, 85.5, 113.4])
X = Produce_X(x)
inputs = X
target = y
# 生成向量w[2,1]
w = torch.rand(2, requires_grad=True)
print(X)
print(w)

tensor([[ 1.4000,  1.0000],
        [ 5.0000,  1.0000],
        [11.0000,  1.0000],
        [16.0000,  1.0000],
        [21.0000,  1.0000]])
tensor([0.2637, 0.4283], requires_grad=True)





tensor([0.2637, 0.4283])

def draw(output, loss):
    plt.cla()  # 清空画布
    plt.scatter(x.numpy(), y.numpy())
    plt.plot(x.numpy(), output.data.numpy(), 'r-', lw=5)
    plt.text(1, 0, 'loss=%s' % (loss.item()),
             fontdict={'size': 20, 'color': 'red'})
    plt.pause(0.005)

def train(epochs=1, learn_rate=0.01):
    for epoch in range(epochs):
        output = inputs.mv(w)
        loss = (output - target).pow(2).sum()
        loss.backward()
        w.data -= learn_rate * w.grad
        w.grad.zero_()  # 将模型的参数梯度初始化为0
        if epoch % 100 == 0:
            draw(output, loss)  # 重新绘制
    return w, loss


w, loss = train(1000, learn_rate=1e-4)
print("final loss:", loss.item())
print("weights:", w.data)

在这里插入图片描述
…省略多张图片…
在这里插入图片描述

 final loss: nan
    weights: tensor([nan, nan], device='cuda:0')

大批量数据处理

import torch
import matplotlib.pyplot as plt


# 生成矩阵X[5,2]
def Produce_X(x):
    x0 = torch.ones(x.numpy().size)
    X = torch.stack((x, x0), dim=1)
    return X


x = torch.linspace(-3, 3, 100000)
y = x + 1.2 * torch.rand(x.size())
X = Produce_X(x)
inputs = X
target = y
# 生成向量w[2,1]
w = torch.rand(2, requires_grad=True)


def draw(output, loss):
    plt.cla()  # 清空画布
    plt.scatter(x.numpy(), y.numpy(), s=0.001)
    plt.plot(x.numpy(), output.data.numpy(), 'r-', lw=5)
    plt.text(0.5, 0, 'loss=%s' % (loss.item()),
             fontdict={'size': 20, 'color': 'red'})
    plt.pause(0.005)


def train(epochs=1, learn_rate=0.01):
    for epoch in range(epochs):
        output = inputs.mv(w)
        loss = (output - target).pow(2).sum()
        loss.backward()
        w.data -= learn_rate * w.grad
        w.grad.zero_()  # 将模型的参数梯度初始化为0
        if epoch % 80 == 0:
            draw(output, loss)  # 重新绘制
    return w, loss


w, loss = train(1000, learn_rate=1e-4)
print("final loss:", loss.item())
print("weights:", w.data)

在这里插入图片描述
…在这里插入图片描述

为什么两次训练都出现none?，猜测可能是损失值过大，溢出内存，我还不太明白，但是毕竟不影响后续的实验

final loss: nan
weights: tensor([nan, nan])

torch.cuda.is_available()

True

使用cuda训练

print(torch.cuda.is_available())
#cuda是否可用；

print(torch.cuda.device_count())
#返回gpu数量；

print(torch.cuda.get_device_name(0))
#返回gpu名字，设备索引默认从0开始；

print(torch.cuda.current_device())
#返回当前设备索引；

True
1
GeForce MX250
0

import torch
import matplotlib.pyplot as plt


# 生成矩阵X[5,2]
def Produce_X(x):
    x0 = torch.ones(x.numpy().size)
    X = torch.stack((x, x0), dim=1)
    return X


x = torch.linspace(-3, 3, 100000)
y = x + 1.2 * torch.rand(x.size())
X = Produce_X(x)
# inputs = X
# target = y
# 生成向量w[2,1]
w = torch.rand(2)

# --------------cuda-----------------
CUDA = torch.cuda.is_available()
if CUDA:
    inputs = X.cuda()
    target = y.cuda()
    w = w.cuda()
    w.requires_grad = True
else:
    inputs = X
    target = y
    w = w
    w.requires_grad = True


# --------------cuda-----------------
def draw(output, loss):
    plt.cla()  # 清空画布
    if CUDA:
        output = output.cpu()  # 还原为cpu类型才能进行绘图
    plt.scatter(x.numpy(), y.numpy(), s=0.001)
    plt.plot(x.numpy(), output.data.numpy(), 'r-', lw=5)
    plt.text(0.5, 0, 'loss=%s' % (loss.item()),
             fontdict={'size': 20, 'color': 'red'})
    plt.pause(0.005)


def train(epochs=1, learn_rate=0.01):
    for epoch in range(epochs):
        output = inputs.mv(w)
        loss = (output - target).pow(2).sum() / 100000
        loss.backward()
        w.data -= learn_rate * w.grad
        w.grad.zero_()  # 将模型的参数梯度初始化为0
        if epoch % 100 == 0:
            draw(output, loss)  # 重新绘制
    return w, loss


w, loss = train(2000, learn_rate=1e-4)
print("final loss:", loss.item())
print("weights:", w.data)

在这里插入图片描述
…
在这里插入图片描述

final loss: 0.17435269057750702
weights: tensor([0.8681, 0.6192], device='cuda:0')

a = torch.rand(2)
print(a)
print(a.device)
a = a.cuda()
print(a.device)

tensor([0.7874, 0.3465])
cpu
cuda:0

引入time包，记录训练时间长度

import torch
import matplotlib.pyplot as plt
from time import perf_counter
# 指定GPU的id
torch.cuda.set_device(0)
# 生成矩阵X[5,2]


def Produce_X(x):
    x0 = torch.ones(x.numpy().size)
    X = torch.stack((x, x0), dim=1)
    return X


x = torch.linspace(-3, 3, 100000)
y = x + 1.2 * torch.rand(x.size())
X = Produce_X(x)
# inputs = X
# target = y
# 生成向量w[2,1]
w = torch.rand(2)

# --------------cuda-----------------
CUDA = torch.cuda.is_available()
if CUDA:
    inputs = X.cuda()
    target = y.cuda()
    w = w.cuda()
    w.requires_grad = True
else:
    inputs = X
    target = y
    w = w
    w.requires_grad = True


# --------------cuda-----------------
def draw(output, loss):
    plt.cla()  # 清空画布
    if CUDA:
        output = output.cpu()  # 还原为cpu类型才能进行绘图
    plt.scatter(x.numpy(), y.numpy(), s=0.001)
    plt.plot(x.numpy(), output.data.numpy(), 'r-', lw=5)
    plt.text(0.5, 0, 'loss=%s' % (loss.item()),
             fontdict={'size': 20, 'color': 'red'})
    plt.pause(0.005)


def train(epochs=1, learn_rate=0.01):
    for epoch in range(epochs):
        output = inputs.mv(w)
        loss = (output - target).pow(2).sum() / 100000
        loss.backward()
        w.data -= learn_rate * w.grad
        w.grad.zero_()  # 将模型的参数梯度初始化为0
        if epoch % 100 == 0:
            draw(output, loss)  # 重新绘制
    return w, loss


start = perf_counter()
w, loss = train(5000, learn_rate=1e-4)
finish = perf_counter()
time = finish - start
print("计算时间：%s" % time)
print("final loss:", loss.item())
print("weights:", w.data)

在这里插入图片描述
…
在这里插入图片描述

计算时间：32.38653709999926
final loss: 0.12629716098308563
weights: tensor([0.9559, 0.6240], device='cuda:0')

import torch
import matplotlib.pyplot as plt
from time import perf_counter

# 生成矩阵X[5,2]


def Produce_X(x):
    x0 = torch.ones(x.numpy().size)
    X = torch.stack((x, x0), dim=1)
    return X


x = torch.linspace(-3, 3, 100000)
y = x + 1.2 * torch.rand(x.size())
X = Produce_X(x)
# inputs = X
# target = y
# 生成向量w[2,1]
w = torch.rand(2)

# --------------cuda-----------------
# CUDA = torch.cuda.is_available()
# if CUDA:
#     inputs = X.cuda()
#     target = y.cuda()
#     w = w.cuda()
#     w.requires_grad = True
# else:
inputs = X
target = y
w = w
w.requires_grad = True


# --------------cuda-----------------
def draw(output, loss):
    plt.cla()  # 清空画布
#     if CUDA:
#         output = output.cpu()  # 还原为cpu类型才能进行绘图
    plt.scatter(x.numpy(), y.numpy(), s=0.001)
    plt.plot(x.numpy(), output.data.numpy(), 'r-', lw=5)
    plt.text(0.5, 0, 'loss=%s' % (loss.item()),
             fontdict={'size': 20, 'color': 'red'})
    plt.pause(0.005)


def train(epochs=1, learn_rate=0.01):
    for epoch in range(epochs):
        output = inputs.mv(w)
        loss = (output - target).pow(2).sum() / 100000
        loss.backward()
        w.data -= learn_rate * w.grad
        w.grad.zero_()  # 将模型的参数梯度初始化为0
        if epoch % 100 == 0:
            draw(output, loss)  # 重新绘制
    return w, loss


start = perf_counter()
w, loss = train(5000, learn_rate=1e-4)
finish = perf_counter()
time = finish - start
print("计算时间：%s" % time)
print("final loss:", loss.item())
print("weights:", w.data)

在这里插入图片描述
…
在这里插入图片描述

计算时间：36.91037469999992
final loss: 0.14871178567409515
weights: tensor([0.9556, 0.4466])

人工神经元

# 导入库
import torch
import matplotlib.pyplot as plt
from torch import nn, optim
from time import perf_counter

x = torch.linspace(-3, 3, 100000)
x = torch.unsqueeze(x, dim=1)  # 在第一维处增加一个维度
y = x + 1.2 * torch.rand(x.size())
print(x.size())


# 回归类
class LineRegression(nn.Module):
    def __init__(self):
        super(LineRegression, self).__init__()
        self.linear = nn.Linear(1, 1)

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


CUDA = torch.cuda.is_available()
if CUDA:
    LR_model = LineRegression().cuda()
    inputs = x.cuda()
    target = y.cuda()
else:
    LR_model = LineRegression()
    inputs = x
    target = y

criterion = nn.MSELoss()
optimizer = optim.SGD(LR_model.parameters(), lr=1e-4)


def draw(output, loss):
    plt.cla()  # 清空画布
    if CUDA:
        output = output.cpu()  # 还原为cpu类型才能进行绘图
    plt.scatter(x.numpy(), y.numpy(), s=0.001)
    plt.plot(x.numpy(), output.data.numpy(), 'r-', lw=5)
    plt.text(0.5, 0, 'loss=%s' % (loss.item()),
             fontdict={'size': 20, 'color': 'red'})
    plt.pause(0.005)


def train(model, criterion, optimizer, epochs):
    for epoch in range(epochs):
        output = model(inputs)
        loss = criterion(output, target)
        optimizer.zero_grad()  # 清空权值
        loss.backward()
        optimizer.step()  # 权值更新
        if epoch % 80 == 0:
            draw(output, loss)
    return model, loss


start = perf_counter()
LR_model, loss = train(LR_model, criterion, optimizer, 5000)
finish = perf_counter()
time = finish - start
print("计算时间：%s" % time)
print("final loss:", loss.item())
print("weights:", list(LR_model.parameters()))


torch.Size([100000, 1])

在这里插入图片描述
…
在这里插入图片描述

计算时间：41.9481209999999
final loss: 0.1268048733472824
weights: [Parameter containing:
tensor([[0.9967]], device='cuda:0', requires_grad=True), Parameter containing:
tensor([0.6864], device='cuda:0', requires_grad=True)]
Shine.Zhang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
pytorch实现学习率衰减的方法总结
PanYHHH的博客
07-16 5830
前言： 之前在训练模型时一直使用自定义的学习率衰减函数，如下所示： def adjust_learning_rate(args, optimizer, epoch, gamma=0.1): """Sets the learning rate to the initial LR decayed 0.1 every 50 epochs""" lr = args.lr * (0.1 ** (epoch // 50)) for param_group in optimizer.para
深度学习数据集生成函数的创建与使用
a_Loki的博客
06-29 880
dataset和dataloader：通过生成数据的生成器或者保存数据的映射关系来避免数据的重复储存数据生成：我们自己生成含有一定规律的数据集， 三个函数可以分别生成回归，分类，小批量随机的数据集，利用该数据集，实现一些简单的模型回归模型（手动创建）： 快速实现（调库）：......
知识蒸馏：《Distilling the Knowledge in a Neural Network》算法介绍及PyTorch代码实例
weixin_44808161的博客
08-02 2204
知识蒸馏开山之作《Distilling the Knowledge in a Neural Network》算法介绍及PyTorch代码实例
深度学习模型、数据集分割、训练、优化算法、模型解释
最新发布
weixin_41733381的博客
05-28 782
深度学习模型训练优化算法的主要特点和步骤
33- PyTorch实现分类和线性回归 (PyTorch系列) (深度学习)
March_A的博客
03-06 2018
线性回归预测的是一个连续值, 逻辑回归给出的”是”和“否”的回答, 逻辑回归通过sigmoid函数把线性回归的结果规范到0到1之间.sigmoid函数是一个概率分布函数， 给定某个输入，它将输出为一个概率值.# 回归和分类之间, 区别不大, 回归后面加上一层sigmoid, 就变成分类了.(pytorch 最常见的创建模型的方式, 子类)# pytorch 最常见的创建模型的方式, 子类# 需要自定义类# 先调用父类的方法# 定义网络中会用到的东西.
pytorch深度学习实战lesson9
weixin_48304306的博客
11-09 1979
线性回归从零开始和简洁版实现
使用Pytorch解决回归问题的一般方法
liuqihang11的博客
09-23 1万+
1 数据预处理 1.1 归一化（Min-Max Scaling）与标准化（Standardization） 归一化与标准化均不改变数据分布，归一化后数据会在0，1之间（也可以设置成其他任意范围），标准化后数据的均值为0，方差为1。 大多数机器学习算法中，会选择标准化进行特征缩放，因为归一化对异常值非常敏感，在神经网络算法中也是采用标准化处理数据。 归一化： 标准化： 归一化代码实现： '''对每列（特征）归一化''' from sklearn.preprocessing import Mi.
Pytorch中的学习率衰减及其用法
开飞机的小毛驴儿
10-10 1万+
学习率衰减是一个非常有效的炼丹技巧之一，在神经网络的训练过程中，当accuracy出现震荡或loss不再下降时，进行适当的学习率衰减是一个行之有效的手段，很多时候能明显提高accuracy。 Pytorch中有两种学习率调整(衰减)方法： 使用库函数进行调整； 手动调整。 1. 使用库函数进行调整： Pytorch学习率调整策略通过 torch.optim.lr_sheduler 接口实现。pytorch提供的学习率调整策略分为三大类，分别是： （1）有序调整：等间隔调整(Step)，多间隔调整(M
keras 分批训练 详解2 - keras 进阶教程
蓝一潇的博客
05-10 3045
keras 分批训练2 今天讲的是如何使用keras进行分批训练（也叫增量训练、增量学习、在线训练）的第二种方法，上一种方法在这里： https://blog.csdn.net/weixin_42744102/article/details/87272950 上一次讲的是fit_generator的方法，那个方法搞不清每层的名字就很容易报错、计算错了step和batch也很麻烦，需要自己写的生成器...
Pytorch深度学习实践第十三讲 循环神经网络（高级篇）
happypybestpy的博客
03-26 124
【代码】Pytorch深度学习实践第十三讲 循环神经网络（高级篇）
深度学习编程笔记：tensorflow2.1案例实战---神经网络实现鸢尾花分类
weixin_42503072的博客
04-07 1423
# 利用鸢尾花数据集，实现前向传播、反向传播，可视化loss曲线 # 导入所需模块 import tensorflow as tf from sklearn import datasets from matplotlib import pyplot as plt import numpy as np import time ##1## # 导入数据，分别为输入特征和标签 x_data = d...
keras 开发文档 6：从头开始编写训练循环（Writing a training loop from scratch）
xiaojianzhao的博客
07-15 1003
设置 import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import numpy as np 介绍 Keras提供了默认的训练和评估循环，fit（）和valuate（）。 用内置方法进行训练与评估指南中介绍了它们的用法。 如果您想自定义模型的学习算法，同时又利用fit（）的便利性（例如，使用fit（）训练GAN），则可以继承Model类并实现自己的train_step（）方法，
Pytorch 带你一行一行分析训练脚本
rosinante
04-13 6713
在使用pytorch进行深度学习模型训练时，训练脚本是不可或缺的一部分，本文将以一个经典的训练脚本为对象，一行一行分析其代码原理。
Pytorch学习笔记
m0_56945333的博客
12-07 949
Pytorch深度学习实践笔记
Pytorch中的学习率衰减方法
weixin_40500230的博客
07-13 2649
原文：https://www.jianshu.com/p/9643cba47655 Pytorch 中的学习率调整方法 Pytorch中的学习率调整有两种方式： 直接修改optimizer中的lr参数； 利用lr_scheduler()提供的几种衰减函数 1. 修改optimizer中的lr： import torch import matplotlib.pyplot as pl...
pytorch学习（一）利用pytorch训练一个最简单的分类器-------（基于CIFAR10数据集）的句句讲解
sinat_42239797的博客
05-20 1万+
刚学pytorch两周，利用这个分类器学习pytorch的如何运用 训练一个分类网络分为以下几个步骤： 1数据的加载及预处理 2网络模型的设置 3.定义损失函数及优化器 4.用训练集训练网络 5.用测试集测试网络 1.数据的加载及预处理 1.加载数据集（训练集和测试集） 2.扩充数据集防止过拟合 2.网络模型的设置 网络模型的设置主要是网络结构的设置： 本次我们使用的是简单的一个类网络的简单设置 ...
PyTorch批训练及优化器使用
荷叶田田
01-09 3355
一、PyTorch批训练 1. 概述 PyTorch提供了一种将数据包装起来进行批训练的工具——DataLoader。使用的时候，只需要将我们的数据首先转换为torch的tensor形式，再转换成torch可以识别的Dataset格式，然后将Dataset放入DataLoader中就可以啦。 import torch import torch.utils.data as Data t...
Pytorch学习笔记（六）
热门推荐
kongshuchen的博客
05-16 1万+
（10）使用Pytorch实现ResNet ResNet要解决的问题 深度学习网络的深度对最后的分类和识别的效果有着很大的影响，所以正常想法就是能把网络设计的越深越好，但是事实上却不是这样，常规的网络的堆叠（plain network）在网络很深的时候，效果却越来越差了。 其中的原因之一即是网络越深，梯度消失的现象就越来越明显，网络的训练效果也不会很好。 但是现在浅层的网络（shallower
pytorch练习
学习笔记
06-05 5289
CIFAR10练习 安装anaconda中没有的包可以在anaconda cloud和python中查找。本次主要是对CIFAR10进行分类（只是简单的分类，代码需要优化），实验代码如下： import torch import torch.nn as nn import torch.nn.functional as F import torchvision import torchvisi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Shine.Zhang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值