[自然语言处理]RNN

Letmooning Letmooning 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 900+累计阅读 936平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄2年
关注
原创 2024-10-11 11:51:33 936 阅读 AI 写同款· GEO 优化 ›
【NLP】NLP基础之RNN循环神经网络 输出张量 包含RNN在输入序列的每个时间步的输出。形状：(seq_len, batch, num_directions * hidden_size) 或 (batch, seq_len, num_directions * hidden_size)（如果 batch_first=True）。它是基于当前时间步输入和先前隐藏状态计算的RNN层的激活输出。 阅读详情

1 传统RNN模型与LSTM

import torch
import torch.nn as nn

torch.manual_seed(6)


# todo:基础RNN模型
def dem01():
    '''
    参数1：input_size 每个词的词向量维度（输入层神经元的个数）
    参数2：hidden_size 隐藏层神经元的个数
    参数3：hidden_layer 隐藏层的层数
    '''
    rnn = nn.RNN(5, 6, 1)
    '''
    参数1：sequence_length 每个样本的句子长度
    参数2：batch_size 每个批次的样本数量
    参数3：input_size 每个词的词向量维度（输入层神经元的个数）
    '''
    input = torch.randn(1, 3, 5)
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    h0 = torch.randn(1, 3, 6)
    output, hn = rnn(input, h0)
    print(f'output {output}')
    print(f'hn {hn}')
    print(f'RNN模型 {rnn}')


# todo:增加输入的sequence_length
def dem02():
    '''
    参数1：input_size 每个词的词向量维度（输入层神经元的个数）
    参数2：hidden_size 隐藏层神经元的个数
    参数3：hidden_layer 隐藏层的层数
    '''
    rnn = nn.RNN(5, 6, 1)
    '''
    参数1：sequence_length 每个样本的句子长度
    参数2：batch_size 每个批次的样本数量
    参数3：input_size 每个词的词向量维度（输入层神经元的个数）
    '''
    input = torch.randn(4, 3, 5)
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    h0 = torch.randn(1, 3, 6)
    output, hn = rnn(input, h0)
    print(f'output {output}')
    print(f'hn {hn}')
    print(f'RNN模型 {rnn}')


# todo:增加隐藏层的个数
def dem03():
    '''
    参数1：input_size 每个词的词向量维度（输入层神经元的个数）
    参数2：hidden_size 隐藏层神经元的个数
    参数3：hidden_layer 隐藏层的层数
    '''
    rnn = nn.RNN(5, 6, 2)
    '''
    参数1：sequence_length 每个样本的句子长度
    参数2：batch_size 每个批次的样本数量
    参数3：input_size 每个词的词向量维度（输入层神经元的个数）
    '''
    input = torch.randn(4, 3, 5)
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    h0 = torch.randn(2, 3, 6)
    output, hn = rnn(input, h0)
    print(f'output {output}')
    print(f'hn {hn}')
    print(f'RNN模型 {rnn}')


# todo:一个一个地向模型输入单词-全零初始化
def dem04_1():
    '''
    参数1：input_size 每个词的词向量维度（输入层神经元的个数）
    参数2：hidden_size 隐藏层神经元的个数
    参数3：hidden_layer 隐藏层的层数
    '''
    rnn = nn.RNN(5, 6, 1)
    '''
    参数1：sequence_length 每个样本的句子长度
    参数2：batch_size 每个批次的样本数量
    参数3：input_size 每个词的词向量维度（输入层神经元的个数）
    '''
    input = torch.randn(4, 1, 5)
    print(f'input {input}')
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    # 每个样本一次性输入神经网络
    hn = torch.zeros(1, 1, 6)
    print(f'hn1 {hn}')
    output, hn = rnn(input, hn)
    print(f'output1 {output}')
    print(f'hn1 {hn}')
    print(f'RNN模型1 {rnn}')
    print('*' * 80)
    # 每个样本逐词送入神经网络
    hn = torch.zeros(1, 1, 6)
    print(f'hn2 {hn}')
    for i in range(4):
        tmp = input[i][0]
        print(f'tmp.shape {tmp.shape}')
        output, hn = rnn(tmp.unsqueeze(0).unsqueeze(0), hn)
        print(f'{i}-output {output}')
        print(f'{i}-hn {hn}')


