Pytorch使用——函数拟合问题样例

最新推荐文章于 2024-03-02 00:07:58 发布
最新推荐文章于 2024-03-02 00:07:58 发布
阅读量2.1k 收藏 12
点赞数
文章标签： pytorch 深度学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyrim_H/article/details/122826616
版权
本文介绍了如何使用PyTorch搭建一个多层神经网络，通过线性层和激活函数的组合来拟合复杂的函数曲线。作者首先展示了如何建立一个包含多个隐藏层的模型，并使用LeakyReLU作为激活函数。然后，创建了一个训练器，包含了模型训练的基本流程，如梯度下降、损失计算等。训练过程中，作者模拟了一个二次函数并进行拟合。训练结果显示，模型在训练区间内拟合效果良好，但在未训练区间表现较差，体现了过拟合的现象。
摘要由CSDN通过智能技术生成

前言

Pytorch使用——回归问题样例
在上一篇文章中，我们解决了一个简单的线性回归问题，即建立了一个线性模型，通过机器学习的方法把bias和weight求出来了。
那么现在我们就要真正地搭建一个神经网络，将线性层和激活函数进行排列组合，完成一些复杂的工作，比如任意函数曲线拟合，我曾经看到有人说理论上线性层加激活函数的排列组合可以模拟任意模型。

头文件

这一次我们使用了这些库

from turtle import forward
from typing import Any, Callable
import torch
import numpy as np
import time
import torch.nn.functional as F
import matplotlib.pyplot as plt
import math

建立模型

可以看到我们这一次的类依然主要包含了两个函数，分别是初始化函数__init__以及实例化前向预测函数forward，而LReLU函数是我自己写的Leaky ReLU激活函数，为了兼容所有shape的tensor，所以效率很低，最后经过测试也发现实际上效率确实很低（无奈）， 追踪F.relu函数，发现它是一个导入的C函数，所以也没办法参考源码了。

我设置了3个输入参数，分别是模型的输入参数数量，输出参数数量，隐藏层参数数量，根据隐藏层参数数量的list定义了len(list)数量的线性层

class multiLayer(torch.nn.Module):
	'''
	构造函数
	输入参数:
	 		_input:		输入层数量，如1
			_output:	输出层数量，如1
			list:		中间层结构，如[3,4,5,6]
	'''
    def __init__(self, _input=1, _output=1, list = []):
        self.layout = len(list)
        self.parameters = []
        # 如果中间层list的size为0，即没有中间层，则该模型回归线性模型
        if self.layout == 0:
            self.model = [torch.nn.Linear(_input, _output)]
        # 如果存在中间层，则模型model将被组装为[_input, list[0], list[1], ..., _output]的形式
        else:
            for i in range(0, self.layout):
                if i == 0:
                    self.model = [torch.nn.Linear(_input, list[0])]
                else:
                    self.model.append(torch.nn.Linear(list[i - 1], list[i]))
            self.model.append(torch.nn.Linear(list[self.layout - 1], _output))
        # self.modelSize用于储存模型的总层数 ，(输入层-隐藏层1-输出层)算2层
        self.modelSize = len(self.model)
        # 使用self.parameters来记录每一层的偏置和权重，用于反向传播
        for i in range(0, self.modelSize):
            self.parameters.append(self.model[i].weight)
            self.parameters.append(self.model[i].bias)
            
    def forward(self, x):
        for i in range(0, self.modelSize):
            x = self.model[i](x)
            if i < self.modelSize - 1:
                x = F.relu(x)
                # x = self.LReLU(x)
        return x        
        
    def LReLU(self, x):
        size = x.shape
        k = 1
        for i in size:
            k = k * i
        x = x.view(k)
        for i in x:
            i = i if i > 0 else 0.01 * i
        return x.view(size)
 
    __call__: Callable[..., Any] = forward

建立训练器

