神经网络以及简单的神经网络模型实现

神经网络基本概念：

1. 神经元（Neuron）：

   神经网络的基本单元，接收输入，应用权重并通过激活函数生成输出。

2. 层（Layer）：

   神经网络由多层神经元组成。常见的层包括输入层、隐藏层和输出层。

3. 权重（Weights）和偏置（Biases）：

   权重用于调整输入的重要性，偏置用于调整模型的输出。

4. 激活函数（Activation Function）：

   在神经元中引入非线性，如ReLU（Rectified Linear Unit）、Sigmoid、Tanh等。

5. 损失函数（Loss Function）：

   用于衡量模型预测与实际结果之间的差异，如均方误差（MSE）、交叉熵损失等。

6. 优化器（Optimizer）：

   用于调整模型权重以最小化损失函数，如随机梯度下降（SGD）、Adam等。

简单的神经网络示例：

下面是一个使用PyTorch构建简单线性回归的神经网络示例代码。这个示例展示了如何定义一个具有一个隐藏层的前馈神经网络，并训练它来逼近一些随机生成的数据点。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt# 生成一些随机数据
np.random.seed(0)
X = np.linspace(0, 10, 100).reshape(-1, 1).astype(np.float32)
y = np.sin(X) + np.random.normal(0, 0.1, size=X.shape).astype(np.float32)# 转换为PyTorch的张量
X_tensor = torch.tensor(X)
y_tensor = torch.tensor(y)# 定义一个简单的神经网络模型
class NeuralNet(nn.Module):def __init__(self):super(NeuralNet, self).__init__()self.fc1 = nn.Linear(1, 10)  # 输入层到隐藏层self.relu = nn.ReLU()        # 激活函数self.fc2 = nn.Linear(10, 1)  # 隐藏层到输出层def forward(self, x):x = self.fc1(x)x = self.relu(x)x = self.fc2(x)return x# 实例化模型、损失函数和优化器
model = NeuralNet()
criterion = nn.MSELoss()  # 均方误差损失函数
optimizer = optim.Adam(model.parameters(), lr=0.01)  # Adam优化器# 训练模型
epochs = 5000
losses = []
for epoch in range(epochs):optimizer.zero_grad()outputs = model(X_tensor)loss = criterion(outputs, y_tensor)loss.backward()optimizer.step()losses.append(loss.item())if (epoch+1) % 1000 == 0:print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.6f}')# 绘制损失函数变化图
plt.plot(losses, label='Training loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()# 测试模型
model.eval()
with torch.no_grad():test_x = torch.tensor([[5.0]])  # 测试输入predicted = model(test_x)print(f'预测值: {predicted.item()}')

运行结果展示: 

代码理解：

下面便是详细分解这段代码进行理解： 

• 生成数据：

  • 使用 numpy 生成一些随机的带有噪声的正弦函数数据。

    import numpy as np# 生成带有正态分布噪声的正弦函数数据
    def generate_data(n_samples):np.random.seed(0)  # 设置随机种子以确保结果可复现X = np.random.uniform(low=0, high=10, size=n_samples)y = np.sin(X) + np.random.normal(scale=0.3, size=n_samples)return X, y# 生成数据
    X_train, y_train = generate_data(100)
    

• 定义神经网络模型：

  • NeuralNet 类继承自 nn.Module，定义了一个具有一个隐藏层的前馈神经网络。使用ReLU作为隐藏层的激活函数。

    import torch
    import torch.nn as nn
    import torch.optim as optim# 定义神经网络模型
    class NeuralNet(nn.Module):def __init__(self):super(NeuralNet, self).__init__()self.fc1 = nn.Linear(1, 10)  # 输入大小为1（X），输出大小为10self.fc2 = nn.Linear(10, 1)  # 输入大小为10，输出大小为1self.relu = nn.ReLU()def forward(self, x):x = self.relu(self.fc1(x))x = self.fc2(x)return x# 实例化模型
    model = NeuralNet()# 打印模型结构
    print(model)
    

• 实例化模型、损失函数和优化器：

  • model 是我们定义的神经网络模型。
  • criterion 是损失函数，这里使用均方误差损失。
  • optimizer 是优化器，这里使用Adam优化器来更新模型参数。

    # 定义损失函数（均方误差损失）
    criterion = nn.MSELoss()# 定义优化器（Adam优化器）
    optimizer = optim.Adam(model.parameters(), lr=0.01)
    

• 训练模型：

  • 使用 X_tensor 和 y_tensor 进行训练，优化模型使其逼近 y_tensor。

    # 将numpy数组转换为PyTorch张量
    X_tensor = torch.tensor(X_train, dtype=torch.float32).view(-1, 1)
    y_tensor = torch.tensor(y_train, dtype=torch.float32).view(-1, 1)# 训练模型
    def train_model(model, criterion, optimizer, X, y, epochs=1000):model.train()for epoch in range(epochs):optimizer.zero_grad()output = model(X)loss = criterion(output, y)loss.backward()optimizer.step()if (epoch+1) % 100 == 0:print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')train_model(model, criterion, optimizer, X_tensor, y_tensor)
    

• 测试模型：

  • 使用 model.eval() 将模型切换到评估模式，使用 torch.no_grad() 关闭梯度计算。
  • 测试输入为 5.0，打印预测结果。

    # 测试模型
    model.eval()
    with torch.no_grad():test_input = torch.tensor([[5.0]], dtype=torch.float32)predicted_output = model(test_input)print(f'预测输入为 5.0 时的输出: {predicted_output.item():.4f}')