# todo:一个一个地向模型输入单词-全一初始化
def dem04_2():
    '''
    参数1：input_size 每个词的词向量维度（输入层神经元的个数）
    参数2：hidden_size 隐藏层神经元的个数
    参数3：hidden_layer 隐藏层的层数
    '''
    rnn = nn.RNN(5, 6, 1)
    '''
    参数1：sequence_length 每个样本的句子长度
    参数2：batch_size 每个批次的样本数量
    参数3：input_size 每个词的词向量维度（输入层神经元的个数）
    '''
    input = torch.randn(4, 1, 5)
    print(f'input {input}')
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    # 每个样本一次性输入神经网络
    hn = torch.ones(1, 1, 6)
    print(f'hn1 {hn}')
    output, hn = rnn(input, hn)
    print(f'output1 {output}')
    print(f'hn1 {hn}')
    print(f'RNN模型1 {rnn}')
    print('*' * 80)
    # 每个样本逐词送入神经网络
    hn = torch.ones(1, 1, 6)
    print(f'hn2 {hn}')
    for i in range(4):
        tmp = input[i][0]
        print(f'tmp.shape {tmp.shape}')
        output, hn = rnn(tmp.unsqueeze(0).unsqueeze(0), hn)
        print(f'{i}-output {output}')
        print(f'{i}-hn {hn}')


# todo:一个一个地向模型输入单词-随机初始化
def dem04_3():
    '''
    参数1：input_size 每个词的词向量维度（输入层神经元的个数）
    参数2：hidden_size 隐藏层神经元的个数
    参数3：hidden_layer 隐藏层的层数
    '''
    rnn = nn.RNN(5, 6, 1)
    '''
    参数1：sequence_length 每个样本的句子长度
    参数2：batch_size 每个批次的样本数量
    参数3：input_size 每个词的词向量维度（输入层神经元的个数）
    '''
    input = torch.randn(4, 1, 5)
    print(f'input {input}')
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    # 每个样本一次性输入神经网络
    hn = torch.randn(1, 1, 6)
    print(f'hn1 {hn}')
    output, hn = rnn(input, hn)
    print(f'output1 {output}')
    print(f'hn1 {hn}')
    print(f'RNN模型1 {rnn}')
    print('*' * 80)
    # 每个样本逐词送入神经网络
    hn = torch.randn(1, 1, 6)
    print(f'hn2 {hn}')
    for i in range(4):
        tmp = input[i][0]
        print(f'tmp.shape {tmp.shape}')
        output, hn = rnn(tmp.unsqueeze(0).unsqueeze(0), hn)
        print(f'{i}-output {output}')
        print(f'{i}-hn {hn}')


# todo:设置batch_first=True
def dem05():
    '''
    参数1：input_size 每个词的词向量维度（输入层神经元的个数）
    参数2：hidden_size 隐藏层神经元的个数
    参数3：hidden_layer 隐藏层的层数
    '''
    rnn = nn.RNN(5, 6, 1, batch_first=True)
    '''
    参数1：batch_size 每个批次的样本数量
    参数2：sequence_length 每个样本的句子长度
    参数3：input_size 每个词的词向量维度（输入层神经元的个数）
    '''
    input = torch.randn(3, 4, 5)
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    h0 = torch.randn(1, 3, 6)
    output, hn = rnn(input, h0)
    print(f'output {output}')
    print(f'hn {hn}')
    print(f'RNN模型 {rnn}')


# todo:基础LSTM模型
def dem06_1():
    '''
    参数1：input_size 每个词的词向量维度（输入层神经元的个数）
    参数2：hidden_size 隐藏层神经元的个数
    参数3：hidden_layer 隐藏层的层数
    '''
    rnn = nn.LSTM(5, 6, 2)
    '''
    参数1：batch_size 每个批次的样本数量
    参数2：sequence_length 每个样本的句子长度
    参数3：input_size 每个词的词向量维度（输入层神经元的个数）
    '''
    input = torch.randn(1, 3, 5)
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    h0 = torch.randn(2, 3, 6)
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    c0 = torch.randn(2, 3, 6)
    output, (hn, cn) = rnn(input, (h0, c0))
    print(f'output {output}')
    print(f'hn {hn}')
    print(f'cn {cn}')