我们在构造函数中传入上面建立好的模型，将模型中需要训练的参数传入SGD优化器，并设置学习率，设置损失函数为MSE均方误差。
将SGD的功能都封装一下，方便调用（zero_grad/step）。
最后，我们需要添加一个归一化方法（很重要），如果不加归一化，当输入数据十分大并且存在负数时，经过几层网络的非线性层之后，一个非常大的输入很有可能直接就变成0或者一个很小的数字，导致我们所需要的特征直接丢失了，最后使网络发散。（个人理解，如果不对，还请指正）
因此我们将输入的数据线性变换到了[0-1]范围内了，为了方便使用，我们还定义了一个predict函数，直接调用predict函数就可以得到反归一化之后的结果了。

class multiTrain():
    def __init__(self, multiLayer: multiLayer) -> None:
        self.model = multiLayer
        self.opt = torch.optim.SGD(self.model.parameters, lr=1e-2)
        self.loss = torch.nn.MSELoss()

    def predict(self, x):
        return self.d_normalize(self.model(x))

    def zero_grad(self):
        # for i in range(0, len(self.opt)):
        self.opt.zero_grad()
    
    def step(self):
        # for i in range(0, len(self.opt)):
        self.opt.step()     

    def normalize(self, x):
        self.dataMax = x.max()
        self.dataMin = x.min()
        return (x - self.dataMin) / (self.dataMax - self.dataMin)

    def d_normalize(self, x):
        return x * (self.dataMax - self.dataMin) + self.dataMin

训练

模型和训练器都搭好之后我们，接下来就是训练过程。
我们模拟了一个y = 3.24 * x ^ 2 - 4.21112的函数。

#初始化数据
x1 = torch.tensor(np.linspace(-10,20,1000), dtype=torch.float32).view(1000,1)
x2 = torch.tensor(np.linspace(-20,40,500), dtype=torch.float32).view(500,1)
yreal = (x1 * 3.24) * x1 - 4.21112 #+ torch.randn(x1.size())

T = multiTrain(multiLayer(1, 1, list = [10,10,10,10,10,10,10,10]))
yreal = T.normalize(yreal)
for i in range(50000):

    y = T.model(x1)
    loss = T.loss(yreal, y)
    T.zero_grad()
    loss.backward()
    T.step()
    # 打印
    if i % 100 == 0:
        pass

整体代码

from turtle import forward
from typing import Any, Callable
import torch
import numpy as np
import time
import torch.nn.functional as F
import matplotlib.pyplot as plt
import math


#这是一个能够拟合任意函数的模型框架


# class linearModel(torch.nn.Module):
#     def __init__(self, _input = 1, _output = 1):
#         super().__init__()
#         self.model = torch.nn.Linear(_input, _output)

#     def forward(self, x):
#         return self.model(x)


# class Train():
#     def __init__(self, model) -> None:
#         self.model = model
#         self.opt = torch.optim.SGD(model.parameters(), lr=1e-3)
#         self.loss = torch.nn.MSELoss()

class multiLayer(torch.nn.Module):
    def __init__(self, _input=1, _output=1, list = []):
        self.layout = len(list)
        self.parameters = []
        if self.layout == 0:
            self.model = [torch.nn.Linear(_input, _output)]
        else:
            for i in range(0, self.layout):
                if i == 0:
                    self.model = [torch.nn.Linear(_input, list[0])]
                else:
                    self.model.append(torch.nn.Linear(list[i - 1], list[i]))
            self.model.append(torch.nn.Linear(list[self.layout - 1], _output))
        self.modelSize = len(self.model)
        for i in range(0, self.modelSize):
            self.parameters.append(self.model[i].weight)
            self.parameters.append(self.model[i].bias)
        
    def LReLU(self, x):
        size = x.shape
        k = 1
        for i in size:
            k = k * i
        x = x.view(k)
        for i in x:
            i = i if i > 0 else 0.01 * i
        return x.view(size)
    
    def forward(self, x):
        for i in range(0, self.modelSize):
            x = self.model[i](x)
            if i < self.modelSize - 1:
                x = F.relu(x)
                # x = self.LReLU(x)
        return x
    
    __call__: Callable[..., Any] = forward

