深度学习训练camp-第R6周：LSTM实现糖尿病探索与预测

最新推荐文章于 2026-06-24 14:51:23 发布
原创 最新推荐文章于 2026-06-24 14:51:23 发布 · 382 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#深度学习 #lstm #人工智能

一、数据预处理

1、设置GPU

import torch.nn as nn  
import torch.nn.functional as F  
import torchvision, torch  

# 设置硬件设备，如果有GPU则使用，没有则使用cpu  
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  
device

代码输出：

device(type='cuda')

2、数据导入

import numpy             as np  
import pandas            as pd  
import seaborn           as sns  
from sklearn.model_selection   import train_test_split  
import matplotlib.pyplot as plt  
plt.rcParams['savefig.dpi'] = 500 # 图片像素  
plt.rcParams['figure.dpi']  = 500 # 分辨率  

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签  

import warnings   
warnings.filterwarnings("ignore")  

DataFrame = pd.read_excel('./data/dia.xls')  
DataFrame.head()

代码输出：
在这里插入图片描述

DataFrame.shape

代码输出：

(1006, 16)

3、数据检查

# 查看数据是否有缺失值  
print('数据缺失值---------------------------------')  
print(DataFrame.isnull().sum())

代码输出：

数据缺失值---------------------------------
卡号            0
性别            0
年龄            0
高密度脂蛋白胆固醇     0
低密度脂蛋白胆固醇     0
极低密度脂蛋白胆固醇    0
甘油三酯          0
总胆固醇          0
脉搏            0
舒张压           0
高血压史          0
尿素氮           0
尿酸            0
肌酐            0
体重检查结果        0
是否糖尿病         0
dtype: int64


# 查看数据是否有重复值  
print('数据重复值---------------------------------')  
print('数据集的重复值为:' f'{DataFrame.duplicated().sum()}')

代码输出：

数据重复值---------------------------------
数据集的重复值为:0

4、数据分布

feature_map = {  
    '年龄': '年龄',  
    '高密度脂蛋白胆固醇': '高密度脂蛋白胆固醇',  
    '低密度脂蛋白胆固醇': '低密度脂蛋白胆固醇',  
    '极低密度脂蛋白胆固醇': '极低密度脂蛋白胆固醇',  
    '甘油三酯': '甘油三酯',  
    '总胆固醇': '总胆固醇',  
    '脉搏': '脉搏',  
    '舒张压': '舒张压',  
    '高血压史': '高血压史',  
    '尿素氮': '尿素氮',  
    '尿酸': '尿酸',  
    '肌酐': '肌酐',  
    '体重检查结果': '体重检查结果'  
}  
plt.figure(figsize=(15, 10))  

for i, (col, col_name) in enumerate(feature_map.items(), 1):  
    plt.subplot(3, 5, i)  
    sns.boxplot(x=DataFrame['是否糖尿病'], y=DataFrame[col])  
    plt.title(f'{col_name}的箱线图', fontsize=14)  
    plt.ylabel('数值', fontsize=12)  
    plt.grid(axis='y', linestyle='--', alpha=0.7)  

plt.tight_layout()  
plt.show()

代码输出：
<Figure size 7500x5000 with 13 Axes>

二、LSTM模型

1、数据集构建

from sklearn.preprocessing import StandardScaler  

# '高密度脂蛋白胆固醇'字段与糖尿病负相关，故而在 X 中去掉该字段  
X = DataFrame.drop(['卡号', '是否糖尿病', '高密度脂蛋白胆固醇'], axis=1)  
y = DataFrame['是否糖尿病']  

# sc_X    = StandardScaler()  
# X = sc_X.fit_transform(X)  

X = torch.tensor(np.array(X), dtype=torch.float32)  
y = torch.tensor(np.array(y), dtype=torch.int64)  

train_X, test_X, train_y, test_y = train_test_split(X, y,   
                                                    test_size=0.2,  
                                                    random_state=1)  
train_X.shape, train_y.shape

代码输出：

