pytorch 线性回归总结

最新推荐文章于 2024-09-26 14:22:22 发布
最新推荐文章于 2024-09-26 14:22:22 发布
阅读量341 收藏 1
点赞数
文章标签： pytorch 线性回归 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45759229/article/details/130036498
版权

测试1( y = 3 ∗ x 1 − 4 ∗ x 2 y=3*x_{1}-4*x_{2} y=3∗x1​−4∗x2​),lr=1e-2

%matplotlib inline
import torch
import numpy as np
torch.manual_seed(1)
from torch.nn import Linear
from torch.autograd import Variable
import torch.nn as nn
import random
np.random.seed(1)
random.seed(1)   #每次运行的结果都一样
torch.manual_seed(1) 

import torch
import matplotlib.pyplot as plt

# x1 = torch.unsqueeze(torch.linspace(-1, 1, 200), dim=1)
# x2 = torch.unsqueeze(torch.linspace(-2, 2, 200), dim=1)
#x3 = torch.unsqueeze(torch.linspace(-2, 2, 100), dim=1)

x1=torch.randn(200,1)
x2=torch.randn(200,1)

y = 3*x1 -4*x2

# # 画图
# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()
# import numpy as np
# import matplotlib.pyplot as plt
# from mpl_toolkits import mplot3d

# ax = plt.axes(projection='3d')
# ax.scatter3D(x1.data.numpy(), x2.data.numpy(),y.data.numpy())
# print(x1.size())
# print(x2.size())
# print(y.size())
#torch.cat((x1,x2),dim=1)#保持
class Net(nn.Module):#这里是大写的Module
    def __init__(self):
        super(Net,self).__init__()
        self.Linear=nn.Linear(2,1)#把线性层赋值给自己的属性
    def forward(self,x):#forward()是有两个参数的
        x=self.Linear(x)
        return x
model=Net()#网络
print(model)
criter=torch.nn.MSELoss()#损失函数

#optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)#优化器

optimizer=torch.optim.Adam(model.parameters(),lr=1e-2)
#还需要一个DataGenerator()
num_epochs=1000
for i in range(num_epochs):
    #向前传播
    input=Variable(torch.cat((x1,x2),dim=1))
    target=Variable(y)
    out=model(input)#
    loss=criter(out,target)#
    #向后传播
    optimizer.zero_grad()#梯度清0
    loss.backward()#反向传播
    optimizer.step()#更新梯度
    print("epoch=%d,loss=%.6f"%(i,loss.item()))
#model.eval()
print(model)
parm={}
for name,parameters in model.named_parameters():
    print(name,':',parameters.size())
    parm[name]=parameters.detach().numpy()
print(parm)

结果如下
在这里插入图片描述
可以看到这个结果是准确的，但是一定要注意迭代的次数不能太少，且学习率不能太低，否则不容易收敛到真值，从而怀疑是不是自己代码写错了

测试2( y = 3 ∗ x 1 − 4 ∗ x 2 y=3*x_{1}-4*x_{2} y=3∗x1​−4∗x2​,lr=1e-3)

%matplotlib inline
import torch
import numpy as np
torch.manual_seed(1)
from torch.nn import Linear
from torch.autograd import Variable
import torch.nn as nn
import random
np.random.seed(1)
random.seed(1)   #每次运行的结果都一样
torch.manual_seed(1) 

import torch
import matplotlib.pyplot as plt

# x1 = torch.unsqueeze(torch.linspace(-1, 1, 200), dim=1)
# x2 = torch.unsqueeze(torch.linspace(-2, 2, 200), dim=1)
#x3 = torch.unsqueeze(torch.linspace(-2, 2, 100), dim=1)

x1=torch.randn(200,1)
x2=torch.randn(200,1)

y = 3*x1 -4*x2

# # 画图
# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()
# import numpy as np
# import matplotlib.pyplot as plt
# from mpl_toolkits import mplot3d

