1. Embedding的使用

pytorch中实现了Embedding，下面是关于Embedding的使用。

torch.nn包下的Embedding，作为训练的一层，随模型训练得到适合的词向量。

建立词向量层

embed = torch.nn.Embedding(n_vocabulary,embedding_size)

找到对应的词向量放进网络：词向量的输入应该是什么样子

实际上，上面通过随机初始化建立了词向量层后，建立了一个“二维表”，存储了词典中每个词的词向量。每个mini-batch的训练，都要从词向量表找到mini-batch对应的单词的词向量作为RNN的输入放进网络。那么怎么把mini-batch中的每个句子的所有单词的词向量找出来放进网络呢，输入是什么样子，输出是什么样子？

首先我们知道肯定先要建立一个词典，建立词典的时候都会建立一个dict：word2id：存储单词到词典序号的映射。假设一个mini-batch如下所示：

['I am a boy.','How are you?','I am very lucky.']

显然，这个mini-batch有3个句子，即batch_size=3

第一步首先要做的是：将句子标准化，所谓标准化，指的是：大写转小写，标点分离，这部分很简单就略过。经处理后，mini-batch变为：

[['i','am','a','boy','.'],['how','are','you','?'],['i','am','very','lucky','.']]

可见，这个list的元素成了一个个list。还要做一步：将上面的三个list按单词数从多到少排列。标点也算单词。至于为什么，后面会说到。

那就变成了：

batch = [['i','am','a','boy','.'],['i','am','very','lucky','.']，['how','are','you','?']]

可见，每个句子的长度，即每个内层list的元素数为：5,5,4。这个长度也要记录。

lens = [5,5,4]

之后，为了能够处理，将batch的单词表示转为在词典中的index序号，这就是word2id的作用。转换过程很简单，假设转换之后的结果如下所示，当然这些序号是我编的。

batch = [[3,6,5,6,7],[6,4,7,9,5]，[4,5,8,7]]

同时，每个句子结尾要加EOS，假设EOS在词典中的index是1。

batch = [[3,6,5,6,7,1],[6,4,7,9,5,1],[4,5,8,7,1]]

那么长度要更新：

lens = [6,6,5]

很显然，这个mini-batch中的句子长度不一致！所以为了规整的处理，对长度不足的句子，进行填充。填充PAD假设序号是2，填充之后为：

batch = [[3,6,5,6,7,1],[6,4,7,9,5,1],[4,5,8,7,1,2]]

这样就可以直接取词向量训练了吗?

不能！上面batch有3个样例，RNN的每一步要输入每个样例的一个单词，一次输入batch_size个样例，所以batch要按list外层是时间步数(即序列长度)，list内层是batch_size排列。即batch的维度应该是：

[seq_len,batch_size]

[seq_len,batch_size]

[seq_len,batch_size]

重要的问题说3遍。

怎么变换呢？变换方法可以是：使用itertools模块的zip_longest函数。而且，使用这个函数，连填充这一步都可以省略，因为这个函数可以实现填充！

  1. batch = list(itertools.zip_longest(batch,fillvalue=PAD))
  2. # fillvalue就是要填充的值，强制转成list

经变换，结果应该是：

  1. batch = [[3,6,4],[6,4,5],[5,7,8],[6,9,7],[7,5,1],[1,1,2]]

记得我们还记录了一个lens：

lens = [6,6,5]

batch还要转成LongTensor：

batch=torch.LongTensor(batch)

这里的batch就是词向量层的输入。

词向量层的输出是什么样的？

好了，现在使用建立了的embedding直接通过batch取词向量了，如：

embed_batch = embed (batch)