(torch.Size([804, 13]), torch.Size([804]))

from torch.utils.data import TensorDataset, DataLoader  

train_dl = DataLoader(TensorDataset(train_X, train_y),  
                      batch_size=64,   
                      shuffle=True)  

test_dl  = DataLoader(TensorDataset(test_X, test_y),  
                      batch_size=64,   
                      shuffle=False)

定义模型

class model_lstm(nn.Module):  
    def __init__(self):  
        super(model_lstm, self).__init__()  
        self.lstm0 = nn.LSTM(input_size=13, hidden_size=200,   
                             num_layers=1, batch_first=True)  
        
        self.lstm1 = nn.LSTM(input_size=200, hidden_size=200,   
                             num_layers=1, batch_first=True)  
        self.fc0 = nn.Linear(200, 2)  
   
    def forward(self, x):  
        out, hidden1 = self.lstm0(x)   
        out, _ = self.lstm1(out, hidden1)   
        out = self.fc0(out)   
        return out   

model = model_lstm().to(device)  
model

代码输出：

model_lstm(
  (lstm0): LSTM(13, 200, batch_first=True)
  (lstm1): LSTM(200, 200, batch_first=True)
  (fc0): Linear(in_features=200, out_features=2, bias=True)
)

三、训练模型

# 训练循环  
def train(dataloader, model, loss_fn, optimizer):  
    size = len(dataloader.dataset)  # 训练集的大小  
    num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)  

    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)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失  
        
        # 反向传播  
        optimizer.zero_grad()  # grad属性归零  
        loss.backward()        # 反向传播  
        optimizer.step()       # 每一步自动更新  
        
        # 记录acc与loss  
        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

def test(dataloader, model, loss_fn):  
    size = len(dataloader.dataset)  # 测试集的大小  
    num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)  
    test_loss, test_acc = 0, 0  
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗  
    with torch.no_grad():  
        for imgs, target in dataloader:  
            imgs, target = imgs.to(device), target.to(device)  
            
            # 计算loss  
            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()  # 创建损失函数  
