使用PyTorch搭建神经网络

一、网络构建

import torch#导入PyTorch库。它提供了张量操作、自动微分等基础功能。
import torch.nn as nn#定义神经网络层 这个模块包含了构建神经网络所需的各种层和函数。

class SimpleNN(nn.Module):#这里定义了一个名为 SimpleNN 的新类，它继承自 nn.Module。在PyTorch中，所有的神经网络模型都应继承自 nn.Module，这样可以利用到该基类中的很多功能，如参数管理和模块化。
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(784, 128) #784个输入特征的数量
        self.fc2 = nn.Linear(128, 128)  #128个（可以使用不同数量的单元）隐藏单元
        self.output = nn.Linear(128, 10)  #self.output 是输出层，接收来自上一层的128个特征的输出，并将其映射到10个输出，通常表示分类任务中的类别数量。

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))#通过ReLU激活函数进行非线性变换。
        x = self.output(x)
        return x

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')#加快计算速度
 

二、数据加载与处理

from torchvision import transforms, datasets#torchvision 是处理图像数据的库，它提供了常用的数据集和图像变换功能。transforms 用于数据预处理和增强。datasets 用于加载数据集。

from torch.utils.data import DataLoader#DataLoader 是PyTorch中一个非常重要的类，它将一个可迭代的数据集封装成一个迭代器，方便批处理和数据洗牌等操作。将其组织成批次进行训练或验证

transform = transforms.Compose([
    transforms.ToTensor(),#ToTensor() 将PIL图像或NumPy ndarray 转换为FloatTensor
    transforms.Normalize((0.5,), (0.5,))
])

train_set = datasets.MNIST(root='./data', train=True, download=True, transform=transform)#root参数指定数据存储的路径，train=True表明是加载训练集（train=False加载测试集），download=True指在数据不在指定路径时自动下载，transform=transform应用之前定义的预处理操作。
train_loader = DataLoader(train_set, batch_size=64, shuffle=True)#DataLoader封装了train_set，batch_size=64指定了每个批次的大小，shuffle=True表示在每个epoch开始时，数据将被打乱，这有助于模型泛化。

test_set = datasets.MNIST(root='./data', train=False, transform=transform)
test_loader = DataLoader(test_set, batch_size=64, shuffle=False)#shuffle=False通常用于测试数据，因为在测试阶段不需要打乱数据。

三、训练过程

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

for epoch in range(5):  # 训练5个Epoch每个epoch包括对整个训练集的一次遍历。
    for images, labels in train_loader:
        images = images.view(-1, 28*28)  
        optimizer.zero_grad()

        output = model(images)
        loss = criterion(output, labels)
        loss.backward()
        optimizer.step()

四、评估与分析

def evaluate_model(model, data_loader):
    model.eval()#将模型设置为评估模式
    total_correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in data_loader:
            images = images.view(-1, 28*28)
            output = model(images)
            _, predicted = torch.max(output.data, 1)
            total += labels.size(0)
            total_correct += (predicted == labels).sum().item()
    print(f'Accuracy: {100 * total_correct / total:.2f}%')

evaluate_model(model, test_loader)#调用函数评估模型

练习： 鸢尾花分类

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler

# 加载鸢尾花数据集
iris = load_iris()
X = iris.data
y = iris.target
# 加载鸢尾花数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 转换为 PyTorch 张量
X_train = torch.FloatTensor(X_train)
y_train = torch.LongTensor(y_train)
X_test = torch.FloatTensor(X_test)
y_test = torch.LongTensor(y_test)

# 定义神经网络模型
class IrisClassifier(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(IrisClassifier, self).__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x
    # 创建模型、损失函数和优化器
# 设置模型参数
input_size = 4  # 输入特征的数量
hidden_size = 8  # 隐藏层神经元的数量
num_classes = 3  # 输出类别的数量

model = IrisClassifier(input_size, hidden_size, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# 加载鸢尾花数据集
num_epochs = 100
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_train)
    loss = criterion(outputs, y_train)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
# 测试模型
with torch.no_grad():
    model.eval()
    outputs = model(X_test)
    _, predicted = torch.max(outputs, 1)
    accuracy = (predicted == y_test).sum().item() / y_test.size(0)
    print(f'Test Accuracy: {accuracy:.4f}')