第4天：RNN应用（心脏病预测）

  • 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
  • 🍖 原作者：K同学啊

目标

具体实现

（一）环境

语言环境：Python 3.10
编 译 器: PyCharm
框 架: Pytorch

（二）具体步骤
1. 代码
import numpy as np  
import pandas as pd  
import torch  
from torch import nn  
import torch.nn.functional as F  
import seaborn as sns  # 设置GPU  
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  
print("设备:", device)  # 导入数据  
df = pd.read_csv("./data/heart.csv")  
print(df)  # 构建数据集  
# 标准化  
from sklearn.preprocessing import StandardScaler  
from sklearn.model_selection import train_test_split  X = df.iloc[:, :-1]  
y = df.iloc[:, -1]  # 将第一列特征标准化为标准正态分布，注意，标准化是针对第一列而言的。  
sc = StandardScaler()  
X = sc.fit_transform(X)  # 划分数据集  
X = torch.tensor(np.array(X), dtype=torch.float32)  
y = torch.tensor(np.array(y), dtype=torch.int64)  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=1)  X_train = X_train.unsqueeze(1)  
X_test = X_test.unsqueeze(1)  
print("训练集大小:", X_train.shape, y_train.shape)  from torch.utils.data import TensorDataset, DataLoader  train_dl = DataLoader(TensorDataset(X_train, y_train), batch_size=64, shuffle=False)  
test_dl = DataLoader(TensorDataset(X_test, y_test), batch_size=64, shuffle=False)  # 构建模型  
"""  
RNN模型类，用于心脏病预测  Attributes:  rnn0: RNN层，处理序列数据  fc0: 全连接层，将RNN输出降维到50维  fc1: 最终全连接层，输出2分类结果  
"""  
class model_rnn(nn.Module):  def __init__(self):  super(model_rnn, self).__init__()  self.rnn0 = nn.RNN(  input_size=13,  hidden_size=200,  num_layers=1,  batch_first=True,  )  self.fc0 = nn.Linear(200, 50)  self.fc1 = nn.Linear(50, 2)  """  前向传播函数  Args:        x: 输入张量，形状为(batch_size, seq_len, input_size)  Returns:        输出张量，形状为(batch_size, 2)，表示两个类别的得分  """    def forward(self, x):  out, _ = self.rnn0(x)  # 取最后一个时间步的输出作为特征  out = out[:, -1, :]  out = self.fc0(out)  out = self.fc1(out)  return out  model = model_rnn().to(device)  
print(model)  print(model(torch.rand(30, 1, 13).to(device)).shape)  #  训练  
"""  
训练函数，执行一个epoch的训练  Args:  dataloader: 数据加载器  model: 神经网络模型  loss_fn: 损失函数  optimizer: 优化器  Returns:  平均训练准确率和损失值  
"""  
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)  pred = model(X)  loss = loss_fn(pred, y)  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  """  
测试函数，评估模型性能  Args:  dataloader: 数据加载器  model: 神经网络模型  loss_fn: 损失函数  Returns:  平均测试准确率和损失值  
"""  
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 imgs, target in dataloader:  imgs, target = imgs.to(device), target.to(device)  target_pred = model(imgs)  loss = loss_fn(target_pred, target)  test_loss += loss.item()  test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()  test_acc /= size  test_loss /= num_batches  return test_acc, test_loss  loss_fn = nn.CrossEntropyLoss()  
learning_rate = 1e-4  
opt = torch.optim.Adam(model.parameters(), lr=learning_rate)  
epochs = 50  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, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss, lr))  print("="*20, 'Done', "="*20)  # 评估模型  
import matplotlib.pyplot as plt  
from datetime import datetime  import warnings  
warnings.filterwarnings("ignore")  current_time = datetime.now()  plt.rcParams['font.sans-serif'] = ['SimHei']  
plt.rcParams['axes.unicode_minus'] = False  
plt.rcParams['figure.dpi'] = 200  epochs_range = range(epochs)  # 可视化训练过程中的准确率和损失曲线  
# 包含训练集和测试集的对比曲线  
plt.figure(figsize=(12, 3))  
plt.subplot(1, 2, 1)  
plt.plot(epochs_range, train_acc, label='训练正确率')  
plt.plot(epochs_range, test_acc, label='测试正确率')  
plt.legend(loc='lower right')  
plt.title('训练和测试正确率')  
plt.xlabel(current_time)  plt.subplot(1, 2, 2)  
plt.plot(epochs_range, train_loss, label='训练损失')  
plt.plot(epochs_range, test_loss, label='测试损失')  
plt.legend(loc='upper right')  
plt.title('训练和测试损失')  
plt.show()  # 混淆矩阵  
print("====================输入数据shape================")  
print("X_test.shape:", X_test.shape)  
print("y_test.shape:", y_test.shape)  
pred = model(X_test.to(device)).argmax(1).cpu().numpy()  
print("\n===================输出数据shape===============")  
print("pred.shape:", pred.shape)  from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay  
#计算混淆矩阵  
# 生成混淆矩阵并可视化  
# 显示分类结果的混淆矩阵热力图  
cm = confusion_matrix(y_test, pred)  plt.figure(figsize=(6, 5))  
plt.suptitle("")  
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')  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()  # 心脏病预测  
test_X = X_test[0].unsqueeze(1)  
pred = model(test_X.to(device)).argmax(1).item()  
print("预测结果为:", pred)  
print("=="*20)  
print("0:不会患心脏病")  
print("1:会患心脏病")