# todo:双向LSTM模型
def dem06_2():
    '''
    参数1：input_size 每个词的词向量维度（输入层神经元的个数）
    参数2：hidden_size 隐藏层神经元的个数
    参数3：hidden_layer 隐藏层的层数
    '''
    rnn = nn.LSTM(5, 6, 2,bidirectional=True)
    '''
    参数1：batch_size 每个批次的样本数量
    参数2：sequence_length 每个样本的句子长度
    参数3：input_size 每个词的词向量维度（输入层神经元的个数）
    '''
    input = torch.randn(1, 3, 5)
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    h0 = torch.randn(4, 3, 6)
    '''
    参数1：hidden_layer 隐藏层的层数
    参数2：batch_size 每个批次的样本数量
    参数3：hidden_size 隐藏层神经元的个数
    '''
    c0 = torch.randn(4, 3, 6)
    output, (hn, cn) = rnn(input, (h0, c0))
    print(f'output {output}')
    print(f'hn {hn}')
    print(f'cn {cn}')


if __name__ == '__main__':
    # dem01()
    # dem02()
    # dem03()
    # dem04_1()
    # dem04_2()
    # dem04_3()
    # dem05()
    # dem06_1()
    dem06_2()
D:\nlplearning\nlpbase\python.exe D:\nlpcoding\rnncode.py 
output tensor([[[ 0.0207, -0.1121, -0.0706,  0.1167, -0.3322, -0.0686],
         [ 0.1256,  0.1328,  0.2361,  0.2237, -0.0203, -0.2709],
         [-0.2668, -0.2721, -0.2168,  0.4734,  0.2420,  0.0349]]],
       grad_fn=<MkldnnRnnLayerBackward0>)
hn tensor([[[ 0.1501, -0.2106,  0.0213,  0.1309,  0.3074, -0.2038],
         [ 0.3639, -0.0394, -0.1912,  0.1282,  0.0369, -0.1094],
         [ 0.1217, -0.0517,  0.1884, -0.1100, -0.5018, -0.4512]],

        [[ 0.0207, -0.1121, -0.0706,  0.1167, -0.3322, -0.0686],
         [ 0.1256,  0.1328,  0.2361,  0.2237, -0.0203, -0.2709],
         [-0.2668, -0.2721, -0.2168,  0.4734,  0.2420,  0.0349]]],
       grad_fn=<StackBackward0>)
cn tensor([[[ 0.2791, -0.7362,  0.0501,  0.2612,  0.4655, -0.2338],
         [ 0.7902, -0.0920, -0.4955,  0.3865,  0.0868, -0.1612],
         [ 0.2312, -0.3736,  0.4033, -0.1386, -1.0151, -0.5971]],

        [[ 0.0441, -0.2279, -0.1483,  0.3397, -0.5597, -0.4339],
         [ 0.2154,  0.4119,  0.4723,  0.4731, -0.0284, -1.1095],
         [-0.5016, -0.5146, -0.4286,  1.5299,  0.5992,  0.1224]]],
       grad_fn=<StackBackward0>)

Process finished with exit code 0

2 GRU

import torch
import torch.nn as nn


# todo:基础GRU
def dem01():
    gru = nn.GRU(5, 6, 1)
    input = torch.randn(4, 3, 5)
    h0 = torch.randn(1, 3, 6)
    output, hn = gru(input, h0)
    print(f'output {output}')
    print(f'hn {hn}')


if __name__ == '__main__':
    dem01()

标签
#自然语言处理 #rnn #深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
循环神经网络（RNN）：自然语言处理的基石 循环神经网络（RNN）：自然语言处理的基石 1. 背景介绍 1.1 自然语言处理的重要性 随着人工智能技术的快速发展，自然语言处理（NLP）已经成为一个非常重要的研究领域。它旨在使计算机能够理解和生成人类语言，从而实现人机自 阅读详情

相关推荐

NLP学习路线图（二十二）： 循环神经网络（RNN）

循环神经网络（RNN）是处理序列数据的革命性模型，通过引入隐藏状态实现记忆功能，解决了传统神经网络无法建模序列依赖关系的核心问题。文章详细解析了RNN的循环结构、参数共享机制及其在NLP中的典型应用（如语言建模、机器翻译等），同时指出基础RNN存在的梯度消失/爆炸等缺陷。重点介绍了LSTM和GRU两种改进结构，它们通过门控机制有效缓解长程依赖问题。尽管当前Transformer模型表现优异，RNN在流式数据处理等场景仍具独特价值，其设计思想仍是序列建模的重要基础。

