这是我在PyTorch中创建的第一个模型，我是这个领域的新手，我运行了几个时期的模型，这是两次运行算法的每个时期的误差输出。
第一节第一节第一节第一节第一次
我也尝试了100个纪元，这是结果

迭代表示时期，错误是每个时期最后一个输入训练样本的错误率。我想知道输出是否正常，或者它必须是递减的？以下是数据集pima-indians-diabetes.csv的代码。如果我的代码有任何错误，我将不胜感激，如果你告诉我。
我还修改了学习率为较小的值，但没有发生。
这是文件dataset.py

import pandas as pd
import torch
from sklearn.preprocessing import StandardScaler

class DataSet:
    divide_rate = 0.8
    file = './pima-indians-diabetes.csv'

    def __init__(self):
        dataframe = pd.read_csv(self.file)
        train_size = int(self.divide_rate * len(dataframe))

        train_set = dataframe.iloc[:train_size, :]
        train_label = train_set['label']
        train_feature = train_set.loc[:, train_set.columns != 'label']
        sc = StandardScaler()
        train_feature = sc.fit_transform(train_feature)
        self.train_labels = torch.tensor(train_label.values, dtype=torch.float32)
        self.train_features = torch.tensor(train_feature, dtype=torch.float32)

    def __getitem__(self, index):
        return self.train_features[index], self.train_labels[index]

    def __len__(self):
        return len(self.train_features)

这是主文件

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import SGD
import matplotlib.pyplot as plt
import seaborn as sns
from dataset import DataSet
from torch.utils.data import DataLoader

class NeuralNetwork(nn.Module):
    input_dim = 8
    hidden_dim = 4
    output_dim = 1

    def __init__(self):
        super().__init__()
        self.layers = [
            nn.Linear(self.input_dim, self.hidden_dim),
            nn.Linear(self.hidden_dim, self.output_dim)
        ]

        self.layers = nn.ModuleList(self.layers)

    def forward(self, x):
        for layer in self.layers:
            x = torch.sigmoid(layer(x))
        return x

dataset = DataSet()
model = NeuralNetwork()
loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

train_loader = torch.utils.data.DataLoader(dataset, shuffle=True)

sns.set(style="whitegrid")
Epochs = 10
loss_per_epoch = []
x = []
for i in range(Epochs):
    x.append(i)
    ll = 0
    for feature, label in train_loader:
        pred = model(feature)
        loss = loss_fn(pred, label.unsqueeze(1))
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()
        ll = loss.item()
    loss_per_epoch.append(ll)
sns.lineplot(x=x,
                 y=loss_per_epoch,
                 color='green',
                 linewidth=1.5)
plt.ylabel('Error')
plt.xlabel('Iteration')

正如@M H提到的，我加上了每个历元的平均误差，这就是结果