网站建设推广型/南京网站制作

网站建设推广型,南京网站制作,中英文双语网站建设,手机网站价格RNN理论知识 RNN（Recurrent Neural Network，循环神经网络） 是一种 专门用于处理序列数据（如时间序列、文本、语音、视频等）的神经网络。与普通的前馈神经网络（如 MLP、CNN）不同，RNN…

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(Wx​Xt​+Wh​ht−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, DataLoadertrain_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则直接用Identityself.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 summaryrnn_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  /= sizetrain_loss /= num_batchesreturn 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 /= sizetest_loss /= num_batchesreturn 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：已患病

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/71117.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Lua的table(表)

Lua的table(表)

Lua表的基本概念 Lua中的表（table）是一种多功能数据结构，可以用作数组、字典、集合等。表是Lua中唯一的数据结构机制，其他数据结构如数组、列表、队列等都可以通过表来实现。 表的实现 Lua的表由两部分组成： 数组部分…
阅读更多...
Linux-基本指令3

Linux-基本指令3

一.grep 语法： grep [选项] 搜寻字符串 ⽂件 功能：在⽂件中搜索字符串，将找到的⾏打印出来 常⽤选项： -i ：忽略⼤⼩写的不同，所以⼤⼩写视为相同 -n ：顺便输出⾏号 -v ：反向选择&…
阅读更多...
GPIO（嵌入式学习）

GPIO（嵌入式学习）

GPIO 通用输入输出口： 可分为八种输入输出模式 输出模式 下端可控制端口输出高低电平，用以驱动LED，控制蜂鸣器，模拟通信协议输出时序 输入模式 读取高低电平或电压，用与读取按键输入，外界模块电平信号…
阅读更多...
【构建工具】Gradle Kotlin DSL中的大小写陷阱：BuildConfigField

【构建工具】Gradle Kotlin DSL中的大小写陷阱：BuildConfigField

在Android开发当中，BuildConfig是一个非常有用的功能，它允许我们在构建过程中定义常量，并在运行时使用它们。But！！当我们从传统的Groovy DSL迁移到Kotlin DSL时或者被Android Studio坑的时候，有一些细微的差…
阅读更多...
【Uniapp-Vue3】开发userStore用户所需的相关操作

【Uniapp-Vue3】开发userStore用户所需的相关操作

在项目根路径下创建的stores文件夹中创建user.js文件 并将以下内容复制到user.js中 import {ref} from "vue" import { defineStore } from pinia; const uniIdCo uniCloud.importObject("uni-id-co") const db uniCloud.database(); const usersTable…
阅读更多...
Redis分布式锁的实现（Redission）

Redis分布式锁的实现（Redission）

写在前面 本人在学习Redis过程中学习到分布式锁时太多困惑和疑难杂点 需要总结梳理思路 以下思路都是最简单最基本的思路 主要用到Redission工具类 会涉及到看门狗机制等 本文内容部分引自Javaguide,小林coding等热门八股 用于个人学习用途 分布式锁介绍 对于单机多线程来说…
阅读更多...
基于Apollo对配置类的热更新优化

基于Apollo对配置类的热更新优化

背景 关于配置的热更新，apollo 通过com.ctrip.framework.apollo.spring.annotation.SpringValueProcessor 处理带Value的方法或字段，通过监听变更事件，采用反射去更新对应的值 但这个功能仅仅用于单个属性，当我有一组有关联关系…
阅读更多...
【AD】3-5 元件在原理图中的基本操作2

【AD】3-5 元件在原理图中的基本操作2

1.导线连接 选择放置->线（CtrlW），或者直接点击横条处，建议使用直角走线 注意：下图中的线不具有电气连接属性，只是单纯的线 双击导线，进行设置导线粗细及颜色 2.网络标签 放置->网络标…
阅读更多...
vim:基础配置

vim:基础配置

Vim 配置清单 设置行号显示 set number 设置相对行号（可选） set relativenumber设置制表符为4个空格 set tabstop4 设置自动缩进 set autoindent " 启用语法高亮 syntax on" 设置背景颜色（可选，根据终端或GUI Vi…
阅读更多...
day02_Java基础

day02_Java基础

文章目录 day02_Java基础一、今日课程内容二、数组（熟悉）1、定义格式2、基本使用3、了解数组的内存图介绍4、数组的两个小问题5、数组的常见操作 三、方法（熟悉）1、定义格式2、方法重载overload 四、面向对象（掌握&…
阅读更多...
【UCB CS 61B SP24】Lecture 17 - Data Structures 3: B-Trees学习笔记

【UCB CS 61B SP24】Lecture 17 - Data Structures 3: B-Trees学习笔记

本文以 2-3-4 树详细讲解了 B 树的概念，逐步分析其操作，并用 Java 实现了标准的 B 树。 1. 2-3 & 2-3-4 Trees 上一节课中讲到的二叉搜索树当数据是随机顺序插入的时候能够使得树变得比较茂密，如下图右侧所示，时间复杂度也就…
阅读更多...
【手撕算法】支持向量机（SVM）从入门到实战：数学推导与核技巧揭秘

【手撕算法】支持向量机（SVM）从入门到实战：数学推导与核技巧揭秘

摘要 支持向量机（SVM）是机器学习中的经典算法！本文将深入解析最大间隔分类原理，手撕对偶问题推导过程，并实战实现非线性分类与图像识别。文中附《统计学习公式手册》及SVM调参指南，助力你掌握这一核心算法…
阅读更多...
西门子S7-1200比较指令

西门子S7-1200比较指令

西门子S7-1200 PLC比较指令学习笔记 一、比较指令的作用 核心功能：用于比较两个数值的大小或相等性，结果为布尔值（True/False）。典型应用： 触发条件控制（如温度超过阈值启动报警）数据筛选&…
阅读更多...
solidwork智能尺寸怎么对称尺寸

solidwork智能尺寸怎么对称尺寸

以构造轴为中心线就能画智能尺寸的对称尺寸。先点击边再点击构造线
阅读更多...
深入浅出：Spring AI 集成 DeepSeek 构建智能应用

深入浅出：Spring AI 集成 DeepSeek 构建智能应用

Spring AI 作为 Java 生态中备受瞩目的 AI 应用开发框架，凭借其简洁的 API 设计和强大的功能，为开发者提供了构建智能应用的强大工具。与此同时，DeepSeek 作为领先的 AI 模型服务提供商，在自然语言处理、计算机视觉等领域展现了卓…
阅读更多...
CSS浮动详解

CSS浮动详解

1. 浮动的简介 浮动是用来实现文字环绕图片效果的 2.元素浮动后会有哪些影响 对兄弟元素的影响： 后面的兄弟元素，会占据浮动元素之前的位置，在浮动元素的下面；对前面的兄弟 无影响。 对父元素的影响： 不能撑起父元…
阅读更多...
python数据类型等基础语法

python数据类型等基础语法

目录 字面量 注释 变量 查数据类型 类型转换 算数运算符 字符串定义的三种方式 字符串占位 数据输入 字面量 被写在代码中固定的值 六种数据类型: 1 字符串 String 如"egg" 2 数字 Number: 整数int 浮点数float 复数complex :如43j 布尔…
阅读更多...
Android 图片压缩详解

Android 图片压缩详解

在 Android 开发中，图片压缩是一个重要的优化手段，旨在提升用户体验、减少网络传输量以及降低存储空间占用。以下是几种主流的图片压缩方法，结合原理、使用场景和优缺点进行详细解析。 效果演示 直接先给大家对比几种图片压缩的效果 质量压缩 质量压缩：根据传递进去的质…
阅读更多...
【linux】详谈 环境变量

【linux】详谈 环境变量

目录 一、基本概念 二、常见的环境变量 取消环境变量 三、获取环境变量 通过代码获取环境变量 环境变量的特性 1. getenv函数:获取指定的环境变量 2. environ获取环境变量 四、本地变量 五、定义环境变量的方法 临时定义（仅对当前会话有效） 永…
阅读更多...
《几何原本》公理

《几何原本》公理

《几何原本》公理 等于同量的量彼此相等 即若 a b , b c ab,bc ab,bc 则 a c ac ac 等量加等量，其和仍相等 即若 a b ab ab 则 a c b c acbc acbc 等量减等量，其差仍相等 即若 a b ab ab 则 a − c b − c a-cb-c a−cb−c 彼此能够&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023