# ax = plt.axes(projection='3d')
# ax.scatter3D(x1.data.numpy(), x2.data.numpy(),y.data.numpy())
# print(x1.size())
# print(x2.size())
# print(y.size())
#torch.cat((x1,x2),dim=1)#保持
class Net(nn.Module):#这里是大写的Module
    def __init__(self):
        super(Net,self).__init__()
        self.Linear=nn.Linear(2,1)#把线性层赋值给自己的属性
    def forward(self,x):#forward()是有两个参数的
        x=self.Linear(x)
        return x
model=Net()#网络
print(model)
criter=torch.nn.MSELoss()#损失函数

#optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)#优化器

optimizer=torch.optim.Adam(model.parameters(),lr=1e-3)
#还需要一个DataGenerator()
num_epochs=1000
for i in range(num_epochs):
    #向前传播
    input=Variable(torch.cat((x1,x2),dim=1))
    target=Variable(y)
    out=model(input)#
    loss=criter(out,target)#
    #向后传播
    optimizer.zero_grad()#梯度清0
    loss.backward()#反向传播
    optimizer.step()#更新梯度
    print("epoch=%d,loss=%.6f"%(i,loss.item()))
#model.eval()
print(model)
parm={}
for name,parameters in model.named_parameters():
    print(name,':',parameters.size())
    parm[name]=parameters.detach().numpy()
print(parm)
## 如果学习率过低，收敛很慢

结果如下
在这里插入图片描述
可以看到这里没有收敛的，