class multiTrain():
    def __init__(self, multiLayer: multiLayer) -> None:
        self.model = multiLayer
        self.opt = torch.optim.SGD(self.model.parameters, lr=1e-2)
        # for i in range(0, self.model.modelSize):
        #     self.opt.append(torch.optim.SGD(self.model.model[i].parameters(), lr=1e-4))
        self.loss = torch.nn.MSELoss()

    def predict(self, x):
        return self.d_normalize(self.model(x))

    def zero_grad(self):
        # for i in range(0, len(self.opt)):
        self.opt.zero_grad()
    
    def step(self):
        # for i in range(0, len(self.opt)):
        self.opt.step()     

    def normalize(self, x):
        self.dataMax = x.max()
        self.dataMin = x.min()
        return (x - self.dataMin) / (self.dataMax - self.dataMin)

    def d_normalize(self, x):
        return x * (self.dataMax - self.dataMin) + self.dataMin

#初始化数据
x1 = torch.tensor(np.linspace(-10,20,1000), dtype=torch.float32).view(1000,1)
x2 = torch.tensor(np.linspace(-20,40,500), dtype=torch.float32).view(500,1)
x3 = torch.tensor(np.linspace(-10, 20, 30), dtype=torch.float32).view(30,1)
yreal = (x1 * 3.24) * x1 - 4.21112 #+ torch.randn(x1.size())
y3 = (x3 * 3.24) * x3 - 4.21112 #+ torch.randn(x1.size())
T = multiTrain(multiLayer(1, 1, list = [10,10,10,10,10,10,10,10]))
yreal = T.normalize(yreal)
for i in range(50000):

    y = T.model(x1)
    loss = T.loss(yreal, y)
    T.zero_grad()
    loss.backward()
    T.step()
    # 打印
    if i % 100 == 0:
        pass
        # print('grad w %f and r is %f' % (T.model.model.weight, T.model.model.bias))
    # 跳出条件
    # if not (abs(wt.grad) > 1e-3 or abs(bt.grad) > 1e-3) :
    #     break 
y = T.predict(x1) 
y2 = T.predict(x2) 
yreal = T.d_normalize(yreal)
plt.plot(x1.data.numpy(),y.data.numpy(), x2.data.numpy(), y2.data.numpy())
plt.scatter(x3.data.numpy(), y3.data.numpy())
plt.show()

结果

可以看到-10到20的训练数据区，曲线拟合的还不错，而-20到-10，以及20到40的未训练区则与实际情况相差较大，并且每次训练的结果都是不一样的。
在这里插入图片描述
在这里插入图片描述