假设词向量维度是6，结果是：

  1. tensor([[[-0.2699,  0.7401, -0.8000,  0.0472,  0.9032, -0.0902],
  2.          [-0.2675,  1.8021,  1.4966,  0.6988,  1.4770,  1.1235],
  3.          [ 0.1146, -0.8077, -1.4957, -1.5407,  0.3755, -0.6805]],
  5.         [[-0.2675,  1.8021,  1.4966,  0.6988,  1.4770,  1.1235],
  6.          [ 0.1146, -0.8077, -1.4957, -1.5407,  0.3755, -0.6805],
  7.          [-0.0387,  0.8401,  1.6871,  0.3057, -0.8248, -0.1326]],
  9.         [[-0.0387,  0.8401,  1.6871,  0.3057, -0.8248, -0.1326],
  10.          [-0.3745, -1.9178, -0.2928,  0.6510,  0.9621, -1.3871],
  11.          [-0.6739,  0.3931,  0.1464,  1.4965, -0.9210, -0.0995]],
  13.         [[-0.2675,  1.8021,  1.4966,  0.6988,  1.4770,  1.1235],
  14.          [-0.7411,  0.7948, -1.5864,  0.1176,  0.0789, -0.3376],
  15.          [-0.3745, -1.9178, -0.2928,  0.6510,  0.9621, -1.3871]],
  17.         [[-0.3745, -1.9178, -0.2928,  0.6510,  0.9621, -1.3871],
  18.          [-0.0387,  0.8401,  1.6871,  0.3057, -0.8248, -0.1326],
  19.          [ 0.2837,  0.5629,  1.0398,  2.0679, -1.0122, -0.2714]],
  21.         [[ 0.2837,  0.5629,  1.0398,  2.0679, -1.0122, -0.2714],
  22.          [ 0.2837,  0.5629,  1.0398,  2.0679, -1.0122, -0.2714],
  23.          [ 0.2242, -1.2474,  0.3882,  0.2814, -0.4796,  0.3732]]],
  24.        grad_fn=<EmbeddingBackward>)

维度的前两维和前面讲的是一致的。可见多了一个第三维，这就是词向量维度。所以，Embedding层的输出是：

[seq_len,batch_size,embedding_size]

2 关于pytorch中的GRU

取词向量，放进GRU。

建立GRU

  1. gru = torch.nn.GRU(input_size,hidden_size,n_layers)
  2. # 这里的input_size就是词向量的维度，hidden_size就是RNN隐藏层的维度，这两个一般相同就可以
  3. # n_layers是GRU的层数

可见，并不需要指定时间步数，也即seq_len，这是因为，GRU和LSTM都实现了自身的迭代。

GRU的输入应该是什么样子的？

上面的embed_batch作为Embedding层的输出，可以直接放进GRU中吗？

理论上可以，但这样不对！因为GRU并不知道哪些是填充的，并不是每一个句子都满足最大序列长度！所以我们事先用lens记录了长度。

将输出embed_batch转成pack_padded_sequence，使用torch.nn.utils.rnn. 下的pack_padded_sequence方法。

  1.  batch_packed = torch.nn.utils.rnn.pack_padded_sequence(embed_batch, lens)
  2.  # 注意这里的输入lens就是前面的长度list

这个 batch_packed 就是GRU的输入。

batch_packed 长啥样？

不妨看一下：

  1. PackedSequence(data=tensor([[-0.2699,  0.7401, -0.8000,  0.0472,  0.9032, -0.0902],
  2.         [-0.2675,  1.8021,  1.4966,  0.6988,  1.4770,  1.1235],
  3.         [ 0.1146, -0.8077, -1.4957, -1.5407,  0.3755, -0.6805],
  4.         [-0.2675,  1.8021,  1.4966,  0.6988,  1.4770,  1.1235],
  5.         [ 0.1146, -0.8077, -1.4957, -1.5407,  0.3755, -0.6805],
  6.         [-0.0387,  0.8401,  1.6871,  0.3057, -0.8248, -0.1326],
  7.         [-0.0387,  0.8401,  1.6871,  0.3057, -0.8248, -0.1326],
  8.         [-0.3745, -1.9178, -0.2928,  0.6510,  0.9621, -1.3871],
  9.         [-0.6739,  0.3931,  0.1464,  1.4965, -0.9210, -0.0995],
  10.         [-0.2675,  1.8021,  1.4966,  0.6988,  1.4770,  1.1235],
  11.         [-0.7411,  0.7948, -1.5864,  0.1176,  0.0789, -0.3376],
  12.         [-0.3745, -1.9178, -0.2928,  0.6510,  0.9621, -1.3871],
  13.         [-0.3745, -1.9178, -0.2928,  0.6510,  0.9621, -1.3871],
  14.         [-0.0387,  0.8401,  1.6871,  0.3057, -0.8248, -0.1326],
  15.         [ 0.2837,  0.5629,  1.0398,  2.0679, -1.0122, -0.2714],
  16.         [ 0.2837,  0.5629,  1.0398,  2.0679, -1.0122, -0.2714],
  17.         [ 0.2837,  0.5629,  1.0398,  2.0679, -1.0122, -0.2714]],
  18.        grad_fn=<PackPaddedBackward>), batch_sizes=tensor([3, 3, 3, 3, 3, 2], grad_fn=<PackPaddedBackward>))

