如何在Pytorch/Python中实现多项式回归

我想让我的神经网络解决一个多项式回归问题，比如y=（x*x）+2x-3

所以现在我创建了一个包含1个输入节点、100个隐藏节点和1个输出节点的网络，并为它提供了大量的历次训练，测试数据量很大。问题是，在大约20000个时代之后的预测是好的，但比训练后的线性回归预测更糟糕

import torch
from torch import Tensor
from torch.nn import Linear, MSELoss, functional as F
from torch.optim import SGD, Adam, RMSprop
from torch.autograd import Variable
import numpy as np


# define our data generation function
def data_generator(data_size=1000):
    # f(x) = y = x^2 + 4x - 3
    inputs = []
    labels = []

    # loop data_size times to generate the data
    for ix in range(data_size):
        # generate a random number between 0 and 1000
        x = np.random.randint(1000) / 1000

        # calculate the y value using the function x^2 + 4x - 3
        y = (x * x) + (4 * x) - 3

        # append the values to our input and labels lists
        inputs.append([x])
        labels.append([y])

    return inputs, labels


# define the model
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = Linear(1, 100)
        self.fc2 = Linear(100, 1)


    def forward(self, x):
        x = F.relu(self.fc1(x)
        x = self.fc2(x)
        return x


model = Net()
# define the loss function
critereon = MSELoss()
# define the optimizer
optimizer = SGD(model.parameters(), lr=0.01)

# define the number of epochs and the data set size
nb_epochs = 20000
data_size = 1000

# create our training loop
for epoch in range(nb_epochs):
    X, y = data_generator(data_size)
    X = Variable(Tensor(X))
    y = Variable(Tensor(y))


    epoch_loss = 0;


    y_pred = model(X)

    loss = critereon(y_pred, y)

    epoch_loss = loss.data
    optimizer.zero_grad()

    loss.backward()

    optimizer.step()

    print("Epoch: {} Loss: {}".format(epoch, epoch_loss))

# test the model
model.eval()
test_data = data_generator(1)
prediction = model(Variable(Tensor(test_data[0][0])))
print("Prediction: {}".format(prediction.data[0]))
print("Expected: {}".format(test_data[1][0]))

---

它们是获得更好结果的一种方式吗？我想知道我是否应该尝试获得3个输出，分别称为a、b和c，这样y=a（x*x）+b（x）+c。但是，我不知道如何实现这一点，并训练我的神经网络。对于这个问题，如果你考虑<代码>网络（<）/代码> 1代码>线性< /代码>层为<代码>线性回归< /代码>，其输入特性包括<代码> [x^ 2，x] < /c> > />代码>。 生成您的数据

导入火炬
从火炬输入张量
从torch.nn导入线性、MSELoss，功能为F
来自torch.optim进口新加坡元、Adam、RMSprop
从torch.autograd导入变量
将numpy作为np导入
#定义我们的数据生成功能
def数据发生器（数据大小=1000）：
#f（x）=y=x^2+4x-3
输入=[]
标签=[]
#循环数据\u生成数据的大小时间
对于范围内的ix（数据大小）：
#生成一个介于0和1000之间的随机数
x=np.random.randint（2000）/1000#我在这里为您编辑
#使用函数x^2+4x-3计算y值
y=（x*x）+（4*x）-3
#将这些值附加到输入和标签列表中
inputs.append（[x*x，x]）
labels.append（[y]）
返回输入、标签

定义您的模型

#定义模型
类别网络（火炬网络模块）：
定义初始化（自）：
超级（网络，自我）。\uuuu初始化
self.fc1=线性（2，1）
def前进（自身，x）：
返回自我.fc1（x）
model=Net（）

然后训练它，我们得到： 系数 您要查找的系数

a

，

b

，

c

实际上是

自身的权重和偏差。fc1

：

print（'a&b:'，型号.fc1.重量）
打印（'c:'，model.fc1.bias）
#输出
a&b：包含以下内容的参数：
张量（[[1.0000，4.0000]]，需要_grad=True）
c：参数包含：
张量（[-3.0000]，需要_grad=True）

在仅仅5000个时代里，所有这些都融合在一起：

a

->1、

b

->4和

c

->-3

该模型重量很轻，只有3个参数，而不是：

(100 + 1) + (100 + 1) = 202 parameters in the old model

---

希望这对你有帮助

输入仅仅是一个？非常感谢您的可能副本，这样更容易！我从没想过。哦，对不起，我不知道。这是我的第一个问题：DI意识到如果

0-2.0

中的

x

在5000个时代内转换得更快，因为你将

x

设置在

0-1.0

范围内，那么很难看到

x^2

的贡献。想象一下

0.1^2

10倍于

0.1

。我刚刚编辑了结果。再次感谢。我只是认识到，当你把数字生成器放在训练循环之外时，你只称它为“一”，它的速度更快，结果也更好。

(100 + 1) + (100 + 1) = 202 parameters in the old model