第4章 - 卷积神经网络 (CNN) 基础实训操作手册

1. 卷积神经网络简介

目标：理解卷积神经网络的基本原理和其在图像处理中的应用。

内容：

a. 什么是卷积神经网络（CNN）？

CNN是一种深度学习算法，它特别适用于处理具有网格结构的数据，如图像。CNN能够自动和适应地从图像中学习空间层次结构的特征。

• b. CNN的主要组件
  • 卷积层：通过卷积操作从输入数据中提取特征。
  • 池化层：减少数据的空间维度，同时保留最重要的信息。
  • 全连接层：与传统的神经网络层相同，用于输出最终的预测结果。

2. 定义一个简单的CNN模型

目标：学会使用PyTorch的nn.Module类来定义一个简单的CNN模型。

内容：

实操：

import torch.nn as nn  


class SimpleCNN(nn.Module):
     def __init__(self):     
         super(SimpleCNN, self).__init__()         
         self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)         
         self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)         
         self.fc1 = nn.Linear(32 * 14 * 14, 128)         
         self.fc2 = nn.Linear(128, 10)      
     def forward(self, x):    
         x = torch.relu(self.conv1(x))         
         x = self.pool(x)         
         x = x.view(-1, 32 * 14 * 14)         
         x = torch.relu(self.fc1(x))         
         x = self.fc2(x)         
         return x  
         
model = SimpleCNN() 
print(model) 

• 注意点：确保了解每一层（特别是卷积层和池化层）如何改变数据的维度。这在为全连接层重新塑形数据时尤为重要。

3. 训练CNN模型

与前馈神经网络类似，但由于CNN的参数通常更多，因此可能需要更长的时间和更多的数据来训练。

实战项目：服装图像分类

项目描述：学生将使用PyTorch构建一个CNN模型来对服装图像进行分类。我们将使用FashionMNIST数据集，它与MNIST数据集相似，但包含10种不同类别的服装图像。

1. 加载和预处理数据

from torchvision import datasets, transforms  


transform = transforms.Compose([
     transforms.ToTensor(),     
     transforms.Normalize((0.5,), (0.5,))
])  


train_dataset = datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform) 
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True) 

2. 使用上面定义的SimpleCNN模型

model = SimpleCNN() 

3. 定义损失函数和优化器

import torch.optim as optim  


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

4. 训练模型

epochs = 5 
for epoch in range(epochs):
     for batch_idx, (data, target) in enumerate(train_loader):         
         optimizer.zero_grad()         
         output = model(data)         
         loss = criterion(output, target)         
         loss.backward()         
         optimizer.step()          
         
         if batch_idx % 100 == 0:             
            print(f"Epoch {epoch+1}/{epochs}, Batch {batch_idx}/{len(train_loader)}, Loss: {loss.item():.4f}") 

注意点：由于CNN模型具有更多的参数，可能需要更长时间进行训练。为了快速收敛，你可以考虑使用更高级的优化器，如Adam。

5. 评估模型

与前面的项目类似，你可以加载FashionMNIST的测试数据集，并使用训练好的模型进行预测，然后评估其准确性。

此实训操作手册和实战项目为学生提供了一个深入了解CNN和其在图像分类任务中应用的机会。通过这些材料，学生将能够掌握卷积神经网络的基本概念和技能，并应用它们来解决实际问题。

 

---

 

第5章 - 循环神经网络 (RNN) 与长短时记忆网络 (LSTM) 实训操作手册

1. RNN基础概念

目标：理解RNN的工作原理及其与传统神经网络的区别。

内容：

a. 什么是RNN？

RNN是一种用于处理序列数据的神经网络结构。与传统神经网络不同，RNN可以处理长度可变的输入序列，并具有“记忆”功能，能够保留前面步骤的信息。

• b. RNN的主要挑战
  • 梯度消失和爆炸：由于时间步长，RNN在反向传播时可能会遇到梯度消失或爆炸的问题。
  • 长依赖关系：RNN可能难以捕捉序列中的长距离依赖关系。

2. 长短时记忆网络 (LSTM) 和门控循环单元 (GRU)

目标：理解LSTM和GRU的工作原理及其如何解决RNN的挑战。

内容：

a. 什么是LSTM和GRU？

LSTM和GRU是RNN的两种变体，它们都通过特定的门结构来解决梯度消失和长依赖问题。

b. LSTM与GRU的区别

• 虽然LSTM和GRU都有门结构，但它们的设计和数量有所不同。LSTM有三个门（输入、遗忘和输出门），而GRU只有两个（更新和重置门）。

3. 使用nn.LSTM和nn.GRU

目标：学会使用PyTorch中的nn.LSTM和nn.GRU模块。

内容：

实操：

import torch.nn as nn  


# LSTM示例 
lstm = nn.LSTM(input_size=10, hidden_size=20, num_layers=2, batch_first=True)  


# GRU示例 
gru = nn.GRU(input_size=10, hidden_size=20, num_layers=2, batch_first=True) 

4. RNN用于序列数据

目标：理解如何使用RNN处理不同类型的序列数据。

内容：

• RNN可以用于多种任务，如时间序列预测、文本生成和语言建模等。

5. 使用RNN进行文本生成

目标：学习如何使用RNN生成文本。

内容：

实操：

class RNNTextGen(nn.Module):
     def __init__(self, input_size, hidden_size, output_size):         
         super(RNNTextGen, self).__init__()         
         self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)         
         self.fc = nn.Linear(hidden_size, output_size)      
         
     def forward(self, x, h0):    
         out, hn = self.rnn(x, h0)         
         out = self.fc(out)         
         return out, hn 

实战项目：时间序列预测

项目描述：学生将使用PyTorch构建一个RNN模型来预测时间序列数据。我们将使用一个简单的合成数据集，其中的模式是学生需要学习的。

1. 生成时间序列数据

import torch 
import numpy as np  


def generate_time_series(batch_size, n_steps):
     freq1, freq2, offsets1, offsets2 = np.random.rand(4, batch_size, 1)     
     time = np.linspace(0, 1, n_steps)     
     series = 0.5 * np.sin((time - offsets1) * (freq1 * 10 + 10))     
     series += 0.2 * np.sin((time - offsets2) * (freq2 * 20 + 20))     
     series += 0.1 * (np.random.rand(batch_size, n_steps) - 0.5)     
     return series[..., np.newaxis].astype(np.float32)  


n_steps = 50 
series = generate_time_series(10000, n_steps + 1) 
X_train, y_train = series[:7000, :n_steps], series[:7000, -1] 
X_valid, y_valid = series[7000:9000, :n_steps], series[7000:9000, -1] 
X_test, y_test = series[9000:, :n_steps], series[9000:, -1] 

2. 使用上面定义的SimpleRNN模型

model = SimpleRNN(1, 20, 1) 

3. 定义损失函数和优化器

import torch.optim as optim  


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

4. 训练模型

epochs = 5 
train_tensor = torch.from_numpy(X_train).float() 
train_labels = torch.from_numpy(y_train).float()  


for epoch in range(epochs):
     optimizer.zero_grad()     
     output = model(train_tensor)     
     loss = criterion(output.squeeze(), train_labels)     
     loss.backward()     
     optimizer.step()     
      
     print(f"Epoch {epoch+1}/{epochs}, Loss: {loss.item():.4f}") 

注意点：确保输入数据的形状是batch_size, sequence_length, input_size

batchs

​ize,sequencel

​ength,inputs

​ize。

5. 评估模型

可以加载验证数据集，并使用训练好的模型进行预测，然后评估其准确性。