[自然语言处理]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()
相关推荐
Rocky Ding*7 分钟前
一文读懂MiniCPM5-2B：端侧 Agent 的突破，不是“小模型打赢大模型”，而是训练系统开始开源
论文阅读·人工智能·深度学习·机器学习·aigc·ai-native·minicpm5-2b
葫三生1 小时前
《论三生原理》神话学构想与“神话历史”理论、《古史中的神话》思路异同？
大数据·人工智能·科技·深度学习·算法
陈年老古董2 小时前
PyTorch食物图像分类实战：从数据集制作到CNN模型训练全流程详解
pytorch·深度学习·学习·机器学习·分类·cnn
早睡早起身体好1233 小时前
用 XGrammar 约束大模型工具调用：解决参数为空的问题
android·人工智能·神经网络·机器学习·自然语言处理·vllm
2601_962301014 小时前
深入探索 TensorFlow 2.0：Python 中的强大深度学习框架
深度学习·分布式训练·keras·tensorflow2.0·eagerexecution
方方洛5 小时前
vllm教程-19-模型架构基础
人工智能·深度学习·llm
weixin_429630266 小时前
17.5 基于角加速度计与陀螺仪融合的深度学习辅助卡尔曼滤波低成本姿态估计
人工智能·深度学习
2601_962300817 小时前
用PyTorch Lightning简化空间分析：Python和机器学习的力量
python·深度学习·机器学习·空间分析·pytorchlightning
June bug7 小时前
【HCIA- AI（正课）】2.6.Transformer架构和Diffusion结构介绍
人工智能·深度学习·transformer
weixin_408266348 小时前
深度学习-nuscenes数据集关系
深度学习
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接03【一等奖版】2026 国赛 A题 药材的烘干问题04GitHub 镜像站点05历年考研数学一、数学二、数学三真题试卷及答案PDF06微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？08如何新建文件夹？ 电脑新建文件夹的4种方法09ZCode 周末送额度活动开启：3 亿 Token 免费领取10Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费