&figure&&img src=&https://pic1.zhimg.com/v2-ffc790c370fc32b489e0b_b.jpg& data-rawwidth=&999& data-rawheight=&986& class=&origin_image zh-lightbox-thumb& width=&999& data-original=&https://pic1.zhimg.com/v2-ffc790c370fc32b489e0b_r.jpg&&&/figure&&p&《利用Python进行数据分析》这本可以说是数据分析中非常经典的书籍了，但是国内的中文版是基于&a href=&https://link.zhihu.com/?target=https%3A//book.douban.com/author/1059618/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Wes McKinney&/a& 在2013年出版的《Python for Data Analysis》（Wes McKinney 开发了用于数据分析的著名开源Python库——pandas，广获用户好评），那个时候还是Python2的流行时代，所以书上的部分知识有些过时了。&/p&&p&前不久作者出版了2017年的第二版，本以为只能看英文版，没想到在github上已经有人&a href=&https://link.zhihu.com/?target=https%3A//github.com/BrambleXu& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&BrambleXu&/a&看完了英文版并且还写出了中文笔记版（精华版），特地来分享给大家。&/p&&figure&&img src=&https://pic4.zhimg.com/v2-73506dcf4b881fba90df8b_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&1010& data-rawheight=&840& class=&origin_image zh-lightbox-thumb& width=&1010& data-original=&https://pic4.zhimg.com/v2-73506dcf4b881fba90df8b_r.jpg&&&/figure&&p&&b&2017第二版主要更新：&/b&&/p&&ol&&li&所有代码，包括Python教程，都升级到了Python3.6（第一版用的是Python2.7）&/li&&li&更新了Python的安装介绍。这次改用Anaconda Python发行版，以及其他一些需要的Python包&/li&&li&使用了最新的2017版pandas&/li&&li&新增了一章，用来介绍pandas的高级应用工具，和其他一些有用的小贴士&/li&&li&简单介绍了如何使用statsmodels和scikit-learn&/li&&/ol&&p&看star数知道的人应该不多，看到我的分享你也不用买书了&/p&&p&&a href=&https://link.zhihu.com/?target=https%3A//github.com/BrambleXu/pydata-notebook& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&github：利用Python进行数据分析 第二版 (2017) 中文翻译笔记&/a&&/p&&p&如果你对数据分析师感兴趣不妨看看这个问题下的回答。&/p&&p&&a href=&https://www.zhihu.com/question/& class=&internal&&如何快速成为数据分析师？&/a&&/p&&p&如果为你省了一笔钱不妨给我点个赞吧，另外我发现收藏了又点赞的都是很帅很漂亮的人。&/p&
《利用Python进行数据分析》这本可以说是数据分析中非常经典的书籍了，但是国内的中文版是基于 在2013年出版的《Python for Data Analysis》（Wes McKinney 开发了用于数据分析的著名开源Python库——pandas，广获用户好评），那个时候还是Pyth…
&p&　　（这篇并不是科普，我尽量写得简略，学过 CTC 的人会知道我在说什么）&/p&&p&　　CTC（connectionist temporal classification）是 sequence-to-sequence learning 的一个重要里程碑。它为 RNN 设计了一种新型的目标函数，使得输入、输出序列不必等长，也不需要在训练前对输入、输出序列进行对齐。有了 CTC 之后，语音识别等系统的性能又上了一个台阶。&/p&&p&　　在用到 CTC 的时候，大家一般都会引用 Alex Graves 在 2006 年的 ICML 会议上发表的开山之作《Connectionist Temporal Classification: Labelling Unsegmented&br&Sequence Data with Recurrent Neural Networks》。这篇论文介绍了 CTC 的解码与训练方法，其中训练方法用到了 forward-backward 算法。不过，在推导过程中，方程 14、15（连带着后面的方程 16）出现了错误。&/p&&p&　　方程 14 是这样的：&/p&&figure&&img src=&https://pic4.zhimg.com/ebb9c2acb20f17ebdf619_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&363& data-rawheight=&63& class=&content_image& width=&363&&&/figure&&p&这里不应该对&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&求和，而应当任选一个&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&。事实上，可以直接选取&img src=&https://www.zhihu.com/equation?tex=t%3DT& alt=&t=T& eeimg=&1&&，这样方程就化归为上一页的方程 8：&/p&&figure&&img src=&https://pic4.zhimg.com/62461aea61ae3d85e3c7f094c6202b34_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&382& data-rawheight=&27& class=&content_image& width=&382&&&/figure&&p&　　方程 15 是方程 14 的导数：&/p&&figure&&img src=&https://pic4.zhimg.com/b4a21bd16f5a054b9aaf0b72eb6f3e68_b.jpg& data-caption=&& data-size=&normal& data-rawwidth=&402& data-rawheight=&68& class=&content_image& width=&402&&&/figure&&p&这里对&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&的求和在各种“马虎眼”下居然恰好消失了。这里的“马虎眼”在于，求和式内部的&img src=&https://www.zhihu.com/equation?tex=%5Calpha& alt=&\alpha& eeimg=&1&&、&img src=&https://www.zhihu.com/equation?tex=%5Cbeta& alt=&\beta& eeimg=&1&&之积，无论&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&等于多少，都是隐含了所有的时间步的；对&img src=&https://www.zhihu.com/equation?tex=y%5Et_k& alt=&y^t_k& eeimg=&1&&求导的时候，并不是只有&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&时间步能留下来。但就时间步方面来说，方程 15 恰恰“错错得对”了。不过，方程 15 里还有另一个错误，就是&img src=&https://www.zhihu.com/equation?tex=%5Calpha& alt=&\alpha& eeimg=&1&&、&img src=&https://www.zhihu.com/equation?tex=%5Cbeta& alt=&\beta& eeimg=&1&&其实也隐含了&img src=&https://www.zhihu.com/equation?tex=y%5Et_k& alt=&y^t_k& eeimg=&1&&（下略作&img src=&https://www.zhihu.com/equation?tex=y& alt=&y& eeimg=&1&&），并且是它的线性函数。这样，求导的过程应该是（省略一切下标等）：&/p&&p&&img src=&https://www.zhihu.com/equation?tex=%5Cfrac%7B%5Cpartial+p%7D%7B%5Cpartial+y%7D+%3D+%5Cfrac%7B%5Cpartial%7D%7B%5Cpartial+y%7D+%5Csum_s+%5Cfrac%7B%5Calpha+%5Ccdot+%5Cbeta%7D%7By%7D+%3D+%5Cfrac%7B%5Cpartial%7D%7B%5Cpartial+y%7D+%5Csum_s+%5Cfrac%7Bay+%5Ccdot+by%7D%7By%7D+%3D+%5Csum_s+ab+%3D+%5Cfrac%7B1%7D%7By%5E2%7D+%5Csum_s+%5Calpha+%5Ccdot+%5Cbeta+%5C%5C& alt=&\frac{\partial p}{\partial y} = \frac{\partial}{\partial y} \sum_s \frac{\alpha \cdot \beta}{y} = \frac{\partial}{\partial y} \sum_s \frac{ay \cdot by}{y} = \sum_s ab = \frac{1}{y^2} \sum_s \alpha \cdot \beta \\& eeimg=&1&&&/p&&p&与方程 15 差了一个负号。这个错误其实很容易看出来：&img src=&https://www.zhihu.com/equation?tex=y& alt=&y& eeimg=&1&&越大，&img src=&https://www.zhihu.com/equation?tex=p& alt=&p& eeimg=&1&&也应该越大，导数应该是正的才对。&/p&&p&　　受这两个错误（尤其是方程 14）的影响，网上的一些 CTC 源码对&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&进行了求和，比如：&/p&&ul&&ul&&li&&a href=&https://link.zhihu.com/?target=https%3A//blog.wtf.sg//connectionist-temporal-classification-ctc-with-theano/& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&blog.wtf.sg//&/span&&span class=&invisible&&connectionist-temporal-classification-ctc-with-theano/&/span&&span class=&ellipsis&&&/span&&/a&&/li&&/ul&&/ul&&p&因为各个时间步的求和是相等的，对&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&求和只是让结果放大了&img src=&https://www.zhihu.com/equation?tex=T& alt=&T& eeimg=&1&&倍，不至于导致错误，但无端增加了计算量。如果你使用 Theano 的自动求导功能，其实用方程 8 的对数值作为目标函数就可以了，连 backward pass 都不需要。&/p&&p&　　Alex Graves 后来也发现了这两个错误，并作出了更正。可惜，现在网上流传的版本，仍然有不少是错误的，比如：&/p&&ul&&ul&&li&&a href=&https://link.zhihu.com/?target=http%3A//www.machinelearning.org/proceedings/icml_Connectionist_Tempor.pdf& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://www.&/span&&span class=&visible&&machinelearning.org/pro&/span&&span class=&invisible&&ceedings/icml_Connectionist_Tempor.pdf&/span&&span class=&ellipsis&&&/span&&/a& &/li&&li&&a href=&https://link.zhihu.com/?target=http%3A//machinelearning.wustl.edu/mlpapers/paper_files/icml2006_GravesFGS06.pdf& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&machinelearning.wustl.edu&/span&&span class=&invisible&&/mlpapers/paper_files/icml2006_GravesFGS06.pdf&/span&&span class=&ellipsis&&&/span&&/a& &/li&&/ul&&/ul&&p&但下面这个版本是更正后的：&/p&&ul&&ul&&li&&a href=&https://link.zhihu.com/?target=http%3A//www.cs.toronto.edu/%7Egraves/icml_2006.pdf& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://www.&/span&&span class=&visible&&cs.toronto.edu/~graves/&/span&&span class=&invisible&&icml_2006.pdf&/span&&span class=&ellipsis&&&/span&&/a&&/li&&/ul&&/ul&
（这篇并不是科普，我尽量写得简略，学过 CTC 的人会知道我在说什么） CTC（connectionist temporal classification）是 sequence-to-sequence learning 的一个重要里程碑。它为 RNN 设计了一种新型的目标函数，使得输入、输出序列不必等长，也不需要在训练…
循环神经网络（RNN）是非常流行的模型，在NLP的很多任务中已经展示出了很大的威力。但与此相对的是，能完整解释RNN是如何工作，如何实现的资源非常有限。这也是本教程所要做的事情，本教程打算覆盖下面几个方面的内容：&p&1. RNN简介（本篇）&br&2. 用python和theano实现一个RNN&br&3. 理解随时间反向传播算法（BPTT）和梯度消失问题&br&4. 实现一个GRU/LSTM RNN&/p&&p&
作为本教程的一部分，将会实现一个基于RNN的语言模型（&a href=&https://link.zhihu.com/?target=http%3A//www.fit.vutbr.cz/research/groups/speech/publi/2010/mikolov_interspeech2010_IS100722.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&rnnlm&/a&）。语言模型有两个方面的应用：一，基于每个序列在现实世界中出现的可能性对其进行打分，这实际上提供了一个针对语法和语义正确性的度量，语言模型通常为作为机器翻译系统的一部分。二，语言模型可以用来生成新文本。根据莎士比亚的作品训练语言模型可以生成莎士比亚风格的文本。这篇博客（&a href=&https://link.zhihu.com/?target=http%3A//karpathy.github.io//rnn-effectiveness/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&The Unreasonable Effectiveness of Recurrent Neural Networks&/a&）说明了基于RNN的字符级别的语言模型能做什么。&br&
这里假设你已经熟悉一些基本的神经网络。否则的话，你可以先浏览一下这篇文章（&a href=&https://link.zhihu.com/?target=http%3A//www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Implementing A Neural Network From Scratch&/a&），它会带你了解非循环神经网络的一些思想和具体实现。&/p&&p&&b&RNN是什么？&/b&&/p&&p&
RNN背后的思想是利用顺序信息。在传统的神经网络中，我们假设所有的输入（包括输出）之间是相互独立的。对于很多任务来说，这是一个非常糟糕的假设。如果你想预测一个序列中的下一个词，你最好能知道哪些词在它前面。RNN之所以循环的，是因为它针对系列中的每一个元素都执行相同的操作，每一个操作都依赖于之前的计算结果。换一种方式思考，可以认为RNN记忆了到当前为止已经计算过的信息。理论上，RNN可以利用任意长的序列信息，但实际中只能回顾之前的几步。下面是RNN的一个典型结构图：&br&&figure&&img src=&https://pic4.zhimg.com/6ee325d3fbb01e489930a_b.jpg& data-rawwidth=&795& data-rawheight=&319& class=&origin_image zh-lightbox-thumb& width=&795& data-original=&https://pic4.zhimg.com/6ee325d3fbb01e489930a_r.jpg&&&/figure&&/p&&p&上面的图中展示了RNN被展开成一个全网络后的结构。这里展开的意思是把针对整个序列的网络结构表示出来。例如，如果这里我们关心的是一个包含5个词的句子，那这里网络将会被展开成一个5层的网络，每个词对应一层。在RNN中进行的计算公式如下：&br&&/p&&ul&&li&&img src=&https://www.zhihu.com/equation?tex=x_%7Bt%7D+& alt=&x_{t} & eeimg=&1&&是&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&时刻的输入。例如，&img src=&https://www.zhihu.com/equation?tex=x_%7B1%7D+& alt=&x_{1} & eeimg=&1&&是句子中第二个词的&a href=&https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/One-hot& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&one hot&/a&编码向量。&br&&/li&&li&&img src=&https://www.zhihu.com/equation?tex=s_%7Bt%7D+& alt=&s_{t} & eeimg=&1&&是对应&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&时刻的隐藏状态，是网络的记忆单元。&img src=&https://www.zhihu.com/equation?tex=s_%7Bt%7D+& alt=&s_{t} & eeimg=&1&&通过前一步的隐藏状态和当前时刻的输入得到：&img src=&https://www.zhihu.com/equation?tex=s_%7Bt%7D%3Df%28Ux_%7Bt%7D%2BWs_%7Bt-1%7D%29+& alt=&s_{t}=f(Ux_{t}+Ws_{t-1}) & eeimg=&1&&。函数&img src=&https://www.zhihu.com/equation?tex=f& alt=&f& eeimg=&1&&通常是非线性的，例如&a href=&https://link.zhihu.com/?target=https%3A//reference.wolfram.com/language/ref/Tanh.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&tanh&/a&和&a href=&https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Rectifier_%28neural_networks%29& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&ReLU&/a&。&img src=&https://www.zhihu.com/equation?tex=s_%7B-1%7D& alt=&s_{-1}& eeimg=&1&&通常用来计算第一个隐藏状态，会被全0初始化。&br&&/li&&li&&img src=&https://www.zhihu.com/equation?tex=o_%7Bt%7D& alt=&o_{t}& eeimg=&1&&是&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&时刻的输出。例如，如果想要预测句子中的下一个词，那么它就会是包含词表中所有词的一个概率向量，&img src=&https://www.zhihu.com/equation?tex=o_%7Bt%7D%3Dsoftmax%28Vs_%7Bt%7D%29& alt=&o_{t}=softmax(Vs_{t})& eeimg=&1&&。&br&&/li&&/ul&&br&&p&这里有一些需要注意的地方：&br&&/p&&ul&&li&你可以认为隐藏状态&img src=&https://www.zhihu.com/equation?tex=s_%7Bt%7D& alt=&s_{t}& eeimg=&1&&是网络的记忆单元。&img src=&https://www.zhihu.com/equation?tex=s_%7Bt%7D& alt=&s_{t}& eeimg=&1&&可以捕捉到之前所有时刻产生的信息。输出&img src=&https://www.zhihu.com/equation?tex=o_%7Bt%7D& alt=&o_{t}& eeimg=&1&&仅仅依赖于&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&时刻的记忆。就像之前提到的那样，在实际中是比较复杂的，因为&img src=&https://www.zhihu.com/equation?tex=s_%7Bt%7D& alt=&s_{t}& eeimg=&1&&通常难以捕捉许多时刻之前的信息。&br&&/li&&li&与传统深度神经网络中每一层使用不同的参数的做法不同，RNN在所有时刻中共享相同的参数&img src=&https://www.zhihu.com/equation?tex=U%2CV%2CW& alt=&U,V,W& eeimg=&1&&。这反应了在每一步中都在执行相同的任务，只是用了不同的输入。这极大地减少了需要学习的参数的个数。&/li&&li&上面的图中每一时刻都有输出，在具体的任务中，这可能是不必要的。例如，在预测一句话的情感时，我们关心的可能只是最终的输出，并不是每一个词之后的情感。相似地，可能并不是每一时刻都需要输入。RNN的主要特征是它的隐藏状态，可以捕捉一句话中的信息。&/li&&/ul&&br&&b&RNN能做什么？&br&&/b&&p&
RNN在NLP的很多任务中都取得了很大的成功。这里我要提下最常用的RNN类型是&a href=&https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Long_short-term_memory& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&LSTM&/a&，相比于普通的RNN，它更擅长于捕捉长期依赖。但是不要担心，LSTM和我们这个教程里要介绍的RNN本质上是相同的，只是使用了一种不同的方式来计算隐藏状态。在后面的文章中，将会更详细的介绍LSTM。下面是RNN在NLP中的一些应用例子。&br&&b&语言模型和文本生成&br&&/b&给定一个词的序列，我们想预测在前面的词确定之后，每个词出现的概率。语言模型可以度量一个句子出现的可能性，这可以作为机器翻译的一个重要输入（因为出现概率高的句子通常是正确的）。能预测下一个词所带来的额外效果是我们得到了一个生成模型，这可以让我们通过对输出概率采样来生成新的文本。根据训练数据的具体内容，我们可以生成任意东西。在语言模型中，输入通常是词的序列（编码成one hot向量），输出是预测得到的词的序列。在训练网络是，设置&img src=&https://www.zhihu.com/equation?tex=o_%7Bt%7D%3Dx_%7Bt%2B1%7D& alt=&o_{t}=x_{t+1}& eeimg=&1&&，因为我们想要的&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&时刻的输出是下一个词。&br&关于语言模型和文本生成的研究论文：&br&&/p&&ul&&li&&a href=&https://link.zhihu.com/?target=http%3A//www.fit.vutbr.cz/research/groups/speech/publi/2010/mikolov_interspeech2010_IS100722.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Recurrent neural network based language model&/a&&br&&/li&&li&&a href=&https://link.zhihu.com/?target=http%3A//www.fit.vutbr.cz/research/groups/speech/publi/2011/mikolov_icassp.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Extensions of Recurrent neural network based language model&/a&&br&&/li&&li&&a href=&https://link.zhihu.com/?target=http%3A//machinelearning.wustl.edu/mlpapers/paper_files/ICML2011Sutskever_524.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Generating Text with Recurrent Neural Networks&/a&&br&&/li&&/ul&&p&&b&机器翻译&/b&&br&机器翻译与语言模型相似，输入是源语言中的一个词的序列（例如，德语），输出是目标语言（例如，英语）的一个词的序列。一个关键不同点在于在接收到了完整的输入后才会开始输出，因为我们要翻译得到的句子的第一个词可能需要前面整个输入序列的信息。&br&&figure&&img src=&https://pic4.zhimg.com/67b7bcee90c78de34eb00_b.jpg& data-rawwidth=&1024& data-rawheight=&557& class=&origin_image zh-lightbox-thumb& width=&1024& data-original=&https://pic4.zhimg.com/67b7bcee90c78de34eb00_r.jpg&&&/figure&&/p&&p&关于机器翻译的研究论文：&br&&/p&&ul&&li&&a href=&https://link.zhihu.com/?target=http%3A//www.aclweb.org/anthology/P14-1140.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&A Recursive Recurrent Neural Network for Statistical Machine Translation&/a&&br&&/li&&li&&a href=&https://link.zhihu.com/?target=http%3A//papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Sequence to Sequence Learning with Neural Networks&/a&&br&&/li&&li&&a href=&https://link.zhihu.com/?target=http%3A//research.microsoft.com/en-us/um/people/gzweig/Pubs/EMNLP2013RNNMT.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Joint Language and Translation Modeling with Recurrent Neural Networks&/a&&/li&&/ul&&p&&b&语音识别&/b&&br&给定一段从声波中产生的输入声学信号序列，我们想要预测一个语音片段序列及其概率。&br&关于语音识别的研究论文：&br&&/p&&ul&&li&&a href=&https://link.zhihu.com/?target=http%3A//www.jmlr.org/proceedings/papers/v32/graves14.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Towards End-to-End Speech Recognition with Recurrent Neural Networks&/a&&br&&/li&&/ul&&p&&b&图像描述生成&/b&&br&和卷及神经网络一起，RNN可以作为生成无标注图像描述模型的一部分。对于这个如何工作的看起来非常令人惊讶。这个联合模型甚至可以对齐生成的词和图像中的特征。&br&&figure&&img src=&https://pic3.zhimg.com/d4f73ce320_b.jpg& data-rawwidth=&1024& data-rawheight=&349& class=&origin_image zh-lightbox-thumb& width=&1024& data-original=&https://pic3.zhimg.com/d4f73ce320_r.jpg&&&/figure&&/p&&p&&b&RNN训练&/b&&br&训练RNN和训练传统神经网络相似，同样要使用反向传播算法，但会有一些变化。因为参数在网络的所有时刻是共享的，每一次的梯度输出不仅依赖于当前时刻的计算结果，也依赖于之前所有时刻的计算结果。例如，为了计算&img src=&https://www.zhihu.com/equation?tex=t%3D4& alt=&t=4& eeimg=&1&&时刻的梯度，需要反向传播3步，并把前面的所有梯度加和。这被称作随时间的反向传播（BPTT）。如果你现在没有理解，不要担心，后面会有关于更多细节的文章。现在，只要知道普通的用BPTT训练的RNN对于学习长期依赖（相距很长时间的依赖）是很困难的，因为这里存在梯度消失或爆炸问题。当然也存在一些机制来解决这些问题，特定类型的RNN（如LSTM）就是专门设计来解决这些问题的。&br&&/p&&p&&b&RNN扩展&/b&&br&这些年来，研究者们已经提出了更加复杂的RNN类型来克服普通RNN模型的缺点，在后面的博客中会更详细的介绍它们，这一节只是一个简单的概述让你能够熟悉模型的类别。&br&&b&Bidirectional RNN&/b&的思想是&img src=&https://www.zhihu.com/equation?tex=t& alt=&t& eeimg=&1&&时刻的输出不仅依赖于序列中之前的元素，也依赖于之后的元素。例如，要预测一句话中缺失的词，你可能需要左右上下文。Bidirecrtional RNN很直观，只是两个RNN相互堆叠在一起，输出是由两个RNN的隐藏状态计算得到的。&br&&figure&&img src=&https://pic4.zhimg.com/5ddc7f5545bf_b.jpg& data-rawwidth=&300& data-rawheight=&196& class=&content_image& width=&300&&&/figure&Deep （Bidirectional）RNN和Bidirectional RNN相似，只是在每个时刻会有多个隐藏层。在实际中会有更强的学习能力，但也需要更多的训练数据。&br&&figure&&img src=&https://pic1.zhimg.com/5d5a02d59bf_b.jpg& data-rawwidth=&272& data-rawheight=&300& class=&content_image& width=&272&&&/figure&&/p&&p&LSTM network最近非常流行，上面也简单讨论过。LSTM与RNN在结构上并没有本质的不同，只是使用了不同的函数来计算隐藏状态。LSTM中的记忆单元被称为细胞，你可以把它当作是黑盒，它把前一刻的状态&img src=&https://www.zhihu.com/equation?tex=h_%7Bt-1%7D& alt=&h_{t-1}& eeimg=&1&&和当前输入&img src=&https://www.zhihu.com/equation?tex=x_%7Bt%7D& alt=&x_{t}& eeimg=&1&&。内部这些细胞能确定什么被保存在记忆中，什么被从记忆中删除。这些细胞把之前的状态，当前的记忆和输入结合了起来，事实证明这些类型的单元对捕捉长期依赖十分有效。LSTM在刚开始时会让人觉得困惑，如果你想了解更多，这篇博客（&a href=&https://link.zhihu.com/?target=http%3A//colah.github.io/posts/2015-08-Understanding-LSTMs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Understanding LSTM Networks&/a&）有很好的解释。&/p&&p&&b&总结&/b&&br&到目前为止一切都很好，希望你已经对RNN是什么以及能做什么有了基本的了解，在接下来的文章中，我会使用python和theano实现RNN语言模型的第一个版本。&br&&br&&/p&&p&PS:本文是针对&a href=&https://link.zhihu.com/?target=http%3A//www.wildml.com/2015/09/recurrent-neural-networks-tutorial-part-1-introduction-to-rnns/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Recurrent Neural Networks Tutorial, Part 1&/a&这篇文章的中文翻译，主要是为了加深自己的理解，后面还会对后续的文章进行翻译，如果有什么翻译的不好的地方，请参见原文。&/p&
循环神经网络（RNN）是非常流行的模型，在NLP的很多任务中已经展示出了很大的威力。但与此相对的是，能完整解释RNN是如何工作，如何实现的资源非常有限。这也是本教程所要做的事情，本教程打算覆盖下面几个方面的内容：1. RNN简介（本篇） 2. 用python和the…
更新：目前已经翻译了以下几篇笔记：&br&&ul&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&获得授权翻译斯坦福CS231n课程笔记系列 - 智能单元 - 知乎专栏&/a&&br&&/li&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&CS231n课程笔记翻译：Python Numpy教程 - 智能单元 - 知乎专栏&/a&&br&&/li&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&CS231n课程笔记翻译：图像分类笔记（上） - 智能单元 - 知乎专栏&/a&&br&&/li&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&CS231n课程笔记翻译：图像分类笔记（下） - 智能单元 - 知乎专栏&/a&&br&&/li&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&CS231n课程笔记翻译：线性分类笔记（上） - 智能单元 - 知乎专栏&/a&&br&&/li&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&CS231n课程笔记翻译：线性分类笔记（中） - 杜客的文章 - 知乎专栏&/a&&br&&/li&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&CS231n课程笔记翻译：最优化笔记（上） - 智能单元 - 知乎专栏&/a&&br&&/li&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&CS231n课程笔记翻译：最优化笔记（下） - 智能单元 - 知乎专栏&/a&&br&&/li&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&斯坦福CS231n课程作业# 1简介 - 智能单元 - 知乎专栏&/a&&br&&/li&&li&&a href=&https://zhuanlan.zhihu.com/p/?refer=intelligentunit& class=&internal&&CS231n课程笔记翻译：反向传播笔记 - 智能单元 - 知乎专栏&/a&&br&&/li&&/ul&我们按照一周1-2篇的速度更新，每篇阅读量控制在1万字左右，完毕。&br&&br&更新：致力于CS231n课程笔记翻译的专栏&a href=&https://zhuanlan.zhihu.com/intelligentunit& class=&internal&&智能单元 - 知乎专栏&/a&已经创建好。&br&后续我和小伙伴会认真翻译更新的，请大家多多批评吧！啊，能通过这个回答遇到这么多同好，真是特别开心！！&br&&br&更新： &b&周末邮件了@&a href=&//link.zhihu.com/?target=http%3A//cs.stanford.edu/people/karpathy/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Andrej Karpathy&/a&，获得了翻译许可:)&/b&&br&简要说了一些情况，请问他自己如果翻译notes并放在网上供大家学习有无和课程团队的版权问题，也表达了大家对于课程能尽快恢复上线的期望。AK回复截图如下：&br&&figure&&img src=&https://pic2.zhimg.com/50/b90cd7cf10af6a8d607b_b.jpg& data-rawwidth=&1620& data-rawheight=&906& class=&origin_image zh-lightbox-thumb& width=&1620& data-original=&https://pic2.zhimg.com/50/b90cd7cf10af6a8d607b_r.jpg&&&/figure&私信我的很多同好都是在读的学生，表示暑期想要专注学习。希望届时自己的翻译功能能够帮助到大家，不当之处也请大家用力批评。目前同寝室的另外两个小伙伴表示愿意提供帮助，比较开心。&br&&br&&b&请问大家&/b&：我们仨讨论了下，觉得可以采取专栏+微信公众号的方式来发翻译，微信公众号发最新的小段的翻译小节，专栏放整理好的长章节，直至翻译完毕。有阅读需求的同好可以好友我或者私信我提出建议，翻译开始后我也通过私信告知开始。完毕。&br&&br&更新。&b&回复两个问题和推荐另两个优秀回答&/b&：&br&&b&一、YouTube上课程CS231n被下架&/b&&br&@&a href=&http://www.zhihu.com/people/MarsCaveman& class=&internal&&缪禧臻&/a&说CS231n课程看不到了。是的，昨天看了@&a href=&//link.zhihu.com/?target=http%3A//cs.stanford.edu/people/karpathy/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Andrej Karpathy&/a&的推特，说是有人告他们的课程里面有不当的引用和视频侵权什么的，被下架了，现在正在和大学一起想办法。这也真是巧了，就是昨天的事情。&br&&br&&b&针对这个情况，我把自己云盘里面的课程视频、PPT和字幕资源链接出来&/b&，请各位同好使用。资源中视频是高清的，有3课是没有字幕的，其余字幕可能是机器翻译，但是大部分能看，业内的同学应该都能听个明白。&br&&br&地址：&a href=&//link.zhihu.com/?target=http%3A//pan.baidu.com/s/1gfEuAX1& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&pan.baidu.com/s/1gfEuAX&/span&&span class=&invisible&&1&/span&&span class=&ellipsis&&&/span&&/a&&br&提取码：&b&请私信我&/b&。&br&&br&&b&二、为什么不建个群交流&/b&&br&没有良好的管理，任何讨论组的氛围都会很快衰减，学习进程就无法迭代到最优了。限于精力，暂时没有这方面想法。&br&&br&但是自己&b&一直在翻译这个课程的note，后面可能会把翻译发布了，届时各位同好批评指正&/b&，也捧捧场，哈哈！&br&&br&三、&b&另一个好回答&/b&&br&@&a class=&internal& href=&https://www.zhihu.com/people/DOUBI-MIAO&&DOUBI MIAO&/a& 同学的补充回答明显是实践经验，有干货，请大家去点赞求更多干货吧！&br&&br&四、&b&@&a class=&& href=&/people/jiayangqing&&贾扬清&/a& 大神被钓出来了&/b&&br&大神言简意赅地表达了对TF的支持。&br&&br&============================================&br&&b&回答提要：&/b&&br&在斯坦福的&b&CS231n课程中的Lecture12，花了一节课对于主流框架进行了分析比对，非常全面和具有时效性，推荐大家学习&/b&。&br&&br&&b&回答内容：&/b&&br&上面各位机器学习同好说得都带有一定倾向性，且不太全面。&br&&br&其实在斯坦福的CS231n - Convolutional Neural Networks for Visual Recognition(Winter 2016)中的Lecture 12中，由课程讲师@&a href=&//link.zhihu.com/?target=http%3A//cs.stanford.edu/people/jcjohns/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Justin Johnson&/a&详细介绍了他个人对于主流第三方库的实践经历和看法，时间新，干货多，这里简要截取课程Slides如下供大家参考：&br&&br&CS231n的3位讲师：&br&&br&&figure&&img src=&https://pic2.zhimg.com/50/b1ecda58b70726deb1b86ad15edc39e3_b.jpg& data-rawwidth=&632& data-rawheight=&710& class=&origin_image zh-lightbox-thumb& width=&632& data-original=&https://pic2.zhimg.com/50/b1ecda58b70726deb1b86ad15edc39e3_r.jpg&&&/figure&Fei-Fei Li就不说了，大老板，只上了第一节课，然后就哈皮地生孩子去了。后面的课程都是&a href=&//link.zhihu.com/?target=http%3A//cs.stanford.edu/people/karpathy/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Andrej Karpathy&/a& 和&a href=&//link.zhihu.com/?target=http%3A//cs.stanford.edu/people/jcjohns/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Justin Johnson&/a& 两个人承担。&br&其中AK的个人网页看这里：&a href=&//link.zhihu.com/?target=http%3A//cs.stanford.edu/people/karpathy/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Andrej Karpathy Academic Website&/a&&br&其中JJ的个人网页可以看这里：&a href=&//link.zhihu.com/?target=http%3A//cs.stanford.edu/people/jcjohns/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Justin Johnson&/a&&br&两位讲师中，AK语速较快，JJ语速较慢。但是感觉AK比较有激情，自己也比较喜欢AK一些。此人最近已经博士毕业，被Open AI挖走了，哎。&br&&br&在Lecture 12中，JJ对于几个主流的库的应用情况，优缺点逐个做了详细的说明。请各位自行查看。&br&&br&这是在总结部分JJ对于几个库的在Lecture12中的评价：&br&&figure&&img src=&https://pic3.zhimg.com/50/75fc656ef6b3941c63bf_b.jpg& data-rawwidth=&1270& data-rawheight=&720& class=&origin_image zh-lightbox-thumb& width=&1270& data-original=&https://pic3.zhimg.com/50/75fc656ef6b3941c63bf_r.jpg&&&/figure&&br&然后他强调了几个&b&用例问题&/b&：&br&1.Extract &b&AlexNet or VGG features&/b&? Use Caffe&br&&br&2.Fine&b& tune AlexNet for new classes&/b&? Use Caffe&br&&br&3.&b&Image caption with finetuning&/b&?&br&&p&-& Need pretrained models (Caffe, Torch, Lasagne) &/p&&p&-& Need RNNs (Torch or Lasagne)&br&
-& Use Torch or Lasagna &/p&&br&4.&b&Segmentation&/b&？(Classify every pixel)&br&&p&-& Need pretrained model (Caffe, Torch, Lasagna)
-& Need funny loss function&br&
-& If loss function exists in Caffe: Use Caffe&br&-& If you want to write your own loss: Use Torch &/p&&br&&p&5.&b&Object &/b&&b&Detection&/b&?&/p&&p&-& Need pretrained model (Torch, Caffe, Lasagne)&br&
-& Need lots of custom imperative code (NOT Lasagne)
-& Use Caffe + Python or Torch &/p&&br&&p&6.&b&Language &/b&&b&modeling with new RNN structure&/b&?&/p&&p&-& Need easy recurrent nets (NOT Caffe, Torch)&/p&&p&
-& No need for pretrained models&br&
-& Use Theano or TensorFlow &/p&&br&&p&7.&b&Implemente &/b&&b&BatchNorm&/b&?&/p&&p&-& Don’t want to derive gradient? Theano or TensorFlow&/p&&p&-& Implement efficient backward pass? Use Torch &/p&&br&&p&最后，JJ比较个人化地给出了自己的偏好：&/p&&figure&&img src=&https://pic3.zhimg.com/50/162dfaed5ea30a18779ecb0eb9f2378b_b.jpg& data-rawwidth=&1270& data-rawheight=&716& class=&origin_image zh-lightbox-thumb& width=&1270& data-original=&https://pic3.zhimg.com/50/162dfaed5ea30a18779ecb0eb9f2378b_r.jpg&&&/figure&&br&&p&最后，讲一点个人的事情。自己最近正在仔细学习CS231n，收获颇丰。从Reddit的论坛上来看，国内的同好不多，这里也算问一下，有一样在学习的知友没有？可以坐而论道，共同学习。&/p&
更新：目前已经翻译了以下几篇笔记：
&p&最近我仔细看了下AlphaGo在《自然》杂志上发表的文章，写一些分析给大家分享。&br&&/p&&p&AlphaGo这个系统主要由几个部分组成：&/p&&p&1. 走棋网络（Policy Network），给定当前局面，预测/采样下一步的走棋。&/p&&p&2. 快速走子（Fast rollout），目标和1一样，但在适当牺牲走棋质量的条件下，速度要比1快1000倍。 &/p&&p&3. 估值网络（Value Network），给定当前局面，估计是白胜还是黑胜。&/p&&p&4. 蒙特卡罗树搜索（Monte Carlo Tree Search，MCTS)，把以上这三个部分连起来，形成一个完整的系统。&/p&&p&我们的DarkForest和AlphaGo同样是用4搭建的系统。DarkForest较AlphaGo而言，在训练时加强了1，而少了2和3，然后以开源软件Pachi的缺省策略
(default policy)部分替代了2的功能。以下介绍下各部分。&/p&&p&&b&1.走棋网络：&/b&&/p&&p&走棋网络把当前局面作为输入，预测/采样下一步的走棋。它的预测不只给出最强的一手，而是对棋盘上所有可能的下一着给一个分数。棋盘上有361个点，它就给出361个数，好招的分数比坏招要高。DarkForest在这部分有创新，通过在训练时预测三步而非一步，提高了策略输出的质量，和他们在使用增强学习进行自我对局后得到的走棋网络（RL network）的效果相当。当然，他们并没有在最后的系统中使用增强学习后的网络，而是用了直接通过训练学习到的网络（SL
network）,理由是RL
network输出的走棋缺乏变化，对搜索不利。&/p&&figure&&img src=&https://pic4.zhimg.com/ea8e3f813f956c63d21bc4_b.jpg& data-rawwidth=&575& data-rawheight=&320& class=&origin_image zh-lightbox-thumb& width=&575& data-original=&https://pic4.zhimg.com/ea8e3f813f956c63d21bc4_r.jpg&&&/figure&&p&有意思的是在AlphaGo为了速度上的考虑，只用了宽度为192的网络，而并没有使用最好的宽度为384的网络（见图2(a))，所以要是GPU更快一点（或者更多一点），AlphaGo肯定是会变得更强的。&/p&&p&所谓的0.1秒走一步，就是纯粹用这样的网络，下出有最高置信度的合法着法。这种做法一点也没有做搜索，但是大局观非常强，不会陷入局部战斗中，说它建模了“棋感”一点也没有错。我们把DarkForest的走棋网络直接放上KGS就有3d的水平，让所有人都惊叹了下。可以说，这一波围棋AI的突破，主要得益于走棋网络的突破。这个在以前是不可想像的，以前用的是基于规则，或者基于局部形状再加上简单线性分类器训练的走子生成法，需要慢慢调参数年，才有进步。&/p&&p&当然，只用走棋网络问题也很多，就我们在DarkForest上看到的来说，会不顾大小无谓争劫，会无谓脱先，不顾局部死活，对杀出错，等等。有点像高手不经认真思考的随手棋。因为走棋网络没有价值判断功能，只是凭“直觉”在下棋，只有在加了搜索之后，电脑才有价值判断的能力。&/p&&p&&b&2. 快速走子&/b&&/p&&p&那有了走棋网络，为什么还要做快速走子呢？有两个原因，首先走棋网络的运行速度是比较慢的，AlphaGo说是3毫秒，我们这里也差不多，而快速走子能做到几微秒级别，差了1000倍。所以在走棋网络没有返回的时候让CPU不闲着先搜索起来是很重要的，等到网络返回更好的着法后，再更新对应的着法信息。&/p&&p&其次，快速走子可以用来评估盘面。由于天文数字般的可能局面数，围棋的搜索是毫无希望走到底的，搜索到一定程度就要对现有局面做个估分。在没有估值网络的时候，不像国象可以通过算棋子的分数来对盘面做比较精确的估值，围棋盘面的估计得要通过模拟走子来进行，从当前盘面一路走到底，不考虑岔路地算出胜负，然后把胜负值作为当前盘面价值的一个估计。这里有个需要权衡的地方：在同等时间下，模拟走子的质量高，单次估值精度高但走子速度慢；模拟走子速度快乃至使用随机走子，虽然单次估值精度低，但可以多模拟几次算平均值，效果未必不好。所以说，如果有一个质量高又速度快的走子策略，那对于棋力的提高是非常有帮助的。&/p&&p&为了达到这个目标，神经网络的模型就显得太慢，还是要用传统的局部特征匹配（local pattern matching）加线性回归（logistic
regression）的方法，这办法虽然不新但非常好使，几乎所有的广告推荐，竞价排名，新闻排序，都是用的它。与更为传统的基于规则的方案相比，它在吸纳了众多高手对局之后就具备了用梯度下降法自动调参的能力，所以性能提高起来会更快更省心。AlphaGo用这个办法达到了2微秒的走子速度和24.2%的走子准确率。24.2%的意思是说它的最好预测和围棋高手的下子有0.242的概率是重合的，相比之下，走棋网络在GPU上用2毫秒能达到57%的准确率。这里，我们就看到了走子速度和精度的权衡。&/p&&figure&&img src=&https://pic3.zhimg.com/85f83f679dc9a8893eebb_b.jpg& data-rawwidth=&1349& data-rawheight=&566& class=&origin_image zh-lightbox-thumb& width=&1349& data-original=&https://pic3.zhimg.com/85f83f679dc9a8893eebb_r.jpg&&&/figure&&p&和训练深度学习模型不同，快速走子用到了局部特征匹配，自然需要一些围棋的领域知识来选择局部特征。对此AlphaGo只提供了局部特征的数目（见Extended Table 4)，而没有说明特征的具体细节。我最近也实验了他们的办法，达到了25.1%的准确率和4-5微秒的走子速度，然而全系统整合下来并没有复现他们的水平。我感觉上24.2%并不能完全概括他们快速走子的棋力，因为只要走错关键的一步，局面判断就完全错误了；而图2(b)更能体现他们快速走子对盘面形势估计的精确度，要能达到他们图2(b)这样的水准，比简单地匹配24.2%要做更多的工作，而他们并未在文章中强调这一点。&/p&&figure&&img src=&https://pic3.zhimg.com/b9e68dd3b2836afece45bf_b.jpg& data-rawwidth=&568& data-rawheight=&322& class=&origin_image zh-lightbox-thumb& width=&568& data-original=&https://pic3.zhimg.com/b9e68dd3b2836afece45bf_r.jpg&&&/figure&&p&在AlphaGo有了快速走子之后，不需要走棋网络和估值网络，不借助任何深度学习和GPU的帮助，不使用增强学习，在单机上就已经达到了3d的水平（见Extended Table 7倒数第二行)，这是相当厉害的了。任何使用传统方法在单机上达到这个水平的围棋程序，都需要花费数年的时间。在AlphaGo之前，Aja Huang曾经自己写过非常不错的围棋程序，在这方面相信是有很多的积累的。&br&&/p&&p&&b&3. 估值网络&/b&&/p&&figure&&img src=&https://pic3.zhimg.com/f99c6bbdd2f404c12a16a13_b.jpg& data-rawwidth=&1374& data-rawheight=&535& class=&origin_image zh-lightbox-thumb& width=&1374& data-original=&https://pic3.zhimg.com/f99c6bbdd2f404c12a16a13_r.jpg&&&/figure&&p&AlphaGo的估值网络可以说是锦上添花的部分，从Fig 2(b)和Extended
Table 7来看，没有它AlphaGo也不会变得太弱，至少还是会在7d-8d的水平。少了估值网络，等级分少了480分，但是少了走棋网络，等级分就会少掉800至1000分。特别有意思的是，如果只用估值网络来评估局面（2177），那其效果还不及只用快速走子（2416），只有将两个合起来才有更大的提高。我的猜测是，估值网络和快速走子对盘面估计是互补的，在棋局一开始时，大家下得比较和气，估值网络会比较重要；但在有复杂的死活或是对杀时，通过快速走子来估计盘面就变得更重要了。考虑到估值网络是整个系统中最难训练的部分（需要三千万局自我对局），我猜测它是最晚做出来并且最有可能能进一步提高的。&/p&&p&关于估值网络训练数据的生成，值得注意的是文章中的附录小字部分。与走棋网络不同，每一盘棋只取一个样本来训练以避免过拟合，不然对同一对局而言输入稍有不同而输出都相同，对训练是非常不利的。这就是为什么需要三千万局，而非三千万个盘面的原因。对于每局自我对局，取样本是很有讲究的，先用SL network保证走棋的多样性，然后随机走子，取盘面，然后用更精确的RL
network走到底以得到最正确的胜负估计。当然这样做的效果比用单一网络相比好多少，我不好说。&/p&&p&一个让我吃惊的地方是，他们完全没有做任何局部死活/对杀分析，纯粹是用暴力训练法训练出一个相当不错的估值网络。这在一定程度上说明深度卷积网络（DCNN）有自动将问题分解成子问题，并分别解决的能力。&/p&&p&另外，我猜测他们在取训练样本时，判定最终胜负用的是中国规则。所以说三月和李世石对局的时候也要求用中国规则，不然如果换成别的规则，就需要重新训练估值网络（虽然我估计结果差距不会太大）。至于为什么一开始就用的中国规则，我的猜测是编程非常方便（我在写DarkForest的时候也是这样觉得的）。&/p&&p&&b&4. 蒙特卡罗树搜索&/b&&/p&&p&这部分基本用的是传统方法，没有太多可以评论的，他们用的是带先验的UCT，即先考虑DCNN认为比较好的着法，然后等到每个着法探索次数多了，选择更相信探索得来的胜率值。而DarkForest则直接选了DCNN推荐的前3或是前5的着法进行搜索。我初步试验下来效果差不多，当然他们的办法更灵活些，在允许使用大量搜索次数的情况下，他们的办法可以找到一些DCNN认为不好但却对局面至关重要的着法。&/p&&p&一个有趣的地方是在每次搜索到叶子节点时，没有立即展开叶子节点，而是等到访问次数到达一定数目(40)才展开，这样避免产生太多的分支，分散搜索的注意力，也能节省GPU的宝贵资源，同时在展开时，对叶节点的盘面估值会更准确些。除此之外，他们也用了一些技巧，以在搜索一开始时，避免多个线程同时搜索一路变化，这部分我们在DarkForest中也注意到了，并且做了改进。&/p&&p&&b&5. 总结&/b&&br&&/p&&p&总的来说，这整篇文章是一个系统性的工作，而不是一两个小点有了突破就能达到的胜利。在成功背后，是作者们，特别是两位第一作者David Silver和Aja Huang，在博士阶段及毕业以后五年以上的积累，非一朝一夕所能完成的。他们能做出AlphaGo并享有现在的荣誉，是实至名归的。&/p&&p&从以上分析也可以看出，与之前的围棋系统相比，AlphaGo较少依赖围棋的领域知识，但还远未达到通用系统的程度。职业棋手可以在看过了寥寥几局之后明白对手的风格并采取相应策略，一位资深游戏玩家也可以在玩一个新游戏几次后很快上手，但到目前为止，人工智能系统要达到人类水平，还是需要大量样本的训练的。可以说，没有千年来众多棋手在围棋上的积累，就没有围棋AI的今天。&/p&&p&在AlphaGo中，增强学习（Reinforcement Learning）所扮演的角色并没有想像中那么大。在理想情况下，我们希望人工智能系统能在对局中动态地适应环境和对手的招式并且找到办法反制之，但是在AlphaGo中增强学习更多地是用于提供更多质量更好的样本，给有监督学习（Supervised Learning）以训练出更好的模型。在这方面增强学习还有很长的路要走。&/p&&p&另外，据他们的文章所言，AlphaGo整个系统在单机上已具有了职业水平，若是谷歌愿意开几万台机器和李世石对决（这对它来说再容易不过了，改个参数就行），相信比赛会非常精彩。 &/p&&p&===========================&/p&&p&一些更新。&/p&&p&问题1：“Alphago的MCTS做rollout的时候，除了使用快速走子，还用了搜索树的已有部分，看起来像是AMAF/RAVE反过来：AMAF是把快速走子的信息传导到树的其它无关部分，Alphago是把树的其它无关部分拿来增强快速走子。我怀疑这是不是它棋力比其它DCNN+MCTS强的原因之一。&&/p&&p&这个办法在解死活题的文章中出现过，会在一定程度上提高搜索效率，但是提高多少还不知道。&/p&&p&问题2：“rollout的走法质量变好可能会导致棋力下降。”&br&&/p&&p&这里要分两种情况，tree policy和default policy。在AlphaGo的文章里面已经说过了，tree policy的分布不能太尖，不然在搜索时太过重视一些看起来的好着，可能使得棋力下降。但是除了这种原因，一般来说tree policy变好棋力还是会变强的。&/p&&p&default policy这边，即（半）随机走子到最后然后判分，就很复杂了，质量变好未必对局面能估得更准。default policy需要保证的是每块棋的死活大体正确，不要把死的棋下成活的或者反之，而对大局观的要求反而没有那么高。双方完全可以配合着把每块棋下完，然后转战另一块，而不是说抢在对方前去别处占先手。&/p&
最近我仔细看了下AlphaGo在《自然》杂志上发表的文章，写一些分析给大家分享。 AlphaGo这个系统主要由几个部分组成：1. 走棋网络（Policy Network），给定当前局面，预测/采样下一步的走棋。2. 快速走子（Fast rollout），目标和1一样，但在适当牺牲走棋质…
&figure&&img src=&https://pic1.zhimg.com/v2-871abd249d9a840f6dcf6f_b.jpg& data-rawwidth=&979& data-rawheight=&512& class=&origin_image zh-lightbox-thumb& width=&979& data-original=&https://pic1.zhimg.com/v2-871abd249d9a840f6dcf6f_r.jpg&&&/figure&说起来，theano也用了很长时间了，对安装这一套理应感觉非常熟练，不过好像这个新的GpuBackend的安装花费了我大量的时间，因此特意写下这篇教程，为各位铺路。&p&让我们回到3月初的某一天，升级了theano的0.9某一版本。起初感觉并没什么特别的，不过导入时的一个警告引起了我的注意。&/p&&blockquote&The old CUDA backend will be deprecated soon, in favor of the new libgpuarray backend.&/blockquote&大概意思是：老的Gpu后端要过期啦，请尽快升级！&p&这用的好好的，干嘛升级呢，不管他。不过，过了两天，我使用的翻译工具包nematus的&a href=&https://link.zhihu.com/?target=https%3A//github.com/rsennrich/nematus& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&官网&/a&上出现了下面一段对比：&/p&&blockquote&&p&GPU, CuDNN 5.1, theano 0.9.0dev5.dev-d5520e:&/p&&p&THEANO_FLAGS=mode=FAST_RUN,floatX=float32,device=gpu ./test_train.sh&/p&&p&173.15 sentences/s&/p&&p&GPU, CuDNN 5.1, theano 0.9.0dev5.dev-d5520e, new GPU backend:&/p&&p&THEANO_FLAGS=mode=FAST_RUN,floatX=float32,device=cuda ./test_train.sh&/p&&p&209.21 sentences/s&/p&&/blockquote&&p&这个速度提升还不小，那赶紧行动吧，点击warning里的&a href=&https://link.zhihu.com/?target=http%3A//deeplearning.net/software/theano/tutorial/using_gpu.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&网址&/a&，你会看到这样一段介绍：&/p&&blockquote&Using the GPU in Theano is as simple as setting the device configuration flag to device=cuda (or device=gpu for the old backend). You can optionally target a specific gpu by specifying the number of the gpu as in e.g. device=cuda2. You also need to set the default floating point precision. For example: THEANO_FLAGS='cuda.root=/path/to/cuda/root,device=cuda,floatX=float32'. You can also set these options in the .theanorc file’s [global] section:&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&[global]
device = cuda
floatX = float32
&/code&&/pre&&/div&&/blockquote&&p&哇，看起来好简单，只要把device从gpu改成cuda就行啦！看到这，是不是有人觉得就把gpu改成cuda，这篇教程也太简单了吧！别急，这只是噩梦的开始。&br&导入后会发现提示pygpu没有安装，继续回到上一次的那个页面，翻到Installation章节，他会告诉你如果是使用conda安装的，那么就执行&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&conda install pygpu theano
&/code&&/pre&&/div&&p&否则呢，就先&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&pip install theano
&/code&&/pre&&/div&&p&再去按照另一个&a href=&https://link.zhihu.com/?target=http%3A//deeplearning.net/software/libgpuarray/installation.html%23windows-specific-instructions& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&官方教程&/a&安装libgpuarray&/p&&p&如果你走第一条路，你会发现安装过程一路顺风，但是导入过程中会发生找不到cudnn.lib的问题。那遵照官方repo的issue里的&a href=&https://link.zhihu.com/?target=https%3A//github.com/Theano/libgpuarray/issues/264& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&解决方案&/a&，会让你在.theanorc文件中添加如下一段代码：&/p&&blockquote&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&[dnn]
enabled = True
include_path=C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v8.0/include
library_path=C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v8.0/lib/x64
&/code&&/pre&&/div&&/blockquote&&p&改完你会发现，哇！竟然闪退了！第一条路，Die！&/p&&p&那第二条路呢，感觉更加惨，官方的教程会让我们用cmake编译一个库，有很大的可能性你无法完成编译，就算你完成了编译，又会回到第一条路上，还是Die!&/p&&p&那怎么办，就这么结束了吗？上面说的的issue更新了一段，总结了新的安装过程：&/p&&p&1. 卸载并重新安装Anaconda或者Miniconda&/p&&p&2. 配置清华镜像，当然大多数教程包括官网的教程都会是下面两行代码：&br&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --set show_channel_urls yes
&/code&&/pre&&/div&&p&我建议大家可以加上他们新&a href=&https://link.zhihu.com/?target=https%3A//github.com/tuna/issues/issues/112& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&推出&/a&的msys2第三方通道，代码如下：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/
&/code&&/pre&&/div&&p&这样后面的某些库就不需要跑到官方源去下载了。&/p&&p&3. 安装一些theano的依赖库，参考官方的&a href=&https://link.zhihu.com/?target=http%3A//deeplearning.net/software/theano/install_windows.html%23gpu-windows& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&安装教程&/a&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&conda install numpy scipy mkl-service libpython m2w64-toolchain nose
&/code&&/pre&&/div&4. 安装theano和pygpu&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&conda install pygpu theano
&/code&&/pre&&/div&&p&5. 清理theano的缓存，如果出错，请保证theano没有在运行，实在不行就用管理员权限。如果出现问题，可以每次在编译失败后都使用这条指令。&br&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&theano-cache purge
&/code&&/pre&&/div&大多数的用户到这里应该都是没问题了，包括我自己。不过呢，最近帮几个同学安装的时候，发现了几个新的问题，大家可以参考一下。&br&首先是这样一个&a href=&https://link.zhihu.com/?target=https%3A//github.com/Theano/libgpuarray/issues/407& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&问题&/a&。&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&&&& import theano
ERROR (theano.gpuarray): Could not initialize pygpu, support disabled
Traceback (most recent call last):
File &/usr/local/lib/python3.5/dist-packages/theano/gpuarray/__init__.py&, line 175, in &module&
use(config.device)
File &/usr/local/lib/python3.5/dist-packages/theano/gpuarray/__init__.py&, line 162, in use
init_dev(device, preallocate=preallocate)
File &/usr/local/lib/python3.5/dist-packages/theano/gpuarray/__init__.py&, line 65, in init_dev
sched=config.gpuarray.sched)
File &pygpu/gpuarray.pyx&, line 614, in pygpu.gpuarray.init (pygpu/gpuarray.c:9419)
File &pygpu/gpuarray.pyx&, line 566, in pygpu.gpuarray.pygpu_init (pygpu/gpuarray.c:9110)
File &pygpu/gpuarray.pyx&, line 1021, in pygpu.gpuarray.GpuContext.__cinit__ (pygpu/gpuarray.c:13472)
pygpu.gpuarray.GpuArrayException: Error loading library: -1
&/code&&/pre&&/div&&p&这是我第一次在别人机器上安装时遇到的，我的解决方案在issue也写了，就是升级CUDA版本到8.0.61及以上，cudnn升级到5.1版本，当然尽量把显卡驱动的版本也进行升级。&/p&&p&当然我遇到最棘手的是这样一个&a href=&https://link.zhihu.com/?target=https%3A//github.com/Theano/Theano/issues/5831& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&问题&/a&。&/p&&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&&&& import theano
ERROR (theano.gpuarray): Could not initialize pygpu, support disabled
Traceback (most recent call last):
File &C:\Users\I\Anaconda2\lib\site-packages\theano\gpuarray\__init__.py&, line 164, in &module&
use(config.device)
File &C:\Users\I\Anaconda2\lib\site-packages\theano\gpuarray\__init__.py&, line 151, in use
init_dev(device)
File &C:\Users\I\Anaconda2\lib\site-packages\theano\gpuarray\__init__.py&, line 66, in init_dev
avail = dnn.dnn_available(name)
File &C:\Users\I\Anaconda2\lib\site-packages\theano\gpuarray\dnn.py&, line 174, in dnn_available
if not dnn_present():
File &C:\Users\I\Anaconda2\lib\site-packages\theano\gpuarray\dnn.py&, line 165, in dnn_present dnn_present.msg)
RuntimeError: You enabled cuDNN, but we aren't able to use it: cannot compile with cuDNN.
We got this error:
In file included from C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0\include/driver_types.h:53:0,
from C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0\include/cudnn.h:63,
from c:\users\iotlab\appdata\local\temp\try_flags_5jgpcp.c:4:
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0\include/host_defines.h:84:0: warning: &__cdecl& redefined
#define __cdecl
&built-in&: note: this is the location of the previous definition
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0\lib\x64/cudnn.lib: error adding symbols: File in wrong format
collect2.exe: error: ld returned 1 exit status
&/code&&/pre&&/div&&br&这个问题重装了VS，Anaconda，驱动都无济于事，正当我准备放弃时，发现了repo的这样一个&a href=&https://link.zhihu.com/?target=https%3A//github.com/Theano/Theano/issues/5838& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&issue&/a&，说是在cmd里能正常导入theano，然而在jupyter notebook中却会报这样的错误。我一抖机灵，赶紧使用jupyter console导入了theano，竟然一切正常。&br&&figure&&img src=&https://pic3.zhimg.com/v2-ef25c351b2cf4b4ac702b9_b.jpg& data-rawwidth=&1156& data-rawheight=&318& class=&origin_image zh-lightbox-thumb& width=&1156& data-original=&https://pic3.zhimg.com/v2-ef25c351b2cf4b4ac702b9_r.jpg&&&/figure&不敢相信这竟然是同一台计算机上发生的。不过呢，这个现象的产生我大概搞明白了问题的产生原因，theano的c++编译器不固定导致的。于是呢，去搜索theano.config的文档，问题就迎刃而解了。解决方案可以看issue描述，我这里也介绍一遍，&br&首先在.theanorc文件的[global]部分，添加一个参数cxx，如下：&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&cxx=C:\Anaconda2\Library\mingw-w64\bin\g++.exe
&/code&&/pre&&/div&接着将目录添加进环境变量PATH中，以上面的路径为例，即为&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&C:\Anaconda2\Library\mingw-w64\bin
&/code&&/pre&&/div&重新打开cmd,让环境变量生效，接着import theano，你会发现奇迹出现了：&br&&figure&&img src=&https://pic4.zhimg.com/v2-365a038b06b6b544b02d_b.jpg& data-rawwidth=&480& data-rawheight=&131& class=&origin_image zh-lightbox-thumb& width=&480& data-original=&https://pic4.zhimg.com/v2-365a038b06b6b544b02d_r.jpg&&&/figure&以上，就是文章的全部内容啦，如果感觉还意犹未尽的话，可以给我的Github &a href=&https://link.zhihu.com/?target=https%3A//github.com/peterjc123& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&主页&/a&或者项目加个watch或者star之类的（滑稽），以后说不定还会再分享一些相关的经验。
说起来，theano也用了很长时间了，对安装这一套理应感觉非常熟练，不过好像这个新的GpuBackend的安装花费了我大量的时间，因此特意写下这篇教程，为各位铺路。让我们回到3月初的某一天，升级了theano的0.9某一版本。起初感觉并没什么特别的，不过导入时的一…
&b&1. 平台选用：&/b&&p&
首先需要选择平台：Win7 64位系统，Python选择Anaconda，Theano与Keras选择最新版即可，Cuda的选择与你的GPU型号有关（这个一定要注意，我用的GTX1060，结果选择Cuda 7.5 一直配置不好，原来Cuda 8.0才支持这个显卡），Visual Studio选择2013比较好（VS15的update3不支持Cuda8.0，VS版本低，也不支持，真的是好坑 ）&/p&&p&&b&2. 安装流程：&/b&&/p&&p&
安装主要分为两个部分：1）VS与CUDA的安装；2）Anaconda，Theano与Keras。注意系统是Win7 64位，其它系统的请绕行。&/p&&p&
1）VS与CUDA的安装&/p&&p&
选择VS2013旗舰版，安装好以后，一定要注意激活，具体怎么激活可以百度。这里遇坑就是脑子一热选择了VS2015的update3版本，结果发现没有办法编译CUDA8.0，上论坛，好多人说VS2015的update3版本不支持CUDA8.0，真的是一脸泪。所以很&b&推荐使用VS2013&/b&，可以编译CUDA8.0及以下的版本。&/p&&p&
然后安装CUDA8.0，如果是GTX1060等显卡，是可以直接精简安装的，亲测。遇坑：我开始使用的显卡是GT630，比较low，然后上的CUDA7.5，直接精简安装，总是出错，后来，直接去掉显卡驱动的安装，就OK了；上GTX1060以后，也安装CUDA7.5，发现总装不好，才知道7.5是不支持GTX1060的，浪费我好多时间。其实&b&CUDA直接上最新的版本就可以了&/b&，只不过比较低端的显卡安装时，选择自定义安装，&b&不安装显卡驱动就可以了&/b&。&/p&&p&
2）Anaconda，Theano与Keras&/p&&p&
安装这几个本来是很快的，但一直没想到Anaconda也会有坑，被坑了好久。&/p&&p&
2.1) 安装Anaconda时，千万别安装Python 3.5版本的，总显示GPU不能使用。而且千万别安装spyder3系列，即Anaconda4.2.0以上。而应该&b&Python 选择2.7，spyder选择2系列，即Anaconda4.1.1版本及以下&/b&。原因是什么呢？因为spyder3总是不调用ipythonw.exe解释器，而调用ipython.exe，导致theano编译的时候，总是弹窗nvcc.exe，我当时一直找不到原因，因为没有想到Anaconda也会有坑。
这个坑算很多人都没有踩到，导致我找原因找了很长时间。如果想看这个坑，这里有我github上的提问：&a href=&https://link.zhihu.com/?target=https%3A//github.com/Theano/Theano/issues/5114& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Can any guys help me: nvcc.exe popup when theano compiles? · Issue #5114 · Theano/Theano · GitHub&/a&&/p&&p&
同时安装Anaconda时，&b&路径里一定不要有空格&/b&，要不然后面Theano依赖的G++库会出错，好像不认有空格的路径。当时也是年轻，直接装到E:\Program Files里了，一脸的泪。有人推荐在安装完Anaconda，在系统环境变量里添加C:\Anaconda2;C:\Anaconda2\S
这个&b&一般没有必要&/b&，Anaconda在安装时，就已经添加了（这里我装到把Anaconda2直接装到C盘根目录了）。&/p&&br&&p&
2.2) 安装Theano其实很简单，装好Anaconda以后，直接在Anaconda prompt或windows的cmd里输入
conda install mingw libpython，把G++装一下，安装完后，会在Anaconda 里看到MinGW的目录，同时在系统变量里添加相应的环境变量： C:\Anaconda2\MinGW\C:\Anaconda2\MinGW\x86_64-w64-mingw32\ 。&/p&&p&
然后直接pip install theano就好了。这里有一个坑，就是有很多人推荐：在用户变量中新建变量pythonpath = C:\Anaconda2\Lib\site-packages\
然后被坑了一把。完全没有必要，而且会导致spyder启动时弹窗，kernel died等问题，这个是我亲测，搞了一天。。。&/p&&p&
直接pip theano有一个问题，就是编译时会显示debug的信息，这个可以通过安装theano develop版本解决。即在github下载最新的theano的zip文件，解压后是theano-master，把里面的theano文件直接拷出来，替换原来在C:\Anaconda2\Lib\site-packages\theano的文件。但不替换也可以，不影响使用。&/p&&p&
安装完后，要配置.theanorc.txt，直接参考&a href=&https://link.zhihu.com/?target=http%3A//blog.csdn.net/niuwei22007/article/details/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&小白Windows7/10 64Bit安装Theano并实现GPU加速(没有MinGw等，详细步骤)&/a&里的第8步就好。注：我一开始就是看的这个教程，没想到还踩了无数的坑。。。&/p&&p&
2.3) 安装Keras.
直接pip就好，没啥说的。。。然后就又有坑了。。。Anaconda4.1.1使用的ipython console在运行keras的model.fit时，会有坑，即运行一会儿显示I/O错误，这里主要是ipython 内核的问题，更新一下就好了。可以参考&a href=&https://link.zhihu.com/?target=https%3A//github.com/fchollet/keras/issues/2110& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&model.fit ValueError: I/O operation on closed file · Issue #2110 · fchollet/keras · GitHub&/a&, 里面也有我的回复^^。&br&&/p&&p&&b&3. 总结&/b&&/p&&p&
没有想到用别人的工具也这么难，前前后后花了我一周时间趟坑。所以把它们写下来，希望可以帮助到别人。 最后，本人水平有限，如果有什么理解不到位的地方，请指正。&/p&
1. 平台选用： 首先需要选择平台：Win7 64位系统，Python选择Anaconda，Theano与Keras选择最新版即可，Cuda的选择与你的GPU型号有关（这个一定要注意，我用的GTX1060，结果选择Cuda 7.5 一直配置不好，原来Cuda 8.0才支持这个显卡），Visual Studio选择2013…
&p&今天早上起来看到这篇文章火了，主要爆点是长达93页的附录证明。下面是附录的一页，你们感受一下（让我们一起心疼reviewer一秒）：&/p&&figure&&img src=&https://pic2.zhimg.com/50/v2-c2e449f06b079ddae10ad_b.jpg& data-rawwidth=&1720& data-rawheight=&1044& class=&origin_image zh-lightbox-thumb& width=&1720& data-original=&https://pic2.zhimg.com/50/v2-c2e449f06b079ddae10ad_r.jpg&&&/figure&&p&而这篇文章的实现却简短的醉人，只有5行：&/p&&figure&&img src=&https://pic3.zhimg.com/50/v2-e9eda63caf103fd4b88f_b.jpg& data-rawwidth=&1070& data-rawheight=&208& class=&origin_image zh-lightbox-thumb& width=&1070& data-original=&https://pic3.zhimg.com/50/v2-e9eda63caf103fd4b88f_r.jpg&&&/figure&&p&我刚刚在飞机上看完了正文，并扫了一眼附录。其实证明思路并不复杂，但是场面十分暴力，满篇复杂不等式求值，还上了电脑辅助证明。作者为了证明过程严谨，还引用了IEEE浮点数的精度保证。。。&/p&&p&先说两句题外话，我认为这篇文章才是深度学习理论研究的正确方向，作者通过求解不动点，设计出了一个新颖的自稳定激活函数，保证训练过程中梯度不会爆炸或消失。而且定理的假设非常弱，作用域非常大，直觉很容易理解。读完证明的感觉是如果那93页的附录没错，那么这个方法就一定会好用，这样才是好理论。&/p&&p&反观很多鸡汤理论，用一车极强的假设，证出一个松到天上的bound，假装解释了一个已经被实践广泛证明好用的算法，实际上原来的算法已经被relax的妈都不认识了。搞理论的证完了心满意足，搞实验的看了感觉就像喝了一碗鸡汤，喝完了该干嘛干嘛，对未来探索新的算法一点具体的启发都没有。&/p&&br&&p&==========================正题的分割线=========================&/p&&p&听我吹了一波以后有兴趣的同学可以自己看证明，我这里主要讲一下直观理解。文章提出的新激活函数很简单：&/p&&figure&&img src=&https://pic1.zhimg.com/50/v2-cc6bf642ed54_b.jpg& data-rawwidth=&1090& data-rawheight=&90& class=&origin_image zh-lightbox-thumb& width=&1090& data-original=&https://pic1.zhimg.com/50/v2-cc6bf642ed54_r.jpg&&&/figure&&p&其实就是ELU乘了个lambda，关键在于这个lambda是大于1的。以前relu，prelu，elu这些激活函数，都是在负半轴坡度平缓，这样在activation的方差过大的时候可以让它减小，防止了梯度爆炸，但是正半轴坡度简单的设成了1。而selu的正半轴大于1，在方差过小的的时候可以让它增大，同时防止了梯度消失。这样激活函数就有一个不动点，网络深了以后每一层的输出都是均值为0方差为1。&/p&&br&&p&美中不足的是这篇论文实验比较弱，但是因为理论很赞，我认为不能成为否定selu的理由，可能只是因为作者的预算或者码力受限吧。另外个人认为没有做cifar，imagenet这些原因是selu的强项是全连接网络，在CNN上不一定好用。可以期待后续在kaggle数据挖掘任务上面的表现。&/p&
今天早上起来看到这篇文章火了，主要爆点是长达93页的附录证明。下面是附录的一页，你们感受一下（让我们一起心疼reviewer一秒）：而这篇文章的实现却简短的醉人，只有5行：我刚刚在飞机上看完了正文，并扫了一眼附录。其实证明思路并不复杂，但是场面十分…
&p&谢&a class=&member_mention& href=&//www.zhihu.com/people/6cd383d2c9c8c293a0e85a9fecda5c67& data-hash=&6cd383d2c9c8c293a0e85a9fecda5c67& data-hovercard=&p$b$6cd383d2c9c8c293a0e85a9fecda5c67&&@Saika&/a&邀&/p&&p&
目前 close-talk 的语音识别已经达到了很高的识别精度（或者也用词错误率来衡量），在干净环境下性能最好的系统之一，是去年微软用LACEA（微软提出的一种神经网络结构的名字，如下图）在switchboard数据集上已经把词错误率降到了5.8%，比人类标注还要好。也许你在使用Siri的时候会发现，如果把手机拿远一点，Siri就gg了。这里主要的原因是人说话的语音信号与手机麦克风所采拾的环境噪声之间信噪比（SNR）较小，噪声影响了正常识别系统的性能，这里的噪声包括环境的背景音，以及声音的混响（reverberation）。&/p&&br&&figure&&img src=&https://pic4.zhimg.com/50/v2-15d9a29f0cf89f1c831fe8bba5646053_b.jpg& data-rawwidth=&537& data-rawheight=&535& class=&origin_image zh-lightbox-thumb& width=&537& data-original=&https://pic4.zhimg.com/50/v2-15d9a29f0cf89f1c831fe8bba5646053_r.jpg&&&/figure&&p&(LACEA 神经网络结构示意图)&/p&&p&
至于为什么会影响识别性能，就要从识别的原理来说明了。以下我会用我的大白话来讲解（想补充的时候再加入公式和科学术语），原因也只能是部分原因，真实的环境和模型会复杂得多，我也讲不全。语音识别主要分为两步，第一步是把声音信号转录成音素序列，由声学模型负责，第二步是把得到的音素序列转化成文字，由语言模型负责；只要把第一步做准确，第二步可以用现有的技术同样处理，那我就只讲第一步了。声学模型的原理是，将语音信号（帧）输入给模型，比如神经网络，得到了这帧可能的音素（分类过程）。&/p&&p&
在干净环境（SNR较大），每种音素的数据分布都在训练集里见过，噪声导致的误差并不大，现有模型足够完美分类。可是在嘈杂环境下（SNR较小），噪声种类千变万化，导致每种音素的分布在各个方向偏移较大，数据分布变得复杂，使得需要更复杂的分类器，甚至也不一定能区分。&/p&&p&
下图是一张数据分布示意，假设每种颜色代表一类音素，每个点是该音素叠加上噪声后在空间里的位置，但是真实情况复杂得多得多！&/p&&br&&figure&&img src=&https://pic1.zhimg.com/50/v2-1e8c539ceba9c36b062debb904ccb36e_b.jpg& data-rawwidth=&1000& data-rawheight=&700& class=&origin_image zh-lightbox-thumb& width=&1000& data-original=&https://pic1.zhimg.com/50/v2-1e8c539ceba9c36b062debb904ccb36e_r.jpg&&&/figure&&br&&p&以上就是噪声造成的主要难点！&/p&&p&
目前采用的方法可以有：使用麦克风阵列采集多个信源的信号，综合分析出噪声和语音;另外也有一些信号分离或者语音增强的方法可以做。&/p&&p&
下面我来说一个噪声环境下有趣的问题---&b&鸡尾酒会问题（cock-tail party)&/b&，采集到的语音里有多个人同时说话，而我们希望识别出每个说话人的内容。这个的主要解决方法就是信号分离相关的了，我身边的小伙伴们也有在研究这方面的问题。&/p&&p&十分感谢&a class=&member_mention& href=&//www.zhihu.com/people/5eb23b17e9aa7ca509225& data-hash=&5eb23b17e9aa7ca509225& data-hovercard=&p$b$5eb23b17e9aa7ca509225&&@hahatt&/a&的帮助！&/p&&p&（以上写得比较粗糙，等我有空再来修改）&/p&
谢邀 目前 close-talk 的语音识别已经达到了很高的识别精度（或者也用词错误率来衡量），在干净环境下性能最好的系统之一，是去年微软用LACEA（微软提出的一种神经网络结构的名字，如下图）在switchboard数据集上已经把词错误率降到了5.8%，比人类标…
&figure&&img src=&https://pic2.zhimg.com/v2-b7d9ba7e3e1ba2971821_b.jpg& data-rawwidth=&850& data-rawheight=&569& class=&origin_image zh-lightbox-thumb& width=&850& data-original=&https://pic2.zhimg.com/v2-b7d9ba7e3e1ba2971821_r.jpg&&&/figure&&h2&&b&介绍&/b&&/h2&&p&上一节在《&a href=&http://link.zhihu.com/?target=https%3A//yjango.gitbooks.io/superorganism/content/lstmgru.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&循环神经网络——实现LSTM&/a&》中介绍了循环神经网络目前最流行的实现方法LSTM和GRU，这一节就演示如何利用Tensorflow来搭建LSTM网络。
代码LV1是指本次的演示是最核心的code，并没有多余的功能。
为了更深刻的理解LSTM的结构，这次所用的并非是tensorflow自带的rnn_cell类，而是从新编写，并且用scan来实现graph里的loop (动态RNN)。&/p&&h2&&b&任务描述：&/b&&/h2&&p&这次所要学习的模型依然是&a href=&http://link.zhihu.com/?target=https%3A//yjango.gitbooks.io/superorganism/content/%25E4%25BB%25A3%25E7%25A0%%25BC%%25A4%25BAlv3.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&代码演示LV3&/a&中的用声音来预测口腔移动，没有阅读的朋友请先阅读链接中的章节对于任务的描述。同时拿链接中的前馈神经网络与循环神经网络进行比较。&/p&&h2&&b&处理训练数据&/b&&/h2&&ul&&li&目的：减掉每句数据的平均值，除以每句数据的标准差，降低模型拟合难度。&/li&&li&代码：&/li&&/ul&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&# 所需库包
import tensorflow as tf
import numpy as np
import time
import matplotlib.pyplot as plt
%matplotlib inline
# 直接使用在代码演示LV3中定义的function
def Standardize(seq):
#subtract mean
centerized=seq-np.mean(seq, axis = 0)
#divide standard deviation
normalized=centerized/np.std(centerized, axis = 0)
return normalized
# 读取输入和输出数据
mfc=np.load('X.npy')
art=np.load('Y.npy')
totalsamples=len(mfc)
# 20%的数据作为validation set
vali_size=0.2
# 将每个样本的输入和输出数据合成list，再将所有的样本合成list
# 其中输入数据的形状是[n_samples, n_steps, D_input]
# 其中输出数据的形状是[n_samples, D_output]
def data_prer(X, Y):
D_input=X[0].shape[1]
for x,y in zip(X,Y):
data.append([Standardize(x).reshape((1,-1,D_input)).astype(&float32&),
Standardize(y).astype(&float32&)])
return data
# 处理数据
data=data_prer(mfc, art)
# 分训练集与验证集
train=data[int(totalsamples*vali_size):]
test=data[:int(totalsamples*vali_size)]
&/code&&/pre&&/div&&ul&&li&示意图：1，2，3，4，5表示list中的每个元素，而每个元素又是一个长度为2的list。&/li&&/ul&&figure&&img src=&https://pic3.zhimg.com/v2-2ffadd794aefa2e598a490ce_b.png& data-rawwidth=&199& data-rawheight=&137& class=&content_image& width=&199&&&/figure&&p&&br&&/p&&ul&&li&解释：比如全部数据有100个序列，如果设定每个input的形状就是[1, n_steps, D_input]，那么处理后的list的长度就是100，这样的数据使用的是SGD的更新方式。而如果想要使用mini-batch GD，将batch size(也就是n_samples)的个数为2，那么处理后的list的长度就会是50，每次网络训练时就会同时计算2个样本的梯度并用均值来更新权重。 因为每句语音数据的时间长短都不相同，如果使用3维tensor，需要大量的zero padding，所以将n_samples设成1。但是这样处理的缺点是：只能使用SGD，无法使用mini-batch GD。如果想使用mini-batch GD，需要几个n_steps长度相同的样本并在一起形成3维tensor（不等长时需要zero padding，如下图）。&/li&&li&演示图：v表示一个维度为39的向量，序列1的n_steps的长度为3，序列2的为7，如果想把这三个序列并成3维tensor，就需要选择最大的长度作为n_steps的长度，将不足该长度的序列补零（都是0的39维的向量）。最后会形成shape为[3,7,39]的一个3维tensor。&/li&&/ul&&figure&&img src=&https://pic3.zhimg.com/v2-918f052df1c5ffe5af441a_b.png& data-rawwidth=&347& data-rawheight=&215& class=&content_image& width=&347&&&/figure&&p&&br&&/p&&p&权重初始化方法&/p&&ul&&li&目的：合理的初始化权重，可以降低网络在学习时卡在鞍点或极小值的损害，增加学习速度和效果&/li&&li&代码：&/li&&/ul&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&def weight_init(shape):
initial = tf.random_uniform(shape,minval=-np.sqrt(5)*np.sqrt(1.0/shape[0]), maxval=np.sqrt(5)*np.sqrt(1.0/shape[0]))
return tf.Variable(initial,trainable=True)
# 全部初始化成0
def zero_init(shape):
initial = tf.Variable(tf.zeros(shape))
return tf.Variable(initial,trainable=True)
# 正交矩阵初始化
def orthogonal_initializer(shape,scale = 1.0):
#https://github.com/Lasagne/Lasagne/blob/master/lasagne/init.py
scale = 1.0
flat_shape = (shape[0], np.prod(shape[1:]))
a = np.random.normal(0.0, 1.0, flat_shape)
u, _, v = np.linalg.svd(a, full_matrices=False)
q = u if u.shape == flat_shape else v
q = q.reshape(shape) #this needs to be corrected to float32
return tf.Variable(scale * q[:shape[0], :shape[1]],trainable=True, dtype=tf.float32)
def bias_init(shape):
initial = tf.constant(0.01, shape=shape)
return tf.Variable(initial)
def shufflelists(data):
ri=np.random.permutation(len(data))
data=[data[i] for i in ri]
return data
&/code&&/pre&&/div&&ul&&li&解释：其中shufflelists是用于洗牌重新排序list的。正交矩阵初始化是有利于gated_rnn的学习的方法。&/li&&/ul&&h2&定义LSTM类&/h2&&ul&&li&属性：使用class类来定义是因为LSTM中有大量的参数，定义成属性方便管理。&/li&&li&代码：在init中就将所有需要学习的权重全部定义成属性&/li&&/ul&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&class LSTMcell(object):
def __init__(self, incoming, D_input, D_cell, initializer, f_bias=1.0):
# incoming是用来接收输入数据的，其形状为[n_samples, n_steps, D_cell]
self.incoming = incoming
# 输入的维度
self.D_input = D_input
# LSTM的hidden state的维度，同时也是memory cell的维度
self.D_cell = D_cell
# parameters
# 输入门的 三个参数
# igate = W_xi.}