测试3( y = 3 ∗ x + 4 y = 3*x +4 y=3∗x+4一元线性回归）

%matplotlib inline
import torch
import numpy as np
torch.manual_seed(1)
from torch.nn import Linear
from torch.autograd import Variable
import torch.nn as nn
import random
np.random.seed(1)
random.seed(1)   #每次运行的结果都一样
torch.manual_seed(1) 

import torch
import matplotlib.pyplot as plt

x1=torch.randn(200,1)


y = 3*x1 +4

# # 画图
# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()
# import numpy as np
# import matplotlib.pyplot as plt
# from mpl_toolkits import mplot3d

# ax = plt.axes(projection='3d')
# ax.scatter3D(x1.data.numpy(), x2.data.numpy(),y.data.numpy())
# print(x1.size())
# print(x2.size())
# print(y.size())
#torch.cat((x1,x2),dim=1)#保持
class Net(nn.Module):#这里是大写的Module
    def __init__(self):
        super(Net,self).__init__()
        self.Linear=nn.Linear(1,1)#把线性层赋值给自己的属性
    def forward(self,x):#forward()是有两个参数的
        x=self.Linear(x)
        return x
model=Net()#网络
print(model)
criter=torch.nn.MSELoss()#损失函数

#optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)#优化器

optimizer=torch.optim.Adam(model.parameters(),lr=1e-2)
#还需要一个DataGenerator()
num_epochs=1000
for i in range(num_epochs):
    #向前传播
    input=Variable(x1)
    target=Variable(y)
    out=model(input)#
    loss=criter(out,target)#
    #向后传播
    optimizer.zero_grad()#梯度清0
    loss.backward()#反向传播
    optimizer.step()#更新梯度
    print("epoch=%d,loss=%.6f"%(i,loss.item()))
#model.eval()
print(model)
parm={}
for name,parameters in model.named_parameters():
    print(name,':',parameters.size())
    parm[name]=parameters.detach().numpy()
print(parm)

结果如下
在这里插入图片描述

测试4 y = 3 ∗ x + 4 y = 3*x +4 y=3∗x+4 使用dataloader-batch_size=32

%matplotlib inline
import torch
import numpy as np
torch.manual_seed(1)
from torch.nn import Linear
from torch.autograd import Variable
from torch.utils.data import DataLoader, Dataset,TensorDataset
import torch.nn as nn
import random
np.random.seed(1)
random.seed(1)   #每次运行的结果都一样
torch.manual_seed(1) 

import torch
import matplotlib.pyplot as plt

x1=torch.randn(200,1)


y = 3*x1 +4

# # 画图
# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()
# import numpy as np
# import matplotlib.pyplot as plt
# from mpl_toolkits import mplot3d

# ax = plt.axes(projection='3d')
# ax.scatter3D(x1.data.numpy(), x2.data.numpy(),y.data.numpy())
# print(x1.size())
# print(x2.size())
# print(y.size())
#torch.cat((x1,x2),dim=1)#保持
class Net(nn.Module):#这里是大写的Module
    def __init__(self):
        super(Net,self).__init__()
        self.Linear=nn.Linear(1,1)#把线性层赋值给自己的属性
    def forward(self,x):#forward()是有两个参数的
        x=self.Linear(x)
        return x
model=Net()#网络
print(model)
criter=torch.nn.MSELoss()#损失函数

dataset = TensorDataset(torch.FloatTensor(x1),torch.FloatTensor(y))

dataloader = DataLoader(dataset,batch_size = 32)

#optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)#优化器

optimizer=torch.optim.Adam(model.parameters(),lr=1e-3)
#还需要一个DataGenerator()
num_epochs=1000
for epoch in range(num_epochs):
    #向前传播
    mse_loss=0
    for idx,(input_x,target_y) in enumerate(dataloader):
        input=Variable(input_x)
        target=Variable(target_y)
        out=model(input)#
        loss=criter(out,target)#
        mse_loss += loss.item()
        #向后传播
        optimizer.zero_grad()#梯度清0
        loss.backward()#反向传播
        optimizer.step()#更新梯度
    print("epoch={},mse loss ={}".format(epoch,mse_loss/len(dataloader)))
model.eval()
print(model)
parm={}
for name,parameters in model.named_parameters():
    print(name,':',parameters.size())
    parm[name]=parameters.detach().numpy()
print(parm)

在这里插入图片描述可以看到使用batch_size进行训练时，也是可以得到准确的结果的

测试5( y = 3 ∗ x 1 − 4 ∗ x 2 + 2.30 y=3*x1-4*x2+2.30 y=3∗x1−4∗x2+2.30 dataloader,batch_size=32)

%matplotlib inline
import torch
import numpy as np
torch.manual_seed(1)
from torch.nn import Linear
from torch.autograd import Variable
from torch.utils.data import DataLoader, Dataset,TensorDataset
import torch.nn as nn
import random
np.random.seed(1)
random.seed(1)   #每次运行的结果都一样
torch.manual_seed(1) 

import torch
import matplotlib.pyplot as plt

# x1 = torch.unsqueeze(torch.linspace(-1, 1, 200), dim=1)
# x2 = torch.unsqueeze(torch.linspace(-2, 2, 200), dim=1)
#x3 = torch.unsqueeze(torch.linspace(-2, 2, 100), dim=1)

x1=torch.randn(200,1)
x2=torch.randn(200,1)

y = 3*x1 -4*x2 + 2.30


class Net(nn.Module):#这里是大写的Module
    def __init__(self):
        super(Net,self).__init__()
        self.Linear=nn.Linear(2,1)#把线性层赋值给自己的属性
    def forward(self,x):#forward()是有两个参数的
        x=self.Linear(x)
        return x
model=Net()#网络
print(model)
criter=torch.nn.MSELoss()#损失函数

#optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)#优化器

optimizer=torch.optim.Adam(model.parameters(),lr=1e-2)
dataset = TensorDataset(torch.FloatTensor(x1),torch.FloatTensor(x2),torch.FloatTensor(y))
dataloader = DataLoader(dataset,batch_size = 32)

#还需要一个DataGenerator()
num_epochs=1000
for epoch in range(num_epochs):
    mse_loss=0
    for idx,(input_x1,input_x2,target_y) in enumerate(dataloader):
        #向前传播
        input=Variable(torch.cat((input_x1,input_x2),dim=1))
        target=Variable(target_y)
        out=model(input)#
        loss=criter(out,target)#
        mse_loss += loss.item()
        #向后传播
        optimizer.zero_grad()#梯度清0
        loss.backward()#反向传播
        optimizer.step()#更新梯度
    print("epoch={},mse loss ={}".format(epoch,mse_loss/len(dataloader)))
#model.eval()
print(model)
parm={}
for name,parameters in model.named_parameters():
    print(name,':',parameters.size())
    parm[name]=parameters.detach().numpy()
print(parm)

在这里插入图片描述

我的心永远是冰冰哒
关注
pytorch线性回归简洁实现总结
hlhwna的博客
03-30 100
用于读取dataset，类似于pd.read类型的1.batch_size指的一次取的批量大小，2.shuffle=False, sampler=None,指的是否打乱以及不打乱用什么方式取得，3.取得批量超额是否舍弃最后一批，4.timeout=0，超额截断。5.nn.Linear(2, 1)，打造一个线性层（无激活函数），且（2，1）分别指输入输出特征，即w为（2，1），相当于上一层是两个节点，这一次一个节点。6..weight.data，.bias.data，可以调用对应的w和b。
Pytorch总结二之 线性回归算法原理与实现
yohnyang的博客
08-23 756
详解线性回归原理及Pytorch实现
轻松学pytorch – 使用多标签损失函数训练卷积网络
小白学视觉
06-19 653
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达大家好，我还在坚持继续写，如果我没有记错的话，这个是系列文章的第十五篇，pytorch中有很多非常方便使用的损失函数，本文就演示了如何通过多标签损失函数训练验证码识别网络，实现验证码识别。数据集这个数据是来自Kaggle上的一个验证码识别例子，作者采用的是迁移学习，基于ResNet18做到的训练。ht...
Pytorch 线性回归
负负得正的博客
04-13 2314
线性回归 回归（regression）是能为一个或多个自变量与因变量之间关系建模的一类方法。 在自然科学和社会科学领域，回归经常用来表示输入和输出之间的关系。 在机器学习领域中的大多数任务通常都与预测（prediction）有关。 当我们想预测一个数值时，就会涉及到回归问题。 常见的例子包括：预测价格（房屋、股票等）、预测住院时间（针对住院病人等）、 预测需求（零售销量等）。 0. 环境介绍 环境使用 Kaggle 里免费建立的 Notebook 教程使用李沐老师的 动手学深度学习 网站和 视频讲解 小
Pytorch线性回归的详细实现
一步一脚印
04-21 2378
线性回归单层神经网络-线性回归代码实现： 线性回归是⼀个单层神经⽹络  输⼊分别为x1和x2，因此输⼊层的输⼊个数为2,输⼊个数也叫特征数或 特征向量维度,输出层的输出个数为1,输出层中的神经元和输⼊层中各个输⼊完全连 接,因此，这⾥的输出层⼜叫全连接层,即一个简单地线性回归。  假设我们有三个预测数据： 转化为矩阵运算： 即 代码实现： 首先导入所需要的包： import torch import random import numpy as np from tqdm im
pytorch实现线性回归
m0_62032391的博客
07-14 2915
【代码】pytorch实现线性回归。
pytorch中的线性回归
jakelihua
03-10 1066
简介：线性回归是一种基本的机器学习模型，用于建立输入特征与连续输出之间的关系。它假设输入特征与输出之间的关系是线性的，并且尝试找到最佳的线性拟合，以最小化预测值与真实值之间的差距。
动手学pytorch 线性回归简洁代码
weixin_43970673的博客
01-16 718
根据李沐老师 动手学pytorch系列 逐行代码解析 仅自用 如有侵权 联系删除。
Pytorch实现线性回归模型
小森的博客
04-21 2307
我们接下来使用Pytorch的API来手动构建一个线性回归的假设函数损失函数及优化方法，熟悉一下训练模型的流程。🧨我们将这批数据每次分成16份训练，并且这样重复训练epochs次，可以更深入地学习数据中的特征和模式，有助于防止模型快速陷入局部最优解，从而提高模型的泛化能力，而且。由于每个批次的数据都是随机抽取的。方法被调用时，PyTorch 会自动计算该张量相对于所有需要梯度的参数的梯度，并将这些梯度累加到对应参数的。是简单函数还是复杂的损失函数，都能利用相同的方法来进行梯度的反向传播。
Pytorch实现线性回归Linear Regression
sweet_Mary的博客
08-01 496
Batch Gradient Descent：使用整个训练集来更新模型的参数。学习率过低，需要大量的迭代才能获得最小值。对于线性回归，特定类型的噪声是高斯噪声。创建自定义模块（内含一个线性回归）用PyTorch实现线性回归模块。学习率过高，可能错过参数的最佳值。与上文类似，只是多加了个b。
PyTorch线性回归和逻辑回归实战示例
09-20
在PyTorch中实现线性回归和逻辑回归是深度学习初学者经常接触的基本任务，这两个模型也是理解机器学习基础的好入口。线性回归用于预测连续数值型数据，而逻辑回归则用于分类问题，特别是二分类问题。下面我们将详细...
Pytorch线性回归分析
03-17
**PyTorch线性回归分析** PyTorch是一款强大的深度学习框架，由Facebook的AI研究团队开发，它提供了动态计算图的功能，使得模型构建和调试更为灵活。在本教程中，我们将深入探讨如何使用PyTorch实现一个简单的线性...
pytorch线性回归.zip
09-02
pytorch实现线性回归。在这个例子中，代码将随机创建一个模拟的数据集，其中包含一些输入特征（x）和对应的目标变量（y），这些目标变量是x的线性变换加上一些随机噪声。
PyTorch线性回归和逻辑回归实战示例.pdf
04-17
在这个实战示例中，我们探讨了如何使用 PyTorch 实现线性回归和逻辑回归。 线性回归是一种简单的统计模型，用于预测一个连续变量。在 PyTorch 中实现线性回归主要涉及以下几个步骤： 1. **设计网络架构**：线性...
seq2seq翻译实战-Pytorch复现
最新发布
Banana0840的博客
09-26 872
Transformer模型通过创新的自注意力机制和位置编码，在seq2seq翻译任务中展现出卓越性能。它由编码器和解码器两部分组成，编码器将源语言文本转换为上下文表示，解码器则基于这些表示和已生成的目标语言文本部分来预测下一个词。自注意力机制允许模型在处理每个词时考虑整个序列的上下文，有效捕捉长距离依赖。尽管模型计算复杂且对计算资源要求较高，但其并行处理能力和在多个NLP任务上的优越表现，使其成为当前自然语言处理领域的重要基石。
libtorch落地AI项目的一些总结
学-> 思->用
09-22 538
总结 1. 为啥C++ 写AI C++ 是一个非常强大的编程语言，它具有非常强大的计算能力，可以处理非常大的数据集，并且可以非常快速地完成计算。 很多项目需要嵌入式部署，C++ 是一个非常适合的编程语言。 C++ 可以非常快速地完成计算，并且可以非常快速地完成计算。 2. C++写AI的好处 计算效率高 AI只是项目的一部分,方便集成测试 3. C++落地AI需要注意什么? 平台选择:ARM还是x86架构?区别还是很大的 linux环境推荐,毕竟很多嵌入式项目是linux libtorch的版本与
nn.Embedding
qq_45809323的博客
09-22 386
在这个代码片段中，类继承了类，并在__init__方法中通过调用来初始化父类。由于没有定义新的方法，默认情况下它会使用的行为来提供返回值。
每天五分钟深度学习框架pytorch：交叉熵计算时的维度是什么？
huanfeng_AI的博客
09-25 282
上面是分别使用了nn模块，还有functional模块来完成交叉熵损失函数，不同的是nn模块先构建对象，而functional模块可以直接调用。使用CrossEntropyLoss可以直接计算交叉熵，而使用nn.NLLoss需要先对数据进行softmax处理，然后再取log，这就是二者的区别。
使用Python的subprocess执行另外一个python文件（应用之一是Pytorch中如何让多个不同的模型同时/并行进行训练）
qq_43391414的博客
09-23 559
p1和p2这两个进程谁先执行完毕是未知的。使用wait之后，我们会等待这两个进程都执行完毕之后再执行主程序。上面这样执行另外一个python程序，其实我们并没有关心那个程序什么时候运行结束。所以，如果helloworld.py需要额外传入参数才能运行，可以在那个列表。上面只调用了一个外部文件执行，我们可以多调用几个，这几个程序是并行执行的！运行结束后会输出一些结果，这些结果是主程序需要的。的文件，在主程序如下运行即可。这样的话，后面的程序就会等待。运行结束才能往下运行，因为。运行结束后再运行，没有。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值