结果：

设备: cudaage  sex  cp  trestbps  chol  fbs  ...  exang  oldpeak  slope  ca  thal  target
0     63    1   3       145   233    1  ...      0      2.3      0   0     1       1
1     37    1   2       130   250    0  ...      0      3.5      0   0     2       1
2     41    0   1       130   204    0  ...      0      1.4      2   0     2       1
3     56    1   1       120   236    0  ...      0      0.8      2   0     2       1
4     57    0   0       120   354    0  ...      1      0.6      2   0     2       1
..   ...  ...  ..       ...   ...  ...  ...    ...      ...    ...  ..   ...     ...
298   57    0   0       140   241    0  ...      1      0.2      1   0     3       0
299   45    1   3       110   264    0  ...      0      1.2      1   0     3       0
300   68    1   0       144   193    1  ...      0      3.4      1   2     3       0
301   57    1   0       130   131    0  ...      1      1.2      1   1     3       0
302   57    0   1       130   236    0  ...      0      0.0      1   1     2       0[303 rows x 14 columns]
训练集大小: torch.Size([272, 1, 13]) torch.Size([272])
model_rnn((rnn0): RNN(13, 200, batch_first=True)(fc0): Linear(in_features=200, out_features=50, bias=True)(fc1): Linear(in_features=50, out_features=2, bias=True)
)
torch.Size([30, 2])
Epoch: 0, Train_acc:41.2%, Train_loss:0.700, Test_acc:45.2%, Test_loss:0.700, Lr:1.00E-04
Epoch: 1, Train_acc:55.9%, Train_loss:0.688, Test_acc:67.7%, Test_loss:0.682, Lr:1.00E-04
Epoch: 2, Train_acc:66.9%, Train_loss:0.676, Test_acc:80.6%, Test_loss:0.664, Lr:1.00E-04
Epoch: 3, Train_acc:76.5%, Train_loss:0.664, Test_acc:87.1%, Test_loss:0.648, Lr:1.00E-04
Epoch: 4, Train_acc:77.6%, Train_loss:0.653, Test_acc:90.3%, Test_loss:0.631, Lr:1.00E-04
Epoch: 5, Train_acc:78.7%, Train_loss:0.642, Test_acc:90.3%, Test_loss:0.615, Lr:1.00E-04
Epoch: 6, Train_acc:79.4%, Train_loss:0.631, Test_acc:90.3%, Test_loss:0.599, Lr:1.00E-04
Epoch: 7, Train_acc:80.9%, Train_loss:0.620, Test_acc:90.3%, Test_loss:0.583, Lr:1.00E-04
Epoch: 8, Train_acc:81.6%, Train_loss:0.609, Test_acc:90.3%, Test_loss:0.567, Lr:1.00E-04
Epoch: 9, Train_acc:82.4%, Train_loss:0.598, Test_acc:90.3%, Test_loss:0.552, Lr:1.00E-04
Epoch:10, Train_acc:81.6%, Train_loss:0.587, Test_acc:90.3%, Test_loss:0.536, Lr:1.00E-04
Epoch:11, Train_acc:80.9%, Train_loss:0.576, Test_acc:90.3%, Test_loss:0.520, Lr:1.00E-04
Epoch:12, Train_acc:81.2%, Train_loss:0.565, Test_acc:90.3%, Test_loss:0.504, Lr:1.00E-04
Epoch:13, Train_acc:80.5%, Train_loss:0.554, Test_acc:90.3%, Test_loss:0.489, Lr:1.00E-04
Epoch:14, Train_acc:81.2%, Train_loss:0.542, Test_acc:90.3%, Test_loss:0.473, Lr:1.00E-04
Epoch:15, Train_acc:80.9%, Train_loss:0.531, Test_acc:90.3%, Test_loss:0.458, Lr:1.00E-04
Epoch:16, Train_acc:80.9%, Train_loss:0.520, Test_acc:90.3%, Test_loss:0.443, Lr:1.00E-04
Epoch:17, Train_acc:80.9%, Train_loss:0.509, Test_acc:90.3%, Test_loss:0.428, Lr:1.00E-04
Epoch:18, Train_acc:80.9%, Train_loss:0.498, Test_acc:90.3%, Test_loss:0.414, Lr:1.00E-04
Epoch:19, Train_acc:81.6%, Train_loss:0.488, Test_acc:90.3%, Test_loss:0.401, Lr:1.00E-04
Epoch:20, Train_acc:81.6%, Train_loss:0.477, Test_acc:90.3%, Test_loss:0.388, Lr:1.00E-04
Epoch:21, Train_acc:81.6%, Train_loss:0.468, Test_acc:90.3%, Test_loss:0.376, Lr:1.00E-04
Epoch:22, Train_acc:81.6%, Train_loss:0.458, Test_acc:87.1%, Test_loss:0.365, Lr:1.00E-04
Epoch:23, Train_acc:81.6%, Train_loss:0.449, Test_acc:87.1%, Test_loss:0.355, Lr:1.00E-04
Epoch:24, Train_acc:82.4%, Train_loss:0.441, Test_acc:87.1%, Test_loss:0.346, Lr:1.00E-04
Epoch:25, Train_acc:82.4%, Train_loss:0.433, Test_acc:87.1%, Test_loss:0.337, Lr:1.00E-04
Epoch:26, Train_acc:82.7%, Train_loss:0.426, Test_acc:87.1%, Test_loss:0.329, Lr:1.00E-04
Epoch:27, Train_acc:82.7%, Train_loss:0.419, Test_acc:87.1%, Test_loss:0.322, Lr:1.00E-04
Epoch:28, Train_acc:83.1%, Train_loss:0.413, Test_acc:87.1%, Test_loss:0.316, Lr:1.00E-04
Epoch:29, Train_acc:83.5%, Train_loss:0.407, Test_acc:87.1%, Test_loss:0.311, Lr:1.00E-04
Epoch:30, Train_acc:83.5%, Train_loss:0.402, Test_acc:87.1%, Test_loss:0.306, Lr:1.00E-04
Epoch:31, Train_acc:83.8%, Train_loss:0.397, Test_acc:87.1%, Test_loss:0.302, Lr:1.00E-04
Epoch:32, Train_acc:84.2%, Train_loss:0.392, Test_acc:87.1%, Test_loss:0.299, Lr:1.00E-04
Epoch:33, Train_acc:84.2%, Train_loss:0.388, Test_acc:87.1%, Test_loss:0.296, Lr:1.00E-04
Epoch:34, Train_acc:84.2%, Train_loss:0.384, Test_acc:87.1%, Test_loss:0.294, Lr:1.00E-04
Epoch:35, Train_acc:84.2%, Train_loss:0.381, Test_acc:87.1%, Test_loss:0.292, Lr:1.00E-04
Epoch:36, Train_acc:84.2%, Train_loss:0.378, Test_acc:87.1%, Test_loss:0.290, Lr:1.00E-04
Epoch:37, Train_acc:83.8%, Train_loss:0.375, Test_acc:87.1%, Test_loss:0.289, Lr:1.00E-04
Epoch:38, Train_acc:83.8%, Train_loss:0.373, Test_acc:87.1%, Test_loss:0.288, Lr:1.00E-04
Epoch:39, Train_acc:83.8%, Train_loss:0.370, Test_acc:87.1%, Test_loss:0.287, Lr:1.00E-04
Epoch:40, Train_acc:83.5%, Train_loss:0.368, Test_acc:87.1%, Test_loss:0.287, Lr:1.00E-04
Epoch:41, Train_acc:83.5%, Train_loss:0.366, Test_acc:87.1%, Test_loss:0.286, Lr:1.00E-04
Epoch:42, Train_acc:83.5%, Train_loss:0.364, Test_acc:87.1%, Test_loss:0.286, Lr:1.00E-04
Epoch:43, Train_acc:83.8%, Train_loss:0.363, Test_acc:87.1%, Test_loss:0.287, Lr:1.00E-04
Epoch:44, Train_acc:83.8%, Train_loss:0.361, Test_acc:87.1%, Test_loss:0.287, Lr:1.00E-04
Epoch:45, Train_acc:83.8%, Train_loss:0.360, Test_acc:87.1%, Test_loss:0.287, Lr:1.00E-04
Epoch:46, Train_acc:83.8%, Train_loss:0.358, Test_acc:87.1%, Test_loss:0.287, Lr:1.00E-04
Epoch:47, Train_acc:84.2%, Train_loss:0.357, Test_acc:87.1%, Test_loss:0.288, Lr:1.00E-04
Epoch:48, Train_acc:84.2%, Train_loss:0.356, Test_acc:87.1%, Test_loss:0.289, Lr:1.00E-04
Epoch:49, Train_acc:84.6%, Train_loss:0.355, Test_acc:87.1%, Test_loss:0.289, Lr:1.00E-04
==================== Done ====================
====================输入数据shape================
X_test.shape: torch.Size([31, 1, 13])
y_test.shape: torch.Size([31])===================输出数据shape===============
pred.shape: (31,)
预测结果为: 0
========================================
0:不会患心脏病
1:会患心脏病

