sin函数拟合

输入层

1 个神经元，用于接收输入 x

隐藏层

10 个神经元，激活函数为 Tanh

输出层

1 个神经元，输出拟合的正弦值

学习率

0.001，优化器的学习率设置为 0.001

迭代次数

最大迭代次数设置为 10,000 次

损失函数

均方误差（MSE）损失函数

优化器

Adam 优化器

图 4减少训练的 epoch 数量

核心代码

介绍：这段代码是使用 Python 编写的，主要利用了 PyTorch 和 NumPy 库来训练一个简单的神经网络模型进行数据拟合。训练过程中的损失值会被记录并展示出来，同时还会展示模型预测结果与原始数据的对比图。

import torch

import torch.nn as nn

import numpy as np

import matplotlib.pyplot as plt

import os

os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"  # 忽略重复的库文件警告

class Network(nn.Module):

    def __init__(self, n_in, n_hidden, n_out):

        super().__init__()

        self.layer1 = nn.Linear(n_in, n_hidden, bias=False)

        self.layer2 = nn.Linear(n_hidden, n_out, bias=False)

    def forward(self, x):

        x = self.layer1(x)

        x = torch.tanh(x)  # 使用 Tanh 激活函数

        return self.layer2(x)

def generate_data(start=0.0, end=1.0, step=0.01):

    """生成训练数据"""

    x = np.arange(start, end, step)

    y = np.sin(2 * np.pi * x)

    return x.reshape(len(x), 1), y.reshape(len(y), 1)

def train_model(model, x, y, criterion, optimizer, num_epochs=10000):

    """训练模型并返回训练过程中的损失值"""

    loss_values = []

    for epoch in range(num_epochs):

        y_pred = model(x)  # 前向传播

        loss = criterion(y_pred, y)  # 计算损失

        loss.backward()  # 反向传播

        optimizer.step()  # 更新参数

        loss_values.append(loss.item())  # 保存损失值

        optimizer.zero_grad()  # 清空梯度

        # 每100次打印一次损失值

        if epoch % 100 == 0:

            print(f'After {epoch} iterations, the loss is {loss.item()}')

    return loss_values

def plot_results(x, y, h, loss_values, num_epochs):

    """绘制原始数据、预测数据和训练损失曲线"""

    fig, axs = plt.subplots(1, 2, figsize=(14, 6))  # 一行两列的子图布局

    # 第一个子图：原始数据与预测数据的散点图

    axs[0].scatter(x, y, label='Original Data')

    axs[0].scatter(x, h, label='Predicted Data', color='r')

    axs[0].set_title("Model Prediction vs Original Data")

    axs[0].legend()

    # 第二个子图：训练损失曲线

    axs[1].plot(range(num_epochs), loss_values, label='Loss Curve')

    axs[1].set_xlabel('Epochs')

    axs[1].set_ylabel('Loss')

    axs[1].set_title('Training Loss')

    axs[1].legend()

    plt.tight_layout()  # 自动调整子图间距

    plt.show()

if __name__ == '__main__':

    # 生成数据

    x, y = generate_data()

    x = torch.Tensor(x)

    y = torch.Tensor(y)

    # 初始化模型、损失函数和优化器

    model = Network(1, 10, 1)

    criterion = nn.MSELoss()  # 均方误差损失函数

    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  # Adam优化器

    # 训练模型

    loss_values = train_model(model, x, y, criterion, optimizer, num_epochs=10000)

    # 获取预测值

    h = model(x).detach().numpy()  # 获取模型输出并转为numpy数组

    x = x.detach().numpy()  # 获取输入数据

    # 调用绘图函数

    plot_results(x, y, h, loss_values, num_epochs=10000)