精华内容
下载资源
问答
  • BI-lstm什么与crf相结合

    千次阅读 2018-08-30 22:58:27
    双向lstm后接一个softmax层,输出各个label的概率。那为何还要加一个crf层呢? 我的理解是softmax层的输出是相互独立的,即虽然BiLSTM学习到了上下文的信息,但是输出相互之间并没有影响,它只是在每一步挑选一个...

    双向lstm后接一个softmax层,输出各个label的概率。那为何还要加一个crf层呢?
    我的理解是softmax层的输出是相互独立的,即虽然BiLSTM学习到了上下文的信息,但是输出相互之间并没有影响,它只是在每一步挑选一个最大概率值的label输出。这样就会导致如B-person后再接一个B-person的问题。而crf中有转移特征,即它会考虑输出label之间的顺序性,所以考虑用crf去做BiLSTM的输出层。
    转载
    https://blog.csdn.net/bobobe/article/details/80489303

    展开全文
  • 这是最近两个月来的一个小总结,实现的demo已经上传github,里面包含了CNN、LSTM、BiLSTM、GRU以及CNN与LSTM、BiLSTM结合还有多层多通道CNN、LSTM、BiLSTM等多个神经网络模型的的实现。这篇文章总结一下最近一段...

    基于pytorch的CNN、LSTM神经网络模型调参小结

    (Demo)

    • 这是最近两个月来的一个小总结,实现的demo已经上传github,里面包含了CNN、LSTM、BiLSTM、GRU以及CNN与LSTM、BiLSTM的结合还有多层多通道CNN、LSTM、BiLSTM等多个神经网络模型的的实现。这篇文章总结一下最近一段时间遇到的问题、处理方法和相关策略,以及经验(其实并没有什么经验)等,白菜一枚。

    • Demo Site:  https://github.com/bamtercelboo/cnn-lstm-bilstm-deepcnn-clstm-in-pytorch

    (一) Pytorch简述

    • Pytorch是一个较新的深度学习框架,是一个 Python 优先的深度学习框架,能够在强大的 GPU 加速基础上实现张量和动态神经网络。

    • 对于没有学习过pytorch的初学者,可以先看一下官网发行的60分钟入门pytorch,参考地址 :http://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html

    (二) CNN、LSTM

    (三)数据预处理

      1、我现在使用的语料是基本规范的数据(例如下),但是加载语料数据的过程中仍然存在着一些需要预处理的地方,像一些数据的大小写、数字的处理以及“\n \t”等一些字符,现在使用torchtext第三方库进行加载数据预处理。

    • You Should Pay Nine Bucks for This : Because you can hear about suffering Afghan refugees on the news and still be unaffected . ||| 2
      Dramas like this make it human . ||| 4

      2、torch建立词表、处理语料数据的大小写:

    • import torchtext.data as data
      # lower word
      text_field = data.Field(lower=True)

      3、处理语料数据数字等特殊字符:

    • 复制代码

       1 from torchtext import data
       2       def clean_str(string):
       3             string = re.sub(r"[^A-Za-z0-9(),!?\'\`]", " ", string)
       4             string = re.sub(r"\'s", " \'s", string)
       5             string = re.sub(r"\'ve", " \'ve", string)
       6             string = re.sub(r"n\'t", " n\'t", string)
       7             string = re.sub(r"\'re", " \'re", string)
       8             string = re.sub(r"\'d", " \'d", string)
       9             string = re.sub(r"\'ll", " \'ll", string)
      10             string = re.sub(r",", " , ", string)
      11             string = re.sub(r"!", " ! ", string)
      12             string = re.sub(r"\(", " \( ", string)
      13             string = re.sub(r"\)", " \) ", string)
      14             string = re.sub(r"\?", " \? ", string)
      15             string = re.sub(r"\s{2,}", " ", string)
      16             return string.strip()
      17 
      18         text_field.preprocessing = data.Pipeline(clean_str)

      复制代码

      4、需要注意的地方:

    • 加载数据集的时候可以使用random打乱数据

    • 1 if shuffle:
      2     random.shuffle(examples_train)
      3     random.shuffle(examples_dev)
      4     random.shuffle(examples_test)
    • torchtext建立训练集、开发集、测试集迭代器的时候,可以选择在每次迭代的时候是否去打乱数据

    • 复制代码

       1 class Iterator(object):
       2     """Defines an iterator that loads batches of data from a Dataset.
       3 
       4     Attributes:
       5         dataset: The Dataset object to load Examples from.
       6         batch_size: Batch size.
       7         sort_key: A key to use for sorting examples in order to batch together
       8             examples with similar lengths and minimize padding. The sort_key
       9             provided to the Iterator constructor overrides the sort_key
      10             attribute of the Dataset, or defers to it if None.
      11         train: Whether the iterator represents a train set.
      12         repeat: Whether to repeat the iterator for multiple epochs.
      13         shuffle: Whether to shuffle examples between epochs.
      14         sort: Whether to sort examples according to self.sort_key.
      15             Note that repeat, shuffle, and sort default to train, train, and
      16             (not train).
      17         device: Device to create batches on. Use -1 for CPU and None for the
      18             currently active GPU device.
      19     """

      复制代码

     

    (四)Word Embedding

      1、word embedding简单来说就是语料中每一个单词对应的其相应的词向量,目前训练词向量的方式最使用的应该是word2vec(参考 http://www.cnblogs.com/bamtercelboo/p/7181899.html

      2、上文中已经通过torchtext建立了相关的词汇表,加载词向量有两种方式,一个是加载外部根据语料训练好的预训练词向量,另一个方式是随机初始化词向量,两种方式相互比较的话当时是使用预训练好的词向量效果会好很多,但是自己训练的词向量并不见得会有很好的效果,因为语料数据可能不足,像已经训练好的词向量,像Google News那个词向量,是业界公认的词向量,但是由于数量巨大,如果硬件设施(GPU)不行的话,还是不要去尝试这个了。

      3、提供几个下载预训练词向量的地址

      4、加载外部词向量方式

    • 加载词汇表中在词向量里面能够找到的词向量

    • 复制代码

       1 # load word embedding
       2 def load_my_vecs(path, vocab, freqs):
       3     word_vecs = {}
       4     with open(path, encoding="utf-8") as f:
       5         count  = 0
       6         lines = f.readlines()[1:]
       7         for line in lines:
       8             values = line.split(" ")
       9             word = values[0]
      10             # word = word.lower()
      11             count += 1
      12             if word in vocab:  # whether to judge if in vocab
      13                 vector = []
      14                 for count, val in enumerate(values):
      15                     if count == 0:
      16                         continue
      17                     vector.append(float(val))
      18                 word_vecs[word] = vector
      19     return word_vecs

      复制代码

    • 处理词汇表中在词向量里面找不到的word,俗称OOV(out of vocabulary),OOV越多,可能对加过的影响也就越大,所以对OOV词的处理就显得尤为关键,现在有几种策略可以参考:

    • 对已经找到的词向量平均化

    • 复制代码

       1 # solve unknown by avg word embedding
       2 def add_unknown_words_by_avg(word_vecs, vocab, k=100):
       3     # solve unknown words inplaced by zero list
       4     word_vecs_numpy = []
       5     for word in vocab:
       6         if word in word_vecs:
       7             word_vecs_numpy.append(word_vecs[word])
       8     print(len(word_vecs_numpy))
       9     col = []
      10     for i in range(k):
      11         sum = 0.0
      12         # for j in range(int(len(word_vecs_numpy) / 4)):
      13         for j in range(int(len(word_vecs_numpy))):
      14             sum += word_vecs_numpy[j][i]
      15             sum = round(sum, 6)
      16         col.append(sum)
      17     zero = []
      18     for m in range(k):
      19         # avg = col[m] / (len(col) * 5)
      20         avg = col[m] / (len(word_vecs_numpy))
      21         avg = round(avg, 6)
      22         zero.append(float(avg))
      23 
      24     list_word2vec = []
      25     oov = 0
      26     iov = 0
      27     for word in vocab:
      28         if word not in word_vecs:
      29             # word_vecs[word] = np.random.uniform(-0.25, 0.25, k).tolist()
      30             # word_vecs[word] = [0.0] * k
      31             oov += 1
      32             word_vecs[word] = zero
      33             list_word2vec.append(word_vecs[word])
      34         else:
      35             iov += 1
      36             list_word2vec.append(word_vecs[word])
      37     print("oov count", oov)
      38     print("iov count", iov)
      39     return list_word2vec

      复制代码

    • 随机初始化或者全部取zero,随机初始化或者是取zero,可以是所有的OOV都使用一个随机值,也可以每一个OOV word都是随机的,具体效果看自己效果

    • 随机初始化的值看过几篇论文,有的随机初始化是在(-0.25,0.25)或者是(-0.1,0.1)之间,具体的效果可以自己去测试一下,不同的数据集,不同的外部词向量估计效果不一样,我测试的结果是0.25要好于0.1

    • 复制代码

       1 # solve unknown word by uniform(-0.25,0.25)
       2 def add_unknown_words_by_uniform(word_vecs, vocab, k=100):
       3     list_word2vec = []
       4     oov = 0
       5     iov = 0
       6     # uniform = np.random.uniform(-0.25, 0.25, k).round(6).tolist()
       7     for word in vocab:
       8         if word not in word_vecs:
       9             oov += 1
      10             word_vecs[word] = np.random.uniform(-0.25, 0.25, k).round(6).tolist()
      11             # word_vecs[word] = np.random.uniform(-0.1, 0.1, k).round(6).tolist()
      12             # word_vecs[word] = uniform
      13             list_word2vec.append(word_vecs[word])
      14         else:
      15             iov += 1
      16             list_word2vec.append(word_vecs[word])
      17     print("oov count", oov)
      18     print("iov count", iov)
      19     return list_word2vec

      复制代码

    • 特别需要注意处理后的OOV词向量是否在一定的范围之内,这个一定要在处理之后手动或者是demo查看一下,想处理出来的词向量大于15,30的这种,可能就是你自己处理方式的问题,也可以是说是你自己demo可能存在bug,对结果的影响很大。

      5、model中使用外部词向量

    • 1         if args.word_Embedding:
      2             pretrained_weight = np.array(args.pretrained_weight)
      3             self.embed.weight.data.copy_(torch.from_numpy(pretrained_weight))

       

    (五)参数初始化

    • 对于pytorch中的nn.Conv2d()卷积函数来说,有weight and bias,对weight初始化是很有必要的,不对其初始化可能减慢收敛速度,影响最终效果等

    • 对weight初始化,一般可以使用torch.nn.init.uniform()、torch.nn.init.normal()、torch.nn.init.xavier_uniform(),具体使用参考 http://pytorch.org/docs/master/nn.html#torch-nn-init

    • 1 init.xavier_normal(conv.weight.data, gain=np.sqrt(args.init_weight_value))
      2 init.uniform(conv.bias, 0, 0)
    • 对于pytorch中的nn.LSTM(),有all_weights属性,其中包括weight and bias,是一个多维矩阵

    • 复制代码

      1 if args.init_weight:
      2     print("Initing W .......")
      3     init.xavier_normal(self.bilstm.all_weights[0][0], gain=np.sqrt(args.init_weight_value))
      4     init.xavier_normal(self.bilstm.all_weights[0][1], gain=np.sqrt(args.init_weight_value))
      5     init.xavier_normal(self.bilstm.all_weights[1][0], gain=np.sqrt(args.init_weight_value))
      6     init.xavier_normal(self.bilstm.all_weights[1][1], gain=np.sqrt(args.init_weight_value))

      复制代码

     

    (六)调参及其策略

    • 神经网络参数设置

    •  CNN中的kernel-size:看过一篇paper(A Sensitivity Analysis of (and Practitioners’ Guide to)Convolutional Neural Networks for Sentence Classification),论文上测试了kernel的使用,根据其结果,设置大部分会在1-10随机组合,具体的效果还好根据自己的任务。

    • CNN中的kernel-num,就是每个卷积窗口的特征数目,大致设置在100-600,我一般会设置200,300

    • Dropout:Dropout大多数论文上设置都是0.5,据说0.5的效果很好,能够防止过拟合问题,但是在不同的task中,还需要适当的调整dropout的大小,出来要调整dropout值之外,dropout在model中的位置也是很关键的,可以尝试不同的dropout位置,或许会收到惊人的效果。

    • batch size:batch size这个还是需要去适当调整的,看相关的blogs,一般设置不会超过128,有可能也很小,在我目前的任务中,batch size =16有不错的效果。

    • learning rate:学习率这个一般初值对于不同的优化器设置是不一样的,据说有一些经典的配置,像Adam :lr = 0.001

    • 迭代次数:根据自己的task、model、收敛速度、拟合效果设置不同的值

    • LSTM中的hidden size:LSTM中的隐藏层维度大小也对结果有一定的影响,如果使用300dim的外部词向量的话,可以考虑hidden size =150或者是300,对于hidden size我最大设置过600,因为硬件设备的原因,600训练起来已经是很慢了,如果硬件资源ok的话,可以尝试更多的hidden size值,但是尝试的过程中还是要考虑一下hidden size 与词向量维度的关系(自认为其是有一定的关系影响的)

    • 二范式约束:pytorch中的Embedding中的max-norm  和norm-type就是二范式约束

    • 1 if args.max_norm is not None:
      2     print("max_norm = {} ".format(args.max_norm))
      3     self.embed = nn.Embedding(V, D, max_norm=args.max_norm)
    • pytorch中实现了L2正则化,也叫做权重衰减,具体实现是在优化器中,参数是 weight_decay(pytorch中的L1正则已经被遗弃了,可以自己实现),一般设置1e-8

    • 1 if args.Adam is True:
      2     print("Adam Training......")
      3     optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.init_weight_decay)
    • 梯度消失、梯度爆炸问题

    • 1 import torch.nn.utils as utils
      2 if args.init_clip_max_norm is not None:
      3     utils.clip_grad_norm(model.parameters(),
      4 max_norm=args.init_clip_max_norm)

       

    • 神经网络提升Acc的策略

    • 数据预处理,建立词汇表的过程中可以把词频为1的单词剔除,这也是一个超参数,如果剔除之后发现准确率下降的话,可以尝试以一定的概率剔除或者是以一定的概率对这部分词向量进行不同的处理

    • 动态学习率:pytorch最新的版本0.2已经实现了动态学习率,具体使用参考 http://pytorch.org/docs/master/optim.html#how-to-adjust-learning-rate

    • 批量归一化(batch normalizations),pytorch中也提供了相应的函数 BatchNorm1d() 、BatchNorm2d() 可以直接使用,其中有一个参数(momentum)可以作为超参数调整

    • 复制代码

      1 if args.batch_normalizations is True:
      2     print("using batch_normalizations in the model......")
      3     self.convs1_bn = nn.BatchNorm2d(num_features=Co, momentum=args.bath_norm_momentum,
      4                                             affine=args.batch_norm_affine)
      5     self.fc1_bn = nn.BatchNorm1d(num_features=in_fea//2, momentum=args.bath_norm_momentum,
      6                                          affine=args.batch_norm_affine)
      7     self.fc2_bn = nn.BatchNorm1d(num_features=C, momentum=args.bath_norm_momentum,
      8                                          affine=args.batch_norm_affine)

      复制代码

    • 宽卷积、窄卷积,在深层卷积model中应该需要使用的是宽卷积,使用窄卷积的话会出现维度问题,我现在使用的数据使用双层卷积神经网络就会出现维度问题,其实也是和数据相关的

    • 复制代码

      1 if args.wide_conv is True:
      2     print("using wide convolution")
      3     self.convs1 = [nn.Conv2d(in_channels=Ci, out_channels=Co, kernel_size=(K, D), stride=(1, 1),
      4                                      padding=(K//2, 0), dilation=1, bias=True) for K in Ks]
      5 else:
      6     print("using narrow convolution")
      7     self.convs1 = [nn.Conv2d(in_channels=Ci, out_channels=Co, kernel_size=(K, D), bias=True) for K in Ks]

      复制代码

    • character-level的处理,最开始的处理方式是使用词进行处理(也就是单词),可以考虑根据字符去划分,划分出来的词向量可以采用随机初始化的方式,这也是一种策略,我试过这种策略,对我目前的任务来说是没有提升的。

    • 优化器:pytorch提供了多个优化器,我们最常用的是Adam,效果还是很不错的,具体的可以参考 http://pytorch.org/docs/master/optim.html#algorithms

    • fine-tune or no-fine-tune:这是一个很重要的策略,一般情况下fine-tune是有很不错的效果的相对于no-fine-tune来说。

     

    (七)参考致谢

    (END)欢迎各位转载,但请指明出处 bamtercelboo

     

     

     

     

     

    展开全文
  • 本文主要针对RNN与LSTM的结构及其原理进行详细的介绍,了解什么是RNN,RNN的1对N、N对1的结构,什么LSTM,以及LSTM中的三门(input、ouput、forget),后续将利用深度学习框架Kreas,结合案例对LSTM进行进一步的...

    本文主要针对RNN与LSTM的结构及其原理进行详细的介绍,了解什么是RNN,RNN的1对N、N对1的结构,什么是LSTM,以及LSTM中的三门(input、ouput、forget),后续将利用深度学习框架Kreas,结合案例对LSTM进行进一步的介绍。

    一、RNN的原理

      RNN(Recurrent Neural Networks),即全称循环神经网络,它是一种对序列型的数据进行建模的深度模型。如图1.1所示。

     

    图1.1

     

      1、其中为序列数据。即神经网络的输入,例如nlp中,X1可以看作第一个单词、X2可以看作是第二个单词,依次类推。语音处理中,可以将是每帧的声音信号。时间序列中,例如,某生活用品的销量数据。

      2、U、W、V是参数矩阵,b、c是偏置项,f是激活函数,通常采用”热撸”、tanh函数作为激活函数,用softmax将输出转换成各个类别的概率。

      3、上图为经典的RNN结构,其运算过程可以表示为:

     

    式中:表示神经网络的输出;表示前一个时间点的状态;

      4、考虑到输入与输出的关系,序列问题具有以下分类:

           一对多的RNN结构:序列输出,用于图像字幕,如图1.2所示。

     

    图1.2

      多对一的RNN结构:序列输入,用于情感分类,如图1.3所示。

     

     

    图1.3

      多对多:序列输入和输出,用于机器翻译

      同步多对多:同步序列输入和输出,用于视频分类

    二、LSTM的原理

      上面第一部分简单介绍了RNN的几种结构,接下来,介绍一下RNN的改进版:LSTM。LSTM(long short-term memory,长短时记忆网络),它的出现解决了很难处理的“长程依赖”问题,即无法学到序列中蕴含的间隔时间较长的规律RNN每一层的隐状态都由前一层的隐状态经过变换和激活函数得到,反向传播求导时最终得到的导数会包含每一步梯度的连乘,将会引起梯度的消失或者梯度的爆炸。LSTM在隐状态使用了加法替代了每一步的迭代变换,这样便可以避免梯度消失的问题,从而使得网络学到长程的规律。

    RNN可用图1.4表示

     

     

    图1.4

     

      同理,LSTM的结构图1.5所示

     

    图1.5

      其中图1.5中的符号,长方形表示对输入的数据做变换或激活函数;圆形表示逐点,逐点运算是指两个形状完全相同的矩形的对应位置进行相加、相乘或者其他的一些运算;箭头则表示向量会在那里进行运算。注意: 通过concat操作,才进入Sigmoid或tanh函数。

      RNN与LSTM有所不同,LSTM的隐状态有两部分,一部分是ht ,另一部分则是在各个步骤之间传递的主要信息,绿色的水平线可看作“主干道”,如图1.6所示。通过加法,可以无障碍的在这条主干道上传递,因此较远的梯度也可以在长程上传播,这便是LSTM的核心思想

     

    图1.6

      但是,不是每一步的信息都是完全使用前一步的,而是在 的基础之上“遗忘”掉一些内容,或“记住”一些内容。

      1、  遗忘门,我们首先谈一谈遗忘门,每个单元都有一个“遗忘门”,用来控制遗忘掉 的那些部分,其结构如图1.7所示。其中σ是sigmoid激活函数,它的输出在0~1之间,遗忘门输出的 相同形状的矩阵,该矩阵将会和逐点相乘,决定遗忘掉那部分内容。经过激活函数的输出,f取值接近0的维度上的信息就会被“忘记”,而f取值接近1的维度上的信息就会被保留。

     

    图1.7

      2、 输入层,如图1.8,在循环神经网络“忘记”了部分之前的状态后,它还需要从当前的输入补充最新的记忆,这个过程就是“输入门”完成的。输入门的输入同样是两项,分别是:。它的输出项,一项是 同样经过Sigmoid函数运算得到,其值都是在0~1之间,还有一项。最终要“记住”的内容是点相乘,如图1.9。

     

     

    图1.8

     

    图1.9

    3、  输出门,输出门用于计算另一个隐状态的值,真正的输出(如类别)需要通过做进一步运算得到。输出门的结构如图1.20所示,同样根据计算,中每一个数值在0~1之间,通过得到。

     

    图1.20

    最终总结:LSTM中每一步的输入是,隐状态是,最终的输出必须要经过进一步变换得到。

    原文地址https://www.cnblogs.com/shenpings1314/p/10428519.html

    展开全文
  • 这是最近两个月来的一个小总结,实现的demo已经上传github,里面包含了CNN、LSTM、BiLSTM、GRU以及CNN与LSTM、BiLSTM结合还有多层多通道CNN、LSTM、BiLSTM等多个神经网络模型的的实现。这篇文章总结一下最近一段...

    Demo

    这是最近两个月来的一个小总结,实现的demo已经上传github,里面包含了CNN、LSTM、BiLSTM、GRU以及CNN与LSTM、BiLSTM的结合还有多层多通道CNN、LSTM、BiLSTM等多个神经网络模型的的实现。这篇文章总结一下最近一段时间遇到的问题、处理方法和相关策略,以及经验(其实并没有什么经验)等,白菜一枚

    Demo Site:  https://github.com/bamtercelboo/cnn-lstm-bilstm-deepcnn-clstm-in-pytorch

    (一) Pytorch简述

    Pytorch是一个较新的深度学习框架,是一个 Python 优先的深度学习框架,能够在强大的 GPU 加速基础上实现张量和动态神经网络。

    对于没有学习过pytorch的初学者,可以先看一下官网发行的60分钟入门pytorch,参考地址 :http://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html

    (二) CNN、LSTM

    卷积神经网络CNN理解参考

    (https://www.zybuluo.com/hanbingtao/note/485480)

    长短时记忆网络LSTM理解参考

    (https://zybuluo.com/hanbingtao/note/581764)

    (三)数据预处理

    1、我现在使用的语料是基本规范的数据(例如下),但是加载语料数据的过程中仍然存在着一些需要预处理的地方,像一些数据的大小写、数字的处理以及“\n \t”等一些字符,现在使用torchtext第三方库进行加载数据预处理。

    2、torch建立词表、处理语料数据的大小写:

    3、处理语料数据数字等特殊字符:

    4、需要注意的地方:

    加载数据集的时候可以使用random打乱数据

    torchtext建立训练集、开发集、测试集迭代器的时候,可以选择在每次迭代的时候是否去打乱数据

    (四)Word Embedding

    1、word embedding简单来说就是语料中每一个单词对应的其相应的词向量,目前训练词向量的方式最使用的应该是word2vec 参考 :

    (http://www.cnblogs.com/bamtercelboo/p/7181899.html)

    2、上文中已经通过torchtext建立了相关的词汇表,加载词向量有两种方式,一个是加载外部根据语料训练好的预训练词向量,另一个方式是随机初始化词向量,两种方式相互比较的话当时是使用预训练好的词向量效果会好很多,但是自己训练的词向量并不见得会有很好的效果,因为语料数据可能不足,像已经训练好的词向量,像Google News那个词向量,是业界公认的词向量,但是由于数量巨大,如果硬件设施(GPU)不行的话,还是不要去尝试这个了。

    3、提供几个下载预训练词向量的地址

    word2vec-GoogleNews-vectors

    (https://github.com/mmihaltz/word2vec-GoogleNews-vectors)

    glove-vectors

    (https://nlp.stanford.edu/projects/glove/)

    4、加载外部词向量方式

    加载词汇表中在词向量里面能够找到的词向量

    处理词汇表中在词向量里面找不到的word,俗称OOV(out of vocabulary),OOV越多,可能对加过的影响也就越大,所以对OOV词的处理就显得尤为关键,现在有几种策略可以参考:

    对已经找到的词向量平均化

    随机初始化或者全部取zero,随机初始化或者是取zero,可以是所有的OOV都使用一个随机值,也可以每一个OOV word都是随机的,具体效果看自己效果

    随机初始化的值看过几篇论文,有的随机初始化是在(-0.25,0.25)或者是(-0.1,0.1)之间,具体的效果可以自己去测试一下,不同的数据集,不同的外部词向量估计效果不一样,我测试的结果是0.25要好于0.1

    特别需要注意处理后的OOV词向量是否在一定的范围之内,这个一定要在处理之后手动或者是demo查看一下,想处理出来的词向量大于15,30的这种,可能就是你自己处理方式的问题,也可以是说是你自己demo可能存在bug,对结果的影响很大。

    5、model中使用外部词向量

    五)参数初始化

    对于pytorch中的nn.Conv2d()卷积函数来说,有weight and bias,对weight初始化是很有必要的,不对其初始化可能减慢收敛速度,影响最终效果等

    对weight初始化,一般可以使用torch.nn.init.uniform()、torch.nn.init.normal()、torch.nn.init.xavier_uniform(),具体使用参考 http://pytorch.org/docs/master/nn.html#torch-nn-init

    对于pytorch中的nn.LSTM(),有all_weights属性,其中包括weight and bias,是一个多维矩阵

     

    (六)调参及其策略

    神经网络参数设置

    CNN中的kernel-size:看过一篇paper(A Sensitivity Analysis of (and Practitioners’ Guide to)Convolutional Neural Networks for Sentence Classification),论文上测试了kernel的使用,根据其结果,设置大部分会在1-10随机组合,具体的效果还要根据自己的任务。

    CNN中的kernel-num,就是每个卷积窗口的特征数目,大致设置在100-600,我一般会设置200,300

    Dropout:Dropout大多数论文上设置都是0.5,据说0.5的效果很好,能够防止过拟合问题,但是在不同的task中,还需要适当的调整dropout的大小,出来要调整dropout值之外,dropout在model中的位置也是很关键的,可以尝试不同的dropout位置,或许会收到惊人的效果。

    batch size:batch size这个还是需要去适当调整的,看相关的blogs,一般设置不会超过128,有可能也很小,在我目前的任务中,batch size =16有不错的效果。

    learning rate:学习率这个一般初值对于不同的优化器设置是不一样的,据说有一些经典的配置,像Adam :lr = 0.001

    迭代次数:根据自己的task、model、收敛速度、拟合效果设置不同的值

    LSTM中的hidden size:LSTM中的隐藏层维度大小也对结果有一定的影响,如果使用300dim的外部词向量的话,可以考虑hidden size =150或者是300,对于hidden size我最大设置过600,因为硬件设备的原因,600训练起来已经是很慢了,如果硬件资源ok的话,可以尝试更多的hidden size值,但是尝试的过程中还是要考虑一下hidden size 与词向量维度的关系(自认为其是有一定的关系影响的)

    二范式约束:pytorch中的Embedding中的max-norm  和norm-type就是二范式约束

    pytorch中实现了L2正则化,也叫做权重衰减,具体实现是在优化器中,参数是 weight_decay(pytorch中的L1正则已经被遗弃了,可以自己实现),一般设置1e-8

    梯度消失、梯度爆炸问题

    神经网络提升Acc的策略

    数据预处理,建立词汇表的过程中可以把词频为1的单词剔除,这也是一个超参数,如果剔除之后发现准确率下降的话,可以尝试以一定的概率剔除或者是以一定的概率对这部分词向量进行不同的处理

    动态学习率:pytorch最新的版本0.2已经实现了动态学习率,具体使用参考 http://pytorch.org/docs/master/optim.html#how-to-adjust-learning-rate

    批量归一化(batch normalizations),pytorch中也提供了相应的函数 BatchNorm1d() 、BatchNorm2d() 可以直接使用,其中有一个参数(momentum)可以作为超参数调整

    宽卷积、窄卷积,在深层卷积model中应该需要使用的是宽卷积,使用窄卷积的话会出现维度问题,我现在使用的数据使用双层卷积神经网络就会出现维度问题,其实也是和数据相关的

    character-level的处理,最开始的处理方式是使用词进行处理(也就是单词),可以考虑根据字符去划分,划分出来的词向量可以采用随机初始化的方式,这也是一种策略,我试过这种策略,对我目前的任务来说是没有提升的。

    优化器:pytorch提供了多个优化器,我们最常用的是Adam,效果还是很不错的,具体的可以参考 http://pytorch.org/docs/master/optim.html#algorithms 

    fine-tune or no-fine-tune:这是一个很重要的策略,一般情况下fine-tune是有很不错的效果的相对于no-fine-tune来说。

     

    七)参考致谢

    你有哪些deep learning(rnn、cnn)调参的经验?

    https://www.zhihu.com/question/41631631

    有谁可以解释下word embedding?

    https://www.zhihu.com/question/32275069

    零基础入门深度学习

    https://zybuluo.com/hanbingtao/note/581764

    PyTorch参数初始化和Finetune

    https://zhuanlan.zhihu.com/p/25983105

    过拟合与正则

    http://hpzhao.com/2017/03/29/机器学习中的正则化/#more

    Batch Normalitions

    https://discuss.pytorch.org/t/example-on-how-to-use-batch-norm/216/2


    bamtercelboo是我实验室的师兄,在之前刚入门的时候总结出来的干货经验,个人感觉值得一看。他的github为https://github.com/bamtercelboo,很多干货代码,欢迎访问。

    更多精彩内容,请关注 深度学习自然语言处理 公众号,就是下方啦!跟随小博主,每天进步一丢丢!哈哈!

    展开全文
  • 其实很简单,因为我不是干这行的哈,数据挖掘对我来说只是一个爱好,一个数学Python结合的爱好,因此在这方面,我不用担心别人比我领先哈。 语料下载:sentiment.zip 采集到的评论数据:sum.zip 来源:...
  • Deep Recurrent Q-Learning for Partially Observable MDPs 1. 论文讲了什么/主要贡献是什么 ...但现实中大部分都是部分可观测的情况——POMDP,本文在DQN的基础上,结合循环神经网络的特性,将LSTM与DQN结合,...
  • 文本匹配ESIM模型详解

    千次阅读 2019-09-06 14:55:53
    ESIM(Enhanced Sequential Inference Model)是一个综合应用了BiLSTM和注意力机制的模型,在文本匹配中效果十分强大,也是目前为止我见过结构最复杂的模型,下面将会结合公式和感性的理解去一步步推导这个模型。...
  • 本文介绍了NIC算法,将CNN与LSTM结合,做了一件什么事呢。就是小学时的看图说话,利用CNN提取图片特征,并作为t−1t_{-1}t−1​输入LSTM中,将描述性词汇转化为独热编码,利用嵌入模型做为StS_tSt...
  • 随从-源码

    2021-02-12 12:59:52
    标准的片段预测方法(LSTM / RNN)相比,该转换器体系结构具有许多优点。 在训练方面,它允许并行计算整个序列,而在LSTM中,一次必须传递一个元素。 此外,它为模型本身提供了更好的机会来研究正在传递的元素之间...
  • 资源主要结合作者之前的博客、AI经验和相关视频及论文介绍,后面随着深入会讲解更多的Python人工智能案例及应用。基础性文章,希望对您有所帮助,如果文章中存在错误或不足之处,还请海涵~作者作为人工智能的菜鸟,...

空空如也

空空如也

1 2 3
收藏数 55
精华内容 22
关键字:

lstm与什么结合