image.png
image.png

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

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

相关文章

STM32学习笔记：外部中断(EXTI)原理与应用详解

STM32学习笔记：外部中断(EXTI)原理与应用详解

前言 在嵌入式系统开发中，中断机制是提高系统实时性和效率的重要手段。相比传统的51单片机，STM32微控制器提供了更为丰富和灵活的外部中断资源。本文将全面介绍STM32的外部中断(EXTI)功能，包括其工作原理、配置方法和实际应用技巧。 一、外…
阅读更多...
嵌入式知识篇---Zigbee串口

嵌入式知识篇---Zigbee串口

在 Python 中，serial和pyserial是经常被提及的两个库，它们在串口通信方面有着紧密的联系，但又存在一些差异。下面将对它们进行详细介绍，并给出各自的适用场景。 1. 基本概念 pyserial：它是 Python 里专门用于串口通信…
阅读更多...
vue中的派发事件与广播事件，及广播事件应用于哪些场景和一个表单验证例子

vue中的派发事件与广播事件，及广播事件应用于哪些场景和一个表单验证例子

在 Vue 2.X 中，$dispatch 和 $broadcast 方法已经被废弃。官方认为基于组件树结构的事件流方式难以理解，并且在组件结构扩展时容易变得脆弱。因此，Vue 2.X 推荐使用其他方式来实现组件间的通信，例如通过 $emit 和 $on 方法&#x…
阅读更多...
阿里云事件总线 EventBridge 正式商业化，构建智能化时代的企业级云上事件枢纽

