多项式拟合代码（pytorch）

import torch
import torch.nn as nn
import torch.optim as optim
import time
import matplotlib.pyplot as plt
class PRS(nn.Module):
    def __init__(self,input_dim,out_dim):
        super(PRS,self).__init__()
        self.input_dim=input_dim
        self.out_dim=out_dim
        a=(self.input_dim+2)*(self.input_dim+1)/2-1
        self.dim = torch.tensor(a, dtype=torch.long)
        self.linear=nn.Linear(self.dim,self.out_dim)

    def items(self,x):
        X=x
        k=len(x)
        for i in range(self.input_dim):
            for j in range(i+1):
                c=x[:, i] * x[:, j]
                c = c.view(k, 1)
                X=torch.cat((X, c), dim=1)
        return X

    def forward(self,x):
        X=self.items(x)
        y=self.linear(X)
        return y
#数据加载
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
iris = load_iris()
X = iris.data  # 获取特征值
y = iris.target  # 获取特征值t
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=10)
X_tensor = torch.tensor(X_train, dtype=torch.float32)  # 明确指定 dtype 以避免潜在的自动转换问题
y_tensor = torch.tensor(y_train, dtype=torch.long)  # 类别标签应使用整数类
X_test = torch.tensor(X_test, dtype=torch.float32)  # 明确指定 dtype 以避免潜在的自动转换问题
y_test = torch.tensor(y_test, dtype=torch.long)
input_dim=len(X[1])
out_dim=3
prs=PRS(input_dim,out_dim)
optimizer = optim.Adam(prs.parameters(), lr=0.001)
loss_fun = nn.CrossEntropyLoss()  # 分类模型
# loss_fun =nn.MSELoss()
start = time.time()
epochs = 10000
Loss = []
for epoch in range(epochs):
    Y_pre = prs(X_tensor)
    loss = loss_fun(Y_pre, y_tensor)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print("epoch:{}\t  loss:{:>.9}".format(epoch + 1, loss.item()))
    Loss.append(loss.item())
end = time.time()
print("time:", end - start)
plt.plot(Loss)
plt.xlabel("epoch")
plt.ylabel("Loss")
plt.show()

from sklearn.metrics import precision_score, recall_score, accuracy_score
def evaluation(y_test, y_predict):
    precision = precision_score(y_test, y_predict, average='macro')
    accuracy = accuracy_score(y_test, y_predict)
    recall = recall_score(y_test, y_predict, average='macro')
    print("accuracy:", accuracy)
    print(" precision:", precision)
    print(" recall:", recall)


# 训练效果
print("!!!训练集！！！")
Y_pre = torch.max(Y_pre, 1)[1]
pred_y = Y_pre.data.numpy()
target_y = y_tensor.data.numpy()
# 衡量训练集准确率
evaluation(pred_y, target_y)

# 预测效果
print("!!!测试集！！！")
y_pre = prs(X_test)
y_pre = torch.max(y_pre, 1)[1]
pred_y = y_pre.data.numpy()
target_y = y_test.data.numpy()
# 衡量测试集准确率
evaluation(pred_y, target_y)

运行结果：