RNN理论知识
RNN（Recurrent Neural Network，循环神经网络） 是一种 专门用于处理序列数据（如时间序列、文本、语音、视频等）的神经网络。与普通的前馈神经网络（如 MLP、CNN）不同，RNN 具有“记忆”能力，能够利用过去的信息来影响当前的计算结果。
1. RNN 的基本结构
RNN 的核心特点是 “循环”结构，它会将前一个时间步 （ t − 1 ） （t-1） （t−1）计算出的隐藏状态 h t − 1 h_{t-1} ht−1 传递给当前时间步 （ t ） （t） （t），使得网络可以保留历史信息。
这种结构可以表示为：
h t = f ( W x X t + W h h t − 1 + b ) h_t=f(W_xX_t+W_hh_{t-1}+b) ht=f(WxXt+Whht−1+b)
其中：
- X t X_t Xt：当前时刻的输入数据。
- h t h_t ht：当前时刻的隐藏状态 。
- W x 、 W h 、 b W_x、W_h、b Wx、Wh、b：可训练的参数 。
- f f f：激活函数（通常是 tanh 或ReLU）。
RNN 的展开结构：
在时间步（time step）上，RNN 结构可以展开成如下形式：
图示解释：
X
1
,
X
2
,
X
3
,
.
.
.
X_1,X_2,X_3,...
X1,X2,X3,... 代表输入的 序列数据（如文本、时间序列信号）。
h
0
,
h
1
,
h
2
,
h
3
,
.
.
.
h_0,h_1,h_2,h_3,...
h0,h1,h2,h3,... 代表 隐藏状态，用于存储过去的信息。
Y
1
,
Y
2
,
Y
3
,
.
.
.
Y_1,Y_2,Y_3,...
Y1,Y2,Y3,...代表 输出。
在每个时间步，RNN 使用当前输入
X
t
X_t
Xt 和前一时刻的隐藏状态
h
t
−
1
h_{t-1}
ht−1来计算新的隐藏状态
h
t
h_t
ht，然后生成输出
Y
t
Y_t
Yt。
2. RNN 的缺点
尽管 RNN 在处理序列数据方面有独特的优势，但它也存在一些明显的问题：
（1）梯度消失（Vanishing Gradient）
在长序列训练时，误差的梯度会随着时间步增多而逐渐变小，导致网络无法有效学习较远时间步的信息。
解决方案：使用 LSTM（长短时记忆网络） 或 GRU（门控循环单元） 结构。
（2）梯度爆炸（Exploding Gradient）
如果梯度在反向传播过程中不断累积，可能会变得 非常大，导致模型更新过快或无法收敛。
解决方案：使用 梯度裁剪（Gradient Clipping） 来防止梯度过大。
（3）无法并行计算
由于 RNN 依赖前一个时间步的计算结果，因此无法像 CNN 那样并行计算，这导致训练速度较慢。
解决方案：使用 Transformer 模型（如 BERT、GPT）来替代 RNN。
3. RNN 的改进版本
由于 RNN 存在梯度消失等问题，研究人员提出了更强大的 变种 RNN 结构：
（1）LSTM（Long Short-Term Memory）
- LSTM 引入了 “记忆单元” 和 “门机制”，使得它能够保留长期信息，解决梯度消失问题。
- 包含 遗忘门（Forget Gate）、输入门（Input Gate）、输出门（Output Gate） 三部分来控制信息流。
（2）GRU（Gated Recurrent Unit）
- GRU 是 LSTM 的简化版本，只包含 更新门（Update Gate） 和 重置门（Reset Gate），计算效率更高。
数据集
精神分裂症数据集，是一个包含精神分裂症人口统计和临床数据的综合数据集。该数据集包括患者的诊断状态、症状评分、治疗史和社会因素。
代码目标
基于给定的特征（如性别、年龄、收入、症状评分等），预测一个人的诊断标签（是否患有精神分裂症），通过可视化训练损失和计算准确率，评估模型的训练效果与性能。
一、前期准备工作
我的环境：
- 操作系统：windows10
- 语言环境：Python3.9
- 编译器：Jupyter notebook
- 数据集：精神分裂症患者数据集（“schizophrenia_dataset.csv”）
1. 导入库，设置硬件设备
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
import torch
#设置GPU训练，也可以使用CPU
device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
代码输出：
device(type='cpu')
使用 torch.device() 方法检查当前系统是否有 GPU，并根据条件设置计算设备为 GPU（CUDA）或 CPU。
2. 导入数据
读取指定路径的 CSV 文件，并加载到 pandas 的 DataFrame 中，然后打印出数据框的前五行，用于检查数据的内容。
# 读取数据
file_path = 'schizophrenia_dataset.csv' # 设置数据文件的路径
df = pd.read_csv(file_path) # 使用pandas的read_csv函数读取CSV文件，结果存储在DataFrame对象df中
print(df.head()) # 打印数据框的前五行，检查数据的结构和内容
代码输出：
Hasta_ID Yaş Cinsiyet Eğitim_Seviyesi Medeni_Durum Meslek \
0 1 72 1 4 2 0
1 2 49 1 5 2 2
2 3 53 1 5 3 2
3 4 67 1 3 2 0
4 5 54 0 1 2 0
Gelir_Düzeyi Yaşadığı_Yer Tanı Hastalık_Süresi Hastaneye_Yatış_Sayısı \
0 2 1 0 0 0
1 1 0 1 35 1
2 1 0 1 32 0
3 2 0 0 0 0
4 2 1 0 0 0
Ailede_Şizofreni_Öyküsü Madde_Kullanımı İntihar_Girişimi \
0 0 0 0
1 1 1 1
2 1 0 0
3 0 1 0
4 0 0 0
Pozitif_Semptom_Skoru Negatif_Semptom_Skoru GAF_Skoru Sosyal_Destek \
0 32 48 72 0
1 51 63 40 2
2 72 85 51 0
3 10 21 74 1
4 4 27 98 0
Stres_Faktörleri İlaç_Uyumu
0 2 2
1 2 0
2 1 1
3 1 2
4 1 0
二、构建数据集
1. 划分数据集
处理数据中的不必要列（唯一标识符）和缺失值，以准备好干净的数据进行模型训练。
df = df.drop(columns=['Hasta_ID']) # 删除 'Hasta_ID' 列，因为该列是唯一标识符，不需要用作模型输入
df = df.fillna(df.mean()) # 使用每一列的均值填充数据框中的缺失值。这里使用 `df.mean()` 来计算均值，并用它来填充缺失值
数据处理流程：
- 使用 LabelEncoder 将类别变量转换为数值。
- 将数据划分为特征（X）和目标（y）。
- 标准化特征数据。
- 将数据划分为训练集和测试集。
- 将数据转换为 PyTorch 张量。
- 调整张量维度以符合 RNN 模型的要求。
label_encoder = LabelEncoder() # 创建LabelEncoder实例，用于将类别变量转换为数值
df['Cinsiyet'] = label_encoder.fit_transform(df['Cinsiyet']) # 将 'Cinsiyet'列中的类别值转化为数值
df['Medeni_Durum'] = label_encoder.fit_transform(df['Medeni_Durum']) # 将 'Medeni_Durum'列中的类别值转化为数值
df['Yaşadığı_Yer'] = label_encoder.fit_transform(df['Yaşadığı_Yer']) # 将 'Yaşadığı_Yer'列中的类别值转化为数值
# 将特征和目标分开
X = df.drop(columns=['Tanı']) # 将数据框中的 'Tanı' 列移除，剩下的列作为特征（X）
y = df['Tanı'] # 'Tanı' 列作为目标变量（y），表示是否患有精神分裂症（二分类标签）
scaler = StandardScaler() # 创建 StandardScaler 实例，用于标准化特征数据
X_scaled = scaler.fit_transform(X) # 对特征进行标准化，使得每列的均值为0，标准差为1
# 使用 train_test_split 将数据随机划分为训练集和测试集，测试集占20%。random_state=42 设置随机种子，以确保每次划分结果相同
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
# 将数据转换为PyTorch的tensor
X_train_tensor = torch.tensor(X_train, dtype=torch.float32) # 将训练特征数据转换为PyTorch的tensor格式，并指定数据类型为float32
X_test_tensor = torch.tensor(X_test, dtype=torch.float32) # 将测试特征数据转换为PyTorch的tensor格式，并指定数据类型为float32
y_train_tensor = torch.tensor(y_train.values, dtype=torch.long) # 将训练目标数据转换为PyTorch的tensor格式，并指定数据类型为long（用于分类问题）
y_test_tensor = torch.tensor(y_test.values, dtype=torch.long) # 将测试目标数据转换为PyTorch的tensor格式，并指定数据类型为long（用于分类问题）
# 确保数据的形状符合RNN的要求: [batch_size, seq_len, features]
X_train_tensor = X_train_tensor.unsqueeze(1) # [batch_size, features] --> [batch_size, 1, features]
X_test_tensor = X_test_tensor.unsqueeze(1) # [batch_size, features] --> [batch_size, 1, features]
# 输出tensor的形状，确保数据正确
print(f"训练数据形状: {X_train_tensor.shape}") # 打印训练数据的形状，检查是否正确
print(f"测试数据形状: {X_test_tensor.shape}") # 打印测试数据的形状，检查是否正确
代码输出：
训练数据形状: torch.Size([8000, 1, 18])
测试数据形状: torch.Size([2000, 1, 18])
2. 构建数据加载器
将训练集和测试集的数据（特征和标签）封装成 TensorDataset 对象，并使用 DataLoader 创建数据加载器。
训练集和测试集被分批次加载，每个批次包含 64 个样本。
shuffle=False 表示数据在加载时不进行打乱，在评估的时候顺序保持一致。
from torch.utils.data import TensorDataset, DataLoader
train_dl = DataLoader(TensorDataset(X_train_tensor, y_train_tensor), # 将训练数据、目标数据包装成一个数据集，并创建一个训练数据加载器
batch_size=64,
shuffle=False)
test_dl = DataLoader(TensorDataset(X_test_tensor, y_test_tensor), # 将测试数据、目标数据包装成一个数据集，并创建一个测试数据加载器
shuffle=False)
三、模型训练
1. 构建模型
import torch.nn as nn
#定义一个名为 _RNN_Base 的类，继承自 nn.Module。该类实现了 RNN（包括 RNN、LSTM 和 GRU）的基础结构
class _RNN_Base(nn.Module):
def __init__(self, c_in, c_out, hidden_size=100, n_layers=1,
bias=True, rnn_dropout=0, bidirectional=False,
fc_dropout=0., init_weights=True):
"""
RNN基础类，支持不同RNN单元（如RNN、LSTM、GRU）的实现。
"""
super(_RNN_Base, self).__init__() # 确保正确调用父类的构造函数
# 定义RNN层，支持RNN、LSTM、GRU等
self.rnn = self._cell(c_in, hidden_size, num_layers=n_layers,
bias=bias, batch_first=True,
dropout=rnn_dropout,
bidirectional=bidirectional)
# 定义全连接层的dropout，如果fc_dropout为0则直接用Identity
self.dropout = nn.Dropout(fc_dropout) if fc_dropout else nn.Identity()
self.fc = nn.Linear(hidden_size * (1 + bidirectional), c_out)
def forward(self, x):
"""
参数:
- x: 形状为[batch_size, n_vars, seq_len]。
返回:
- output: 形状为[batch_size, c_out]。
"""
# [batch_size, n_vars, seq_len] --> [batch_size, seq_len, n_vars]
x = x.transpose(2,1)
# 输出形状为[batch_size, seq_len, hidden_size * (1 + bidirectional)]
output, _ = self.rnn(x)
# 取最后一个时间步的输出，形状为[batch_size, hidden_size * (1 + bidirectional)]
output = output[:, -1]
output = self.fc(self.dropout(output))
return output
# 定义RNN类，继承自_RNN_Base
class RNN(_RNN_Base):
_cell = nn.RNN # 使用nn.RNN单元
# 定义LSTM类，继承自_RNN_Base
class LSTM(_RNN_Base):
_cell = nn.LSTM # 使用nn.LSTM单元
# 定义GRU类，继承自_RNN_Base
class GRU(_RNN_Base):
_cell = nn.GRU # 使用nn.GRU单元
定义名为 _RNN_Base 的类，继承自 nn.Module。该类实现了 RNN（包括 RNN、LSTM 和 GRU）的基础结构。
_RNN_Base 类的参数解释：
- c_in：输入特征的维度，即每个时间步的特征数量。
- c_out：输出类别数量，即模型的输出维度。
- hidden_size：RNN隐藏层的大小。
- n_layers：RNN的层数。
- bias：是否在RNN层中使用偏置项。
- rnn_dropout：RNN层中的dropout比例。
- bidirectional：是否使用双向RNN。
- fc_dropout：全连接层的dropout比例。
- init_weights：是否初始化权重。
关于_cell ，定义 RNN 层。self._cell 是一个占位符，它将会被具体子类（RNN、LSTM、GRU）的 _cell 属性替代，相关参数解释：
- c_in：输入特征的数量。
- hidden_size：RNN单元的隐藏层大小。
- num_layers：RNN的层数。
- bias：是否使用偏置项。
- batch_first=True：意味着输入和输出的格式为 [batch_size, seq_len,features]。
- dropout=rnn_dropout：RNN中dropout的概率，用来防止过拟合。
- bidirectional=bidirectional：是否使用双向RNN（即处理序列时同时考虑正向和反向的时间步）。
# 创建一个基于 RNN 的神经网络模型，并将模型移动到指定的设备（CPU 或 GPU）
model = RNN(c_in=X_train_tensor.shape[1], c_out=2).to(device)
model
代码输出：
RNN(
(rnn): RNN(1, 100, batch_first=True)
(dropout): Identity()
(fc): Linear(in_features=100, out_features=2, bias=True)
)
from torchinfo import summary
rnn_model = RNN(c_in=3, c_out=5, hidden_size=100,n_layers=2,
bidirectional=True, rnn_dropout=.5, fc_dropout=.5) # 初始化一个 RNN 模型，并设置相关参数
summary(rnn_model, input_size=(16, 3, 5)) # 调用 summary 函数，输出 rnn_model 的结构和每一层的详细信息
代码输出：
==========================================================================================
Layer (type:depth-idx) Output Shape Param #
==========================================================================================
RNN -- --
├─RNN: 1-1 [16, 5, 200] 81,400
├─Dropout: 1-2 [16, 200] --
├─Linear: 1-3 [16, 5] 1,005
==========================================================================================
Total params: 82,405
Trainable params: 82,405
Non-trainable params: 0
Total mult-adds (M): 6.53
==========================================================================================
Input size (MB): 0.00
Forward/backward pass size (MB): 0.13
Params size (MB): 0.33
Estimated Total Size (MB): 0.46
==========================================================================================
2. 定义训练函数
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset) # 训练集的大小
num_batches = len(dataloader) # 批次数目
train_loss, train_acc = 0, 0 # 初始化训练损失和正确率
for X, y in dataloader: # 获取数据及其标签
X, y = X.to(device), y.to(device)
# 1. 确保输入数据有三个维度，添加一个seq_len维度
if X.dim() == 2: # 如果是二维输入，添加一个序列长度维度
X = X.unsqueeze(1) # [batch_size, features] --> [batch_size, 1, features]
# 2. 前向传播
pred = model(X) # 网络输出
loss = loss_fn(pred, y) # 计算网络输出和真实值之间的损失
# 3. 反向传播
optimizer.zero_grad() # 清零梯度
loss.backward() # 反向传播
optimizer.step() # 更新参数
# 记录准确率和损失
train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
train_loss += loss.item()
train_acc /= size
train_loss /= num_batches
return train_acc, train_loss
3. 定义测试函数
def test(dataloader, model, loss_fn):
size = len(dataloader.dataset) # 测试集的大小
num_batches = len(dataloader) # 批次数目
test_loss, test_acc = 0, 0
# 当不进行训练时，停止梯度更新，节省计算内存消耗
with torch.no_grad():
for X, y in dataloader:
X, y = X.to(device), y.to(device)
# 1. 确保输入数据有三个维度，添加一个seq_len维度
if X.dim() == 2: # 如果是二维输入，添加一个序列长度维度
X = X.unsqueeze(1) # [batch_size, features] --> [batch_size, 1, features]
# 2. 计算损失
pred = model(X)
loss = loss_fn(pred, y)
test_loss += loss.item()
test_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
test_acc /= size
test_loss /= num_batches
return test_acc, test_loss
4. 正式训练模型
loss_fn = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 2e-5 # 学习率
opt = torch.optim.Adam(model.parameters(),lr=learn_rate) # 使用 Adam 优化器，并将学习率 learn_rate 应用到优化器中
epochs = 20 # 设置训练的总轮数为 20。每轮训练都将通过整个训练集一次
train_loss = [] # 初始化一个空列表用于记录每一轮的训练损失
train_acc = [] # 初始化一个空列表用于记录每一轮的训练准确率
test_loss = [] # 初始化一个空列表用于记录每一轮的测试损失
test_acc = [] # 初始化一个空列表用于记录每一轮的测试准确率
# 循环遍历训练轮数
for epoch in range(epochs):
model.train() # 设置模型为训练模式
epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
model.eval() # 设置模型为评估模式
epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
train_acc.append(epoch_train_acc) # 将当前训练轮的准确率添加到列表中
train_loss.append(epoch_train_loss) # 将当前训练轮的损失添加到列表中
test_acc.append(epoch_test_acc) # 将当前测试轮的准确率添加到列表中
test_loss.append(epoch_test_loss) # 将当前测试轮的损失添加到列表中
# 获取当前的学习率
lr = opt.state_dict()['param_groups'][0]['lr']
# 格式化输出每一轮训练和测试的准确率、损失以及当前学习率
template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss,
epoch_test_acc*100, epoch_test_loss, lr))
print("="*20, 'Done', "="*20)
代码输出：
Epoch: 1, Train_acc:70.1%, Train_loss:0.665, Test_acc:70.9%, Test_loss:0.636, Lr:2.00E-05
Epoch: 2, Train_acc:71.4%, Train_loss:0.596, Test_acc:70.3%, Test_loss:0.558, Lr:2.00E-05
Epoch: 3, Train_acc:72.7%, Train_loss:0.507, Test_acc:80.2%, Test_loss:0.442, Lr:2.00E-05
Epoch: 4, Train_acc:90.8%, Train_loss:0.337, Test_acc:95.7%, Test_loss:0.259, Lr:2.00E-05
Epoch: 5, Train_acc:95.9%, Train_loss:0.212, Test_acc:96.4%, Test_loss:0.179, Lr:2.00E-05
Epoch: 6, Train_acc:96.0%, Train_loss:0.161, Test_acc:96.4%, Test_loss:0.146, Lr:2.00E-05
Epoch: 7, Train_acc:96.2%, Train_loss:0.137, Test_acc:96.7%, Test_loss:0.128, Lr:2.00E-05
Epoch: 8, Train_acc:96.5%, Train_loss:0.121, Test_acc:96.7%, Test_loss:0.116, Lr:2.00E-05
Epoch: 9, Train_acc:96.6%, Train_loss:0.110, Test_acc:96.8%, Test_loss:0.107, Lr:2.00E-05
Epoch:10, Train_acc:96.8%, Train_loss:0.103, Test_acc:96.7%, Test_loss:0.100, Lr:2.00E-05
Epoch:11, Train_acc:96.9%, Train_loss:0.097, Test_acc:96.7%, Test_loss:0.095, Lr:2.00E-05
Epoch:12, Train_acc:96.9%, Train_loss:0.092, Test_acc:96.7%, Test_loss:0.091, Lr:2.00E-05
Epoch:13, Train_acc:97.0%, Train_loss:0.089, Test_acc:96.8%, Test_loss:0.088, Lr:2.00E-05
Epoch:14, Train_acc:97.1%, Train_loss:0.085, Test_acc:96.9%, Test_loss:0.084, Lr:2.00E-05
Epoch:15, Train_acc:97.2%, Train_loss:0.082, Test_acc:97.0%, Test_loss:0.081, Lr:2.00E-05
Epoch:16, Train_acc:97.3%, Train_loss:0.078, Test_acc:97.0%, Test_loss:0.077, Lr:2.00E-05
Epoch:17, Train_acc:97.4%, Train_loss:0.075, Test_acc:97.2%, Test_loss:0.073, Lr:2.00E-05
Epoch:18, Train_acc:97.5%, Train_loss:0.071, Test_acc:97.4%, Test_loss:0.070, Lr:2.00E-05
Epoch:19, Train_acc:97.6%, Train_loss:0.068, Test_acc:97.5%, Test_loss:0.065, Lr:2.00E-05
Epoch:20, Train_acc:97.9%, Train_loss:0.063, Test_acc:97.9%, Test_loss:0.061, Lr:2.00E-05
==================== Done ====================
四、模型评估
1. Loss与Accuracy图
import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore") #忽略警告信息
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
plt.rcParams['figure.dpi'] = 200 #分辨率
from datetime import datetime
current_time = datetime.now() # 获取当前时间
epochs_range = range(epochs)
plt.figure(figsize=(12, 3)) # 创建一个新的图表，并设置图表的大小
plt.subplot(1, 2, 1)
plt.plot(epochs_range, train_acc, label='Training Accuracy') # 绘制训练准确率曲线
plt.plot(epochs_range, test_acc, label='Test Accuracy') # 绘制测试准确率曲线
plt.legend(loc='lower right') # 显示图例，位置为右下角
plt.title('Training and Validation Accuracy') # 设置子图的标题
plt.xlabel(current_time) # 将当前时间作为横坐标标签
plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss') # 绘制训练损失曲线
plt.plot(epochs_range, test_loss, label='Test Loss') # 绘制测试损失曲线
plt.legend(loc='upper right') # 显示图例，位置为右上角
plt.title('Training and Validation Loss') # 设置子图的标题
plt.show() # 显示图表
代码输出：
2. 混淆矩阵
混淆矩阵（Confusion Matrix） 是一种常用的分类模型评估工具，特别适用于 二分类 和 多分类问题。它能够清晰地展示模型的 真实类别（True Labels） 与 预测类别（Predicted Labels） 之间的对应关系，深入分析模型的分类性能。
# 确保输入数据的维度为 [batch_size, seq_len, features]
print("==============输入数据Shape为==============")
print("X_test.shape：", X_test_tensor.shape)
print("y_test.shape：", y_test_tensor.shape)
# 获取预测结果
pred = model(X_test_tensor.to(device)).argmax(1).cpu().numpy()
print("\n==============输出数据Shape为==============")
print("pred.shape：", pred.shape)
代码输出：
==============输入数据Shape为==============
X_test.shape： torch.Size([2000, 1, 18])
y_test.shape： torch.Size([2000])
==============输出数据Shape为==============
pred.shape： (2000,)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
import seaborn as sns
# 计算混淆矩阵
cm = confusion_matrix(y_test, pred)
plt.figure(figsize=(6,5)) # 创建一个新的图形，设置图形的大小为 6x5 英寸
plt.suptitle('') # 设置图形的总标题，这里设置为空字符串 ''，即不显示总标题
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues") # 使用 seaborn 的热力图函数绘制混淆矩阵
# 修改字体大小
plt.xticks(fontsize=10)
plt.yticks(fontsize=10)
plt.title("Confusion Matrix", fontsize=12)
plt.xlabel("Predicted Label", fontsize=10)
plt.ylabel("True Label", fontsize=10)
# 显示图
plt.tight_layout() # 调整布局防止重叠
plt.show()
代码输出：
3. 调用模型进行预测
# 选择单个样本并调整形状为 [batch_size, seq_len, features]
test_X = X_test_tensor[0].reshape(1, 1, -1) # 注意这里调整为三维的 [1, 1, features]
# 获取模型的预测结果
pred = model(test_X.to(device)).argmax(1).item()
print("模型预测结果为：", pred)
print("==" * 20)
print("0：未患病")
print("1：已患病")
代码输出：
模型预测结果为： 0
========================================
0：未患病
1：已患病