可以看到，属性batch_sizes清楚的记录了每个时间步上batch输出是多少，而且去除了PAD。

此外，GRU还需要一个初始隐藏向量（注意层数和方向），嫌麻烦直接传None也无妨。

所以输入应该是( batch_packed , None )

GRU的输出？

  1. output,hidden = gru(batch_packed,None)

output：PackedSequence对象

  1. PackedSequence(data=tensor([[ 0.0432, -0.0149, -0.0884, -0.0194, -0.0740,  0.1278],
  2.         [-0.0436, -0.0726,  0.0568, -0.0995, -0.1992,  0.1594],
  3.         [ 0.0582,  0.0625, -0.1639,  0.1474,  0.0077,  0.0542],
  4.         [-0.0052, -0.0732,  0.0031, -0.1367, -0.2336,  0.2307],
  5.         [ 0.0131,  0.0234, -0.0681,  0.0535, -0.1651,  0.1864],
  6.         [ 0.0324,  0.1441, -0.1788,  0.1800, -0.0816,  0.1684],
  7.         [-0.0788, -0.0148, -0.0292, -0.1348, -0.3352,  0.3045],
  8.         [ 0.0502,  0.0436, -0.1509,  0.1481, -0.1284,  0.1523],
  9.         [ 0.0627,  0.1626, -0.1888,  0.1341, -0.0984,  0.2627],
  10.         [-0.1391, -0.0149,  0.0473, -0.2069, -0.4410,  0.3690],
  11.         [ 0.1378,  0.0578, -0.2008,  0.1265, -0.0149,  0.2053],
  12.         [ 0.0780,  0.1199, -0.2107,  0.1460, -0.0906,  0.2291],
  13.         [-0.1019,  0.0055, -0.0304, -0.1277, -0.4149,  0.3582],
  14.         [ 0.0906,  0.1025, -0.1646,  0.0933, -0.0953,  0.2905],
  15.         [ 0.1004,  0.1175, -0.1911,  0.0979, -0.0877,  0.2771],
  16.         [-0.0607,  0.0469, -0.0935, -0.1002, -0.3568,  0.3707],
  17.         [ 0.0737,  0.1213, -0.1516,  0.0365, -0.1417,  0.3591]],
  18.        grad_fn=<CatBackward>), batch_sizes=tensor([3, 3, 3, 3, 3, 2], grad_fn=<PackPaddedBackward>))

前三个list对应于第一时间步，mini-batch的三个样例的输出。依次类推。最后只有两个，因为最后是有缺省的。

hidden：是个张量。维度[n_layers,batch_size,hidden_size]

  1. tensor([[[-0.1057,  0.2273,  0.0964,  0.2777,  0.1391, -0.1769],
  2.          [-0.1792,  0.1942,  0.1248,  0.0800, -0.0082,  0.0778],
  3.          [-0.2631,  0.1654,  0.1455, -0.1428,  0.1888, -0.2379]],
  5.         [[-0.0607,  0.0469, -0.0935, -0.1002, -0.3568,  0.3707],
  6.          [ 0.0737,  0.1213, -0.1516,  0.0365, -0.1417,  0.3591],
  7.          [ 0.1004,  0.1175, -0.1911,  0.0979, -0.0877,  0.2771]]],
  8.        grad_fn=<ViewBackward>)

所以到这，为什么逆序，为什么记录长度也就清楚了。

3 关于pytroch中的LSTM

有点累了，过会写。差不对，就LSTM有两个隐藏层向量。