阿里云事件总线 EventBridge 正式商业化，构建智能化时代的企业级云上事件枢纽

作者：肯梦、稚柳 产品演进历程：在技术浪潮中的成长之路 早在 2018 年，Gartner 评估报告便将事件驱动模型（Event-Driven Model）列为十大战略技术趋势之一，指出事件驱动架构（EDA，Eve…
阅读更多...
《前端面试题：BFC（块级格式化上下文）》

《前端面试题：BFC（块级格式化上下文）》

前端BFC完全指南：布局魔法与面试必备 🎋 端午安康！ 各位前端探险家，端午节快乐！🥮 愿你的代码如龙舟竞渡般乘风破浪，样式如香糯粽子般完美包裹！今天我们来解锁CSS中的布局魔法——B…
阅读更多...
dvwa10——XSS(DOM)

dvwa10——XSS(DOM)

XSS攻击： DOM型XSS 只在浏览器前端攻击触发：修改url片段代码不存储 反射型XSS 经过服务器攻击触发：可能通过提交恶意表单，连接触发代码不存储 存储型XSS 经由服务器攻击触发：可能通过提交恶意表单，连…
阅读更多...
跨平台资源下载工具：res-downloader 的使用体验

跨平台资源下载工具：res-downloader 的使用体验

一款基于 Go Wails 的跨平台资源下载工具，简洁易用，支持多种资源嗅探与下载。res-downloader 一款开源免费的下载软件(开源无毒、放心使用)！支持Win10、Win11、Mac系统.支持视频、音频、图片、m3u8等网络资源下载.支持视频号、小程序、抖音、…
阅读更多...
AOSP CachedAppOptimizer中的冻结和内存压缩功能