learn_rate = 1e-4   # 学习率  
opt = torch.optim.Adam(model.parameters(), lr=learn_rate)  
epochs = 30  

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:55.6%, Train_loss:0.690, Test_acc:53.0%, Test_loss:0.707, Lr:1.00E-04
Epoch: 2, Train_acc:56.2%, Train_loss:0.684, Test_acc:53.0%, Test_loss:0.702, Lr:1.00E-04
Epoch: 3, Train_acc:56.2%, Train_loss:0.683, Test_acc:53.0%, Test_loss:0.701, Lr:1.00E-04
Epoch: 4, Train_acc:56.2%, Train_loss:0.685, Test_acc:53.0%, Test_loss:0.703, Lr:1.00E-04
Epoch: 5, Train_acc:56.2%, Train_loss:0.680, Test_acc:53.0%, Test_loss:0.701, Lr:1.00E-04
Epoch: 6, Train_acc:56.2%, Train_loss:0.680, Test_acc:53.0%, Test_loss:0.699, Lr:1.00E-04
Epoch: 7, Train_acc:56.2%, Train_loss:0.680, Test_acc:53.0%, Test_loss:0.698, Lr:1.00E-04
Epoch: 8, Train_acc:56.2%, Train_loss:0.680, Test_acc:53.0%, Test_loss:0.687, Lr:1.00E-04
Epoch: 9, Train_acc:56.2%, Train_loss:0.676, Test_acc:53.0%, Test_loss:0.701, Lr:1.00E-04
Epoch:10, Train_acc:56.2%, Train_loss:0.673, Test_acc:53.0%, Test_loss:0.688, Lr:1.00E-04
Epoch:11, Train_acc:56.2%, Train_loss:0.670, Test_acc:53.5%, Test_loss:0.680, Lr:1.00E-04
Epoch:12, Train_acc:57.0%, Train_loss:0.664, Test_acc:53.5%, Test_loss:0.683, Lr:1.00E-04
Epoch:13, Train_acc:56.2%, Train_loss:0.664, Test_acc:55.4%, Test_loss:0.670, Lr:1.00E-04
Epoch:14, Train_acc:58.2%, Train_loss:0.652, Test_acc:55.4%, Test_loss:0.669, Lr:1.00E-04
Epoch:15, Train_acc:59.2%, Train_loss:0.646, Test_acc:57.9%, Test_loss:0.665, Lr:1.00E-04
Epoch:16, Train_acc:58.2%, Train_loss:0.645, Test_acc:59.4%, Test_loss:0.659, Lr:1.00E-04
Epoch:17, Train_acc:61.1%, Train_loss:0.636, Test_acc:60.9%, Test_loss:0.646, Lr:1.00E-04
Epoch:18, Train_acc:68.0%, Train_loss:0.626, Test_acc:61.4%, Test_loss:0.648, Lr:1.00E-04
Epoch:19, Train_acc:61.3%, Train_loss:0.618, Test_acc:63.9%, Test_loss:0.632, Lr:1.00E-04
Epoch:20, Train_acc:66.7%, Train_loss:0.613, Test_acc:58.4%, Test_loss:0.648, Lr:1.00E-04
Epoch:21, Train_acc:66.7%, Train_loss:0.595, Test_acc:67.8%, Test_loss:0.611, Lr:1.00E-04
Epoch:22, Train_acc:67.5%, Train_loss:0.592, Test_acc:66.8%, Test_loss:0.612, Lr:1.00E-04
Epoch:23, Train_acc:68.7%, Train_loss:0.581, Test_acc:65.8%, Test_loss:0.604, Lr:1.00E-04
Epoch:24, Train_acc:71.4%, Train_loss:0.566, Test_acc:61.9%, Test_loss:0.629, Lr:1.00E-04
Epoch:25, Train_acc:69.5%, Train_loss:0.565, Test_acc:63.4%, Test_loss:0.610, Lr:1.00E-04
Epoch:26, Train_acc:69.8%, Train_loss:0.552, Test_acc:67.8%, Test_loss:0.589, Lr:1.00E-04
Epoch:27, Train_acc:70.9%, Train_loss:0.550, Test_acc:68.8%, Test_loss:0.584, Lr:1.00E-04
Epoch:28, Train_acc:72.9%, Train_loss:0.537, Test_acc:69.8%, Test_loss:0.573, Lr:1.00E-04
Epoch:29, Train_acc:71.5%, Train_loss:0.531, Test_acc:68.3%, Test_loss:0.584, Lr:1.00E-04
Epoch:30, Train_acc:74.4%, Train_loss:0.525, Test_acc:68.8%, Test_loss:0.592, Lr:1.00E-04
==================== Done ====================

四、数据可视化

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']         = 100        # 分辨率  

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()

代码输出：
在这里插入图片描述
可以看到准确度超过70%