2501_91516851的博客 1206

【自然语言处理（NLP）】循环神经网络RNN

循环神经网络（Recurrent Neural Network，RNN）是一类特殊的人工神经网络，它适合处理序列数据，在自然语言处理、语音识别等领域应用广泛。下面从结构原理、特点、存在的问题及应用场景等方面详细介绍。

专注上位机开发、机器视觉、机器学习、嵌入式软硬件开发 1万+

Python机器学习实战：循环神经网络(RNN)与自然语言处理(NLP)

Python机器学习实战：循环神经网络(RNN)与自然语言处理(NLP) 1. 背景介绍 1.1 问题的由来 在过去的几十年里，自然语言处理(NLP)一直是人工智能领域的一个重要挑战。作为人类与机器交互的桥梁,N

AI大模型应用之禅 567

【自然语言处理（NLP）】双向循环神经网络（Bidirectional Recurrent Neural Network，Bi - RNN）原理和实现

双向循环神经网络（Bidirectional Recurrent Neural Network，Bi - RNN）是循环神经网络（RNN）的一种拓展形式，在处理序列数据时具有独特优势，以下是对它的详细介绍： ## 结构特点 双向循环神经网络由两个方向相反的循环层构成，一个按时间顺序正向处理序列数据（前向RNN），另一个则逆向处理（后向RNN）。在每个时间步，这两个循环层都分别计算各自的隐藏状态，然后将它们的结果进行合并（如拼接或相加等），作为该时间步的最终隐藏状态输出。这种结构使得模型在处理当前时刻的信息

专注上位机开发、机器视觉、机器学习、嵌入式软硬件开发 1万+

【自然语言处理（NLP）】从零实现循环神经网络RNN、Pytorch实现循环神经网络RNN

【自然语言处理（NLP）】从零实现循环神经网络RNN、Pytorch实现循环神经网络RNN

专注上位机开发、机器视觉、机器学习、嵌入式软硬件开发 1万+

全面掌握RNN及其在NLP中的高级应用

NLP 是人工智能与语言学的交叉学科，它让计算机能够理解、解释和操纵人类语言。NLP的出现极大地推动了人机交互的变革，使得计算机能够执行更复杂、更人性化的任务。循环神经网络（Recurrent Neural Networks, RNN）是专为处理序列数据而设计的神经网络类型，广泛应用于自然语言处理（NLP）、语音识别等领域。RNN的核心特性在于其内部结构包含循环连接，这使得网络能够处理任意长度的序列数据。相比于传统前馈神经网络，RNN可以捕捉时间序列中的时间动态信息。

weixin_42593549的博客 1047

深度学习初学4：循环神经网络（RNN）及其在自然语言处理（NLP）中的应用

通过Backpropagation Through Time (BPTT)计算梯度：尽管基础RNN存在长期依赖问题，但其思想催生了LSTM、GRU等改进架构，以及Transformer革命性模型。掌握这些基础原理，是理解现代NLP技术的必经之路。门控循环单元和长短期记忆网络通过精巧的门控设计，显著提升了RNN处理长序列的能力。当结合深度架构和双向处理时，这些模型能够捕捉文本中复杂的时空依赖关系。在实际应用中，建议根据任务需求和数据规模选择合适的架构，并通过细致的调优释放模型潜力。

a4679588的博客 1837

CTF密码学奇技淫巧：当Base64遇到ROT13与Atbash

本文深入解析CTF竞赛中Base64、ROT13与Atbash的复合编码技术，提供Python实现与CyberChef可视化处理方案，帮助选手掌握密码学题目的解题技巧。通过NewStarCTF2025实战案例，对比脚本化与可视化工具的优劣，提升Web安全竞赛中的编码处理能力。

weixin_29001683的博客 509

循环神经网络（RNN）在自然语言处理（NLP）中的应用

自动摘要是将长文本简化为简短摘要的过程。RNN在这方面的应用可以减少用户阅读大量信息的时间，快速获取关键信息。它通过分析文本内容，提取关键句子，生成一段具有代表性的摘要。在新闻报道中，RNN可以自动生成新闻摘要，让用户快速了解新闻的主要内容。在学术论文中，RNN可以生成摘要，帮助研究人员快速了解论文的研究内容和结论。自动摘要的应用不仅提高了信息获取的效率，也为信息过载的问题提供了解决方案。自动摘要的实际应用非常广泛，它不仅可以用于新闻报道和学术论文，还可以用于企业报告、法律文件和医疗记录等专业领域。

