[自然语言处理]RNN

Letmooning2024-10-16 20:36

1 传统RNN模型与LSTM

python 复制代码 
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()
bash 复制代码 
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

python 复制代码 
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()
相关推荐
yyfhq1 小时前
dcgan
深度学习·机器学习·生成对抗网络
这个男人是小帅1 小时前
【图神经网络】 AM-GCN论文精讲（全网最细致篇）
人工智能·pytorch·深度学习·神经网络·分类
YRr YRr3 小时前
深度学习：正则化（Regularization）详细解释
人工智能·深度学习
YRr YRr3 小时前
长短期记忆网络（LSTM）如何在连续的时间步骤中处理信息
人工智能·rnn·lstm
yyfhq3 小时前
rescorediff
python·深度学习·机器学习
会飞的Anthony4 小时前
基于Python的自然语言处理系列（42）：Token Classification（标注分类）
人工智能·自然语言处理
ai产品老杨7 小时前
深度学习模型量化原理
开发语言·人工智能·python·深度学习·安全·音视频
脆皮茄条7 小时前
车牌识别算法demo
深度学习·paddle
坠金8 小时前
神经网络的常用layer
人工智能·深度学习·神经网络
热门推荐
01Windows10安装PCL1.14.0及点云配准02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）03【经验分享】Ubuntu22.04安装微信(linux官方版)04ECharts 地图实战分析：实现一个完整的地图下钻功能05制冷毛细管的计算方法介绍06RAG 实践- Ollama+RagFlow 部署本地知识库07支付宝短视频平台创作分成激励项目08Coze扣子平台完整体验和实践（附国内和国际版对比）09苍穹外卖面试总结10优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间