skyrim_H
关注
使用Pytorch来拟合函数方式
01-20
其实各大深度学习框架背后的原理都可以理解为拟合一个参数数量特别庞大的函数，所以各框架都能用来拟合任意函数，Pytorch也能。 在这篇博客中，就以拟合y = ax + b为例（a和b为需要拟合的参数），说明在Pytorch中如何拟合一个函数。 一、定义拟合网络 1、观察普通的神经网络的优化流程 # 定义网络 net = ... # 定义优化器 optimizer = torch.optim.Adam(net.parameters(), lr=0.001, weight_decay=0.0005) # 定义损失函数 loss_op = torch.nn.MSELoss(reduction='
Pytorch学习笔记（二）——使用pytorch实现BP神经网络拟合函数（附python和C++实现)
qq_23345187的博客
10-23 7734
使用BP神经网络拟合函数 最近学习bp神经网络，但是网上的代码很多都是做分类决策，我们要拟合函数需要对代码进行修改，进行回归预测，修改思路就是将输出层的激活函数改为f(x)=x,并且对反向传播过程中更改隐藏层到输出层的权重公式进行修改。 生成测试数据程序。 贴几个参考的博文： 神经网络实现连续型变量的回归预测（python) BP神经网络与Python实现 C++实现的BP神经网络（代码与详解） # 生成测试数据 import numpy as np import pandas as pd import m
pytorch拟合函数
sinoai
04-12 1945
pytorch拟合一元一次函数1. 这个程序定义网络的方式很特别2. 使用卷积拟合   拟合函数y=a×x+by=a\times x+by=a×x+b，其中a=1,b=2a=1,b=2a=1,b=2。 1. 这个程序定义网络的方式很特别 import torch import numpy as np class Net: def __init__(self): self....
使用Pytorch来拟合函数
Marvek的博客
06-10 6618
使用Pytorch拟合函数 使用Pytorch来拟合函数 raise ValueError("can't optimize a non-leaf Tensor")
python-torch:实现拟合任意函数
Danger的博客
01-28 2075
python-torch:实现拟合任意函数
torch学习 (七)：多项式函数拟合实验
因吉的博客
12-06 3461
文章目录引入1 生成数据集 引入   本文通过多项式函数的拟合实验，来理解模型复杂度和训练数据集大小对欠拟合和过拟合的影响。   参考文献：李沐、Aston Zhang等老师的这本《动手学深度学习》一书。 1 生成数据集   给定样本特征x{x}x，将使用下列三阶多项式来生成样本标签： y=1.2x−3.4x2+5.6x3+5+ϵ,(1) y = 1.2 x - 3.4 x^2 + 5.6 x^3 + 5 + \epsilon, \tag{1} y=1.2x−3.4x2+5.6x3+5+ϵ,(1) ...
使用 pytorch 创建神经网络拟合sin函数的实现
09-17
在本教程中，我们将探讨如何使用PyTorch创建神经网络来拟合正弦函数。PyTorch是一个流行的深度学习框架，它提供了灵活的张量计算和动态计算图，非常适合进行神经网络的构建和训练。 首先，我们要理解深度神经网络的...
使用 pytorch 创建神经网络拟合sin函数
01-21
本博客写一个小例子，使用 pytorch 来编写一个神经网络来拟合 sin 函数 废话少说，直接上代码： from torch.utils.data import DataLoader from torch.utils.data import TensorDataset import torch.nn as nn ...
Pytorch学习笔记——过拟合、欠拟合及其解决方案
01-20
3. 通过多项式函数拟合实验，我们可以直观地观察到模型复杂度对拟合效果的影响。在给定的例子中，随着多项式的阶数增加，模型能够更精确地拟合训练数据，但可能导致在测试集上的表现下降，这是过拟合的典型表现。...
pytorch 曲线拟合
Ring__Rain的博客
04-14 749
#!/usr/bin/env python # coding: utf-8 # In[1]: import numpy as np import torch import matplotlib.pyplot as plt from torch.autograd import Variable as var # In[2]: def get_data(x,w,b,d): c,r = x.shape y = (w * x * x + b*x + d)+ (0.1*(5*np.ra.
神经网络拟合函数曲线--pytorch
KJNKJNKJN的博客
12-03 1254
之前看了很多神经网络的算法，但是一直没有实操作过，加上对pytorch 不太熟悉，趁此机会熟悉一下。
神经网络之万能定理python-pytorch实现，可以拟合任意曲线
最新发布
weixin_43327597的博客
03-02 1244
你们可能觉得这个拟合好像也一般啊，其实不是，我这个问题非常难，基本上网上的代码都是拟合效果很差的，数据的话，感兴趣的，可以私聊我，我可以发给你们。这个实现想做到博主这个效果的，很难，因为博主做了大量实现，发现，其实严格意义上的万能定理的实现其实是需要很多的考虑的。另外随着训练轮数和神经元的增加，实际上我们的效果可以真正实现万能定理。
Pytorch归一化方法讲解与实战：BatchNormalization、LayerNormalization、nn.BatchNorm1d和LayerNorm()和F.normalize()
热门推荐
qq_43391414的博客
10-16 1万+
文章目录LayerNormalizationBatchNormalization 这些Normalization的作用都是让数据保持一个比较稳定的分布，从而加速收敛。Batch Normalization 的处理对象是对一批样本， Layer Normalization 的处理对象是单个样本。不过，他们到底指的是什么呢？有的时候，讲解是多余的，实战一下，你就懂了： talk is cheap,show me the code import torch import torch.nn as nn Laye
使用pytoch简洁创建隐层，拟合正弦函数，深入理解深度学习是一种高维非线性拟合
Liujianhuixd的博客
02-18 1420
网上关于拟合直线和二次曲线的教程已经很多，隐藏层设置差不多1到2层，便可以得到很好的拟合效果。 我们知道深度神经网络的本质是输入端数据和输出端数据的一种高维非线性拟合，如何更好的理解它，下面尝试拟合一个正弦函数。 基于pytorch的深度神经网络实战，无论任务多么复杂，都可以将其拆分成必要的几个模块来进行理解。 1）构建数据集，包括输入，对应的标签y 2) 构建神经网络模型，一般基于nn.Mod...
使用PyTorch拟合曲线
qq_42024963的博客
07-18 4600
如何搭建拟合曲线模型 目的： 神经网络是如何通过简单的形式将一群数据用一条线条来表示. 或者说, 是如何在数据当中找到他们的关系, 然后用神经网络模型来建立一个可以代表他们关系的线条 在研究过程中，我们会得到大量的数据，这些数据之间有着紧密的联系，最简单的我们做重力和质量关系的试验时，我们改变试验物体的质量，其重力也跟着改变，于是我们获得重力与质量的比值，建立了G=mg的关系式。当然，在研究复杂...
[PyTorch小试牛刀]实战一·使用PyTorch拟合曲线（对比PyTorch与TensorFlow实现的区别）
简明AI工作室
11-28 6290
[PyTorch小试牛刀]实战一·使用PyTorch拟合曲线 在深度学习入门的博客中，我们用TensorFlow进行了拟合曲线，到达了不错的效果。 我们现在使用PyTorch进行相同的曲线拟合，进而来比较一下TensorFlow与PyTorch的异同。 搭建神经网络进行训练的步骤基本相同，我们现在开始用PyTorch来实现。 问题描述 拟合y= x*x -2x +3 + 0.1(-1到1的随...
PyTorch实现多项式拟合
pylittlebrat的博客
04-27 5935
利用梯度下降的方法对原函数继续拟合 import torch import math import matplotlib.pyplot as plt class Fitting_polynomial(torch.nn.Module): def __init__(self): super(Fitting_polynomial,self).__init__() self.a = torch.nn.Parameter(torch.randn(())) s
pytorch实现函数拟合
暮木的博客
07-13 2374
导入必要模块随机生成数据 import random import numpy as np import matplotlib.pyplot as plt import torch import torch.nn as nn import torch.nn.functional as F x_train_list = [] y_train_list = [] for i in range(1, 50): x = i*random.choice([0.7,0.8,0.9]) y = i*
pytorch使用GPU进行计算的样例
03-13
可以使用以下代码将 PyTorch 模型放到 GPU 上进行计算： ```python import torch # 检查是否有可用的 GPU device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 定义模型 model = YourModel().to(device) # 定义数据 data = YourData() # 将数据放到 GPU 上 data = data.to(device) # 运行模型 output = model(data) ``` 其中，`YourModel()` 和 `YourData()` 分别代表你自己定义的模型和数据。在这个样例中，我们首先检查是否有可用的 GPU，然后将模型和数据都放到 GPU 上，最后运行模型并得到输出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值