ciweic的博客 1949

告别“盲开”：手把手教你用MCU内置比较器搞定BLDC无感方波启动（附代码片段）

本文详细介绍了如何利用MCU内置比较器实现BLDC无感方波启动，解决传统无传感器控制中的'盲开'问题。通过虚拟中性点电路设计和三段式启动流程，结合反电动势检测和过零检测技术，提供了一套经济高效的解决方案，并附有可直接移植的代码片段，助力工程师快速实现可靠的无感控制。

weixin_33694172的博客 507

使用python读取卫星测高数据并做相应的处理

5.在python处理结果如下，最大的优点就是比matlab快30-40倍。4.进行粗差的如NaN值，还有进行3倍方差进行对粗差处理。1.首先遍历卫星数据的文件，挨个读取每个数据。有问题，请各位读者及时告知，一起完善内容。3.进行下一步，筛选在研究区域的数据。4.进行按天求平均和按月求平均。2.读取数据主体代码。

爱下去更难！ 1133

循环神经网络（RNN）与自然语言处理（NLP）全面解析

与传统的图像分类（一对一模型）不同，序列模型需要考虑时间维度上的依赖关系。- 示例：{'<unk>':0, 'the':1, 'i':2, 'and':3, ...}a. 读取数据：加载原始文本（如IMDB影评数据集）- 多类别特征：独热编码（如国籍197维向量）解决方案：学习低维稠密向量表示（如32/64维）独热编码问题：维度灾难（词汇表大时维度过高）- 长期依赖遗忘：梯度随时间步指数衰减/爆炸。- 解决方案：门控机制（GRU/LSTM）- 二值特征：0/1编码（如性别）- 改进结构：测试精度85.4%

weixin_65062258的博客 958

Aspose Java 25.10 版本深度破解：基于字节码修改的实战指南

本文提供了Aspose Java 25.10版本基于字节码修改的实战指南。详细介绍了如何通过Javassist工具逆向分析并修改Aspose Cells、Words、Slides及PDF组件的许可证验证逻辑，从而实现绕过限制，并完成最终的打包与功能验证。

stone的博客 1365

【笔记】循环神经网络（RNN，Recurrent Neural Networks）：在众多自然语言处理(Natural Language Processing, NLP)中广泛应用

循环神经网络(RNN, Recurrent Neural Networks)介绍    这篇文章很多内容是参考：http://www.wildml.com/2015/09/recurrent-neural-networks-tutorial-part-1-introduction-to-rnns/，在这篇文章中，加入了一些新的内容与一些自己的理解。 该tutorial默认读者已经熟悉了基本的神经网络模型。如果不熟悉，可以点击：Implementing...

nyist_yangguang的博客 1728

【OS】AUTOSAR OS Alarm实现原理

AUTOSAR OS Alarm实现原理

qq_36056498的博客 1025

基于多模态融合的反无人机视觉跟踪算法研究

本研究提出了一种基于多模态融合的反无人机视觉跟踪算法，通过整合可见光、红外、深度等多种视觉信息源，提高了对无人机的跟踪精度和可靠性。设计并实现了多模态特征提取方法，针对不同模态图像的特点提取了有效的特征信息，为多模态融合提供了基础。研究了多种多模态融合策略，包括特征级融合、决策级融合和混合融合，并通过实验对比分析了它们的优缺点，确定了适合反无人机视觉跟踪的融合方法。选择并改进了跟踪算法，将多模态融合信息融入到跟踪过程中，提高了算法对复杂环境和无人机运动变化的适应性。

AI的内部世界的博客 1354

【自然语言处理（NLP）】深度循环神经网络（Deep Recurrent Neural Network，DRNN）原理和实现