【pytorch】关于Embedding和GRU、LSTM的使用详解的更多相关文章

  1. RNN 与 LSTM 的原理详解

    原文地址:https://blog.csdn.net/happyrocking/article/details/83657993 RNN(Recurrent Neural Network)是一类用于处 ...

  2. （数据科学学习手札39）RNN与LSTM基础内容详解

    一.简介 循环神经网络(recurrent neural network,RNN),是一类专门用于处理序列数据(时间序列.文本语句.语音等)的神经网络,尤其是可以处理可变长度的序列:在与传统的时间序列 ...

  3. tensorflow LSTM+CTC使用详解

    最近用tensorflow写了个OCR的程序,在实现的过程中,发现自己还是跳了不少坑,在这里做一个记录,便于以后回忆.主要的内容有lstm+ctc具体的输入输出,以及TF中的CTC和百度开源的warp ...

  4. pytorch学习笔记（十二）：详解 Module 类

    Module 是 pytorch 提供的一个基类,每次我们要 搭建 自己的神经网络的时候都要继承这个类,继承这个类会使得我们 搭建网络的过程变得异常简单. 本文主要关注 Module 类的内部是怎么样 ...

  5. torch.nn.LSTM()函数维度详解

    123456789101112lstm=nn.LSTM(input_size,                     hidden_size,                      num_la ...

  6. PyTorch 中 torch.matmul() 函数的文档详解

    官方文档 torch.matmul() 函数几乎可以用于所有矩阵/向量相乘的情况,其乘法规则视参与乘法的两个张量的维度而定. 关于 PyTorch 中的其他乘法函数可以看这篇博文,有助于下面各种乘法的 ...

  7. Pytorch学习笔记08----优化器算法Optimizer详解（SGD、Adam）

    1.优化器算法简述 首先来看一下梯度下降最常见的三种变形 BGD,SGD,MBGD,这三种形式的区别就是取决于我们用多少数据来计算目标函数的梯度,这样的话自然就涉及到一个 trade-off,即参数更 ...

  8. IMPLEMENTING A GRU/LSTM RNN WITH PYTHON AND THEANO - 学习笔记

    catalogue . 引言 . LSTM NETWORKS . LSTM 的变体 . GRUs (Gated Recurrent Units) . IMPLEMENTATION GRUs 0. 引言 ...

  9. pytorch nn.Embedding

    pytorch nn.Embeddingclass torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, max_no ...

随机推荐

  1. 【技术解析】如何用Docker实现SequoiaDB集群的快速部署

    1. 背景 以Docker和Rocket为代表的容器技术现在正变得越来越流行,它改变着公司和用户创建.发布.运行分布式应用的方式,在未来5年将给云计算行业带来它应有的价值.它的诱人之处在于: 1)资源 ...

  2. 如何使用.net开发一款小而美的O2O移动应用？ ——“家庭小秘”APP介绍及采访记录

    “家庭小秘”是一款“互联网+生活服务”平台,为市民家庭提供优质家庭生活服务和企业后勤服务,包含了用户注册.购买预约.订单查询.充值付款.即时通讯等功能. 这款应用已上线至AppStore和安卓的应用商 ...

  3. 使用 DotNet CLI 创建自定义的 WPF 项目模板

    描述 当我们安装完 DotNetCore 3.0 版本的 SDK 后,我们就可以创建基于 DotNetCore 的 WPF 项目模板,通过如下 CLI 可以方便快捷的创建并运行我们的项目: dotne ...

  4. pdf文件下载水印添加的中文与空格问题解决

    public static boolean waterMark(String inputFile, String outputFile, String waterMarkName)throws IOE ...

  5. h5与c3权威指南笔记--css3新属性选择器

    [att*=val] 选择所有att属性值中包含val的.只要包含val值,不论val值在属性值的前面还是中间还是后面~ <style> div[class*=div]{ color: r ...

  6. px妙转rem

    px:像素,相对长度单位,相对于显示器屏幕的分辨率而言(其实我个人认为可以理解为固定单位): rem:这是个web前端中的新成员,是CSS3中新增的一个相对单位.相对的只是html根元素: 1.设定两 ...

  7. 自定义修改Anaconda Jupyterlab Home目录

    自定义修改Anaconda Jupyterlab Home目录 最近在使用Anaconda学习数据分析和机器学习,会使用到Jupyter,但是他默认目录是用户的目录,我并没有习惯将项目和资料放在C盘, ...

  8. 【AO例子】生成TIN

    当然,通过GP生成也是可以的.这里介绍的是已经烂大街的生成方法. 上代码: public ITin CreateTin(IFeatureClass featureClass, IField Z, st ...

  9. Webpack4教程 - 第三部分，如何使用插件

    转载请注明出处:葡萄城官网,葡萄城为开发者提供专业的开发工具.解决方案和服务,赋能开发者.原文出处:https://wanago.io/2018/07/23/webpack-4-course-part ...

  10. Python 标准类库 - 因特网协议与支持之socketserver

    标准类库 - 因特网协议与支持之socketserver by:授客 QQ:1033553122 socketserver 模块,简化网络服务编写任务. 创建服务的步骤 1  通过子类化BaseReq ...