精华内容
下载资源
问答
  • 多层双向LSTM with Attention对多层双向LSTM模型做了一些改进,不再单纯地只利用最后时刻的隐藏状态(两个方向最后时刻隐藏状态拼接)进行分类,而是考虑每个时间步的隐藏状态,对每个时间步的隐藏状...

    项目Github地址

    本篇博客主要介绍基于多层双向LSTM with Attention的文本分类算法的原理及实现细节。

    目录

    1. 分类原理

    2. 实现细节


    1. 分类原理

    多层双向LSTM with Attention对多层双向LSTM模型做了一些改进,不再单纯地只利用最后时刻的隐藏状态(两个方向最后时刻隐藏状态拼接)进行分类,而是考虑每个时间步的隐藏状态,对每个时间步的隐藏状态(两个方向拼接)进行加权求和,然后对加权求和结果进行分类。其分类流程如上图所示。

    Attention机制的原理:

    其中,W_w,b_w,u_w都是需要自己设置的权重参数(随模型训练),u_w可以认为是Attention机制中的Query,u_t可以认为是Attention机制中的Key,h_t 是第 t个时间步的隐藏状态(两个方向拼接),同时也是Attention机制中的Value,\alpha_t为每个时间步隐藏状态对应的权重,s是加权求和后得到的特征向量,用于最后接全连接层进行分类。

    对于Attention机制不了解的同学,可以查看我的另一篇博客Attention机制总结。 

    2. 实现细节

    class MulBiLSTM_Atten(BasicModule):#继承自BasicModule 其中封装了保存加载模型的接口,BasicModule继承自nn.Module
    
        def __init__(self,vocab_size,opt):#opt是config类的实例 里面包括所有模型超参数的配置
    
            super(MulBiLSTM_Atten, self).__init__()
            # 嵌入层
            self.embedding = nn.Embedding(vocab_size, opt.embed_size)#词嵌入矩阵 每一行代表词典中一个词对应的词向量;
            # 词嵌入矩阵可以随机初始化连同分类任务一起训练,也可以用预训练词向量初始化(冻结或微调)
    
            #多层双向LSTM 默认seq_len作为第一维 也可以通过batch_first=True 设置batch_size 为第一维
            self.lstm = nn.LSTM(opt.embed_size,opt.recurrent_hidden_size, opt.num_layers,
                                bidirectional=True, batch_first=True, dropout=opt.drop_prop)
    
            self.tanh1 = nn.Tanh()
            self.u = nn.Parameter(torch.Tensor(opt.recurrent_hidden_size * 2, opt.recurrent_hidden_size * 2))
            #定义一个参数(变量) 作为Attention的Query
            self.w = nn.Parameter(torch.Tensor(opt.recurrent_hidden_size*2))
            
            #均匀分布 初始化
            nn.init.uniform_(self.w, -0.1, 0.1)
            nn.init.uniform_(self.u, -0.1, 0.1)
            
            #正态分布 初始化
            #nn.init.normal_(self.w, mean=0, std=0.01)
            self.tanh2 = nn.Tanh()
            #最后的全连接层
            self.content_fc = nn.Sequential(
                nn.Linear(opt.recurrent_hidden_size*2, opt.linear_hidden_size),
                nn.BatchNorm1d(opt.linear_hidden_size),
                nn.ReLU(inplace=True),
                nn.Dropout(opt.drop_prop),
                # 可以再加一个隐层
                # nn.Linear(opt.linear_hidden_size,opt.linear_hidden_size),
                # nn.BatchNorm1d(opt.linear_hidden_size),
                # nn.ReLU(inplace=True),
                # 输出层
                nn.Linear(opt.linear_hidden_size, opt.classes)
            )
    
        def forward(self, inputs):
            #由于batch_first = True 所有inputs不用转换维度
            embeddings = self.embedding(inputs)  # (batch_size, seq_len, embed_size)
    
            outputs,_ = self.lstm(embeddings)   #(batch_size,seq_len,recurrent_hidden_size*2)
    
            #M = self.tanh1(outputs) #(batch_size,seq_len,recurrent_hidden_size*2)
            M = torch.tanh(torch.matmul(outputs, self.u)) #也可以先做一个线性变换 再通过激活函数  作为Key
    
            #M (batch_size,seq_len,recurrent_hidden_size*2) self.w (recurrent_hidden_size*2,)
            #torch.matmul(M, self.w) (batch_size,seq_len) w作为Query与各个隐藏状态(Key) 做内积
            #再对第一维seq_len做softmax 转换为概率分布 (batch_size,seq_len)  得到权重
            alpha = F.softmax(torch.matmul(M, self.w), dim=1).unsqueeze(-1)  # (batch_size,seq_len,1)
    
            #对各个隐藏状态和权重 对应相乘
            out = alpha * outputs #(batch_size,seq_len,recurrent_hidden_size*2)
    
            #对乘积求和 out为加权求和得到的特征向量
            out = torch.sum(out,dim=1) #(batch_size,recurrent_hidden_size*2)
    
            #out = F.relu(out)
    
            out = self.content_fc(out)  #(batch_size,classes)
    
            return out
    

     

    展开全文
  • ner-lstm, 基于多层双向LSTM的命名实体识别 这里知识库包含实现以下Arxiv预编译中所述方法的代码: https://arxiv.org/abs/1610.09756,在 ICON-16 会议( http://aclweb.org/anthology/W/W16/W16-63.pd
  • 文本分类(一) | (6) 多层双向LSTM

    千次阅读 2019-12-21 22:16:48
    本篇博客主要介绍基于多层双向LSTM的文本分类算法的原理及实现细节。 目录 1. 分类原理 2. 实现细节 1. 分类原理 对于输入文本序列,在LSTM的每个时间步输入序列中一个单词的嵌入表示,计算当前时间步的隐藏...

    项目Github地址

    本篇博客主要介绍基于多层双向LSTM的文本分类算法的原理及实现细节。

    目录

    1. 分类原理

    2. 实现细节


    1. 分类原理

     对于输入文本序列,在LSTM的每个时间步输入序列中一个单词的嵌入表示,计算当前时间步的隐藏状态,用于当前时间步的输出以及传递给下一个时间步和下一 个单词的词向量一起作为LSTM单元输入,然后再计算下一个时间步的LSTM隐藏状态,以此重复...直到处理完输入文本序列中的每一个单词,如果输入文本序列的长度为n,那么就要经历n个时间步。

    一般取前向和反向LSTM在最后一个时间步的隐藏状态,进行拼接,再接一个全连接层进行分类。由于LSTM训练比较困难,层数一般不超过两层。

    2. 实现细节

    class MulBiLSTM(BasicModule):#继承自BasicModule 其中封装了保存加载模型的接口,BasicModule继承自nn.Module
        def __init__(self, vocab_size,opt):#opt是config类的实例 里面包括所有模型超参数的配置
            super(MulBiLSTM, self).__init__()
    
            #嵌入层
            self.embedding = nn.Embedding(vocab_size, opt.embed_size)#词嵌入矩阵 每一行代表词典中一个词对应的词向量;
            # 词嵌入矩阵可以随机初始化连同分类任务一起训练,也可以用预训练词向量初始化(冻结或微调)
    
            # bidirectional设为True即得到双向循环神经网络
            self.encoder = nn.LSTM(input_size=opt.embed_size,
                                   hidden_size=opt.recurrent_hidden_size,
                                   num_layers=opt.num_layers,
                                   bidirectional=True,
                                   dropout=opt.drop_prop
                                   )
            self.fc = nn.Linear(4 * opt.recurrent_hidden_size, opt.classes)  # 初始时间步和最终时间步的隐藏状态作为全连接层输入
    
        def forward(self, inputs):
            # inputs的形状是(批量大小, 词数),因为上述定义的LSTM没有设置参数batch_first=True(默认False),所以需要将序列长度(seq_len)作为第一维,所以将输入转置后再提取词特征
            embeddings = self.embedding(inputs.permute(1,0)) # (seq_len, batch_size,embed_size)
    
            # rnn.LSTM只传入输入embeddings(第一层的输入),因此只返回最后一层的隐藏层在各时间步的隐藏状态。
            # outputs形状是(seq_len, batch_size, 2 * recurrent_hidden_size)
            outputs, _ = self.encoder(embeddings)  # output, (h, c)
            # 连结初始时间步和最终时间步的隐藏状态作为全连接层输入。它的形状为
            # (batch_size, 4 * recurrent_hidden_size)。
            encoding = torch.cat((outputs[0], outputs[-1]), -1)
            outs = self.fc(encoding)
            #(batch_size,classes)
            return outs
    

     

     

     

    展开全文
  • # 输入特征维度为10 输出特征维度为20 2层 双向 LSTM rnn = nn.LSTM(10, 20, 2, bidirectional=True) 初始化隐藏状态 # h0[0]:第一层正向初始时间步隐藏状态(时间步1) # h0[1]:第一层反向初始时间步隐藏状态...

    导包

    import torch.nn as nn
    import torch

    输入数据

    # 时间步为5 批量大小为3 特征维度为10
    input = torch.randn(5, 3, 10)

    创建LSTM

    # 输入特征维度为10 输出特征维度为20 2层 双向 LSTM
    rnn = nn.LSTM(10, 20, 2, bidirectional=True)

    初始化隐藏状态

    # h0[0]:第一层正向初始时间步隐藏状态(时间步1)
    # h0[1]:第一层反向初始时间步隐藏状态(时间步5)
    # h0[2]:第二层正向初始时间步隐藏状态(时间步1)
    # h0[3]:第二层反向初始时间步隐藏状态(时间步5)
    h0 = torch.randn(4, 3, 20)

    初始化细胞状态

    c0 = torch.randn(4, 3, 20)

    执行

    output, (hn, cn) = rnn(input, (h0, c0))

     output维度分析

    # output[0]时间步1输出   output[0][:, :20] 时间1步正向隐藏状态   output[0][:, 20:] 时间1步反向隐藏状态
    # output[1]时间步2输出
    # output[2]时间步3输出
    # output[3]时间步4输出
    # output[4]时间步5输出 output[4][:, :20] 时间5步正向隐藏状态   output[4][:, 20:] 时间5步反向隐藏状态
    output.shape
    # torch.Size([5, 3, 40])

    hn维度分析

    # hn[0]:第一层正向最后时间步隐藏状态(时间步5)
    # hn[1]:第一层反向最后时间步隐藏状态(时间步1)
    # hn[2]:第二层正向最后时间步隐藏状态(时间步5)
    # hn[3]:第二层反向最后时间步隐藏状态(时间步1)
    hn.shape
    # torch.Size([4, 3, 20])
    output[:, :, :20] == hn[2] # 输出第5时间步的正向隐藏状态 == 第二层正向最后时间步(5)隐藏状态
    tensor([[[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True],
             [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True],
             [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True]]])
    output[:, :, 20:] == hn[3] # 输出第1时间步的反向隐藏状态 == 第二层反向最后时间步(1)隐藏状态
    tensor([[[ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True],
             [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True],
             [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]]]) 
    output[4][:, :20] == hn
    tensor([[[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True],
             [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True],
             [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]]])
    output[0][:,20:] == hn
    tensor([[[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True],
             [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True],
             [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,
               True,  True,  True,  True,  True,  True,  True,  True,  True,  True]]])
    output[4][:,20:] == h0 # 输出第5时间步的反向隐藏状态 != 第二层反向初始时间步(1)隐藏状态 
    # output[4][:,20:] != h0[3]
    tensor([[[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]]])
    output[0][:,:20] == h0 # 输出第1时间步的正向隐藏状态 != 第二层正向初始时间步(1)隐藏状态 
    # output[0][:,:20] != h0[2]
    tensor([[[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]],
    
            [[False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False],
             [False, False, False, False, False, False, False, False, False, False,
              False, False, False, False, False, False, False, False, False, False]]])

    各层LSTM输入-隐藏权重维度分析

    # 第一层ih正向权重
    rnn.weight_ih_l0.shape
    torch.Size([80, 10])
    # 第二维10为input的特征维度
    # weight_ih_l0[:20]为W_ii权重矩阵[20, 10]
    # weight_ih_l0[20:40]为W_if权重矩阵[20, 10]
    # weight_ih_l0[40:60]为W_ig权重矩阵[20, 10]
    # weight_ih_l0[60:]为W_io权重矩阵[20, 10]
    
    # 第一层ih反向权重
    rnn.weight_ih_l0_reverse.shape
    torch.Size([80, 10])
    
    # 第二层ih正向权重
    rnn.weight_ih_l1.shape
    torch.Size([80, 40])
    # 为何shape (4*hidden_size, input_size) for k = 0. Otherwise, the shape is (4*hidden_size, num_directions * hidden_size)?
    # 因为如果为双向的话,第一层输出的隐藏状态维度不再是hidden_size,而是num_directions * hidden_size,包含正向和反向隐藏状态,为两者的拼接
    # 而第二层的输入为第一层输出的隐藏状态
    # 所以weight_ih_l1的第二维也是num_directions * hidden_size,其中num_directions并不是因为包含正向weight_ih_l1和反向weight_ih_l1
    # 因为反向weight_ih_l1由weight_ih_l1_reverse定义
    
    # 第二层ih反向权重
    rnn.weight_ih_l1_reverse.shape
    torch.Size([80, 40])

    各层LSTM隐藏-隐藏权重维度分析

    # 第一层hh正向权重
    rnn.weight_hh_l0.shape
    # torch.Size([80, 20])
    
    # 第一层hh反向权重
    rnn.weight_hh_l0_reverse.shape
    # torch.Size([80, 20])
    
    # 第二层hh正向权重
    rnn.weight_hh_l1.shape
    # torch.Size([80, 20])
    
    # 第二层hh反向权重
    rnn.weight_hh_l1_reverse.shape
    # torch.Size([80, 20])
    
    
    

    各层输入-隐藏偏置分析

    # 第一层ih正向偏置
    rnn.bias_ih_l0.shape
    torch.Size([80])
    
    # 第一层ih反向偏置
    rnn.bias_ih_l0_reverse.shape
    torch.Size([80])
    
    # 第二层ih正向偏置
    rnn.bias_ih_l1.shape
    torch.Size([80])
    
    # 第二层ih反向偏置
    rnn.bias_ih_l1_reverse.shape
    torch.Size([80])

    各层隐藏-隐藏偏置分析

    # 第一层hh正向偏置
    rnn.bias_hh_l0.shape
    torch.Size([80])
    
    # 第一层hh反向偏置
    rnn.bias_hh_l0_reverse.shape
    torch.Size([80])
    
    # 第二层hh正向偏置
    rnn.bias_hh_l1.shape
    torch.Size([80])
    
    # 第二层hh反向偏置
    rnn.bias_hh_l1_reverse.shape
    torch.Size([80])

    展开全文
  • LSTM.py培训代码”,该代码包含简单的LSTM,多层LSTM和多层双向LSTM。 请引用以下论文 Ullah, A., Ahmad, J., Muhammad, K., Sajjad, M., & Baik, S. W. (2018). Action Recognition in Video Sequences using Deep ...
  • LSTM: nn.LSTM(input_size, hidden_size, num_layers=1, nonlinearity=tanh, bias=True, batch_first=False, dropout=0, bidirectional=False)   input_size:表示输入 xt 的特征维度 ...

    LSTM原理请看这:点击进入

    LSTM:

    在这里插入图片描述

    nn.LSTM(input_size, 
    		hidden_size, 
    		num_layers=1, 
    		nonlinearity=tanh, 
    		bias=True, 
    		batch_first=False, 
    		dropout=0, 
    		bidirectional=False)
    


    input_size:表示输入 xt 的特征维度
    hidden_size:表示输出的特征维度
    num_layers:表示网络的层数
    nonlinearity:表示选用的非线性激活函数,默认是 ‘tanh’
    bias:表示是否使用偏置,默认使用
    batch_first:表示输入数据的形式,默认是 False,就是这样形式,(seq, batch, feature),也就是将序列长度放在第一位,batch 放在第二位
    dropout:表示是否在输出层应用 dropout
    bidirectional:表示是否使用双向的 LSTM,默认是 False。

    import  torch
    from    torch import nn
    from    torch.nn import functional as F 
    lstm = nn.LSTM(input_size=10, hidden_size=20, num_layers=2,bidirectional=False)
    # 可理解为一个字串长度为5, batch size为3, 字符维度为10的输入
    input_tensor  = torch.randn(5, 3, 10)
    # 两层LSTM的初始H参数,维度[layers, batch, hidden_len]
     #在lstm中c和h是不一样的,而RNN中是一样的
    h0,c0 = torch.randn(2,3, 20),torch.randn(2,3, 20)
    # output_tensor最后一层所有的h输出, hn表示两层最后一个时序的输出, cn表示两层最后一个时刻的状态的输出
    output_tensor, (hn,cn) =lstm(input_tensor, (h0,c0))
    print(output_tensor.shape, hn.shape,cn.shape)
    

    torch.Size([5, 3, 20]) torch.Size([2, 3, 20]) torch.Size([2, 3, 20])

    从上面可以看到输出的h,x,和输入的h,x维度一致。
    上面的参数中,num_layers=2相当于有两个rnn cell串联,即一个的输出h作为下一个的输入x。也可单独使用两个nn.LSTMCell实现

    而当我们设置成双向LSTM时,即bidirectional=True

    lstm = nn.LSTM(input_size=10, hidden_size=20, num_layers=2,bidirectional=True) 
    h0,c0 = torch.randn(4,3, 20),torch.randn(4,3, 20)
    

    torch.Size([5, 3, 40]) torch.Size([4, 3, 20]) torch.Size([4, 3, 20])

    一共5个时刻,可以看到最后一时刻的output维度是[3, 40],因为nn.LSTM模块他在最后会将正向和反向的结果进行拼接concat。而hn中的4是指正反向,还有因为num_layers是两层所以为4。

    output_tenso只输出最后一层!!!的所有时刻的状态输出(且正向和反向拼接好了。而hn和cn包含所有层,所有方向的最后时刻的输出。

    (🚀具体输出output、h和c的索引是指哪一层和哪一个方向,可以看这个链接解释:PyTorch 多层双向LSTM输入、输出、隐藏状态、权重、偏置的维度分析

    基于LSTM(多层LSTM、双向LSTM只需修改两个参数即可实现)的英文文本分类:

    数据集:英文电影评论(积极、消极)二分类

    分词表是我自己修改了nltk路径:
    C:\用户\AppData\Roaming\nltk_data\corpora\stopwords里的english文件。
      然后你把我的my_english文件放进里面就可以,或者你直接用它的english
      数据集链接和my_english分词表都在以下网盘链接:
    链接:https://pan.baidu.com/s/1vhh5FmU01KqyjRtxByyxcQ
    提取码:bx4k
    关于词嵌入是用了nn.embedding(),它的用法请看这:点击进入

    import torch
    import numpy as np
    import pandas as pd
    import torch.nn as nn
    import torch.optim as optim
    import torch.utils.data as Data
    import torch.nn.functional as F
    

    读入数据集,数据集为电影评论数据(英文,一个24500条数据),分为积极和消极两类:

    df = pd.read_csv('Dataset.csv')
    print('一共有{}条数据'.format(len(df)))
    df.info()
    

    分词去停用词,我的csv文件里已经处理完保存好了分词结果,可以不运行这一部分:

    from nltk.corpus import stopwords
    import nltk
    def separate_sentence(text):
        disease_List = nltk.word_tokenize(text)
        #去除停用词
        filtered = [w for w in disease_List if(w not in stopwords.words('my_english'))]
        #进行词性分析,去掉动词、助词等
        Rfiltered =nltk.pos_tag(filtered)
        #以列表的形式进行返回,列表元素以(词,词性)元组的形式存在
        filter_word = [i[0] for i in Rfiltered]
        return " ".join(filter_word)
    df['sep_review'] = df['review'].apply(lambda x:separate_sentence(x))
    

    根据需要筛选数据(这里我使用了1000条):

    #用xxx条玩玩
    use_df = df[:1000]
    use_df.head(10)
    sentences = list(use_df['sep_review'])
    labels = list(use_df['sentiment'])
    

    小于最大长度的补齐:

    max_seq_len = max(use_df['sep_review'].apply(lambda x: len(x.split())))
    PAD = ' <PAD>'  # 未知字,padding符号用来填充长短不一的句子(用啥符号都行,到时在nn.embedding的参数设为padding_idx=word_to_id['<PAD>'])即可
    
    #小于最大长度的补齐
    for i in range(len(sentences)):
        sen2list = sentences[i].split()
        sentence_len = len(sen2list)
        if sentence_len<max_seq_len:
            sentences[i] += PAD*(max_seq_len-sentence_len)  
    

    制作词表(后面用来给单词编号):

    num_classes = len(set(labels))  # num_classes=2
    word_list = " ".join(sentences).split()
    vocab = list(set(word_list))
    word2idx = {w: i for i, w in enumerate(vocab)}
    vocab_size = len(vocab)
    

    给单词编号(编完号后续还要在embeding层将其转成词向量):

    def make_data(sentences, labels):
        inputs = []
        for sen in sentences:
            inputs.append([word2idx[n] for n in sen.split()])
    
        targets = []
        for out in labels:
            targets.append(out) # To using Torch Softmax Loss function
        return inputs, targets
    
    input_batch, target_batch = make_data(sentences, labels)
    input_batch, target_batch = torch.LongTensor(input_batch), torch.LongTensor(target_batch)
    

    用Data.TensorDataset(torch.utils.data)对给定的tensor数据(样本和标签),将它们包装成dataset,
    然后用Data.DataLoader(torch.utils.data)数据加载器,组合数据集和采样器,并在数据集上提供单进程或多进程迭代器。它可以对我们上面所说的数据集dataset作进一步的设置(比如可以设置打乱,对数据裁剪,设置batch_size等操作,很方便):

    from sklearn.model_selection import train_test_split
    # 划分训练集,测试集
    x_train,x_test,y_train,y_test = train_test_split(input_batch,target_batch,test_size=0.2,random_state = 0)
    
    train_dataset = Data.TensorDataset(torch.tensor(x_train), torch.tensor(y_train))
    test_dataset = Data.TensorDataset(torch.tensor(x_test), torch.tensor(y_test))
    dataset = Data.TensorDataset(input_batch, target_batch)
    
    batch_size = 16
    train_loader = Data.DataLoader(
        dataset=train_dataset,      # 数据,封装进Data.TensorDataset()类的数据
        batch_size=batch_size,      # 每块的大小
        shuffle=True,               # 要不要打乱数据 (打乱比较好)
        num_workers=2,              # 多进程(multiprocess)来读数据
    )
    test_loader = Data.DataLoader(
        dataset=test_dataset,      # 数据,封装进Data.TensorDataset()类的数据
        batch_size=batch_size,      # 每块的大小
        shuffle=True,               # 要不要打乱数据 (打乱比较好)
        num_workers=2,              # 多进程(multiprocess)来读数据
    )
    

    搭建网络:

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(device,'能用')
    class LSTM(nn.Module):
        def __init__(self,vocab_size, embedding_dim, hidden_size, num_classes, num_layers,bidirectional):
            super(LSTM, self).__init__()
            self.vocab_size = vocab_size
            self.embedding_dim = embedding_dim
            self.hidden_size = hidden_size
            self.num_classes = num_classes
            self.num_layers = num_layers
            self.bidirectional = bidirectional
            
            self.embedding = nn.Embedding(self.vocab_size, embedding_dim, padding_idx=word2idx['<PAD>'])
            self.lstm = nn.LSTM(input_size=self.embedding_dim, hidden_size=self.hidden_size,batch_first=True,num_layers=self.num_layers,bidirectional=self.bidirectional)
            if self.bidirectional:
                self.fc = nn.Linear(hidden_size*2, num_classes)
            else:
                self.fc = nn.Linear(hidden_size, num_classes)
            
        def forward(self, x):
            batch_size, seq_len = x.shape
            #初始化一个h0,也即c0,在RNN中一个Cell输出的ht和Ct是相同的,而LSTM的一个cell输出的ht和Ct是不同的
            #维度[layers, batch, hidden_len]
            if self.bidirectional:
                h0 = torch.randn(self.num_layers*2, batch_size, self.hidden_size).to(device)
                c0 = torch.randn(self.num_layers*2, batch_size, self.hidden_size).to(device)
            else:
                h0 = torch.randn(self.num_layers, batch_size, self.hidden_size).to(device)
                c0 = torch.randn(self.num_layers, batch_size, self.hidden_size).to(device)
            x = self.embedding(x)
            out,(_,_)= self.lstm(x, (h0,c0))
            output = self.fc(out[:,-1,:]).squeeze(0) #因为有max_seq_len个时态,所以取最后一个时态即-1层
            return output
            
              
    

    实例化网络:
    要实现多层LSTM只需修改参数:num_layers。要实现双向LSTM只需修改参数:bidirectional=True。

    model = LSTM(vocab_size=vocab_size,embedding_dim=300,hidden_size=20,num_classes=2,num_layers=2,bidirectional=True).to(device)
    criterion = nn.CrossEntropyLoss().to(device)
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    

    模型训练过程:

    model.train()
    for epoch in range(1):
        for batch_x, batch_y in train_loader:
            batch_x, batch_y = batch_x.to(device), batch_y.to(device)
            pred = model(batch_x)
            loss = criterion(pred, batch_y)  #batch_y类标签就好,不用one-hot形式   
            
            if (epoch + 1) % 10 == 0:
                print('Epoch:', '%04d' % (epoch + 1), 'loss =', '{:.6f}'.format(loss))
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
    

    模型测试过程:这里只测试准确率

    test_acc_list = []
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            pred = output.max(1, keepdim=True)[1]                           # 找到概率最大的下标
            correct += pred.eq(target.view_as(pred)).sum().item()
    
    # test_loss /= len(test_loader.dataset)
    # test_loss_list.append(test_loss)
    test_acc_list.append(100. * correct / len(test_loader.dataset))
    print('Accuracy: {}/{} ({:.0f}%)\n'.format(correct, len(test_loader.dataset),100. * correct / len(test_loader.dataset)))
    
    展开全文
  • 1.首先关于tf.contrib.rnn.static_bidirectional_rnn建立双向lstm,代码如下:(总之大体意思就是,这个已经是级联好了的,所以说output【-1】就代表我们的最终输出,他的size是【time,batch_size,hidden_size*2】*2...
  • outputs, fw_state, bw_state = tf.contrib.rnn.static_bidirectional_rnn(mul_lstm_fw_cell, mul_lstm_bw_cell, x, dtype=tf.float32) print(len(outputs))##300,等于时间步的长度,一般取outputs[-1]也就是最后...
  • 本文采用双向LSTM网络对其进行预测。 我喜欢直接代码+ 结果展示 先代码可以跑通,才值得深入研究每个部分之间的关系;进而改造成自己可用的数据。 1 数据集 链接: https://pan.baidu.com/s/1jv7
  • 基于keras的双层LSTM网络和双向LSTM网络中,都会用到 LSTM层,主要参数如下: LSTM(units,input_shape,return_sequences=False) units:隐藏层神经元个数 input_shape=(time_step, input_feature):time_step是...
  • LSTM 的例子 单向LSTM 双向LSTM 多层LSTM
  • 利用双向LSTM进行数据的预测

    千次阅读 2018-11-30 12:10:34
    双向LSTM 我们为什么要用双向LSTM? 双向卷积神经网络的隐藏层要保存两个值, A 参与正向计算, A’ 参与反向计算。最终的输出值 y 取决于 A 和 A’: 即正向计算时,隐藏层的 s_t 与 s_t-1 有关;反向计算时,隐藏...
  • 本文探讨了如何使用深度双向LSTM网络来解决问答社区的问题。
  • 堆叠多层bi-lstm的方法

    千次阅读 2019-01-07 10:13:52
    自己在搭建多层双向lstm网络的时候,看了很多的资料,一开始的时候搭建都是不成功的,后来看了官方的资料还有一些博客,使用了2种方法搭建成功了! 方法1: n_hidden_units=50 # 隐藏层神经元数目 num_layers=3 #...
  • 1.双向递归神经网络简介双向递归神经网络(Bidirectional Recurrent Neural Networks, Bi-RNN),是由Schuster和Paliwal于1997年首次提出的,和LSTM是在同一年被提出的。Bi-RNN的主要目标是增加RNN可利用的信息。RNN...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,864
精华内容 1,545
关键字:

多层双向lstm