AOSP CachedAppOptimizer中的冻结和内存压缩功能

AOSP CachedAppOptimizer：应用进程长期处于 Cached 状态的内存压缩和冻结优化管控 冻结和内存压缩两个功能独立触发，可以单独触发也可以组合触发，默认顺序：先压缩，后冻结 public class OomAdjuster { protected b…
阅读更多...
相机--相机成像原理和基础概念

相机--相机成像原理和基础概念

教程 成像原理 基础概念 焦距（物理焦距） 镜头的光学中心到感光元件之间的距离，用f表示，单位：mm；。 像素焦距 相机内参矩阵中的 fx​ 和 fy​ 是将物理焦距转换到像素坐标系的产物，可能不同。…
阅读更多...
Vue3项目实现WPS文件预览和内容回填功能

Vue3项目实现WPS文件预览和内容回填功能

技术方案背景：根据项目需要，要实现在线查看、在线编辑文档，并且进行内容的快速回填，根据这一项目背景，最终采用WPS的API来实现，接下来我们一起来实现项目功能。 1.首先需要先准备好测试使用的文档&#xf…
阅读更多...
汇编语言学习（三）——DoxBox中debug的使用

汇编语言学习（三）——DoxBox中debug的使用

目录 一、安装DoxBox，并下载汇编工具（MASM文件） 二、debug是什么 三、debug中的命令 一、安装DoxBox，并下载汇编工具（MASM文件） 链接： https://pan.baidu.com/s/1IbyJj-JIkl_oMOJmkKiaGQ?pw…
阅读更多...
关于DDOS

关于DDOS

DDOS是一门没什么技术含量的东西，其本质而言是通过大量数据报文，发送到目标受害主机IP地址上，导致目标主机无法继续服务（俗称：拒绝服务） DDOS灰产人期望达成的预期目标，几乎都是只要把对面打到 …
阅读更多...
Modbus转Ethernet IP网关助力罗克韦尔PLC数据交互

Modbus转Ethernet IP网关助力罗克韦尔PLC数据交互

在工业自动化领域，Modbus协议是一种广泛应用的串行通信协议，它定义了主站和从站之间的通信规则和数据格式。罗克韦尔PLC是一种可编程的逻辑控制器，通过Modbus协议实现与其他设备之间的数据交互。然而，随着以太网技术的普及和发展&…
阅读更多...
C# winform教程(二)----button

C# winform教程(二)----button

一、button的使用方法 主要使用方法几乎都在属性内，我们操作也在这个界面 二、作用 用户点击时触发事件，事件有很多种，可以根据需要选择。 三、常用属性 虽然属性很多，但是常用的并不多 3.常用属性 名称内容含义AutoSize自动调…
阅读更多...
【 java 基础问题 第二篇 】

【 java 基础问题 第二篇 】

目录 1.深拷贝和浅拷贝 1.1.区别 定义 定义 1.2.实现深拷贝的方式 2.泛型 2.1.定义 2.2.作用 3.对象 3.1.创建对象的方式 3.2.对象回收 3.3. 获取私有成员 4.反射 4.1.定义 4.2.特性 4.3.原理 5.异常 5.1.异常的种类 5.2.处理异常的方法 6.Object 6.1.等于与…
阅读更多...
Kafka 入门指南与一键部署

Kafka 入门指南与一键部署

Kafka 介绍 想象一下你正在运营一个大型电商平台，每秒都有成千上万的用户浏览商品、下单、支付，同时后台系统还在记录用户行为、更新库存、处理物流信息。这些海量、持续产生的数据就像奔腾不息的河流，你需要一个强大、可靠且实时的系统来接…
阅读更多...
湖北理元理律师事务所：企业债务重组的风险控制方法论

湖北理元理律师事务所：企业债务重组的风险控制方法论

一、担保链破解：阻断债务传染的核心技术 2023年武汉某建材公司案例： 原始债务结构： A公司（主债务人）欠款200万 ↓ B公司（担保人）←连带责任触发执行 ↓ C公司（B公司担…
阅读更多...
如何在CloudCompare中打开pcd文件

如何在CloudCompare中打开pcd文件

你只需要将pcd文件的路径改在全英文路径下，CloudCompare就可以打开。若含中文，就会报错：
阅读更多...
中医的十问歌和脉象分类

中医的十问歌和脉象分类

中医核心理论框架如下 诊断技术如下 本文主要介绍问诊和切诊。 十问歌的“十”是虚指，实际包含12个核心问题，脉象28种中常见仅10余种，重点解释脉诊的物理本质（血流动力学触觉感知） 以下是中医十问歌的完整内容及脉…
阅读更多...
基于智能代理人工智能（Agentic AI）对冲基金模拟系统:模范巴菲特、凯西·伍德的投资策略

基于智能代理人工智能（Agentic AI）对冲基金模拟系统:模范巴菲特、凯西·伍德的投资策略

股票市场涉及众多统计数据和模式。股票交易基于研究和数据驱动的决策。人工智能的使用可以实现流程自动化，让投资者在研究上花费更少的时间，同时提高准确性。这使他们能够更加专注于监督实际交易和服务客户。 顶尖对冲基金经理发挥着至关重要的作用&…
阅读更多...
最新文章

Copyright @ 2022~2023