深度循环神经网络（Deep Recurrent Neural Network，DRNN）是在循环神经网络（RNN）基础上发展而来的一种深度学习模型。 ## 结构特点 - **多层循环结构**：普通的RNN通常只有一层循环层，而DRNN包含多个循环层堆叠在一起。每一层循环层都可以学习到不同层次和粒度的序列特征。底层的循环层可以捕捉到序列中的局部短期依赖关系，随着层数的增加，高层的循环层能够逐渐提取出更抽象、更长期的依赖关系。 - **丰富的连接方式**：除了循环层之间的堆叠，DRNN还可以有多种连接方式。例

专注上位机开发、机器视觉、机器学习、嵌入式软硬件开发 1万+

手把手教你从入门到精通C# 操作MySql数据库

本文是《C#操作MySql数据库从入门到精通》专栏的导读，帮助大家知道学习本专栏能够获取什么！

qq_34059233的博客 1936

[人工智能-深度学习-49]：循环神经网络 - RNN与NLP的关系以及RNN在人工神经网络中的位置

作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_优快云博客 本文网址： 目录 前言： 第1章 NLP自然语言处理概述 1.1 什么是NLP 1.2 自然语言处理的主要功能 1.3 自然语言发展阶段 1.3自然语言处理的基础框架 第2章 NLP的处理流程 2.1NLP的一般处理流程 2.2结构化机器学习模型 2.3 学习模型 第3章 NLP的语言模型与RNN 3.1 什么是语言模型 3.2NLP语言模型在NLP中的位置 3.3 RNN/L...

文火冰糖（王文兵）的博客 1万+

2026.2.23：AgentScope框架实战＜一＞：安装并使用agentscope

本文介绍了AgentScope框架的安装与使用实践。通过PyPI安装agentscope[full]后，演示了如何创建ReActAgent代理：1)配置DashScope聊天模型；2)注册自定义工具函数（查询位置和天气）；3)初始化代理并处理用户请求。示例展示了代理如何响应复合查询（如同时获取北京位置和天气信息），输出结果显示代理成功执行了工具调用并返回结构化响应。该框架支持Python 3.13环境，提供内存管理、工具集成等功能，适用于构建智能代理系统。

拥抱具身智能，昇腾Ascend C 512

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox（带书签），MATLAB统计学习工具

【NLP】循环神经网络RNN

RNN(Recurrent Neural Network)，中文称作循环神经网络，一般以序列数据为输入，通过网络内部的结构设计有效捕捉序列之间的关系特征，一般也是以序列形式进行输出RNN的循环机制使模型隐层上一时间步产生的结果，能够作为当下时间步输入的一部分（当下时间步的输入除了正常的输入外还包括上一步的隐层输出）对当下时间步的输出产生影响。

GG_Bruse的博客 1579

android 蓝牙通讯demo

android 下蓝牙通讯demo，实现了发现蓝牙，使能蓝牙，通过蓝牙发送消息。

【NLP】循环神经网络--RNN学习.day3

循环神经网络（Recurrent Neural Network, RNN）是一种用于处理序列数据的深度学习模型。与传统的静态神经网络相比，RNN 可以有效处理输入数据的时间序列特性。这使得 RNN 在处理自然语言处理（NLP）、时间序列预测、音频处理等任务时非常有效。以下是对 RNN 的详细解释。

alb3117149013的博客 1406

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

SAP B1中文培訓教材_SDK

公司内部培训资料，对开发工具 ，DIAPI， UIAPI，Add-ON有详细解说

推荐NLP基础 RNN循环神经网络

目的：让计算机处理或“理解”自然语言，以执行语言翻译和问题回答等任务；最终来讲就是构建机器语言和人类语言之间的沟通桥梁，实现人机交流为最终目的。关键词提取、概要抽取、事件提取命名实体识别(提取价格、日期、姓名、公司、地点等) 关系抽取分类：文本分类、情感分析、意图识别等机器翻译语音文本转换、图像文本转换问答系统NLU(Natural Language Understanding)自然语言理解含义：让计算机理解自然语言文本的意义；

qq_44089890的博客 1012

【NLP】 深度学习NLP开篇-循环神经网络(RNN)

从这篇文章开始，有三AI-NLP专栏就要进入深度学习了。本文会介绍自然语言处理早期标志性的特征提取工具-循环神经网络(RNN)。首先，会介绍RNN提出的由来；然后，详细介...

hacker_long的专栏 663
上一篇： [自然语言处理]概述
点赞 11
评论 0
书签 书签 1
Letmooning
Letmooning
博客等级 码龄2年 503粉丝 24原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值