[自然语言处理]RNN

已于 2024-10-11 11:51:33 修改
阅读量781 收藏 1
点赞数 11
文章标签： 自然语言处理 rnn 深度学习
于 2024-10-09 22:20:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Letmooning/article/details/142787722
版权

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

Letmooning
关注
【自然语言处理】RNN模型(循环神经网络)
m0_69355534的博客
03-22 1444
当前时间步的输入不仅有当前的输入还有上一时间步隐藏层的输出，它们进入RNN结构会进行融合拼接，形成新的张量x(t),h(t-1)，之后新的张量通过一个全连接层(线性层），该层使用anh激活函数，最终得到当前时间步的输出h(t)，它将作为下一时间步的输入和x(t+1)一起进入结构体，以此循环。其结构图如下所示，其特点是输入一个序列，而输出一个值而不是序列，要得到模型只需要在最后一个隐藏层进行线性变换就可以了，为了更好的结果，还要使用sigmoid和softmax进行处理。该模型可应用于图片转文字等问题上。
递归神经网络（RNN）基础与实践：自然语言处理的核心.md
08-20
递归神经网络（RNN）的基础原理及其在自然语言处理（NLP）中的实际应用。首先，文章讲解了RNN的循环结构和前向传播、反向传播的机制，强调了RNN在处理序列数据方面的优势。接着，讨论了RNN的两种关键变种——长短期...
RNN及自然语言处理 相关
whaosoft143ai的博客
10-22 693
同时，智能的机器也成就了人类，给人类带来了前所未有的应用和价值。随着技术的不断发展，人工智能的相关应用已经融入人类生活的方方面面，如今“AI+”也已经成为未来各大行业发展的主流方向，可见人类与人工智能的和谐共处将会成为未来社会的新常态。实现人机无障碍交互一直是科研工作者们追求的目标，在早期的传统人机交互中，基本都是基于硬件比如键盘和鼠标来进行的，相比于人类的语音交互显得不是很自然，而且效率较低，所以将人与人之间的语言推广到人与机器之间的智能语音交互一直以来都是一个备受关注同时也极具挑战性的研究课题。
自然语言处理：RNN
larrino的博客
08-04 1289
关键词：RNN；吴恩达课堂笔记；自然语言处理；联合概率-后验概率；马尔可夫性； - - - - - - - - - - 笔记：桃子???? 日期：2021.8 - - - - - - - - - - 目录 概念 联合概率 马尔可夫性 语言模型（language model） 为什么不能用CBOW、word2vec？ 传统神经网络模型为什么不适应？ RNN结构 RNN结构及其应用 公式 矩阵形状 Forward RNN语言模型（例子：创建莎士比亚文风） RN
自然语言处理之RNN
qq_40216188的博客
08-28 1103
自然语言处理之RNN一、循环神经网络（ Recurrent Neural Network, RNN）1.1 全连接神经网络弊端，引出RNN1.2 循环神经网络RNN1.2 循环神经网络RNN训练方法1.3 循环神经网络RNN的多种类型任务1.3.1 one-to-one1.3.2 one-to-n1.3.3 n-to-n1.3.4 n-to-one1.3. 5 n-to-m1.4 BiRNN：双向RNN1.5 DRNN：深层RNN 一、循环神经网络（ Recurrent Neural Network, RN
自然语言处理—RNN循环神经网络
qq_45031079的博客
05-07 1538
1. RNN基本介绍 (参见吴恩达深度学习—RNN篇https://www.bilibili.com/video/BV16r4y1Y7jv?p=152&spm_id_from=pageDriver) 1.1 基本介绍 RNN神经网络可以用来处理时间序列类型的数据，一段文字也可以看成一个时间序列。比如， The cat ate many food that was delicious was full ...
RNN在自然语言处理中的应用案例 - 深度学习教程
shandianfk_com的博客
08-19 281
本文介绍了RNN（循环神经网络）在自然语言处理（NLP）中的多个应用案例，包括语言模型、机器翻译、情感分析、语音识别、文本生成和自动摘要。通过对这些案例的深入解读，展现了RNN在处理序列数据时的强大功能，帮助读者更好地理解这项技术的潜力和实用性。
深度学习 | 自然语言处理之RNN/LSTM
RichardsZ_的博客
02-13 1505
循环神经网络RNN 提示：本文默认读者具备基本的深度学习知识，如加权激活，链式求导，权重矩阵等信息。 文章目录循环神经网络RNN前言一、循环神经网络结构 前言     RNN非常适合"具备序列特性的特征"，因此能够挖掘特征中的时序信息和语义信息。利用了RNN的这种能力，使深度学习模型在解决语音识别、语言模型、机器翻译以及时序分析等NLP领域的问题时有所突破。 序列特性，即符合时间顺序，逻辑顺序，或者其他顺序就叫序列特性，举几个例子： 拿人类的某句话来说，也就是
深度学习之自然语言处理（RNN）
weixin_55922470的博客
05-07 1206
前馈型神网络：指网络的传播方向是单向的，先将输入信号传给下一层（隐藏层），接收到信号的层也同样传给下一层，然后再传给下一层……像这样，信号仅在一个方向上传播。存在问题：不能很好地处理时间序列数据（以下简称为“时序数据”）即单纯的前馈网络无法充分学习时序数据的性质。所以需要引入RNN（循环神经网络）1 概率和语言模型。
《深度学习进阶 自然语言处理》第五章：RNN通俗介绍
sherwinzhang的博客
11-17 1129
RNN通俗的介绍
自然语言处理基础知识入门(三) RNN，LSTM，GRU模型详解
WANGYANG的博客
04-14 1803
在上一章节中，深入探讨了Word2vec模型的两种训练策略以及创新的优化方法，从而得到了优质的词嵌入表示。不仅如此，Word2vec作为一种语言模型，也具备根据上下文预测中心词的能力，这是其训练的核心任务，也是模型所能实现的功能。那么，既然已有语言模型，为何还需要引入RNN呢？又或者，RNN具有何种独特性呢？而LSTM和GRU为什么会被视为RNN的变体？本章节将针对这些问题，用深入浅出的语言解读这些模型背后的核心逻辑，以便让读者对整个知识体系存在一个全面的理解。
word-language-model.zip_RNN_bite4ze_自然语言处理
09-21
在"word-language-model.zip_RNN_bite4ze_自然语言处理"这个压缩包中，我们可以看到两个关键的Python源代码文件——main.py和model.py，这通常意味着它包含了一个使用循环神经网络（RNN）实现的词语言模型。...
python自然语言处理实战pdf_dode.zip
01-05
《Python自然语言处理实战》是一本深入探讨Python在NLP（自然语言处理）领域的实践应用的书籍。PDF版本为读者提供了方便的电子阅读体验，同时附带的代码资源则可以帮助读者更好地理解和应用书中的理论知识。这个...
【人工智能】10分钟解读-深入浅出大语言模型（LLM）——从ChatGPT到未来AI的演进
万物皆有灵
11-08 828
2022年底，OpenAI推出的聊天机器人ChatGPT一经上线，便迅速引发了全球范围内的热议与追捧。仅在上线五天内，注册用户便突破了百万大关。ChatGPT的成功不仅展示了大语言模型（LLM）的强大能力，也标志着人类正式迈入了一个全新的人工智能时代。本文将以ChatGPT为切入点，回顾GPT模型的发展历程，深入解析大语言模型（LLM）的构成及其工作原理。同时，我们将涵盖自然语言处理（NLP）、深度学习、Transformer等相关知识，帮助读者全面了解LLM及其在AI领域中的重要地位。
Bert框架详解（上）
qq_61600833的博客
11-06 1093
语义编码：例如当我们翻译法语中的“abandon”时，我们大脑是先将abandon所表达的概念意识提取出来，这也就是一个编码的过程。然后提取出来的这个意识概念也就是我们的Feature Vector. 接下来我们的大脑就会基于这个意识概念，去我们大脑中的英语语言库中把与这个意识概念匹配的英文单词提取出来， 这也就是解码的过程。人在处理信息的时候，会将注意力放在需要关注的信息上，对于其他无关的外部信息进行过滤，这种处理方式被称为注意力机制。前面的模型，并没有考虑词的顺序，只是单纯考虑一段话有哪些词。
bert-base-uncased使用
m0_56065966的博客
11-09 404
轻松学习bert-base-uncased使用
一文讲清楚人工智能自然语言处理中的数据预处理(数据清洗)
最新发布
qq_22201881的博客
11-11 182
当然了，对于不同的食材我们可能会采用不同的清洗方式，也就是说，对于不同结构的数据样本我们选取的数据处理方法也可能会不同，比如说对于某些蔬菜我们需要用水清洗，然后切成小段，但是对于豆豉，酸菜之类的食材我想没有人会用水清洗它吧，因此不同形式的数据样本往往采取的是不同数据处理方法的组合。还有，我们对于面粉之类的食材一般没有人生啃吧，是需要对其进行醒面发酵之后才能被我们用作完美的食材，所以这个过程也就涉及食材的转化，也就是说，我们的样本数据也可能会利用一些方法进行适当的转化从而被我们更好地用来训练模型。
EMNLP 2024 BoF 活动报名：用 Embeddings、Reranker、小型语言模型打造更优搜索！
Jina AI 的博客
11-07 642
在 2023 年 EMNLP 大会上，Jina AI 举办了 一场关于向量技术前沿探索的 Bird of a Feather (BoF) 会议，超过 80 位参会者，包括 DeepMind、Meta 等机构的顶尖研究员以及行业专家们，一起讨论向量前沿技术的最新进展。<<< 闪电分享、圆桌讨论和午餐会>>>今年的 EMNLP 2024 在迈阿密举行，我们将延续在...
王树森自然语言处理视频：RNN模型与NLP应用详解
本压缩文件收录了由王树森主讲的自然语言处理系列视频，涵盖了RNN（Recurrent Neural Networks，循环神经网络）模型及其在自然语言处理（NLP）中的应用。视频内容详细介绍了RNN及其变体模型如LSTM（Long Short-Term ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值