iracole
关注
深度学习训练camp-第R7周：糖尿病预测模型优化探索
iracole的博客
04-02 547
self.attn = nn.Linear(hidden_dim, 1) # 输出为1个attention scoreattn_weights = torch.softmax(attn_weights, dim=1) # 时间维度归一化self.attn = Attention(hidden_dim=200) # 添加 Attention 层self.fc0 = nn.Linear(200, 2) # 输出维度根据你的任务设置为2类分类。
学习长短期记忆网络lstm
qq_52122048的博客
06-17 499
Ct可能是-2到2之间，所以后面再来一个tanh缩小范围-1到1之间。
深度学习知识点
06-23 271
但一个“全连接网络”如果不包含隐藏层（比如只有输入直接映射到输出的单层感知机），或者结构上不满足多层非线性变换的条件，那它。这 m 个数据必须要有 m 个输入神经元来“接住”它们，然后分别通过 m 条独立的连接线（权重），传递给下一层（第一个隐藏层）的每一个神经元。假设你的数据集是一个表格，有 m 列（比如：年龄、工资、身高），那么你的输入特征维度就是 m。这种层与层之间的“两两相连”就是“全连接”名称的由来。3.多层感知机的第一层的神经元的数目等于输入特征向量的维度。1.全连接网络是指神经网络中的。
#从零到一搭建微博情感分类系统：基于BiLSTM的PyTorch完整实战教程【3W字保姆级详解】
2401_88566519的博客
06-24 307
项目使用的是0 → 喜悦1 → 愤怒2 → 厌恶3 → 低落每条数据由两部分组成：第一列为标签（0-3的数字），第二列为微博文本内容。数据集为字符级处理，无需分词，直接按汉字拆分即可。为什么使用字符级而非词语级？对于中文短文本（如微博），字符级处理可以规避分词错误带来的误差，且词表规模更小，模型训练更快，非常适合入门级情感分类任务。函数定义与文档字符串函数接收三个参数：语料文件路径、词表最大尺寸、最低词频。文档字符串清晰说明了函数功能和参数含义，这是工程化代码的好习惯。
Python全栈项目--基于深度学习的自动驾驶模拟系统
exlink2012的专栏
06-17 796
本文介绍了一个基于深度学习的自动驾驶模拟系统全栈项目，包含以下核心内容： 系统架构：采用前后端分离设计，Python+FastAPI处理后端逻辑和深度学习模拟，Vue3构建前端交互界面。 功能模块： 用户认证（JWT+bcrypt加密） 场景配置（道路类型/天气/交通密度） 自动驾驶模拟（车道线识别/障碍物检测/碰撞风险评估） 数据看板展示 技术特点： 轻量级SQLite数据库存储 完整的认证流程实现 可扩展的深度学习模拟框架 响应式前端界面 学习价值：项目提供了完整的开发流程和可运行源码，适合作为深度学习
LSTM预判+速度门控双保险自愈
2301_77211362的博客
06-21 273
模块功能LSTM 预判预警分析历史通量/应力序列，预测未来失稳风险（如裂纹萌生）Speed-Gated 自愈实时监测通量变化率（速度），当超过阈值时自动增强修复强度双重触发机制满足任一条件（预判高风险 或 实际失稳）即启动自愈动态调节自愈强度随风险等级与速度同步变化。
Intelligent Tomato Ripeness Detection System Based on YOLOv8 Deep Learning
ZSW1218的博客
06-21 205
Abstract: With the intelligent development of modern agriculture, traditional manual tomato ripeness detection methods suffer from low efficiency, strong subjectivity, and high labor costs. To improve the accuracy and efficiency of tomato ripeness detectio
深度学习稀疏编码与 PCA 的流形解释 —— 线性因子模型收官（八十一）
hello.reader
06-21 213
本文总结了线性因子模型的两个重要主题：稀疏编码和PCA的流形解释。稀疏编码通过L1范数约束实现因子稀疏性，其编码器是非参数的优化过程，虽能获得更优重构但计算效率较低。PCA可视为学习数据所在的低维线性流形（"薄饼"几何），通过保留方差最大的主成分实现降维，并可从线性自编码器角度理解其编码-解码过程。这些线性模型为后续自编码器等深度表示学习模型奠定了基础，同时也揭示了线性方法的局限性，如稀疏编码生成样本质量不佳的问题。文章通过几何动画和对比表格直观展示了关键概念的技术原理与优劣。
吴恩达《深度学习》之看懂注意力机制的“精准一瞥”
m0_74435839的博客
06-24 263
多头注意力机制。语言是极其复杂的。当我们看到一句话里的某个词时，我们往往需要同时关注很多不同的维度。比如看这句话：“那只巨大的猫懒洋洋地躺在垫子上，它刚刚吃了鱼。当我们盯着“猫”我们的左眼可能需要关注它的修饰语（什么猫？——巨大的猫）；我们的右眼可能需要追踪它的代词指代（谁吃了鱼？——“它”指的是猫）。如果我们只有“一双眼睛”（单头注意力机制），网络在同一时间只能计算出一组α\alphaα。它如果去看了“巨大的”，就没办法同时去死死盯着“它”。
深度学习自编码器基础与欠完备自编码器 —— 复制的艺术（八十二）
hello.reader
06-21 458
自编码器不需要标签（用数据自身作监督信号，目标是重构 x），产出有用表示 h，能利用无标注的海量数据。非线性自编码器能找弯曲的流形（曲面），是 PCA 的强大推广，能捕捉更复杂的数据结构。上图展示自编码器的两个组件：编码器 f（x→h）和解码器 g（h→r），目标是 r 近似 x。上图展示欠完备自编码器的沙漏结构：编码维度（瓶颈，如 2 维）小于输入维度（如 8 维）。也有更具生物学意义的**再循环（recirculation）**算法（比较原始输入与重构输入的激活），但很少用于实际。
理解RNN：Learning long-term dependencies with gradient descent is difficult
weixin_45209433的博客
06-24 232
为什么说记住了h1，因为即使到后面100个时刻，a100仍然大于0，说明输入h1>0，a100>0，当然h1<0，a100<0，这个可以自行计算，这就是过去的信息仍然存在于当前状态。之后如果没有输入，RNN持续输出0.957左右，根据上的计算可可以知道，隐藏值a一直在1.9左右，处于tanh的饱和区，所以输出经过tanh后，输出在0.957左右。这是只有1个神经元的RNN，我们通过举例子，来说明下RNN的内部具体是怎么操作的，以及其特点，假设w =2, a0 = 0，给予的输入是正值。
深度学习自编码器的概率视角与流形学习 —— 编码器即分布（八十四）
hello.reader
06-21 130
上图总结自编码器的概率视角三层次：确定函数（h=f(x), r=g(h)，传统自编码器）→ 概率分布（p(h|x), p(x|h)，随机自编码器）→ 生成模型（近似后验+似然+先验，VAE）。上图展示流形的经典例子：把一张 MNIST 图像垂直平移，所有平移版本在 784 维空间中构成一条 1 维流形（弯曲路径），平移量就是沿流形的坐标。把编码器/解码器从函数推广为分布，再加上对隐变量先验的建模和变分下界，就得到了 VAE——一个真正的深度生成模型。前两篇讲了自编码器的结构（82）和正则化（83）。
深度学习迁移学习与域适应 —— 知识的搬运术（八十七）
最新发布
hello.reader
06-24 40
迁移学习和域适应指的是利用一个情景（如分布P1P_1P1​）中已经学到的内容，去改善另一个情景（如分布P2P_2P2​）中的泛化情况。在迁移学习中，学习器必须执行两个或更多个不同的任务，但我们假设能够解释P1P_1P1​变化的许多因素和学习P2P_2P2​需要抓住的变化相关。在域适应的相关情况下，每个情景之间任务（和最优的输入到输出映射）都是相同的，但输入分布稍有不同。迁移学习：任务不同域适应：任务相同，输入分布不同。
【训练与微调篇07】训练监控与模型评估：从实验管理到Benchmark实战
weixin_54908067的博客
06-22 431
本文系统介绍了2026年大模型评估体系的最新发展与实践方法，主要内容包括： 系统化评估的必要性 指出仅监控训练Loss的局限性 提出三层评估架构：实时训练监控、定期基准测试、最终全面评估 训练监控系统搭建 详细演示Weights & Biases(W&B)的实战应用 提供完整的Python实现代码 介绍MLflow自托管方案作为替代选择 评估体系创新 强调多维度标准化评估的重要性 涵盖16+核心Benchmark指标 提出Multi-Score综合评分框架 文章通过具体代码示例和系统架构图，展示了如何构建完
基于深度学习的目标跟踪综述（A review of object tracking based on deep learningq）
2301_78173237的博客
06-17 426
随着深度学习技术的快速发展，目标跟踪算法的发展也随之兴起。鉴于目标、骨干网络和应用方法的多样性，本研究旨在综合整合现有的目标跟踪方法。我们提出了一种基于应用场景和主要方法的系统分类方案，伴随着对每个类别的透彻分析和简明摘要。这种方法提供了更广泛的跟踪技术覆盖面，便于新手研究人员更快地理解该领域。此外，我们提出了标准化的评估指标和广泛使用的数据集，包括在相同的基准上对选定算法进行跨方法性能比较，以增强读者对上下文的理解。最后，我们对当前的局限性、实用建议和前瞻性观点进行了批判性评估，以指导未来的研究方向。
通用表格识别技术通过深度学习与计算机视觉，实现了复杂表格的高精度数字化解析
智能图像识别
06-22 381
摘要：通用表格识别技术通过深度学习与计算机视觉，实现了复杂表格的高精度数字化解析。该技术采用CNN+Transformer融合架构，支持有线/无线表格检测、结构还原与文字识别同步处理，具备多级表头识别、跨页续接等能力，在金融、政务、医疗等领域广泛应用。相比传统OCR，其突破性在于保留表格行列关系与合并单元格结构，将静态图像转化为可计算数据，解决了低质量文档识别难题，显著提升了企业数据自动化处理效率，成为数字化转型的关键基础设施。
NLP基础（RNN，LSTM，GRU）
Maxwell_Newton的博客
06-22 341
则引入一个重要的思想，编码器-解码器架构，先用多次循环读入全部输入，这被称为编码阶段，这个阶段没有输出，再把编码阶段的记忆传递下去，每一步都输出一个token，然后新的输入为上一步的记忆+上一步的输出token。前面的RNN很容易发现一个问题，推理都是从前往后读的，也就是生成第i个token的隐状态时，只能看到前i个token，但现实文本很容易出现的情况是，一个词的含义不仅要看上文，还要看下文，比如。RNN的关键是，会在隐藏层传递记忆，单看隐藏层的话，是一个循环的过程，这也是循环神经网络名字的由来。
深入浅出 RNN 反向传播与梯度消失
weixin_48609829的博客
06-21 417
title: 深入浅出 RNN 反向传播与梯度消失tags: Agent开发, 深度学习, 算法基础excerpt: 详细解析 RNN 的随时间反向传播（BPTT）过程。从底层的前向信息流，到严谨的微积分链式法则，直击全导数展开与连乘导致梯度消失的数学本质。循环神经网络（RNN）的核心优势在于处理带有序列依赖的数据。在训练阶段，这种处理时间序列的“记忆”特性，使得其反向传播算法（Backpropagation Through Time, BPTT）比传统的前馈神经网络多了一个关键的时间维度。
开源计算机视觉项目easy12306深度剖析：基于深度学习的12306验证码识别算法原理与本地部署实战指南
wulechun的博客
06-21 249
easy12306不仅是一个实用的验证码识别工具，更是一个优秀的深度学习入门教材。它展示了如何将复杂的现实问题（验证码识别）转化为计算机可以理解的数学模型。对于开发者而言，掌握该项目不仅能解决具体的抢票难题，更能深入理解卷积神经网络在图像分类领域的强大威力。随着AI技术的对抗升级，虽然12306的验证码机制在不断变化，但easy12306所代表的技术思路依然具有极高的参考价值。
深度学习结构化概率模型——有向与无向图模型 —— 用图描述概率（八十九）
hello.reader
06-24 38
结构化概率模型通过图结构描述高维数据变量间的直接相互作用，解决维度灾难问题。有向图模型（贝叶斯网络）适用于明确因果关系的场景（如接力赛），通过局部条件分布分解联合概率。无向图模型（马尔可夫随机场）适用于双向交互场景（如感冒传染），通过团因子乘积表示未归一化概率。两者均显著减少参数规模，但无向模型需额外计算配分函数进行归一化。选择模型类型取决于变量间作用是否具有方向性，图结构编码的条件独立性是概率分解的数学基础。** （字数：150） 核心要点： 维度灾难：朴素查表法不可行，需结构化建模 图模型价值：边
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值