knn720手机手机服务密码是什么多少
点击联系发帖人
时间：2017-12-18 00:06
&p&（活久见，本答案的感谢数是赞同数的1/3，看来学渣还是占大多数，23333）&/p&&p&看了其它的答案，&b&恕我直言，大部分都是垃圾&/b&，不是说内容垃圾（很多内容我看不懂），而是说方法垃圾，对于一个不是学计算机而想要入门tensorflow的人，上来讲一大堆原理和算法，有个鸟用，就像对一个想学PHP编程的人，上来就讲《编译原理》或者汇编指令，一辈子都入不了门！&/p&&p&至于题主说学不到原理，或者看不懂源码，这就不是入门的要求了，这是要深入研究深度学习和tensorflow了，如果不是学术研究和理论研究，我觉得完全没有必要，能用tensorflow解决你的问题才是最关键的。&/p&&p&正好之前我在朋友圈分享了我的“机器学习”学习之路，朋友圈点赞甚多，相信很多人都有同感，这里也分享一下，希望能对大家有所帮助，&/p&&p&=======以下内容分享给各位学渣，学霸们一笑而过就好==========&/p&&p&&b&1）第一阶段：陷入各种算法：贝叶斯、K近邻。。。。。。&/b&&br&开始机器学习，上网搜索，发现一堆算法，于是开始学习各种算法，花了一定的时间才了解了&b&监督、无监督&/b&学习的基本分类和差异，学习过程中遇到几个主要问题：&/p&&ul&&li&&i&算法原理看不懂：大学高数还可以，但现在看完全看不懂&/i&&/li&&li&&i&不知道算法有什么用：例如，购物推荐用了什么算法？&/i&&/li&&li&&i&搞不清这些算法和深度学习什么关系&/i&&/li&&/ul&&p&&b&2）第二阶段：线性代数、统计&/b&&br&经历第一阶段后，感觉是不是自己的数学基础太薄弱了，于是开始看线性代数和统计的基础知识，尝试了一下，发现&b&简单一些的还能够看懂，稍微复杂一些的完全看不懂&/b&，遂放弃。。。。。&/p&&p&&b&3）第三阶段：人工智能历史&/b&&br&由于各种概念和术语混杂，于是想到看看人工智能历史，找到了&b&《人工智能狂潮》&/b&一书，详细的介绍了人工智能的发展历史，尤其是对于人工智能发展的几个阶段，每个阶段的特点和不足都解释的非常清楚，看完后对人工智能相关的各种概念有了清晰的认识，例如人工智能第三阶段分为“基于特征的算法学习”和“无特征的深度学习”两部分，一下子将第一阶段的各种算法疑惑解答了。&/p&&figure&&img src=&/v2-df5b2f3fa5_b.jpg& data-caption=&& data-rawwidth=&800& data-rawheight=&800& class=&origin_image zh-lightbox-thumb& width=&800& data-original=&/v2-df5b2f3fa5_r.jpg&&&/figure&&p&&br&&/p&&p&&b&4）第四阶段：《集体智慧编程》&/b&&br&无意中在知乎看到有人推荐这本书，于是买来认真看了一下，发现真是本好书：算法结合实践，理解了“基于特征的算法学习”在实际业务中的应用，包括商品推荐、方案优化、用户分组、垃圾邮件过滤，通过《集体智慧编程》这本书发现，其实这些算法用起来没那么复杂。&/p&&figure&&img src=&/v2-4ef3e9edc2bf_b.jpg& data-caption=&& data-rawwidth=&500& data-rawheight=&672& class=&origin_image zh-lightbox-thumb& width=&500& data-original=&/v2-4ef3e9edc2bf_r.jpg&&&/figure&&p&&br&&/p&&p&&b&5）第五阶段：keras&/b&&br&由于对算法基础和数学实在是没有兴趣和精力深入，于是找到了keras这个开源项目，发现真是神器，封装非常好，使用非常简单直观。使用keras写一个cnn手写数字识别程序，简单直观，很好理解。&/p&&p&&b&6）第六阶段：tensorflow&/b&&br&开始的时候我也是看官方文档，发现文档虽然全，但是是从查阅的角度组织的，而不是从教学的角度组织的，先看什么，后看什么，流程是什么。。。。。。看官方文档会陷进去出不来。于是上网找到了两本书，&b&强烈推荐，入门神器，&/b&不用花费大量时间去搜索乱七八糟的文档，也不用去吭官方文档，对照着两本足够了。&/p&&p&《TensorFlow实践》，对TensorFlow的基本原理，实践步骤讲解清晰，没有太多的算法和数学公式介绍&br&&/p&&figure&&img src=&/v2-d0cd0a639a91bd84244d5b_b.jpg& data-caption=&& data-rawwidth=&350& data-rawheight=&350& class=&content_image& width=&350&&&/figure&&p&&br&&/p&&p&《TensorFlow实战指南》讲解了使用TensorFlow来实现各类机器学习算法，可以与《集体智慧编程》中的python对比来看，看看用tensorflow和普通的python实现同一个算法差异在哪里&/p&&figure&&img src=&/v2-6b72ccd024e46ff8d3a287_b.jpg& data-caption=&& data-rawwidth=&350& data-rawheight=&350& class=&content_image& width=&350&&&/figure&&p&&br&&/p&&p&到目前为止，机器学习和tensorflow我可以说已经基本入门，但如果说要深入的话，相信网易云课堂的吴恩达教程是不可少的，我看过一些，但是一到算法和原理我就懵了，看来创造和研究算法的事情还是交给学霸们就好，我等学渣只需要简单调用即可。例如：&/p&&figure&&img src=&/v2-3ac42d3fa6fd0b53bab537c4_b.jpg& data-caption=&& data-rawwidth=&2880& data-rawheight=&1800& class=&origin_image zh-lightbox-thumb& width=&2880& data-original=&/v2-3ac42d3fa6fd0b53bab537c4_r.jpg&&&/figure&&p&学霸们请将算法像tensorflow这样封装好，我一行代码调用就可以了 ，233333 ：）&/p&
（活久见，本答案的感谢数是赞同数的1/3，看来学渣还是占大多数，23333）看了其它的答案，恕我直言，大部分都是垃圾，不是说内容垃圾（很多内容我看不懂），而是说方法垃圾，对于一个不是学计算机而想要入门tensorflow的人，上来讲一大堆原理和算法，有个鸟…
&p&常言道，师傅领进门，修行靠个人，相信很多人或多或少是在别人的建议或带领下步入深度学习这个大坑，然后师傅说深度学习是个玄学，后面就靠个人修行，瞬间就懵了对不对？可能后面经过自己不断实验积累相关经验，会有一些自己的学习心得。本文可谓是深度学习中的一份秘籍，帮助你少走一些弯路。在本文中，列举了一些常用的机器学习的训练技巧，目的是对这些技巧进行简单的介绍并说明它们的工作原理。另外一些建议是斯坦福的&u&&a href=&/?target=http%3A//cs231n.github.io/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&CS231n&i class=&icon-external&&&/i&&/a&&/u&课程及之前总结的&u&&a href=&/?target=https%3A///Conchylicultor/Deep-Learning-Tricks/blob/master/networks.md& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&网络结构&i class=&icon-external&&&/i&&/a&&/u&。&/p&&p&本文的目录如下：&/p&&ul&&li&数据预处理&/li&&li&初始化&/li&&li&训练&/li&&li&正则化&/li&&li&网络结构&/li&&li&自然语言处理&/li&&li&增强学习&/li&&li&网络压缩&br&&/li&&/ul&&h2&&b&数据预处理&/b&&/h2&&p&（本部分原作者没有写，以个人的理解及相关补充这部分内容）&/p&&p&&b&What&/b&：输入神经网络数据的好坏直接关系着网络训练结果，一般需要对数据进行预处理，常用的数据预处理方式有：&/p&&p&&br&&/p&&ul&&li&去均值：每个原始数据减去全部数据的均值，即把输入数据各个维度的数据都中心化到0； &/li&&li&归一化：一种方式是使用去均值后的数据除以标准差，另外一种方式是全部数据都除以数据绝对值的最大值；&br&&/li&&li&PCA/白化：这是另外一种形式的数据预处理方式，一种方式是降维处理，另外一种是进行方差处理； &/li&&/ul&&p&&br&&/p&&p&&b&Why&/b&：通过对数据进行预处理能够使得它们对模型的影响具有同样的尺度或其他的一些目的。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=http%3A//cs231n.github.io/neural-networks-2/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&CS231n Convolutional Neural Networks for Visual Recognition.&i class=&icon-external&&&/i&&/a&&/u&&/p&&h2&&b&初始化&/b&&/h2&&p&&b&What&/b&：权重若初始化合理能够提升性能并加快训练速度，偏置一般设置为0，对于权重而言，建议统一到一定区间内：&/p&&p&&br&&/p&&ul&&li&对于线性层[1]：区间为[-v,v]，v = 1/sqrt(输入尺寸)，sqrt表示开根号； &/li&&li&对于卷积层[2]：区间为[-v,v]，v = 1/sqrt(卷积核的宽度x卷积核的高度x输入深度)； &/li&&li&批量标准化[3]在某些方面的应用降低了调整权值初始化的需要，一些研究结果页提出了相应的替代公式。 &/li&&/ul&&p&&br&&/p&&p&&b&Why&/b&：使用默认的初始化，每个神经元会随着输入数量的增多而存在一个方差，通过求根号缩放每个权重能确保神经元有近似的输出分布。&/p&&p&&b&Ref&/b&：&/p&&p&&br&&/p&&ul&&li&1.&u&&a href=&/?target=http%3A//www./pubs/192769/tricks-2012.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Stochastic Gradient Descent Tricks, Leon Bottou&i class=&icon-external&&&/i&&/a&&/u&； &/li&&li&2.在Torch中默认这么操作； &/li&&li&3.&u&&a href=&/?target=https%3A//arxiv.org/abs/%3Fspm%3D.blogcont.AWmFul%26file%3D& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift, S. Ioffe and C. Szegedy；&i class=&icon-external&&&/i&&/a&&/u&&/li&&/ul&&p&&br&&/p&&p&&b&What&/b&：对于长短期记忆网络（LSTM），遗忘偏置一般设置为1，可以加快训练过程。&/p&&p&&b&Why&/b&：直觉是训练开始时，想要信息在细胞之间传播，故不希望细胞忘记它的状态。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=http%3A//www.datascienceassn.org/sites/default/files/An%2520Empirical%2520Exploration%2520of%2520Recurrent%2520Network%2520Architectures.pdf%3Fspm%3D.blogcont.AWmFul%26file%3DAn%2520Empirical%2520Exploration%2520of%2520Recurrent%2520Network%2520Architectures.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&An Empirical Exploration of Recurrent Network Architectures, Rafal Jozefowicz et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：对于t-分布领域嵌入算法（t-SNE），原作者建议对于大小为之间的数据集，将困惑度设置为5和50之间[1]，对于更大的数据集，相应的困惑度也会增。&/p&&p&&b&Why&/b&：困惑度决定了每个点的高斯分布的方差大小，更小的困惑度将获得更多的集群，大的困惑度与之相反，太大的困惑度没有任何意义；另外需要考虑的是画出的聚类不能保留原有的规模，聚类之间的距离不一定代表原始的空间几何，不同的困惑度能在数据结构上提供互补的信息，每次运行都会产生不同的结果[2]。&/p&&p&&b&Ref&/b&：&/p&&p&&br&&/p&&ul&&li&1.&u&&a href=&/?target=http%3A///s%3Fwd%3Dpaperuri%253A%d0e53d5d8ce70cf0dfdc3dfilter%3Dsc_long_sign%26tn%3DSE_xueshusource_2kduw22v%26sc_vurl%3Dhttp%253A%252F%%252Fdocument%252Fvid%252Fdb04eb2c-31d8-4ee3-abde-d422c86e2bc9%26ie%3Dutf-8%26sc_us%3D43442& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Visualizing High-Dimensional Data Using t-SNE, L.J.P. van der Maaten&i class=&icon-external&&&/i&&/a&&/u&. &/li&&li&2.&u&&a href=&/?target=http%3A//distill.pub/2016/misread-tsne/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&How to Use t-SNE Effectively, Wattenberg, et al., Distill, 2016.&i class=&icon-external&&&/i&&/a&&/u& &/li&&/ul&&p&&br&&/p&&h2&&b&训练&/b&&/h2&&p&&b&What&/b&：除了使用真值硬化目标外，同样可以使用软化目标（softmax输出）训练网络。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Distilling the Knowledge in a Neural Network / Dark knowledge, G. Hinton et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：学习率可能是需要调参中最重要的一个参数，一种策略是选择一些参数均有随机化学习率，并观察几次迭代后的测试误差。&/p&&figure&&img src=&/v2-832a0a34abcc59ee0561d_b.jpg& data-caption=&& data-rawwidth=&576& data-rawheight=&720& class=&origin_image zh-lightbox-thumb& width=&576& data-original=&/v2-832a0a34abcc59ee0561d_r.jpg&&&/figure&&p&&b&Ref&/b&：Some advice for tuning the hyperparameters. Ref: Goodfellow et al 2016 Book&/p&&p&&br&&/p&&h2&&b&正则化&/b&&/h2&&p&&b&What：&/b&在RNN中使用Dropout，它仅仅应用于非循环连接[1]，但是一些最近的文章提出了一些技巧使得Dropout能应用于循环连接[2]。&/p&&p&&b&Ref&/b&：&/p&&p&&br&&/p&&ul&&li&1.&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Recurrent Neural Network Regularization, Wojciech Zaremba et al.&i class=&icon-external&&&/i&&/a&&/u& &/li&&li&2.&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Recurrent Dropout without Memory Loss, Stanislau Semeniuta et al.&i class=&icon-external&&&/i&&/a&&/u& &/li&&/ul&&p&&br&&/p&&p&&br&&/p&&p&&b&What&/b&：批量标准化（Batch Normalization, BN），增添了一个新的层，作者给出一些额外的技巧加速BN层的工作：&/p&&p&&br&&/p&&ul&&li&增大学习率；&br&&/li&&li&移除/减少dropout：在不增加过拟合发生的条件下加快训练； &/li&&li&移除/减少L2范数权值归一化； &/li&&li&加快学习率衰减速度：使得网络训练更快；&br&&/li&&li&移除局部响应归一化；&br&&/li&&li&将训练样本打乱地更彻底：防止相同的样本总出现在小批量中（验证集上提高了1%）； &/li&&li&减少光度失真；&br&&/li&&/ul&&p&&br&&/p&&p&&b&Why&/b&：&u&&a href=&/?target=https%3A///Why-does-batch-normalization-help& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&一些好的解释在此&i class=&icon-external&&&/i&&/a&&/u&。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Accelerating Deep Network Training by Reducing Internal Covariate Shift, S. Ioffe and C. Szegedy.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&h2&&b&网络结构&/b&&/h2&&p&&b&What&/b&：使用跳跃式连接，直接将中间层连接到输入/输出层。&/p&&p&&b&Why&/b&：作者的观点是通过减少神经网络的底端与顶端之间的处理步骤使得训练深层网络更加简单，并减轻梯度消失问题。&/p&&p&&b&When&/b&：在一些CNN结构中或RNN中一些重要的层。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Generating Sequences With Recurrent Neural Networks, Alex Grave et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&figure&&img src=&/v2-a568d8d4f87f890b363b0_b.jpg& data-rawwidth=&560& data-rawheight=&373& class=&origin_image zh-lightbox-thumb& width=&560& data-original=&/v2-a568d8d4f87f890b363b0_r.jpg&&&figcaption&RNN的跳跃式连接例子&/figcaption&&/figure&&p&&br&&/p&&p&&b&What&/b&：为LSTM增加窥视孔连接（连接之前输出到门的输入），根据作者的观点，这个操作对长时间依赖关系有用。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=http%3A//www.schraudolph.org/pubs/GerSchSch02.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Learning Precise Timing with LSTM Recurrent Networks, Felix A. Gers et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：大多数的深度学习框架提供了一个结合SoftMax和Log的函数或者是在损失函数中计算SoftMax（在Tensorflow中是softmax_cross_entropy_with_logits，在Torch中是nn.LogSoftMax），这些应该被更好地使用。&/p&&p&&b&Why&/b&：Log（SoftMax）在数值上不稳定是小概率，从而导致溢出等不良结果。另外一种流行的方法是在Log中加入一些小数避免不稳定。&/p&&p&&br&&/p&&h2&&b&自然语言处理（NLP）&/b&&/h2&&p&&b&What：&/b&对于RNN和seq2seq模型的一些技巧：&/p&&p&&br&&/p&&ul&&li&嵌入尺寸：。更小的维度比如256也能导致很好的表现，但是更高的维度不一定导致更好的表现； &/li&&li&对于译码器而言：LSTM&GRU&Vanilla-RNN； &/li&&li&2-4层似乎普遍足够，但带有残差的更深网络看起来很难收敛，更多去挖掘更多的技巧； &/li&&li&Resd（密集的残差连接）&Res（近连接先前层）&无残差连接； &/li&&li&对于编码器而言：双向&单向（反向输入）&单向； &/li&&li&注意力（加法）&注意力（乘法）&无注意力； &/li&&li&使用光束会导致更好的结果；&br&&/li&&/ul&&p&&br&&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=http%3A///s%3Fwd%3Dpaperuri%253A%252822abe28be9bbb62ecc079%2529%26filter%3Dsc_long_sign%26tn%3DSE_xueshusource_2kduw22v%26sc_vurl%3Dhttp%253A%252F%252Farxiv.org%252Fpdf%252F%26ie%3Dutf-8%26sc_us%3D& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Massive Exploration of Neural Machine Translation Architectures, Denny Britz, Anna Goldie et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：对于seq2seq而言，翻转输入序列的顺序，保持目标序列的完整。&/p&&p&&b&Why&/b&：根据作者的观点，这种简单的数据变换极大提升了LSTM的性能。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/Fspm%3D.blogcont.AWmFul%26file%3D& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Sequence to Sequence Learning with Neural Networks, Ilya Sutskever et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：对于seq2seq而言，为编码器和译码器网络使用不同的权值。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Sequence to Sequence Learning with Neural Networks, Ilya Sutskever et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：当训练时，强制更正译码器的输入；在测试时，使用先前的步骤，这使得训练在开始时非常高效，Samy等人提出了一种基于模型转变的改进方法[1]。&/p&&p&&b&Ref&/b&：1.&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Scheduled Sampling for Sequence Prediction with Recurrent Neural Networks, Samy Bengio et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：以无监督的方式训练一个网络去预测文本的下一个字符（char-RNN），该网络将学习一种能用来监督任务的表示（比如情感分析）。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Learning to Generate Reviews and Discovering Sentiment, Ilya Sutskever et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&h2&&b&增强学习&/b&&/h2&&p&&b&What&/b&：异步：以不同的勘探政策同时训练多个代理，提升了鲁棒性。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Asynchronous Methods for Deep Reinforcement Learning, V. Mnih.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：跳帧：每隔4帧计算一次动作，而不是每帧都计算，对于其它帧，重复这个动作。&/p&&p&&b&Why&/b&：在Atari游戏中工作得很好，并且使用这个技巧以大约4倍的速度加快了训练过程。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Playing Atari &i class=&icon-external&&&/i&&/a&&/u&with Deep Reinforcement Learning, V. Mnih. &/p&&p&&br&&/p&&p&&b&What&/b&：历史：不是仅仅将当前帧作为输入，而是将最后的帧与输入叠加，结合间隔为4的跳帧，这意味着我们有一个含t、t-4、t-8及t-12的帧栈。&/p&&p&&b&Why&/b&：这允许网络有一些动量信息。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Deep Reinforcement Learning with Double Q-learning, V. Mnih.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：经验回放：为了避免帧间的相关性，作为一个代理不是更新每一帧，最好是在过渡时期的历史中采样一些样本，该思想类似于有监督学习中训练前打乱数据集。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Prioritized Experience Replay, Tom Schaul et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：Parallel Advantage Actor Critic(PAAC)：通过代理的经验以及使用一个单一的同步更新模型使得简化A3C算法成为可能。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/v2& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Efficient Parallel Methods for Deep Reinforcement Learning, Alfredo V. Clemente et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&h2&&b&网络压缩&/b&&/h2&&p&&b&What&/b&：在推理中，为了减少层数，通过批量归一化（BN）层能够吸收其它的权值。这是因为在测试时批量归一化进行地是一个简单的线性缩放。&/p&&p&&br&&/p&&p&&b&作者信息&/b&&/p&&p&&br&&/p&&b&&figure&&img src=&/v2-a4dae8f704d112fcd583d_b.jpg& data-caption=&& data-rawwidth=&326& data-rawheight=&326& class=&content_image& width=&326&&&/figure&&/b&&p&&br&&/p&&p&&u&&a href=&/?target=http%3A//e-pot.xyz/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Conchylicultor&i class=&icon-external&&&/i&&/a&&/u&，谷歌大脑参与者,专注于机器学习和软件开发。&/p&&p&Linkedin：&u&&a href=&/?target=https%3A///in/potetienne/& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://www.&/span&&span class=&visible&&/in/potetie&/span&&span class=&invisible&&nne/&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&Mail：etiennefg.&/p&&p&本文由北邮&a href=&/?target=http%3A///fly51fly%3Fspm%3D.blogconte60Y& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&@爱可可-爱生活&i class=&icon-external&&&/i&&/a&老师推荐，&a href=&/?target=http%3A///taobaodeveloperclub%3Fspm%3D.blogconte60Y& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&阿里云云栖社区&i class=&icon-external&&&/i&&/a&组织翻译。&/p&&p&文章原标题《Deep Learning Tricks》，作者：Conchylicultor，译者：海棠&/p&&p&&br&&/p&&p&&a href=&/?target=http%3A///m/33443/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&原文链接&i class=&icon-external&&&/i&&/a&&/p&&p&&b&更多技术干货敬请关注云栖社区知乎机构号：&a href=&/org/a-li-yun-yun-qi-she-qu-48& class=&internal&&阿里云云栖社区 - 知乎&/a&&/b&&/p&&p&&/p&
常言道，师傅领进门，修行靠个人，相信很多人或多或少是在别人的建议或带领下步入深度学习这个大坑，然后师傅说深度学习是个玄学，后面就靠个人修行，瞬间就懵了对不对？可能后面经过自己不断实验积累相关经验，会有一些自己的学习心得。本文可谓是深度学习…
&figure&&img src=&/v2-4be2c6332abef18bdf64cafe31f1416c_b.jpg& data-rawwidth=&740& data-rawheight=&431& class=&origin_image zh-lightbox-thumb& width=&740& data-original=&/v2-4be2c6332abef18bdf64cafe31f1416c_r.jpg&&&/figure&&p&这是RoboMaster 2018赛季展望系列文章中的一篇技术教学文。作者是RoboMaster智囊团的许悦聪，新加坡南洋理工大学在读博士，校RoboMaster 机器人代表队技术顾问，无人机爱好者，主攻视频和语意相关的机器学习方向。文章部分有修改。&/p&&p&&br&&/p&&p&我会在接下来一段时间里陆续发布“RoboMaster 2018赛季展望”系列文章，有些是RoboMaster比赛内所需技术的介绍文章，作者都是之前参加RoboMaster比赛的学生，有些则是关于RoboMaster 2018赛季的一些新情况介绍。&/p&&p&&br&&/p&&p&这些文章，尤其是技术教学文，对于刚上大学的学生、机器人爱好者或者对RoboMaster比赛感兴趣的观众来说，都是一些不错的入门介绍。&/p&&p&======================================================================&/p&&p&我们都知道，人类有学习的能力。由于人类不断的追求学习和进步，我们今天才处于一个美好的文明社会。百科上是这么定义学习的：学习是通过阅读、观察、实践等手段获得知识或技能的过程，是使得个体得到持续性变化的行为方式。&/p&&p&在工业革命过后，关于&b&机器学习&/b&的话题不停被人们提及和研究。&/p&&p&不难想象，具备有学习能力的机器人，由于经验可以被无穷无尽的芯片储存，机器人做出的判断将越来越精准，犯错的几率也将趋于零。正因为这些优势，机器学习被应用在了高级的、复杂条件下的视觉识别、决策判定等领域。&/p&&p&最近，某著名手机品牌又火了一把，它可以通过摄像头，识别人脸并完成解锁手机等功能。有趣的是，不管主人造型怎么变化，它都能认出主人的脸。&/p&&figure&&img src=&/v2-eb169a90d95e2e7dbf550df_b.jpg& data-rawwidth=&819& data-rawheight=&455& class=&origin_image zh-lightbox-thumb& width=&819& data-original=&/v2-eb169a90d95e2e7dbf550df_r.jpg&&&figcaption&人脸视觉识别&/figcaption&&/figure&&p&&br&&/p&&p&实际上，该手机搭载有&b&神经网络芯片&/b&，通过&b&机器学习&/b&，它能不断的记住主人在每个造型下的微小区别（积累经验）并进行横向对比，最终它将基本不会认错人。&/p&&p&&br&&/p&&p&同样的，在 RoboMaster2017 的赛场上，有着一个九宫格大能量机关。这是当前版本的赛场中，唯一需要用到机器学习式视觉识别的人工智能机关。&/p&&figure&&img src=&/v2-a78b5e233c_b.jpg& data-rawwidth=&490& data-rawheight=&268& data-thumbnail=&/v2-a78b5e233c_b.jpg& class=&origin_image zh-lightbox-thumb& width=&490& data-original=&/v2-a78b5e233c_r.gif&&&figcaption& 击打大能量机关&/figcaption&&/figure&&p&&br&&/p&&p&激活机关的过程有些复杂。机器人先要识别上方的 LED 数字灯，按照先后顺序，依次识别并击打下方每 1.5 秒就变换一次位置的手写体数字，连续 5 次击打成功即可激活机关。&/p&&figure&&img src=&/v2-d8e7aa03b54e2dabcf1c09b80dfce30f_b.jpg& data-rawwidth=&2530& data-rawheight=&1423& class=&origin_image zh-lightbox-thumb& width=&2530& data-original=&/v2-d8e7aa03b54e2dabcf1c09b80dfce30f_r.jpg&&&figcaption& 大能量机关&/figcaption&&/figure&&p&我们来看下这个机关的难点：上方数码管为有序、随机变化的固定形态数字，下方九宫格为每 1.5 秒随机变化位置和字体的手写体数字，1.5 秒内只要错了一个就要重头开始。手写体数字举例如下：&/p&&figure&&img src=&/v2-b424e48bd4543_b.jpg& data-caption=&& data-rawwidth=&751& data-rawheight=&417& class=&origin_image zh-lightbox-thumb& width=&751& data-original=&/v2-b424e48bd4543_r.jpg&&&/figure&&p&&br&面对各种字体的数字一，若按照上一期的传统视觉方法来识别，机器人需要将这五种情况“背下来”。但是，万一比赛出现了第 6 种数字一，机器人就会彻底蒙圈了：“这是啥？没见过，不认识。”&/p&&p&&b&传统视觉识别拓展阅读：&/b&&a href=&/p/?fc=1&group_id=751040#comment-& class=&internal&&RoboMaster 新赛季展望之视觉识别基础教程&/a&&/p&&p&通过上面两个例子，我们可以知道，RoboMaster 赛场中的大能量机关属于更高级的、复杂条件下的视觉识别难题，需要用&b&机器学习&/b&来解决。&/p&&p&&br&&/p&&h2&&b&什么是机器学习？&/b&&/h2&&p&机器人具备机器学习的能力，实际上是在说它的计算机程序具备机器学习的能力。&/p&&p&一个计算机程序不断地实战，过程中不断累积经验，自己提高解决问题的能力，则认为该程序具有机器学习能力。简单说，就是丢给机器一大堆样本范例，让它自己学习理解，再举一反三，解决范例以外的问题。&/p&&figure&&img src=&/v2-cc931ba06e4fb_b.jpg& data-rawwidth=&376& data-rawheight=&208& class=&content_image& width=&376&&&figcaption& 传统方法可能认出中间是萝卜君, 但绝对不知道右边也是萝卜君&/figcaption&&/figure&&p&在上图中，若想要识别萝卜君，传统方法需要手动输入萝卜君的所有特征：比方说它是桔黄色的、有大板牙、头上带点绿...当萝卜君被切成丝，榨成汁，机器人就认不出了。&/p&&p&如果是经过机器学习训练的机器人呢？只要训练得当，哪怕萝卜君变异成白萝卜，变成炒萝卜丝，都逃不过它的法眼，一眼看穿！&/p&&p&&br&&/p&&h2&&b&搭建系统所用的架构&/b&&/h2&&p&要想让机器人能通过程序学习，首先需要搭建机器学习系统的架构。&/p&&p&前人栽树，后人乘凉。对于初学者来说，大部分常见的架构都是搭建好的，有些甚至只需要在软件中敲入几行代码就能完成一个机器学习系统的搭建。&/p&&p&由谷歌开发的&b& TensorFlow&/b&，在机器学习研究领域中较为主流，其代码质量高、成熟度高。&/p&&figure&&img src=&/v2-acabc5ce87cfbc88f91503_b.jpg& data-caption=&& data-rawwidth=&638& data-rawheight=&354& class=&origin_image zh-lightbox-thumb& width=&638& data-original=&/v2-acabc5ce87cfbc88f91503_r.jpg&&&/figure&&p&接下来，小R就以识别 RoboMaster 比赛中的大能量机关为实例，利用 TensorFlow 架构来搭建一个机器学习系统，让机器人拥有辨识不同手写数字的能力！&/p&&p&&br&&/p&&h2&&b&机器学习实战&/b&&/h2&&figure&&img src=&/v2-c3fc52d7f3ceca3c7cba_b.jpg& data-rawwidth=&1080& data-rawheight=&600& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&/v2-c3fc52d7f3ceca3c7cba_r.jpg&&&figcaption&机器学习的视觉识别处理&/figcaption&&/figure&&p&&br&&/p&&h2&&b&机器学习分类&/b&&/h2&&p&机器学习经常被分为以下几类：&b&监督学习，无监督学习，增强学习，半监督学习&/b&。准确率在 90% 以上的任务，基本上都属于监督学习。&/p&&p&&b&监督学习&/b&，就像让机器人完成一本已经有明确答案的练习册，通过这种练习和比对答案，最后在测试中取得优异成绩。简单来讲，机器人用下图左边 5 个奇形怪状的 1 来训练，我们告诉它这些结果都是右边的 1。&/p&&figure&&img src=&/v2-79863adf6f5e1ed53c0ef43d7f1c8f32_b.jpg& data-rawwidth=&988& data-rawheight=&261& class=&origin_image zh-lightbox-thumb& width=&988& data-original=&/v2-79863adf6f5e1ed53c0ef43d7f1c8f32_r.jpg&&&figcaption&有答案的练习&/figcaption&&/figure&&p&&br&&b&无监督学习&/b&，就像让机器人一本没有答案的练习册来学习。丢给它一堆图片，又不告诉它这些图片都是什么，恩让它用心去感受。将来给它一张图片，它只能告诉我们这张图片和谁比较像。&br&在大能量机关识别中，当然要用准确率较高的监督学习啦。想让机器人成绩好，训练量要足够。我们要拥有一套训练数据，也就是各种各样的手写字符图片。&/p&&p&&i&这里没有介绍增强学习和半监督学习。增强学习需要和环境进行交互，文中未有相应案例；相比半监督学习，监督学习更适合初学者研究。有兴趣的同学可进一步阅读：《机器学习》周志华著，清华大学出版社。&/i&&/p&&p&&br&&/p&&h2&&b&机器的练习册&/b&&/h2&&p&我们先看下哪些地方可以找到训练用的练习册。在官网和论坛上，RoboMaster 组委会大方地提供了大能量机关显示程序里 90% 的手写数字。&/p&&figure&&img src=&/v2-f10ec060cf807b4d4b81d_b.jpg& data-rawwidth=&741& data-rawheight=&388& class=&origin_image zh-lightbox-thumb& width=&741& data-original=&/v2-f10ec060cf807b4d4b81d_r.jpg&&&figcaption&整理整齐的训练数据&/figcaption&&/figure&&p&这些都是宝，其中不乏很难认出来的幼儿园小朋友手写体。&/p&&figure&&img src=&/v2-4d8dbfc7baa_b.jpg& data-caption=&& data-rawwidth=&269& data-rawheight=&290& class=&content_image& width=&269&&&/figure&&p&&br&我们从上一期的视觉基础篇知道，图片是以很多的像素点组成，每个像素点的值介于 0~255。因此，一切的图片在机器人眼里就是一个个矩阵。&/p&&figure&&img src=&/v2-6fa1ec00d53fb8c63e9bd4e1_b.jpg& data-rawwidth=&865& data-rawheight=&341& class=&origin_image zh-lightbox-thumb& width=&865& data-original=&/v2-6fa1ec00d53fb8c63e9bd4e1_r.jpg&&&figcaption&一个个矩阵&/figcaption&&/figure&&p&&i&把数字 1 放大就能看到像素点，这里显示的是标准化后的灰度值。&/i&&/p&&p&&br&&/p&&p&先将所有的数据格式统一，比如都转换为28*28的图片（为了之后处理更方便），然后再对所有数据做标签，训练数据集就完成啦，这就是机器的练习册。&/p&&figure&&img src=&/v2-2aec40c7f2dbb2b996687_b.jpg& data-caption=&& data-rawwidth=&407& data-rawheight=&409& class=&content_image& width=&407&&&/figure&&p&&i&现在有和手写数字输入相关的训练数据集——MNIST 数据集。有兴趣的同学请至&br&&a href=&/?target=http%3A///exdb/mnist/& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&/exdb/mni&/span&&span class=&invisible&&st/&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& 浏览。&/i&&/p&&p&&br&&/p&&p&有了数据（练习册）之后，我们需要用前面说到的机器学习的系统架构来进行处理。&/p&&p&一种非常流行的机器学习的系统架构，有个听上去更高端的叫法——&b&神经网络&/b&。&/p&&h2&&br&&b&神经网络&/b&&/h2&&p&简单来说，神经网络模仿的即是人类的中枢神经系统，由大量的神经元构成，神经元在程序中体现为参数可改变的函数。线性神经元大概长这样：&/p&&figure&&img src=&/v2-8b946b7ed3317ebca38b02caebad278b_b.jpg& data-caption=&& data-rawwidth=&1080& data-rawheight=&600& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&/v2-8b946b7ed3317ebca38b02caebad278b_r.jpg&&&/figure&&p&x 是输入神经元的内容，y 是神经元输出的内容，相当于人脑中神经元突触传递信号。W 和 b 都是可以改变的&b&神经元参数&/b&。其中，W 是权重（weight），它可以代表两个神经元之间联系的相关性。&br&利用 TensorFlow 架构，这个线性的神经元就由下面这几行代码就可以完成搭建啦：&/p&&div class=&highlight&&&pre&&code class=&language-cpp&&&span&&/span& &span class=&n&&x&/span& &span class=&o&&=&/span& &span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&placeholder&/span&&span class=&p&&(&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&float32&/span&&span class=&p&&,[&/span&&span class=&n&&None&/span&&span class=&p&&,&/span& &span class=&mi&&784&/span&&span class=&p&&])&/span&
&span class=&n&&W&/span& &span class=&o&&=&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&Variable&/span&&span class=&p&&(&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&zeros&/span&&span class=&p&&([&/span&&span class=&mi&&784&/span&&span class=&p&&,&/span& &span class=&mi&&10&/span&&span class=&p&&]))&/span&
&span class=&n&&b&/span& &span class=&o&&=&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&Variable&/span&&span class=&p&&(&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&zeros&/span&&span class=&p&&([&/span&&span class=&mi&&10&/span&&span class=&p&&]))&/span&
&span class=&n&&y&/span& &span class=&o&&=&/span& &span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&matmul&/span&&span class=&p&&(&/span&&span class=&n&&x&/span&&span class=&p&&,&/span&&span class=&n&&W&/span&&span class=&p&&)&/span& &span class=&o&&+&/span& &span class=&n&&b&/span&
&/code&&/pre&&/div&&p&线性模型在二维空间中，就是一条死板的直线，没有想象力是干不成大事的。因此，在线性模型之后要加入一个&b&非线性的激活函数&/b&，来激活这个神经元的想象力，让它的思维“拐个弯”。&/p&&figure&&img src=&/v2-54c6b16c1b805e94b30ea1eb41e82f06_b.jpg& data-rawwidth=&1080& data-rawheight=&600& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&/v2-54c6b16c1b805e94b30ea1eb41e82f06_r.jpg&&&figcaption&非线性的神经元模型&/figcaption&&/figure&&p&我们采用 softmax 归一化指数函数作为激活函数，那 y 的代码就变成：&/p&&div class=&highlight&&&pre&&code class=&language-cpp&&&span&&/span&&span class=&n&&y&/span& &span class=&o&&=&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&nn&/span&&span class=&p&&.&/span&&span class=&n&&softmax&/span&&span class=&p&&(&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&matmul&/span&&span class=&p&&(&/span&&span class=&n&&x&/span&&span class=&p&&,&/span& &span class=&n&&W&/span&&span class=&p&&)&/span& &span class=&o&&+&/span& &span class=&n&&b&/span&&span class=&p&&)&/span&
&/code&&/pre&&/div&&p&实际的神经网络中，上述变量和参数通常都是矩阵形式。矩阵形式的神经元大概像这样：&/p&&figure&&img src=&/v2-bfce04f4e6511cca186fcea_b.jpg& data-rawwidth=&865& data-rawheight=&211& class=&origin_image zh-lightbox-thumb& width=&865& data-original=&/v2-bfce04f4e6511cca186fcea_r.jpg&&&figcaption&神经元模型的矩阵形式&/figcaption&&/figure&&p&要跟其他一堆神经元组成神经网络，它不能只有一个输入输出，就像你大脑里的神经元也不只有一个突触。多个输入的神经元长这样：&/p&&figure&&img src=&/v2-7c2ef7c708a01e23b2d95_b.jpg& data-rawwidth=&704& data-rawheight=&392& class=&origin_image zh-lightbox-thumb& width=&704& data-original=&/v2-7c2ef7c708a01e23b2d95_r.jpg&&&figcaption&多个输入的神经元&/figcaption&&/figure&&p&把这些神经元首尾相连就得到一个神经网络。每一个神经元都可以对特定的输入产生响应，从而得到一个最终的响应。&/p&&figure&&img src=&/v2-9dd561cacfebd0ea1a0ad1f3ae13cc84_b.jpg& data-caption=&& data-rawwidth=&687& data-rawheight=&382& class=&origin_image zh-lightbox-thumb& width=&687& data-original=&/v2-9dd561cacfebd0ea1a0ad1f3ae13cc84_r.jpg&&&/figure&&p&上图是简单的一个神经网络。圆圈表示神经元，箭头连线表示的“权重”。每一列的神经元称作一个&b&层&/b&，红色的是&b&输入层&/b&，蓝色的是&b&隐藏层&/b&，绿色的是&b&输出层&/b&。输入层输入的是图像，输出层输出的就是识别结果啦！&/p&&p&隐藏层越多的机器人，想象力越丰富，只要你用更多的训练去填它的脑洞，它就能做更复杂的工作。如果训练不够，它就会想歪。这种深深的脑洞，就是&b&深度学习神经网络&/b&。&br&&br&&/p&&figure&&img src=&/v2-f7fde8c4ee3bf0f_b.jpg& data-rawwidth=&866& data-rawheight=&481& class=&origin_image zh-lightbox-thumb& width=&866& data-original=&/v2-f7fde8c4ee3bf0f_r.jpg&&&figcaption&深度学习神经网络模型&/figcaption&&/figure&&h2&&b&增强机器人判断力&/b&&/h2&&p&大脑搭好后，需要用到“损失函数”帮助它完成训练，这是一种可以衡量机器人训练得到的输出值和实际给出的输出值到底有多大的差距的东西。&b&简单来说，就是给机器人的行为打分，让它知道自己几斤几两。&/b&&/p&&p&一种最简单的损失函数就是&b&平方损失函数&/b&。由于练习册给出的参考答案（标记）或者机器的回答（输出）都是用矩阵表示，我们可以把它们理解为 N 维空间中的一个点，那么机器的回答和参考答案之间的距离（损失），就是它这道题的扣掉的分数。&/p&&p&&br&&/p&&p&
L(Y,f(X)) = (Y-f(X))^2 &/p&&p&
损失 = ( 参考答案 – 机器答案 )?&/p&&p&&br&&/p&&p&在实际使用中，常用交叉熵损失函数代替平方损失函数。TensorFlow 已经贴心地帮我们把这个损失函数和上文提到的激活函数合并为一行代码：&br&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_,
logits=y))
&/code&&/pre&&/div&&p&&br&在这个神经网络模型中，神经网络的训练可以简单地描述为如何最小化损失。机器训练的过程，其实就是通过&b&改变神经元参数来减少损失&/b&。简单来说，就是&b&机器人通过改变自己的脑回路（参数值）来减少被扣掉的分数。&/b&&br&如果把参数看作是函数的自变量，损失看作因变量，那么，这个过程相当于找到这个函数的最低点。最简单的方法是&b&梯度下降法&/b&。&/p&&figure&&img src=&/v2-854f966b2a341fd6d8d261ee65095b12_b.jpg& data-rawwidth=&679& data-rawheight=&377& class=&origin_image zh-lightbox-thumb& width=&679& data-original=&/v2-854f966b2a341fd6d8d261ee65095b12_r.jpg&&&figcaption&梯度下降法&/figcaption&&/figure&&p&&b&梯度下降法&/b&就像一个人在黑夜里要下山，由于不知道整座山长什么样子（机器也不知道整个函数的图像），所以只能一直找着最陡的下坡路（数学上就是梯度的负方向），那他总能找到一个地势比较低的点（局部最优解）。&/p&&p&&br&&/p&&p&梯度下降法在 TensorFlow 里也是一行代码：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
&/code&&/pre&&/div&&p&&br&&/p&&p&接下来要读取数据库当中的训练数据:&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&batch_xs,batch_ys = mnist.train.next_batch(100)
&/code&&/pre&&/div&&p&&br&&/p&&p&然后依照上面这个训练方法进行训练，读取和训练的代码，变身！&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&sess.run(train_step,feed_dict={x:batch_xs, y_: batch_ys})
&/code&&/pre&&/div&&p&&br&&/p&&p&通过最后两行代码，就能完整地将之前定义的权重和其他参数训练出来，得到一个训练好的、新参数的神经网络。&br&&/p&&figure&&img src=&/v2-2af7b71f51_b.jpg& data-caption=&& data-rawwidth=&3582& data-rawheight=&1990& class=&origin_image zh-lightbox-thumb& width=&3582& data-original=&/v2-2af7b71f51_r.jpg&&&/figure&&p&最后，做练习册的题（训练数据）做得很棒的机器，也不一定能够适应新题型（调整新参数不一定就能判断准确）。要看机器人真正的能力，还要再出考题对它进行测试（测试数据）。&/p&&p&&br&&/p&&p&&br&&/p&&h2&&b&测验最终成果&/b&&/h2&&p&测试用的考题和练习册当然不一样，我们需要准备另一套测试样本。&/p&&p&这里先用摄像头读取实战中的手写图像，经过数据格式统一和贴标签，再将它输入到神经网络里，就能测试出机器学习的结果啦！&/p&&figure&&img src=&/v2-b7e9ddda03e_b.jpg& data-rawwidth=&452& data-rawheight=&251& data-thumbnail=&/v2-b7e9ddda03e_b.jpg& class=&origin_image zh-lightbox-thumb& width=&452& data-original=&/v2-b7e9ddda03e_r.gif&&&figcaption&代码跑起来&/figcaption&&/figure&&p&聪明的机器会懂得举一反三，这种“举一反三”的能力称为&b&泛化能力&/b&。在这里也就是说，机器人能够自己组合不同数字样本的特征，去识别全新的、没有见过的数字。&/p&&p&至此，机器学习视觉识别的整个流程已经完成，训练好的机器终于可以跟操作手一起奔赴 RoboMaster 战场！成功识别出 3 倍攻击力加成的大能量机关，深藏功与名。&/p&&figure&&img src=&/v2-1d5cfcd8d6a529e6e2fc9cc2ac65b7fe_b.jpg& data-caption=&& data-rawwidth=&1258& data-rawheight=&698& class=&origin_image zh-lightbox-thumb& width=&1258& data-original=&/v2-1d5cfcd8d6a529e6e2fc9cc2ac65b7fe_r.jpg&&&/figure&&p&&br&然而，完成大能量机关的视觉识别，在 RoboMaster 比赛中只是激活该机关的第一个步骤。当识别出数字后，机器人身上搭载的发射机构（类似枪口）可不会自己转动到我们想要的角度去击打目标。&/p&&p&如何控制发射机构呢？下一期“闭环控制”，我们再见！&/p&&p&&br&&/p&&p&&a href=&/?target=http%3A///r/BUz64l7E8AOPrRqB9xkX& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&/r/BUz64l7&/span&&span class=&invisible&&E8AOPrRqB9xkX&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& (二维码自动识别)&/p&&p&&/p&
这是RoboMaster 2018赛季展望系列文章中的一篇技术教学文。作者是RoboMaster智囊团的许悦聪，新加坡南洋理工大学在读博士，校RoboMaster 机器人代表队技术顾问，无人机爱好者，主攻视频和语意相关的机器学习方向。文章部分有修改。 我会在接下来一段时间里…
&figure&&img src=&/v2-753ebca93da86afd4aa225_b.jpg& data-rawwidth=&4000& data-rawheight=&3000& class=&origin_image zh-lightbox-thumb& width=&4000& data-original=&/v2-753ebca93da86afd4aa225_r.jpg&&&/figure&&h2&简介&/h2&&p&最近AlphaGo Zero又火了一把，paper和各种分析文章都有了，有人看到了说不就是普通的Reinforcement learning吗，有人还没理解估值网络、快速下子网络的作用就放弃了。&/p&&p&实际上，围棋是一种零和、信息对称的combinatorial game，因此&b&AlphaGo用的是蒙特卡罗树搜索算法的一种&/b&，在计算树节点Q值时使用了ResNet等神经网络模型，只是在论文中也归类为增强学习而已。&/p&&p&如果你想真正了解AlphaGo的原理（或者不被其他AI将统治人类的文章所忽悠），理解蒙特卡罗树搜索（Monte Carlo Tree Search）、博弈论（Game Theory）、多臂老虎机（Multi-arm Bandit）、探索与利用（Exploration and Exploitation）等基础必不可少。&/p&&h2&MCTS初探&/h2&&p&&b&MCTS也就是蒙特卡罗树搜索（Monte Carlo Tree Search），是一类树搜索算法的统称&/b&，可以较为有效地解决一些探索空间巨大的问题，例如一般的围棋算法都是基于MCTS实现的。&/p&&p&这类算法要解决的问题是这样的，我们把围棋的每一步所有可能选择都作为树的节点，第零层只有1个根节点，第1层就有361种下子可能和节点，第2层有360种下子可能和节点，这是一颗非常大的树，我们要在每一层树节点中搜索出赢概率最大的节点，也就是下子方法。&/p&&p&那么树搜索的算法有很多，如果树的层数比较浅，我们可以穷举计算每个节点输赢的概率，那么可以使用一种最简单的策略，叫做minmax算法。基本思路是这样的，从树的叶子结点开始看，如果是本方回合就选择max的，如果是对方回合就是min的，实际上这也是假设对方是聪明的也会使用minmax算法，这样在博弈论里面就达到一个纳什均衡点。&/p&&p&这是搜索空间比较小的时候的策略，MCTS要解决的问题是搜索空间足够大，不能计算得到所有子树的价值，这是需要一种较为高效的搜索策略，同时也得兼顾探索和利用，避免陷入局部最优解。MCTS实现这些特性的方式有多种，例如经典的UCB（Upper Confidence Bounds）算法，就是在选择子节点的时候优先考虑没有探索过的，如果都探索过就根据得分来选择，得分不仅是由这个子节点最终赢的概率来，而且与这个子节点玩的次数成负相关，也就是说这个子节点如果平均得分高就约有可能选中（因为认为它比其他节点更值得利用），同时如果子节点选中次数较多则下次不太会选中（因为其他节点选择次数少更值得探索），因此MCTS根据配置探索和利用不同的权重，可以实现比随机或者其他策略更有启发式的方法。&/p&&p&到这里我们需要理解，&b&蒙特卡罗树搜索是一种基于树数据结构、能权衡探索与利用、在搜索空间巨大仍然比较有效的的搜索算法&/b&。至于这个树搜索算法主要包括Selection、Expansion、Simulation和Backpropagation四个阶段，具体原理和实现会在后面介绍。&/p&&p&前面提到MCTS的使用场景需要是搜索空间巨大，因为搜索空间如果在计算能力以内，其实是没必要用MCTS的，而真正要应用上还需要有其他的假设。涉及到博弈论的概念，我们要求的条件是zero-sum、fully information、determinism、sequential、discrete，也就是说这个场景必须是能分出输赢（不能同时赢）、游戏的信息是完全公开的（不像打牌可以隐藏自己的手牌）、确定性的（每一个操作结果没有随机因素）、顺序的（操作都是按顺序执行的）、离散的（没有操作是一种连续值），除了博弈论我们要求场景是类似多臂老虎机的黑盒环境，不能通过求导或者凸优化方法找到最优解，否则使用MCTS也是没有意义。因此在讨论蒙特卡罗树搜索前，我们需要先有下面的理论基础。&/p&&h2&Game theory基础&/h2&&p&Game theory翻译过来就是博弈论，其实是研究多个玩家在互相交互中取胜的方法。例如在耶鲁大学的博弈论公开课中，有一个游戏是让全班同学从0到100中选一个数，其中如果选择的数最接近所有数的平均值的三分之一则这个玩家获胜。首先大家应该不会选择比33大的数，因为其他人都选择100也不能赢不了，那么如果大家都选择比33小，自己就应该选择比11小的数，考虑到其他人也是这样想的，那么自己应该选择比11小很多的数，如果我知道别人也知道自己选择比11小很多的数的话，那应该选择更小的数。那么这个游戏的理想值是0，也就是纳什均衡点，就是当对方也是深晦游戏规则并且知道你也很懂游戏规则时做出的最优决定，当然第一次游戏大家都不是完美的决策者（或者不知道对方是不是完美的决策者），因此不一定会选择纳什均衡点，但多次游戏后结果就是最终取胜的就是非常接近0的选择。&/p&&p&那么前面提到的什么是纳什均衡点呢？这是Game theory里面很神奇的概念，就是所有人已经选择了对自己而言的最优解并且自己单方面做其他选择也无法再提高的点。也就是说，如果玩家都是高手，能达到或者逼近纳什均衡的策略就是最优策略，如果对手不是高手不会选择最优策略，那么纳什均衡点不一定保证每局都赢，但长远来看极大概率会赢这样的新手。&/p&&p&那么前面提到MCTS适用于特定的游戏场景，因此&b&MCTS也是一种找到逼近纳什均衡的搜索策略&/b&。那么逼近纳什均衡点的策略还有很多，例如前面提到的minmax算法，还有适用于非信息对称游戏的CFR（Counterfactual Regret）算法。像德州扑克我们就会考虑用CFR而不是MCTS，为什么呢？因为MCTS要求是一种Combinatorial Game而不能是信息不对称的。&/p&&p&在博弈论里，信息对称（Perfect information / Fully information）是指游戏的所有信息和状态都是所有玩家都可以观察到的，因此双方的游戏策略只需要关注共同的状态即可，而信息不对称（Imperfect information / Partial information）就是玩家拥有只有自己可以观察到的状态，这样游戏决策时也需要考虑更多的因素。&/p&&p&还有一个概念就是零和（zero-sum），就是所有玩家的收益之和为零，如果我赢就是你输，没有双赢或者双输，因此游戏决策时不需要考虑合作等因素。&/p&&p&那么博弈论中，我们把zero-sum、perfect&br&information、deterministic、discrete、sequential的游戏统称为Combinatorial Game，例如围棋、象棋等，而&b&MCTS只能解决Combinatorial Game的问题&/b&。&/p&&p&对博弈论感兴趣的，可以在 &a href=&/?target=http%3A///movie/2007/7/L/H/M6GOEJOME_M7KDCJHLH.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&网易公开课&i class=&icon-external&&&/i&&/a& 参加耶鲁大学博弈论公开课。&/p&&h2&Black box optimization基础&/h2&&p&了解完Game theory，第二个需要了解的是Black box optimization，也就是黑盒优化。我们知道优化就是根据给定的数据集找到更好的选择，例如机器学习就是典型的优化过程，但我们用的机器学习算法如LR、SVM、DNN都不是黑盒，而是根据数学公式推导通过对函数求导等方式进行的优化。如果我们能把问题描述成一个函数或者凸优化问题，那么我们通过数学上的求导就可以找到最优解，这类问题并不需要用到MCTS等搜索算法，但实际上很多问题例如围棋就无法找到一个描述输赢的函数曲线，这样就无法通过纯数学的方法解决。&/p&&p&这类问题统称为黑盒优化问题，我们不能假设知道这个场景内部的函数或者模型结构，只能通过给定模型输入得到模型输出结果来优化。例如多臂老虎机（Multi-arm Bandit）问题，我们有多台老虎机可以投币，但不知道每一台输赢的概率，只能通过多次投币来测试，根据观察的结果预估每台机器的收益分布，最终选择认为收益最大的，这种方法一般会比随机方法效果好。&/p&&p&黑盒优化的算法也有很多，例如进化算法、贝叶斯优化、MCTS也算是，而这些算法都需要解决如何权衡探索和利用（Exploration and Exploitation）的问题。如果我们只有一个投币，那么当前会选择期望收益最高的老虎机来投（Exploitation），但如果我们有一万个投币，我们不应该只投一个老虎机，而应该用少量币来探索一下其他老虎机（Exploration），说不定能跳过局部最优解找到更优解，当然我们也不能全部投币都用来探索了。&/p&&p&对于Exploration和Exploitation，我在 &a href=&/p/& class=&internal&&一种更好的超参数调优方式&/a& 有更详细的剖析，感兴趣可以关注下 。&/p&&h2&UCB算法基础&/h2&&p&前面讲了Game theory和Black box optimization，这里再补充一个UCB算法基础，这是MCTS的经典实现UCT（Upper Confidence bounds for Trees）里面用到的算法。&/p&&p&算法本身很简单，公式如下。&/p&&figure&&img src=&/v2-2d346fa93431c4feb77c52a_b.jpg& data-caption=&& data-rawwidth=&626& data-rawheight=&136& class=&origin_image zh-lightbox-thumb& width=&626& data-original=&/v2-2d346fa93431c4feb77c52a_r.jpg&&&/figure&&p&其中v'表示当前树节点，v表示父节点，Q表示这个树节点的累计quality值，N表示这个树节点的visit次数，C是一个常量参数（可以控制exploitation和exploration权重）。&/p&&p&这个公式的意思时，对每一个节点求一个值用于后面的选择，这个值有两部分组成，左边是这个节点的平均收益值（越高表示这个节点期望收益好，越值得选择，用于exploitation），右边的变量是这个父节点的总访问次数除以子节点的访问次数（如果子节点访问次数越少则值越大，越值得选择，用户exploration），因此使用这个公式是可以兼顾探索和利用的。&/p&&p&用Python也很容易实现这个算法，其中C常量我们可以使用 &img src=&/equation?tex=1+%2F+%5Csqrt%7B2%7D& alt=&1 / \sqrt{2}& eeimg=&1&& ，这是Kocsis、Szepesvari提出的经验值，完整代码如下。&/p&&figure&&img src=&/v2-34dfa622e17f3b33973e_b.jpg& data-caption=&& data-rawwidth=&1852& data-rawheight=&446& class=&origin_image zh-lightbox-thumb& width=&1852& data-original=&/v2-34dfa622e17f3b33973e_r.jpg&&&/figure&&p&这样我们就有了MCTS的最基础选择算法实现了，下面讨论完整的MCTS算法实现。&/p&&h2&MCTS算法原理&/h2&&p&首先，MCTS的完整实现代码在 &a href=&/?target=https%3A///tobegit3hub/ml_implementation/tree/master/monte_carlo_tree_search& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&tobegit3hub/ml_implementation&i class=&icon-external&&&/i&&/a& ，想直接看源码或者测试的可以去下载运行。&/p&&p&然后，我们需要知道MCTS的算法步骤，可以参考论文 A Survey of Monte Carlo Tree Search Methods &a href=&/?target=http%3A//pubs.doc.ic.ac.uk/survey-mcts-methods/survey-mcts-methods.pdf& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&pubs.doc.ic.ac.uk/surve&/span&&span class=&invisible&&y-mcts-methods/survey-mcts-methods.pdf&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& 。&/p&&p&MCTS的算法分为四步，第一步是Selection，就是在树中找到一个最好的值得探索的节点，一般策略是先选择未被探索的子节点，如果都探索过就选择UCB值最大的子节点。第二步是Expansion，就是在前面选中的子节点中走一步创建一个新的子节点，一般策略是随机自行一个操作并且这个操作不能与前面的子节点重复。第三步是Simulation，就是在前面新Expansion出来的节点开始模拟游戏，直到到达游戏结束状态，这样可以收到到这个expansion出来的节点的得分是多少。第四步是Backpropagation，就是把前面expansion出来的节点得分反馈到前面所有父节点中，更新这些节点的quality value和visit times，方便后面计算UCB值。&/p&&p&基本思路就是这样的，通过不断的模拟得到大部分节点的UCB值，然后下次模拟的时候根据UCB值有策略得选择值得利用和值得探索的节点继续模拟，在搜索空间巨大并且计算能力有限的情况下，这种启发式搜索能更集中地、更大概率找到一些更好的节点。下面是论文的伪代码实现。&/p&&figure&&img src=&/v2-fa50d56d14f560cba37fdc98be1824e0_b.jpg& data-caption=&& data-rawwidth=&884& data-rawheight=&1652& class=&origin_image zh-lightbox-thumb& width=&884& data-original=&/v2-fa50d56d14f560cba37fdc98be1824e0_r.jpg&&&/figure&&p&其中TREE_POLICY就是实现了Selection和和Expansion两个阶段，DEFAULT_POLICY实现了Simulation阶段，BACKUP实现了Backpropagation阶段，基本思路和前面介绍的一样。&/p&&h2&MCTS算法实现&/h2&&p&最后我们看一下前面基于Python的MCTS代码实现，源码在 &a href=&/?target=https%3A///tobegit3hub/ml_implementation/tree/master/monte_carlo_tree_search& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&tobegit3hub/ml_implementation&i class=&icon-external&&&/i&&/a& ，这是整理的代码实现架构图。&/p&&figure&&img src=&/v2-753ebca93da86afd4aa225_b.jpg& data-caption=&& data-rawwidth=&4000& data-rawheight=&3000& class=&origin_image zh-lightbox-thumb& width=&4000& data-original=&/v2-753ebca93da86afd4aa225_r.jpg&&&/figure&&p&由于这是一棵树，我们需要定义N叉树的Node数据结构。&/p&&figure&&img src=&/v2-54dd9b161ca06c78a585cec6dbb56278_b.jpg& data-caption=&& data-rawwidth=&2022& data-rawheight=&514& class=&origin_image zh-lightbox-thumb& width=&2022& data-original=&/v2-54dd9b161ca06c78a585cec6dbb56278_r.jpg&&&/figure&&p&首先Node包含了parent和children属性，还有就是用于计算UCB值的visit times和quality value，为了关联游戏状态，我们还需要为每个Node绑定一个State对象。Node需要实现增加节点、删除节点等功能，还有需要提供函数判断子节点的个数和是否有空闲的子节点位置。&/p&&p&而State的定义与我们使用MCTS的游戏定义有关，我们定义下面的数据结构。&/p&&figure&&img src=&/v2-423f3be3b05cf46e7dccb21_b.jpg& data-caption=&& data-rawwidth=&1930& data-rawheight=&430& class=&origin_image zh-lightbox-thumb& width=&1930& data-original=&/v2-423f3be3b05cf46e7dccb21_r.jpg&&&/figure&&p&每一个State都需要包含当前的游戏得分，可以继续当前游戏玩到第几轮，还有每一轮的选择是什么。当然更重要的，它还需要实现is_terminal()方法判断游戏是否结局，实现compute_reward()方法告诉用户当前得分是多少，还有提供get_next_state()方法用户进行游戏得到新的状态，几个函数与游戏场景游戏，这里简单实现了一个“选择数字保证累加和为1”的游戏。&/p&&figure&&img src=&/v2-293784fdebd468c9f791b_b.jpg& data-caption=&& data-rawwidth=&1392& data-rawheight=&718& class=&origin_image zh-lightbox-thumb& width=&1392& data-original=&/v2-293784fdebd468c9f791b_r.jpg&&&/figure&&p&要实现伪代码提到的几个方法，我们直接定义一个monte_carlo_tree_search()函数，然后依次调用tree_policy()、default_policy()、backup()这些方法实现即可。&/p&&figure&&img src=&/v2-06fa5f47acde9a73e17804df_b.jpg& data-caption=&& data-rawwidth=&2244& data-rawheight=&1098& class=&origin_image zh-lightbox-thumb& width=&2244& data-original=&/v2-06fa5f47acde9a73e17804df_r.jpg&&&/figure&&p&为了避免程序无限搜索下去，我们需要定义一个computation budget，限制搜索次数或者搜索时间，这里限制只能向下搜索1000次，然后通过下面的方法来找到expansion node、计算reward、并且backpropation到所有有关的节点中。我们继续看一下tree_policy()实现。&/p&&figure&&img src=&/v2-b2a85fa8dd0a03b9727223_b.jpg& data-caption=&& data-rawwidth=&2262& data-rawheight=&712& class=&origin_image zh-lightbox-thumb& width=&2262& data-original=&/v2-b2a85fa8dd0a03b9727223_r.jpg&&&/figure&&p&这里代码很简洁，实现了一个策略，就是检查如果一个节点下面还有未探索的子节点，那么先expansion下面的子节点就可以了，如果没有子节点，那么就用best_child()函数（其实也就是UCB算法）来得到下一个子节点，然后便利下直到有未探索的节点可以探索。&/p&&figure&&img src=&/v2-5cbf1b57ed24f1aa5e023_b.jpg& data-caption=&& data-rawwidth=&1818& data-rawheight=&1004& class=&origin_image zh-lightbox-thumb& width=&1818& data-original=&/v2-5cbf1b57ed24f1aa5e023_r.jpg&&&/figure&&p&best_child()算法很简单，就是根据Node的State获取quality value和visit times，然后计算出UCB值，然后比较返回UCB值最大的子节点而已。&/p&&figure&&img src=&/v2-8ed8f022bbd1c75c273cabd100b90d56_b.jpg& data-caption=&& data-rawwidth=&2060& data-rawheight=&750& class=&origin_image zh-lightbox-thumb& width=&2060& data-original=&/v2-8ed8f022bbd1c75c273cabd100b90d56_r.jpg&&&/figure&&p&expand()函数实现稍微复杂些，实际上就是在当前节点下，选择一个未被执行的Action来执行即可，策略就是随机选，如果有随机选中之前已经执行过的则重新选。&/p&&p&因此tree_policy()方法就是根据是否有未探索子节点和UCB值（也就是权衡和exploration和exploitation）后选出了expansion节点，然后就是用default_policy()来模拟剩下的游戏了。&/p&&figure&&img src=&/v2-0c03ddb7af1c622cfbf8b_b.jpg& data-caption=&& data-rawwidth=&1684& data-rawheight=&684& class=&origin_image zh-lightbox-thumb& width=&1684& data-original=&/v2-0c03ddb7af1c622cfbf8b_r.jpg&&&/figure&&p&在这个游戏种模拟也很简单，我们直接调用State类中实现的随机玩游戏策略，一直玩到最后得到一个reward值即可，当然对于AlphaGo等其他游戏可能需要实现一个更优的快速走子网络实现类似的功能，后面会细谈区别与AlphaGo的区别。&/p&&p&那么最后我们就需要把前面计算的这个reward反馈到“相关的”的节点上了，这个相关的意思是从根节点开始一直到这个expansion节点经过的所有节点，他们的quality value和visit times都需要更新，backup()函数实现如下。&/p&&figure&&img src=&/v2-4cbc1c775db56ca5c6d33bf7_b.jpg& data-caption=&& data-rawwidth=&2218& data-rawheight=&568& class=&origin_image zh-lightbox-thumb& width=&2218& data-original=&/v2-4cbc1c775db56ca5c6d33bf7_r.jpg&&&/figure&&p&这就是实现一个典型MCTS算法的完整实现，大概两百多行代码即可，可以通过它来玩搜索空间很大的游戏，并且在给定一定计算能力的基础上找到较优的解。感兴趣的还可以关注下 &a href=&/?target=https%3A///tobegit3hub/ml_implementation& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&tobegit3hub/ml_implementation&i class=&icon-external&&&/i&&/a&，里面有更多机器学习算法的实现源码，也可以提Pull-request贡献更多的算法代码。&/p&&h2&AlphaGo算法区别&/h2&&p&前面我们实现的这种基于UCB的MCTS算法，实际上离训练围棋机器人的算法还是比较远的，其中AlphaGo也是基于MCTS算法，但做了很多优化。&/p&&p&我简单看了下 &a href=&/?target=http%3A///alphago-zero-notes& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://www.&/span&&span class=&visible&&/alphag&/span&&span class=&invisible&&o-zero-notes&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& 的介绍，AlphaGo不仅替换了经典实现的UCB算法，而是使用policy network的输出替换父节点访问次数，同样使用子节点访问次数作为分母保证exploration，Q值也改为从快速走子网络得到的所有叶子节点的均值，神经网络也是从前代的CNN改为最新的ResNet，这样复杂的神经网络模型比一般的UCB算法效果会好更多。&/p&&p&首先，AlphaGo每个节点可选action太多了，selection阶段不能像前面先遍历完所有子节点再expansion，这里是用改进的UCB算法来找到最优的需要expansion子节点，算法基本类似也是有控制exploration/exploitation的常量C并且与该子节点visit times成反比。&/p&&p&其次，进行expansion时不会像前面这样直接random选择任意的action，而是这里也考虑到exploration/exploitation，一般前30步根据visit times成正比来选择，这样可以尽可能得先探索（根节点加入了狄利克雷分布保证所有点都经过），后面主要是根据visit times来走了。&/p&&p&第三，新版AlphaGo Zero去掉了基于handcraft规则的rollout policy，也就是快速走子网络，以前是必须有快速走子直到完成比赛才能得到反馈，现在是直接基于神经网络计算预估的winer value概率值，然后平均得到每个子节点的state-action value也就是Q值。&/p&&p&第四，AlphaGo在MCTS基础上收集最终的比赛结果作为label，MCTS作为policy evalution和policy iteration来实现增强学习。&/p&&p&当然AlphaGo在MCTS上还可以做更懂优化，只是一旦我们理解了MCTS的核心原理，看这些paper和介绍就更加清晰明了。&/p&&h2&总结&/h2&&p&最后再次推荐蒙特卡罗树搜索的论文 A Survey of Monte Carlo Tree Search Methods &a href=&/?target=http%3A//pubs.doc.ic.ac.uk/survey-mcts-methods/survey-mcts-methods.pdf& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&pubs.doc.ic.ac.uk/surve&/span&&span class=&invisible&&y-mcts-methods/survey-mcts-methods.pdf&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& ，里面提到MCTS适用于各种Combinatorial game的场景，当然也提到它的不足，例如在象棋游戏种就不如围棋效果好。&/p&&p&希望大家看完有所启发，也能用蒙特卡罗树搜索做出更有意思的东西！！！&/p&&p&&br&&/p&&p&------------------------------- Updated -------------------------------&/p&&p&更新，经 @聂风 提醒，“exploitation”翻译为“利用”。&/p&&p&更新，经 &a class=&member_mention& href=&/people/5bbed775b9097eedbb974e& data-hash=&5bbed775b9097eedbb974e& data-hovercard=&p$b$5bbed775b9097eedbb974e&&@李树槐&/a& 提醒，AlphaGo算法区别章节有错漏，重新编写。&/p&&p&更新，经 &a class=&member_mention& href=&/people/a2e55f3fe779a094e91e& data-hash=&a2e55f3fe779a094e91e& data-hovercard=&p$b$a2e55f3fe779a094e91e&&@Jin Wang&/a& 提醒，更新对示例游戏的描述。&/p&
简介最近AlphaGo Zero又火了一把，paper和各种分析文章都有了，有人看到了说不就是普通的Reinforcement learning吗，有人还没理解估值网络、快速下子网络的作用就放弃了。实际上，围棋是一种零和、信息对称的combinatorial game，因此AlphaGo用的是蒙特卡罗…
&figure&&img src=&/v2-8cc09c2cfcf1c981eead68_b.jpg& data-rawwidth=&504& data-rawheight=&254& class=&origin_image zh-lightbox-thumb& width=&504& data-original=&/v2-8cc09c2cfcf1c981eead68_r.jpg&&&/figure&&p&在 AlphaGo Zero 论文发布几天后，著名免费围棋程序 Leela 的作者就已开源了 &a href=&/?target=https%3A///gcp/leela-zero& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&gcp/leela-zero&i class=&icon-external&&&/i&&/a& 项目，基本复制了 AlphaGo Zero 方法（其中还对特征层做了个小改进可能会让黑白棋力更一致）。感兴趣的读者可点击看看。&/p&&p&但是 AlphaGo Zero 的难点不在于它的方法，它的方法是特别简单，我从前在这个专栏的文章也说过应该用 MCTS 去直接强化网络。关键是 DeepMind 的论文其实有点狡猾，没有说训练时的精确配置，结果所有新闻报道都把训练过程说成特别轻而易举。&/p&&p&实际上：&/p&&ol&&li&对弈时只需 4 个 TPU v2（估计相当于 40 张 GTX 1080 Ti？）就可实现超强的实力。&/li&&li&&b&从自我对弈棋谱训练网络，也不需要很强的算力。DeepMind 论文中的 64 个 GPU worker，完全足够。请评论中的朋友看清楚这一点。&/b&&/li&&li&&b&但生成自我对弈的棋谱，需要大量算力，需要的 TPU v2 数未知，经大家估算，需要 10000 张 GTX 1080 Ti 的算力。&/b&&/li&&/ol&&p&如 CGI 团队所计算的：&/p&&figure&&img src=&/v2-ddbd1ce84a8f8_b.jpg& data-caption=&& data-rawwidth=&580& data-rawheight=&1031& class=&origin_image zh-lightbox-thumb& width=&580& data-original=&/v2-ddbd1ce84a8f8_r.jpg&&&/figure&&figure&&img src=&/v2-c28d13fd91eea4dea743e879_b.jpg& data-caption=&& data-rawwidth=&580& data-rawheight=&1031& class=&origin_image zh-lightbox-thumb& width=&580& data-original=&/v2-c28d13fd91eea4dea743e879_r.jpg&&&/figure&&figure&&img src=&/v2-ce34cca8c183b634e66e7d_b.jpg& data-caption=&& data-rawwidth=&580& data-rawheight=&693& class=&origin_image zh-lightbox-thumb& width=&580& data-original=&/v2-ce34cca8c183b634e66e7d_r.jpg&&&/figure&&p&而 Leela 的作者也有类似的估算。&b&所以这需要许多人通力合作，把自我对弈过程做成一个分布式项目。估计除非把虚拟货币和这个挂上钩才会有这么多的算力。&/b&&/p&&p&此外，AlphaGo Zero 的 39 层（20 block）和 79 层（40 block）版本的棋力也有一定区别。下面是 20 block 版本，看上去极限小于 5000 ELO：&/p&&figure&&img src=&/v2-ce7cc14d316_b.jpg& data-caption=&& data-rawwidth=&273& data-rawheight=&238& class=&content_image& width=&273&&&/figure&&p&下面是 40 block 版本，看上去极限在 5500 ELO 或以上：&/p&&figure&&img src=&/v2-6ed0bf1ddf411c017e431c7e252d773d_b.jpg& data-caption=&& data-rawwidth=&510& data-rawheight=&252& class=&origin_image zh-lightbox-thumb& width=&510& data-original=&/v2-6ed0bf1ddf411c017e431c7e252d773d_r.jpg&&&/figure&&p&据 Zen 的作者所言，DeepMind 团队曾告诉他 Master 使用的是 20 block 版本的网络，而 ELO 在 4858。&b&所以 Zero 和 Master 在相同架构下棋力并没有区别，人类棋谱并没有反作用&/b&。&/p&
在 AlphaGo Zero 论文发布几天后，著名免费围棋程序 Leela 的作者就已开源了
项目，基本复制了 AlphaGo Zero 方法（其中还对特征层做了个小改进可能会让黑白棋力更一致）。感兴趣的读者可点击看看。但是 AlphaGo Zero 的难点不在于它的方法…
我来讲一讲Random Forest和Gradient Tree Boosting这两个模型是如何调参的好了，以下引自于我的博文：&br&&a href=&///?target=http%3A///jasonfreak/p/5720137.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&使用sklearn进行集成学习——实践&i class=&icon-external&&&/i&&/a&&br&&b&系列&/b&&ul&&li&&a href=&///?target=http%3A///jasonfreak/p/5657196.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&《使用sklearn进行集成学习——理论》&i class=&icon-external&&&/i&&/a&&/li&&li&&a href=&///?target=http%3A///jasonfreak/p/5720137.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&《使用sklearn进行集成学习——实践》&i class=&icon-external&&&/i&&/a&&/li&&/ul&&b&目录&/b&&p&1 Random Forest和Gradient Tree Boosting参数详解&br&2 如何调参？&br& 2.1 调参的目标：偏差和方差的协调&br& 2.2 参数对整体模型性能的影响&br& 2.3 一个朴实的方案：贪心的坐标下降法&br& 2.3.1 Random Forest调参案例：Digit Recognizer&br& 2.3.1.1 调整过程影响类参数&br& 2.3.1.2 调整子模型影响类参数&br& 2.3.2 Gradient Tree Boosting调参案例：Hackathon3.x&br& 2.3.2.1 调整过程影响类参数&br& 2.3.2.2 调整子模型影响类参数&br& 2.3.2.3 杀一记回马枪&br& 2.4 “局部最优解”（温馨提示：看到这里有彩蛋！）&br& 2.5 类别不均衡的陷阱&br&3 总结&br&4 参考资料&br&&/p&&b&1 Random Forest和Gradient Tree Boosting参数详解&/b&&p& 在sklearn.ensemble库中，我们可以找到Random Forest分类和回归的实现：RandomForestClassifier和RandomForestRegression，Gradient Tree Boosting分类和回归的实现：GradientBoostingClassifier和GradientBoostingRegression。有了这些模型后，立马上手操练起来？少侠请留步！且听我说一说，使用这些模型时常遇到的问题：&/p&&ul&&li&明明模型调教得很好了，可是效果离我的想象总有些偏差？——模型训练的第一步就是要定好目标，往错误的方向走太多也是后退。&/li&&li&凭直觉调了某个参数，可是居然没有任何作用，有时甚至起到反作用？——定好目标后，接下来就是要确定哪些参数是影响目标的，其对目标是正影响还是负影响，影响的大小。&/li&&li&感觉训练结束遥遥无期，sklearn只是个在小数据上的玩具？——虽然sklearn并不是基于分布式计算环境而设计的，但我们还是可以通过某些策略提高训练的效率。&/li&&li&模型开始训练了，但是训练到哪一步了呢？——饱暖思淫欲啊，目标，性能和效率都得了满足后，我们有时还需要有别的追求，例如训练过程的输出，袋外得分计算等等。&/li&&/ul&&p& 通过总结这些常见的问题，我们可以把模型的参数分为4类：目标类、性能类、效率类和附加类。下表详细地展示了4个模型参数的意义：&/p&&figure&&img src=&/69e2dda971db9dc79d3ff2_b.png& data-rawwidth=&1117& data-rawheight=&2391& class=&origin_image zh-lightbox-thumb& width=&1117& data-original=&/69e2dda971db9dc79d3ff2_r.png&&&/figure&&p&&em&# ★：默认值&/em&&/p&&p& 不难发现，基于bagging的Random Forest模型和基于boosting的Gradient Tree Boosting模型有不少共同的参数，然而某些参数的默认值又相差甚远。在&a href=&///?target=http%3A///jasonfreak/p/5657196.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&《使用sklearn进行集成学习——理论》&i class=&icon-external&&&/i&&/a&一文中，我们对bagging和boosting两种集成学习技术有了初步的了解。Random Forest的子模型都拥有较低的偏差，整体模型的训练过程旨在降低方差，故其需要较少的子模型（n_estimators默认值为10）且子模型不为弱模型（max_depth的默认值为None），同时，降低子模型间的相关度可以起到减少整体模型的方差的效果（max_features的默认值为auto）。另一方面，Gradient Tree Boosting的子模型都拥有较低的方差，整体模型的训练过程旨在降低偏差，故其需要较多的子模型（n_estimators默认值为100）且子模型为弱模型（max_depth的默认值为3），但是降低子模型间的相关度不能显著减少整体模型的方差（max_features的默认值为None）。&/p&&b&2 如何调参？&/b&&p& 聪明的读者应当要发问了：”博主，就算你列出来每个参数的意义，然并卵啊！我还是不知道无从下手啊！”&/p&&p& 参数分类的目的在于缩小调参的范围，首先我们要明确训练的目标，把目标类的参数定下来。接下来，我们需要根据数据集的大小，考虑是否采用一些提高训练效率的策略，否则一次训练就三天三夜，法国人孩子都生出来了。然后，我们终于进入到了重中之重的环节：调整那些影响整体模型性能的参数。&/p&&b&2.1 调参的目标：偏差和方差的协调&/b&&p& 同样在&a href=&///?target=http%3A///jasonfreak/p/5657196.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&《使用sklearn进行集成学习——理论》&i class=&icon-external&&&/i&&/a&中，我们已讨论过偏差和方差是怎样影响着模型的性能——准确度。调参的目标就是为了达到整体模型的偏差和方差的大和谐！进一步，这些参数又可分为两类：过程影响类及子模型影响类。在子模型不变的前提下，某些参数可以通过改变训练的过程，从而影响模型的性能，诸如：“子模型数”（n_estimators）、“学习率”（learning_rate）等。另外，我们还可以通过改变子模型性能来影响整体模型的性能，诸如：“最大树深度”（max_depth）、“分裂条件”（criterion）等。正由于bagging的训练过程旨在降低方差，而boosting的训练过程旨在降低偏差，过程影响类的参数能够引起整体模型性能的大幅度变化。一般来说，在此前提下，我们继续微调子模型影响类的参数，从而进一步提高模型的性能。&/p&&b&2.2 参数对整体模型性能的影响&/b&&p& 假设模型是一个多元函数F，其输出值为模型的准确度。我们可以固定其他参数，从而对某个参数对整体模型性能的影响进行分析：是正影响还是负影响，影响的单调性？&/p&&p& 对Random Forest来说，增加“子模型数”（n_estimators）可以明显降低整体模型的方差，且不会对子模型的偏差和方差有任何影响。模型的准确度会随着“子模型数”的增加而提高。由于减少的是整体模型方差公式的第二项，故准确度的提高有一个上限。在不同的场景下，“分裂条件”（criterion）对模型的准确度的影响也不一样，该参数需要在实际运用时灵活调整。调整“最大叶节点数”（max_leaf_nodes）以及“最大树深度”（max_depth）之一，可以粗粒度地调整树的结构：叶节点越多或者树越深，意味着子模型的偏差越低，方差越高；同时，调整“分裂所需最小样本数”（min_samples_split）、“叶节点最小样本数”（min_samples_leaf）及“叶节点最小权重总值”（min_weight_fraction_leaf），可以更细粒度地调整树的结构：分裂所需样本数越少或者叶节点所需样本越少，也意味着子模型越复杂。一般来说，我们总采用bootstrap对样本进行子采样来降低子模型之间的关联度，从而降低整体模型的方差。适当地减少“分裂时考虑的最大特征数”（max_features），给子模型注入了另外的随机性，同样也达到了降低子模型之间关联度的效果。但是一味地降低该参数也是不行的，因为分裂时可选特征变少，模型的偏差会越来越大。在下图中，我们可以看到这些参数对Random Forest整体模型性能的影响：&/p&&p&&figure&&img src=&/1a914a6cb136d042d6d8efef78800c0c_b.jpg& data-rawwidth=&1781& data-rawheight=&1263& class=&origin_image zh-lightbox-thumb& width=&1781& data-original=&/1a914a6cb136d042d6d8efef78800c0c_r.jpg&&&/figure& 对Gradient Tree Boosting来说，“子模型数”（}
（活久见，本答案的感谢数是赞同数的1/3，看来学渣还是占大多数，23333）看了其它的答案，恕我直言，大部分都是垃圾，不是说内容垃圾（很多内容我看不懂），而是说方法垃圾，对于一个不是学计算机而想要入门tensorflow的人，上来讲一大堆原理和算法，有个鸟…
&p&常言道，师傅领进门，修行靠个人，相信很多人或多或少是在别人的建议或带领下步入深度学习这个大坑，然后师傅说深度学习是个玄学，后面就靠个人修行，瞬间就懵了对不对？可能后面经过自己不断实验积累相关经验，会有一些自己的学习心得。本文可谓是深度学习中的一份秘籍，帮助你少走一些弯路。在本文中，列举了一些常用的机器学习的训练技巧，目的是对这些技巧进行简单的介绍并说明它们的工作原理。另外一些建议是斯坦福的&u&&a href=&/?target=http%3A//cs231n.github.io/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&CS231n&i class=&icon-external&&&/i&&/a&&/u&课程及之前总结的&u&&a href=&/?target=https%3A///Conchylicultor/Deep-Learning-Tricks/blob/master/networks.md& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&网络结构&i class=&icon-external&&&/i&&/a&&/u&。&/p&&p&本文的目录如下：&/p&&ul&&li&数据预处理&/li&&li&初始化&/li&&li&训练&/li&&li&正则化&/li&&li&网络结构&/li&&li&自然语言处理&/li&&li&增强学习&/li&&li&网络压缩&br&&/li&&/ul&&h2&&b&数据预处理&/b&&/h2&&p&（本部分原作者没有写，以个人的理解及相关补充这部分内容）&/p&&p&&b&What&/b&：输入神经网络数据的好坏直接关系着网络训练结果，一般需要对数据进行预处理，常用的数据预处理方式有：&/p&&p&&br&&/p&&ul&&li&去均值：每个原始数据减去全部数据的均值，即把输入数据各个维度的数据都中心化到0； &/li&&li&归一化：一种方式是使用去均值后的数据除以标准差，另外一种方式是全部数据都除以数据绝对值的最大值；&br&&/li&&li&PCA/白化：这是另外一种形式的数据预处理方式，一种方式是降维处理，另外一种是进行方差处理； &/li&&/ul&&p&&br&&/p&&p&&b&Why&/b&：通过对数据进行预处理能够使得它们对模型的影响具有同样的尺度或其他的一些目的。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=http%3A//cs231n.github.io/neural-networks-2/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&CS231n Convolutional Neural Networks for Visual Recognition.&i class=&icon-external&&&/i&&/a&&/u&&/p&&h2&&b&初始化&/b&&/h2&&p&&b&What&/b&：权重若初始化合理能够提升性能并加快训练速度，偏置一般设置为0，对于权重而言，建议统一到一定区间内：&/p&&p&&br&&/p&&ul&&li&对于线性层[1]：区间为[-v,v]，v = 1/sqrt(输入尺寸)，sqrt表示开根号； &/li&&li&对于卷积层[2]：区间为[-v,v]，v = 1/sqrt(卷积核的宽度x卷积核的高度x输入深度)； &/li&&li&批量标准化[3]在某些方面的应用降低了调整权值初始化的需要，一些研究结果页提出了相应的替代公式。 &/li&&/ul&&p&&br&&/p&&p&&b&Why&/b&：使用默认的初始化，每个神经元会随着输入数量的增多而存在一个方差，通过求根号缩放每个权重能确保神经元有近似的输出分布。&/p&&p&&b&Ref&/b&：&/p&&p&&br&&/p&&ul&&li&1.&u&&a href=&/?target=http%3A//www./pubs/192769/tricks-2012.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Stochastic Gradient Descent Tricks, Leon Bottou&i class=&icon-external&&&/i&&/a&&/u&； &/li&&li&2.在Torch中默认这么操作； &/li&&li&3.&u&&a href=&/?target=https%3A//arxiv.org/abs/%3Fspm%3D.blogcont.AWmFul%26file%3D& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift, S. Ioffe and C. Szegedy；&i class=&icon-external&&&/i&&/a&&/u&&/li&&/ul&&p&&br&&/p&&p&&b&What&/b&：对于长短期记忆网络（LSTM），遗忘偏置一般设置为1，可以加快训练过程。&/p&&p&&b&Why&/b&：直觉是训练开始时，想要信息在细胞之间传播，故不希望细胞忘记它的状态。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=http%3A//www.datascienceassn.org/sites/default/files/An%2520Empirical%2520Exploration%2520of%2520Recurrent%2520Network%2520Architectures.pdf%3Fspm%3D.blogcont.AWmFul%26file%3DAn%2520Empirical%2520Exploration%2520of%2520Recurrent%2520Network%2520Architectures.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&An Empirical Exploration of Recurrent Network Architectures, Rafal Jozefowicz et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：对于t-分布领域嵌入算法（t-SNE），原作者建议对于大小为之间的数据集，将困惑度设置为5和50之间[1]，对于更大的数据集，相应的困惑度也会增。&/p&&p&&b&Why&/b&：困惑度决定了每个点的高斯分布的方差大小，更小的困惑度将获得更多的集群，大的困惑度与之相反，太大的困惑度没有任何意义；另外需要考虑的是画出的聚类不能保留原有的规模，聚类之间的距离不一定代表原始的空间几何，不同的困惑度能在数据结构上提供互补的信息，每次运行都会产生不同的结果[2]。&/p&&p&&b&Ref&/b&：&/p&&p&&br&&/p&&ul&&li&1.&u&&a href=&/?target=http%3A///s%3Fwd%3Dpaperuri%253A%d0e53d5d8ce70cf0dfdc3dfilter%3Dsc_long_sign%26tn%3DSE_xueshusource_2kduw22v%26sc_vurl%3Dhttp%253A%252F%%252Fdocument%252Fvid%252Fdb04eb2c-31d8-4ee3-abde-d422c86e2bc9%26ie%3Dutf-8%26sc_us%3D43442& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Visualizing High-Dimensional Data Using t-SNE, L.J.P. van der Maaten&i class=&icon-external&&&/i&&/a&&/u&. &/li&&li&2.&u&&a href=&/?target=http%3A//distill.pub/2016/misread-tsne/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&How to Use t-SNE Effectively, Wattenberg, et al., Distill, 2016.&i class=&icon-external&&&/i&&/a&&/u& &/li&&/ul&&p&&br&&/p&&h2&&b&训练&/b&&/h2&&p&&b&What&/b&：除了使用真值硬化目标外，同样可以使用软化目标（softmax输出）训练网络。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Distilling the Knowledge in a Neural Network / Dark knowledge, G. Hinton et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：学习率可能是需要调参中最重要的一个参数，一种策略是选择一些参数均有随机化学习率，并观察几次迭代后的测试误差。&/p&&figure&&img src=&/v2-832a0a34abcc59ee0561d_b.jpg& data-caption=&& data-rawwidth=&576& data-rawheight=&720& class=&origin_image zh-lightbox-thumb& width=&576& data-original=&/v2-832a0a34abcc59ee0561d_r.jpg&&&/figure&&p&&b&Ref&/b&：Some advice for tuning the hyperparameters. Ref: Goodfellow et al 2016 Book&/p&&p&&br&&/p&&h2&&b&正则化&/b&&/h2&&p&&b&What：&/b&在RNN中使用Dropout，它仅仅应用于非循环连接[1]，但是一些最近的文章提出了一些技巧使得Dropout能应用于循环连接[2]。&/p&&p&&b&Ref&/b&：&/p&&p&&br&&/p&&ul&&li&1.&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Recurrent Neural Network Regularization, Wojciech Zaremba et al.&i class=&icon-external&&&/i&&/a&&/u& &/li&&li&2.&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Recurrent Dropout without Memory Loss, Stanislau Semeniuta et al.&i class=&icon-external&&&/i&&/a&&/u& &/li&&/ul&&p&&br&&/p&&p&&br&&/p&&p&&b&What&/b&：批量标准化（Batch Normalization, BN），增添了一个新的层，作者给出一些额外的技巧加速BN层的工作：&/p&&p&&br&&/p&&ul&&li&增大学习率；&br&&/li&&li&移除/减少dropout：在不增加过拟合发生的条件下加快训练； &/li&&li&移除/减少L2范数权值归一化； &/li&&li&加快学习率衰减速度：使得网络训练更快；&br&&/li&&li&移除局部响应归一化；&br&&/li&&li&将训练样本打乱地更彻底：防止相同的样本总出现在小批量中（验证集上提高了1%）； &/li&&li&减少光度失真；&br&&/li&&/ul&&p&&br&&/p&&p&&b&Why&/b&：&u&&a href=&/?target=https%3A///Why-does-batch-normalization-help& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&一些好的解释在此&i class=&icon-external&&&/i&&/a&&/u&。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Accelerating Deep Network Training by Reducing Internal Covariate Shift, S. Ioffe and C. Szegedy.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&h2&&b&网络结构&/b&&/h2&&p&&b&What&/b&：使用跳跃式连接，直接将中间层连接到输入/输出层。&/p&&p&&b&Why&/b&：作者的观点是通过减少神经网络的底端与顶端之间的处理步骤使得训练深层网络更加简单，并减轻梯度消失问题。&/p&&p&&b&When&/b&：在一些CNN结构中或RNN中一些重要的层。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Generating Sequences With Recurrent Neural Networks, Alex Grave et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&figure&&img src=&/v2-a568d8d4f87f890b363b0_b.jpg& data-rawwidth=&560& data-rawheight=&373& class=&origin_image zh-lightbox-thumb& width=&560& data-original=&/v2-a568d8d4f87f890b363b0_r.jpg&&&figcaption&RNN的跳跃式连接例子&/figcaption&&/figure&&p&&br&&/p&&p&&b&What&/b&：为LSTM增加窥视孔连接（连接之前输出到门的输入），根据作者的观点，这个操作对长时间依赖关系有用。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=http%3A//www.schraudolph.org/pubs/GerSchSch02.pdf& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Learning Precise Timing with LSTM Recurrent Networks, Felix A. Gers et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：大多数的深度学习框架提供了一个结合SoftMax和Log的函数或者是在损失函数中计算SoftMax（在Tensorflow中是softmax_cross_entropy_with_logits，在Torch中是nn.LogSoftMax），这些应该被更好地使用。&/p&&p&&b&Why&/b&：Log（SoftMax）在数值上不稳定是小概率，从而导致溢出等不良结果。另外一种流行的方法是在Log中加入一些小数避免不稳定。&/p&&p&&br&&/p&&h2&&b&自然语言处理（NLP）&/b&&/h2&&p&&b&What：&/b&对于RNN和seq2seq模型的一些技巧：&/p&&p&&br&&/p&&ul&&li&嵌入尺寸：。更小的维度比如256也能导致很好的表现，但是更高的维度不一定导致更好的表现； &/li&&li&对于译码器而言：LSTM&GRU&Vanilla-RNN； &/li&&li&2-4层似乎普遍足够，但带有残差的更深网络看起来很难收敛，更多去挖掘更多的技巧； &/li&&li&Resd（密集的残差连接）&Res（近连接先前层）&无残差连接； &/li&&li&对于编码器而言：双向&单向（反向输入）&单向； &/li&&li&注意力（加法）&注意力（乘法）&无注意力； &/li&&li&使用光束会导致更好的结果；&br&&/li&&/ul&&p&&br&&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=http%3A///s%3Fwd%3Dpaperuri%253A%252822abe28be9bbb62ecc079%2529%26filter%3Dsc_long_sign%26tn%3DSE_xueshusource_2kduw22v%26sc_vurl%3Dhttp%253A%252F%252Farxiv.org%252Fpdf%252F%26ie%3Dutf-8%26sc_us%3D& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Massive Exploration of Neural Machine Translation Architectures, Denny Britz, Anna Goldie et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：对于seq2seq而言，翻转输入序列的顺序，保持目标序列的完整。&/p&&p&&b&Why&/b&：根据作者的观点，这种简单的数据变换极大提升了LSTM的性能。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/Fspm%3D.blogcont.AWmFul%26file%3D& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Sequence to Sequence Learning with Neural Networks, Ilya Sutskever et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：对于seq2seq而言，为编码器和译码器网络使用不同的权值。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Sequence to Sequence Learning with Neural Networks, Ilya Sutskever et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：当训练时，强制更正译码器的输入；在测试时，使用先前的步骤，这使得训练在开始时非常高效，Samy等人提出了一种基于模型转变的改进方法[1]。&/p&&p&&b&Ref&/b&：1.&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Scheduled Sampling for Sequence Prediction with Recurrent Neural Networks, Samy Bengio et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：以无监督的方式训练一个网络去预测文本的下一个字符（char-RNN），该网络将学习一种能用来监督任务的表示（比如情感分析）。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Learning to Generate Reviews and Discovering Sentiment, Ilya Sutskever et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&h2&&b&增强学习&/b&&/h2&&p&&b&What&/b&：异步：以不同的勘探政策同时训练多个代理，提升了鲁棒性。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Asynchronous Methods for Deep Reinforcement Learning, V. Mnih.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：跳帧：每隔4帧计算一次动作，而不是每帧都计算，对于其它帧，重复这个动作。&/p&&p&&b&Why&/b&：在Atari游戏中工作得很好，并且使用这个技巧以大约4倍的速度加快了训练过程。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Playing Atari &i class=&icon-external&&&/i&&/a&&/u&with Deep Reinforcement Learning, V. Mnih. &/p&&p&&br&&/p&&p&&b&What&/b&：历史：不是仅仅将当前帧作为输入，而是将最后的帧与输入叠加，结合间隔为4的跳帧，这意味着我们有一个含t、t-4、t-8及t-12的帧栈。&/p&&p&&b&Why&/b&：这允许网络有一些动量信息。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Deep Reinforcement Learning with Double Q-learning, V. Mnih.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：经验回放：为了避免帧间的相关性，作为一个代理不是更新每一帧，最好是在过渡时期的历史中采样一些样本，该思想类似于有监督学习中训练前打乱数据集。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Prioritized Experience Replay, Tom Schaul et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&p&&b&What&/b&：Parallel Advantage Actor Critic(PAAC)：通过代理的经验以及使用一个单一的同步更新模型使得简化A3C算法成为可能。&/p&&p&&b&Ref&/b&：&u&&a href=&/?target=https%3A//arxiv.org/abs/v2& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Efficient Parallel Methods for Deep Reinforcement Learning, Alfredo V. Clemente et al.&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&&br&&/p&&h2&&b&网络压缩&/b&&/h2&&p&&b&What&/b&：在推理中，为了减少层数，通过批量归一化（BN）层能够吸收其它的权值。这是因为在测试时批量归一化进行地是一个简单的线性缩放。&/p&&p&&br&&/p&&p&&b&作者信息&/b&&/p&&p&&br&&/p&&b&&figure&&img src=&/v2-a4dae8f704d112fcd583d_b.jpg& data-caption=&& data-rawwidth=&326& data-rawheight=&326& class=&content_image& width=&326&&&/figure&&/b&&p&&br&&/p&&p&&u&&a href=&/?target=http%3A//e-pot.xyz/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Conchylicultor&i class=&icon-external&&&/i&&/a&&/u&，谷歌大脑参与者,专注于机器学习和软件开发。&/p&&p&Linkedin：&u&&a href=&/?target=https%3A///in/potetienne/& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://www.&/span&&span class=&visible&&/in/potetie&/span&&span class=&invisible&&nne/&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/u&&/p&&p&Mail：etiennefg.&/p&&p&本文由北邮&a href=&/?target=http%3A///fly51fly%3Fspm%3D.blogconte60Y& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&@爱可可-爱生活&i class=&icon-external&&&/i&&/a&老师推荐，&a href=&/?target=http%3A///taobaodeveloperclub%3Fspm%3D.blogconte60Y& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&阿里云云栖社区&i class=&icon-external&&&/i&&/a&组织翻译。&/p&&p&文章原标题《Deep Learning Tricks》，作者：Conchylicultor，译者：海棠&/p&&p&&br&&/p&&p&&a href=&/?target=http%3A///m/33443/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&原文链接&i class=&icon-external&&&/i&&/a&&/p&&p&&b&更多技术干货敬请关注云栖社区知乎机构号：&a href=&/org/a-li-yun-yun-qi-she-qu-48& class=&internal&&阿里云云栖社区 - 知乎&/a&&/b&&/p&&p&&/p&
常言道，师傅领进门，修行靠个人，相信很多人或多或少是在别人的建议或带领下步入深度学习这个大坑，然后师傅说深度学习是个玄学，后面就靠个人修行，瞬间就懵了对不对？可能后面经过自己不断实验积累相关经验，会有一些自己的学习心得。本文可谓是深度学习…
&figure&&img src=&/v2-4be2c6332abef18bdf64cafe31f1416c_b.jpg& data-rawwidth=&740& data-rawheight=&431& class=&origin_image zh-lightbox-thumb& width=&740& data-original=&/v2-4be2c6332abef18bdf64cafe31f1416c_r.jpg&&&/figure&&p&这是RoboMaster 2018赛季展望系列文章中的一篇技术教学文。作者是RoboMaster智囊团的许悦聪，新加坡南洋理工大学在读博士，校RoboMaster 机器人代表队技术顾问，无人机爱好者，主攻视频和语意相关的机器学习方向。文章部分有修改。&/p&&p&&br&&/p&&p&我会在接下来一段时间里陆续发布“RoboMaster 2018赛季展望”系列文章，有些是RoboMaster比赛内所需技术的介绍文章，作者都是之前参加RoboMaster比赛的学生，有些则是关于RoboMaster 2018赛季的一些新情况介绍。&/p&&p&&br&&/p&&p&这些文章，尤其是技术教学文，对于刚上大学的学生、机器人爱好者或者对RoboMaster比赛感兴趣的观众来说，都是一些不错的入门介绍。&/p&&p&======================================================================&/p&&p&我们都知道，人类有学习的能力。由于人类不断的追求学习和进步，我们今天才处于一个美好的文明社会。百科上是这么定义学习的：学习是通过阅读、观察、实践等手段获得知识或技能的过程，是使得个体得到持续性变化的行为方式。&/p&&p&在工业革命过后，关于&b&机器学习&/b&的话题不停被人们提及和研究。&/p&&p&不难想象，具备有学习能力的机器人，由于经验可以被无穷无尽的芯片储存，机器人做出的判断将越来越精准，犯错的几率也将趋于零。正因为这些优势，机器学习被应用在了高级的、复杂条件下的视觉识别、决策判定等领域。&/p&&p&最近，某著名手机品牌又火了一把，它可以通过摄像头，识别人脸并完成解锁手机等功能。有趣的是，不管主人造型怎么变化，它都能认出主人的脸。&/p&&figure&&img src=&/v2-eb169a90d95e2e7dbf550df_b.jpg& data-rawwidth=&819& data-rawheight=&455& class=&origin_image zh-lightbox-thumb& width=&819& data-original=&/v2-eb169a90d95e2e7dbf550df_r.jpg&&&figcaption&人脸视觉识别&/figcaption&&/figure&&p&&br&&/p&&p&实际上，该手机搭载有&b&神经网络芯片&/b&，通过&b&机器学习&/b&，它能不断的记住主人在每个造型下的微小区别（积累经验）并进行横向对比，最终它将基本不会认错人。&/p&&p&&br&&/p&&p&同样的，在 RoboMaster2017 的赛场上，有着一个九宫格大能量机关。这是当前版本的赛场中，唯一需要用到机器学习式视觉识别的人工智能机关。&/p&&figure&&img src=&/v2-a78b5e233c_b.jpg& data-rawwidth=&490& data-rawheight=&268& data-thumbnail=&/v2-a78b5e233c_b.jpg& class=&origin_image zh-lightbox-thumb& width=&490& data-original=&/v2-a78b5e233c_r.gif&&&figcaption& 击打大能量机关&/figcaption&&/figure&&p&&br&&/p&&p&激活机关的过程有些复杂。机器人先要识别上方的 LED 数字灯，按照先后顺序，依次识别并击打下方每 1.5 秒就变换一次位置的手写体数字，连续 5 次击打成功即可激活机关。&/p&&figure&&img src=&/v2-d8e7aa03b54e2dabcf1c09b80dfce30f_b.jpg& data-rawwidth=&2530& data-rawheight=&1423& class=&origin_image zh-lightbox-thumb& width=&2530& data-original=&/v2-d8e7aa03b54e2dabcf1c09b80dfce30f_r.jpg&&&figcaption& 大能量机关&/figcaption&&/figure&&p&我们来看下这个机关的难点：上方数码管为有序、随机变化的固定形态数字，下方九宫格为每 1.5 秒随机变化位置和字体的手写体数字，1.5 秒内只要错了一个就要重头开始。手写体数字举例如下：&/p&&figure&&img src=&/v2-b424e48bd4543_b.jpg& data-caption=&& data-rawwidth=&751& data-rawheight=&417& class=&origin_image zh-lightbox-thumb& width=&751& data-original=&/v2-b424e48bd4543_r.jpg&&&/figure&&p&&br&面对各种字体的数字一，若按照上一期的传统视觉方法来识别，机器人需要将这五种情况“背下来”。但是，万一比赛出现了第 6 种数字一，机器人就会彻底蒙圈了：“这是啥？没见过，不认识。”&/p&&p&&b&传统视觉识别拓展阅读：&/b&&a href=&/p/?fc=1&group_id=751040#comment-& class=&internal&&RoboMaster 新赛季展望之视觉识别基础教程&/a&&/p&&p&通过上面两个例子，我们可以知道，RoboMaster 赛场中的大能量机关属于更高级的、复杂条件下的视觉识别难题，需要用&b&机器学习&/b&来解决。&/p&&p&&br&&/p&&h2&&b&什么是机器学习？&/b&&/h2&&p&机器人具备机器学习的能力，实际上是在说它的计算机程序具备机器学习的能力。&/p&&p&一个计算机程序不断地实战，过程中不断累积经验，自己提高解决问题的能力，则认为该程序具有机器学习能力。简单说，就是丢给机器一大堆样本范例，让它自己学习理解，再举一反三，解决范例以外的问题。&/p&&figure&&img src=&/v2-cc931ba06e4fb_b.jpg& data-rawwidth=&376& data-rawheight=&208& class=&content_image& width=&376&&&figcaption& 传统方法可能认出中间是萝卜君, 但绝对不知道右边也是萝卜君&/figcaption&&/figure&&p&在上图中，若想要识别萝卜君，传统方法需要手动输入萝卜君的所有特征：比方说它是桔黄色的、有大板牙、头上带点绿...当萝卜君被切成丝，榨成汁，机器人就认不出了。&/p&&p&如果是经过机器学习训练的机器人呢？只要训练得当，哪怕萝卜君变异成白萝卜，变成炒萝卜丝，都逃不过它的法眼，一眼看穿！&/p&&p&&br&&/p&&h2&&b&搭建系统所用的架构&/b&&/h2&&p&要想让机器人能通过程序学习，首先需要搭建机器学习系统的架构。&/p&&p&前人栽树，后人乘凉。对于初学者来说，大部分常见的架构都是搭建好的，有些甚至只需要在软件中敲入几行代码就能完成一个机器学习系统的搭建。&/p&&p&由谷歌开发的&b& TensorFlow&/b&，在机器学习研究领域中较为主流，其代码质量高、成熟度高。&/p&&figure&&img src=&/v2-acabc5ce87cfbc88f91503_b.jpg& data-caption=&& data-rawwidth=&638& data-rawheight=&354& class=&origin_image zh-lightbox-thumb& width=&638& data-original=&/v2-acabc5ce87cfbc88f91503_r.jpg&&&/figure&&p&接下来，小R就以识别 RoboMaster 比赛中的大能量机关为实例，利用 TensorFlow 架构来搭建一个机器学习系统，让机器人拥有辨识不同手写数字的能力！&/p&&p&&br&&/p&&h2&&b&机器学习实战&/b&&/h2&&figure&&img src=&/v2-c3fc52d7f3ceca3c7cba_b.jpg& data-rawwidth=&1080& data-rawheight=&600& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&/v2-c3fc52d7f3ceca3c7cba_r.jpg&&&figcaption&机器学习的视觉识别处理&/figcaption&&/figure&&p&&br&&/p&&h2&&b&机器学习分类&/b&&/h2&&p&机器学习经常被分为以下几类：&b&监督学习，无监督学习，增强学习，半监督学习&/b&。准确率在 90% 以上的任务，基本上都属于监督学习。&/p&&p&&b&监督学习&/b&，就像让机器人完成一本已经有明确答案的练习册，通过这种练习和比对答案，最后在测试中取得优异成绩。简单来讲，机器人用下图左边 5 个奇形怪状的 1 来训练，我们告诉它这些结果都是右边的 1。&/p&&figure&&img src=&/v2-79863adf6f5e1ed53c0ef43d7f1c8f32_b.jpg& data-rawwidth=&988& data-rawheight=&261& class=&origin_image zh-lightbox-thumb& width=&988& data-original=&/v2-79863adf6f5e1ed53c0ef43d7f1c8f32_r.jpg&&&figcaption&有答案的练习&/figcaption&&/figure&&p&&br&&b&无监督学习&/b&，就像让机器人一本没有答案的练习册来学习。丢给它一堆图片，又不告诉它这些图片都是什么，恩让它用心去感受。将来给它一张图片，它只能告诉我们这张图片和谁比较像。&br&在大能量机关识别中，当然要用准确率较高的监督学习啦。想让机器人成绩好，训练量要足够。我们要拥有一套训练数据，也就是各种各样的手写字符图片。&/p&&p&&i&这里没有介绍增强学习和半监督学习。增强学习需要和环境进行交互，文中未有相应案例；相比半监督学习，监督学习更适合初学者研究。有兴趣的同学可进一步阅读：《机器学习》周志华著，清华大学出版社。&/i&&/p&&p&&br&&/p&&h2&&b&机器的练习册&/b&&/h2&&p&我们先看下哪些地方可以找到训练用的练习册。在官网和论坛上，RoboMaster 组委会大方地提供了大能量机关显示程序里 90% 的手写数字。&/p&&figure&&img src=&/v2-f10ec060cf807b4d4b81d_b.jpg& data-rawwidth=&741& data-rawheight=&388& class=&origin_image zh-lightbox-thumb& width=&741& data-original=&/v2-f10ec060cf807b4d4b81d_r.jpg&&&figcaption&整理整齐的训练数据&/figcaption&&/figure&&p&这些都是宝，其中不乏很难认出来的幼儿园小朋友手写体。&/p&&figure&&img src=&/v2-4d8dbfc7baa_b.jpg& data-caption=&& data-rawwidth=&269& data-rawheight=&290& class=&content_image& width=&269&&&/figure&&p&&br&我们从上一期的视觉基础篇知道，图片是以很多的像素点组成，每个像素点的值介于 0~255。因此，一切的图片在机器人眼里就是一个个矩阵。&/p&&figure&&img src=&/v2-6fa1ec00d53fb8c63e9bd4e1_b.jpg& data-rawwidth=&865& data-rawheight=&341& class=&origin_image zh-lightbox-thumb& width=&865& data-original=&/v2-6fa1ec00d53fb8c63e9bd4e1_r.jpg&&&figcaption&一个个矩阵&/figcaption&&/figure&&p&&i&把数字 1 放大就能看到像素点，这里显示的是标准化后的灰度值。&/i&&/p&&p&&br&&/p&&p&先将所有的数据格式统一，比如都转换为28*28的图片（为了之后处理更方便），然后再对所有数据做标签，训练数据集就完成啦，这就是机器的练习册。&/p&&figure&&img src=&/v2-2aec40c7f2dbb2b996687_b.jpg& data-caption=&& data-rawwidth=&407& data-rawheight=&409& class=&content_image& width=&407&&&/figure&&p&&i&现在有和手写数字输入相关的训练数据集——MNIST 数据集。有兴趣的同学请至&br&&a href=&/?target=http%3A///exdb/mnist/& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&/exdb/mni&/span&&span class=&invisible&&st/&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& 浏览。&/i&&/p&&p&&br&&/p&&p&有了数据（练习册）之后，我们需要用前面说到的机器学习的系统架构来进行处理。&/p&&p&一种非常流行的机器学习的系统架构，有个听上去更高端的叫法——&b&神经网络&/b&。&/p&&h2&&br&&b&神经网络&/b&&/h2&&p&简单来说，神经网络模仿的即是人类的中枢神经系统，由大量的神经元构成，神经元在程序中体现为参数可改变的函数。线性神经元大概长这样：&/p&&figure&&img src=&/v2-8b946b7ed3317ebca38b02caebad278b_b.jpg& data-caption=&& data-rawwidth=&1080& data-rawheight=&600& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&/v2-8b946b7ed3317ebca38b02caebad278b_r.jpg&&&/figure&&p&x 是输入神经元的内容，y 是神经元输出的内容，相当于人脑中神经元突触传递信号。W 和 b 都是可以改变的&b&神经元参数&/b&。其中，W 是权重（weight），它可以代表两个神经元之间联系的相关性。&br&利用 TensorFlow 架构，这个线性的神经元就由下面这几行代码就可以完成搭建啦：&/p&&div class=&highlight&&&pre&&code class=&language-cpp&&&span&&/span& &span class=&n&&x&/span& &span class=&o&&=&/span& &span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&placeholder&/span&&span class=&p&&(&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&float32&/span&&span class=&p&&,[&/span&&span class=&n&&None&/span&&span class=&p&&,&/span& &span class=&mi&&784&/span&&span class=&p&&])&/span&
&span class=&n&&W&/span& &span class=&o&&=&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&Variable&/span&&span class=&p&&(&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&zeros&/span&&span class=&p&&([&/span&&span class=&mi&&784&/span&&span class=&p&&,&/span& &span class=&mi&&10&/span&&span class=&p&&]))&/span&
&span class=&n&&b&/span& &span class=&o&&=&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&Variable&/span&&span class=&p&&(&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&zeros&/span&&span class=&p&&([&/span&&span class=&mi&&10&/span&&span class=&p&&]))&/span&
&span class=&n&&y&/span& &span class=&o&&=&/span& &span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&matmul&/span&&span class=&p&&(&/span&&span class=&n&&x&/span&&span class=&p&&,&/span&&span class=&n&&W&/span&&span class=&p&&)&/span& &span class=&o&&+&/span& &span class=&n&&b&/span&
&/code&&/pre&&/div&&p&线性模型在二维空间中，就是一条死板的直线，没有想象力是干不成大事的。因此，在线性模型之后要加入一个&b&非线性的激活函数&/b&，来激活这个神经元的想象力，让它的思维“拐个弯”。&/p&&figure&&img src=&/v2-54c6b16c1b805e94b30ea1eb41e82f06_b.jpg& data-rawwidth=&1080& data-rawheight=&600& class=&origin_image zh-lightbox-thumb& width=&1080& data-original=&/v2-54c6b16c1b805e94b30ea1eb41e82f06_r.jpg&&&figcaption&非线性的神经元模型&/figcaption&&/figure&&p&我们采用 softmax 归一化指数函数作为激活函数，那 y 的代码就变成：&/p&&div class=&highlight&&&pre&&code class=&language-cpp&&&span&&/span&&span class=&n&&y&/span& &span class=&o&&=&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&nn&/span&&span class=&p&&.&/span&&span class=&n&&softmax&/span&&span class=&p&&(&/span&&span class=&n&&tf&/span&&span class=&p&&.&/span&&span class=&n&&matmul&/span&&span class=&p&&(&/span&&span class=&n&&x&/span&&span class=&p&&,&/span& &span class=&n&&W&/span&&span class=&p&&)&/span& &span class=&o&&+&/span& &span class=&n&&b&/span&&span class=&p&&)&/span&
&/code&&/pre&&/div&&p&实际的神经网络中，上述变量和参数通常都是矩阵形式。矩阵形式的神经元大概像这样：&/p&&figure&&img src=&/v2-bfce04f4e6511cca186fcea_b.jpg& data-rawwidth=&865& data-rawheight=&211& class=&origin_image zh-lightbox-thumb& width=&865& data-original=&/v2-bfce04f4e6511cca186fcea_r.jpg&&&figcaption&神经元模型的矩阵形式&/figcaption&&/figure&&p&要跟其他一堆神经元组成神经网络，它不能只有一个输入输出，就像你大脑里的神经元也不只有一个突触。多个输入的神经元长这样：&/p&&figure&&img src=&/v2-7c2ef7c708a01e23b2d95_b.jpg& data-rawwidth=&704& data-rawheight=&392& class=&origin_image zh-lightbox-thumb& width=&704& data-original=&/v2-7c2ef7c708a01e23b2d95_r.jpg&&&figcaption&多个输入的神经元&/figcaption&&/figure&&p&把这些神经元首尾相连就得到一个神经网络。每一个神经元都可以对特定的输入产生响应，从而得到一个最终的响应。&/p&&figure&&img src=&/v2-9dd561cacfebd0ea1a0ad1f3ae13cc84_b.jpg& data-caption=&& data-rawwidth=&687& data-rawheight=&382& class=&origin_image zh-lightbox-thumb& width=&687& data-original=&/v2-9dd561cacfebd0ea1a0ad1f3ae13cc84_r.jpg&&&/figure&&p&上图是简单的一个神经网络。圆圈表示神经元，箭头连线表示的“权重”。每一列的神经元称作一个&b&层&/b&，红色的是&b&输入层&/b&，蓝色的是&b&隐藏层&/b&，绿色的是&b&输出层&/b&。输入层输入的是图像，输出层输出的就是识别结果啦！&/p&&p&隐藏层越多的机器人，想象力越丰富，只要你用更多的训练去填它的脑洞，它就能做更复杂的工作。如果训练不够，它就会想歪。这种深深的脑洞，就是&b&深度学习神经网络&/b&。&br&&br&&/p&&figure&&img src=&/v2-f7fde8c4ee3bf0f_b.jpg& data-rawwidth=&866& data-rawheight=&481& class=&origin_image zh-lightbox-thumb& width=&866& data-original=&/v2-f7fde8c4ee3bf0f_r.jpg&&&figcaption&深度学习神经网络模型&/figcaption&&/figure&&h2&&b&增强机器人判断力&/b&&/h2&&p&大脑搭好后，需要用到“损失函数”帮助它完成训练，这是一种可以衡量机器人训练得到的输出值和实际给出的输出值到底有多大的差距的东西。&b&简单来说，就是给机器人的行为打分，让它知道自己几斤几两。&/b&&/p&&p&一种最简单的损失函数就是&b&平方损失函数&/b&。由于练习册给出的参考答案（标记）或者机器的回答（输出）都是用矩阵表示，我们可以把它们理解为 N 维空间中的一个点，那么机器的回答和参考答案之间的距离（损失），就是它这道题的扣掉的分数。&/p&&p&&br&&/p&&p&
L(Y,f(X)) = (Y-f(X))^2 &/p&&p&
损失 = ( 参考答案 – 机器答案 )?&/p&&p&&br&&/p&&p&在实际使用中，常用交叉熵损失函数代替平方损失函数。TensorFlow 已经贴心地帮我们把这个损失函数和上文提到的激活函数合并为一行代码：&br&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_,
logits=y))
&/code&&/pre&&/div&&p&&br&在这个神经网络模型中，神经网络的训练可以简单地描述为如何最小化损失。机器训练的过程，其实就是通过&b&改变神经元参数来减少损失&/b&。简单来说，就是&b&机器人通过改变自己的脑回路（参数值）来减少被扣掉的分数。&/b&&br&如果把参数看作是函数的自变量，损失看作因变量，那么，这个过程相当于找到这个函数的最低点。最简单的方法是&b&梯度下降法&/b&。&/p&&figure&&img src=&/v2-854f966b2a341fd6d8d261ee65095b12_b.jpg& data-rawwidth=&679& data-rawheight=&377& class=&origin_image zh-lightbox-thumb& width=&679& data-original=&/v2-854f966b2a341fd6d8d261ee65095b12_r.jpg&&&figcaption&梯度下降法&/figcaption&&/figure&&p&&b&梯度下降法&/b&就像一个人在黑夜里要下山，由于不知道整座山长什么样子（机器也不知道整个函数的图像），所以只能一直找着最陡的下坡路（数学上就是梯度的负方向），那他总能找到一个地势比较低的点（局部最优解）。&/p&&p&&br&&/p&&p&梯度下降法在 TensorFlow 里也是一行代码：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
&/code&&/pre&&/div&&p&&br&&/p&&p&接下来要读取数据库当中的训练数据:&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&batch_xs,batch_ys = mnist.train.next_batch(100)
&/code&&/pre&&/div&&p&&br&&/p&&p&然后依照上面这个训练方法进行训练，读取和训练的代码，变身！&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&sess.run(train_step,feed_dict={x:batch_xs, y_: batch_ys})
&/code&&/pre&&/div&&p&&br&&/p&&p&通过最后两行代码，就能完整地将之前定义的权重和其他参数训练出来，得到一个训练好的、新参数的神经网络。&br&&/p&&figure&&img src=&/v2-2af7b71f51_b.jpg& data-caption=&& data-rawwidth=&3582& data-rawheight=&1990& class=&origin_image zh-lightbox-thumb& width=&3582& data-original=&/v2-2af7b71f51_r.jpg&&&/figure&&p&最后，做练习册的题（训练数据）做得很棒的机器，也不一定能够适应新题型（调整新参数不一定就能判断准确）。要看机器人真正的能力，还要再出考题对它进行测试（测试数据）。&/p&&p&&br&&/p&&p&&br&&/p&&h2&&b&测验最终成果&/b&&/h2&&p&测试用的考题和练习册当然不一样，我们需要准备另一套测试样本。&/p&&p&这里先用摄像头读取实战中的手写图像，经过数据格式统一和贴标签，再将它输入到神经网络里，就能测试出机器学习的结果啦！&/p&&figure&&img src=&/v2-b7e9ddda03e_b.jpg& data-rawwidth=&452& data-rawheight=&251& data-thumbnail=&/v2-b7e9ddda03e_b.jpg& class=&origin_image zh-lightbox-thumb& width=&452& data-original=&/v2-b7e9ddda03e_r.gif&&&figcaption&代码跑起来&/figcaption&&/figure&&p&聪明的机器会懂得举一反三，这种“举一反三”的能力称为&b&泛化能力&/b&。在这里也就是说，机器人能够自己组合不同数字样本的特征，去识别全新的、没有见过的数字。&/p&&p&至此，机器学习视觉识别的整个流程已经完成，训练好的机器终于可以跟操作手一起奔赴 RoboMaster 战场！成功识别出 3 倍攻击力加成的大能量机关，深藏功与名。&/p&&figure&&img src=&/v2-1d5cfcd8d6a529e6e2fc9cc2ac65b7fe_b.jpg& data-caption=&& data-rawwidth=&1258& data-rawheight=&698& class=&origin_image zh-lightbox-thumb& width=&1258& data-original=&/v2-1d5cfcd8d6a529e6e2fc9cc2ac65b7fe_r.jpg&&&/figure&&p&&br&然而，完成大能量机关的视觉识别，在 RoboMaster 比赛中只是激活该机关的第一个步骤。当识别出数字后，机器人身上搭载的发射机构（类似枪口）可不会自己转动到我们想要的角度去击打目标。&/p&&p&如何控制发射机构呢？下一期“闭环控制”，我们再见！&/p&&p&&br&&/p&&p&&a href=&/?target=http%3A///r/BUz64l7E8AOPrRqB9xkX& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&/r/BUz64l7&/span&&span class=&invisible&&E8AOPrRqB9xkX&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& (二维码自动识别)&/p&&p&&/p&
这是RoboMaster 2018赛季展望系列文章中的一篇技术教学文。作者是RoboMaster智囊团的许悦聪，新加坡南洋理工大学在读博士，校RoboMaster 机器人代表队技术顾问，无人机爱好者，主攻视频和语意相关的机器学习方向。文章部分有修改。 我会在接下来一段时间里…
&figure&&img src=&/v2-753ebca93da86afd4aa225_b.jpg& data-rawwidth=&4000& data-rawheight=&3000& class=&origin_image zh-lightbox-thumb& width=&4000& data-original=&/v2-753ebca93da86afd4aa225_r.jpg&&&/figure&&h2&简介&/h2&&p&最近AlphaGo Zero又火了一把，paper和各种分析文章都有了，有人看到了说不就是普通的Reinforcement learning吗，有人还没理解估值网络、快速下子网络的作用就放弃了。&/p&&p&实际上，围棋是一种零和、信息对称的combinatorial game，因此&b&AlphaGo用的是蒙特卡罗树搜索算法的一种&/b&，在计算树节点Q值时使用了ResNet等神经网络模型，只是在论文中也归类为增强学习而已。&/p&&p&如果你想真正了解AlphaGo的原理（或者不被其他AI将统治人类的文章所忽悠），理解蒙特卡罗树搜索（Monte Carlo Tree Search）、博弈论（Game Theory）、多臂老虎机（Multi-arm Bandit）、探索与利用（Exploration and Exploitation）等基础必不可少。&/p&&h2&MCTS初探&/h2&&p&&b&MCTS也就是蒙特卡罗树搜索（Monte Carlo Tree Search），是一类树搜索算法的统称&/b&，可以较为有效地解决一些探索空间巨大的问题，例如一般的围棋算法都是基于MCTS实现的。&/p&&p&这类算法要解决的问题是这样的，我们把围棋的每一步所有可能选择都作为树的节点，第零层只有1个根节点，第1层就有361种下子可能和节点，第2层有360种下子可能和节点，这是一颗非常大的树，我们要在每一层树节点中搜索出赢概率最大的节点，也就是下子方法。&/p&&p&那么树搜索的算法有很多，如果树的层数比较浅，我们可以穷举计算每个节点输赢的概率，那么可以使用一种最简单的策略，叫做minmax算法。基本思路是这样的，从树的叶子结点开始看，如果是本方回合就选择max的，如果是对方回合就是min的，实际上这也是假设对方是聪明的也会使用minmax算法，这样在博弈论里面就达到一个纳什均衡点。&/p&&p&这是搜索空间比较小的时候的策略，MCTS要解决的问题是搜索空间足够大，不能计算得到所有子树的价值，这是需要一种较为高效的搜索策略，同时也得兼顾探索和利用，避免陷入局部最优解。MCTS实现这些特性的方式有多种，例如经典的UCB（Upper Confidence Bounds）算法，就是在选择子节点的时候优先考虑没有探索过的，如果都探索过就根据得分来选择，得分不仅是由这个子节点最终赢的概率来，而且与这个子节点玩的次数成负相关，也就是说这个子节点如果平均得分高就约有可能选中（因为认为它比其他节点更值得利用），同时如果子节点选中次数较多则下次不太会选中（因为其他节点选择次数少更值得探索），因此MCTS根据配置探索和利用不同的权重，可以实现比随机或者其他策略更有启发式的方法。&/p&&p&到这里我们需要理解，&b&蒙特卡罗树搜索是一种基于树数据结构、能权衡探索与利用、在搜索空间巨大仍然比较有效的的搜索算法&/b&。至于这个树搜索算法主要包括Selection、Expansion、Simulation和Backpropagation四个阶段，具体原理和实现会在后面介绍。&/p&&p&前面提到MCTS的使用场景需要是搜索空间巨大，因为搜索空间如果在计算能力以内，其实是没必要用MCTS的，而真正要应用上还需要有其他的假设。涉及到博弈论的概念，我们要求的条件是zero-sum、fully information、determinism、sequential、discrete，也就是说这个场景必须是能分出输赢（不能同时赢）、游戏的信息是完全公开的（不像打牌可以隐藏自己的手牌）、确定性的（每一个操作结果没有随机因素）、顺序的（操作都是按顺序执行的）、离散的（没有操作是一种连续值），除了博弈论我们要求场景是类似多臂老虎机的黑盒环境，不能通过求导或者凸优化方法找到最优解，否则使用MCTS也是没有意义。因此在讨论蒙特卡罗树搜索前，我们需要先有下面的理论基础。&/p&&h2&Game theory基础&/h2&&p&Game theory翻译过来就是博弈论，其实是研究多个玩家在互相交互中取胜的方法。例如在耶鲁大学的博弈论公开课中，有一个游戏是让全班同学从0到100中选一个数，其中如果选择的数最接近所有数的平均值的三分之一则这个玩家获胜。首先大家应该不会选择比33大的数，因为其他人都选择100也不能赢不了，那么如果大家都选择比33小，自己就应该选择比11小的数，考虑到其他人也是这样想的，那么自己应该选择比11小很多的数，如果我知道别人也知道自己选择比11小很多的数的话，那应该选择更小的数。那么这个游戏的理想值是0，也就是纳什均衡点，就是当对方也是深晦游戏规则并且知道你也很懂游戏规则时做出的最优决定，当然第一次游戏大家都不是完美的决策者（或者不知道对方是不是完美的决策者），因此不一定会选择纳什均衡点，但多次游戏后结果就是最终取胜的就是非常接近0的选择。&/p&&p&那么前面提到的什么是纳什均衡点呢？这是Game theory里面很神奇的概念，就是所有人已经选择了对自己而言的最优解并且自己单方面做其他选择也无法再提高的点。也就是说，如果玩家都是高手，能达到或者逼近纳什均衡的策略就是最优策略，如果对手不是高手不会选择最优策略，那么纳什均衡点不一定保证每局都赢，但长远来看极大概率会赢这样的新手。&/p&&p&那么前面提到MCTS适用于特定的游戏场景，因此&b&MCTS也是一种找到逼近纳什均衡的搜索策略&/b&。那么逼近纳什均衡点的策略还有很多，例如前面提到的minmax算法，还有适用于非信息对称游戏的CFR（Counterfactual Regret）算法。像德州扑克我们就会考虑用CFR而不是MCTS，为什么呢？因为MCTS要求是一种Combinatorial Game而不能是信息不对称的。&/p&&p&在博弈论里，信息对称（Perfect information / Fully information）是指游戏的所有信息和状态都是所有玩家都可以观察到的，因此双方的游戏策略只需要关注共同的状态即可，而信息不对称（Imperfect information / Partial information）就是玩家拥有只有自己可以观察到的状态，这样游戏决策时也需要考虑更多的因素。&/p&&p&还有一个概念就是零和（zero-sum），就是所有玩家的收益之和为零，如果我赢就是你输，没有双赢或者双输，因此游戏决策时不需要考虑合作等因素。&/p&&p&那么博弈论中，我们把zero-sum、perfect&br&information、deterministic、discrete、sequential的游戏统称为Combinatorial Game，例如围棋、象棋等，而&b&MCTS只能解决Combinatorial Game的问题&/b&。&/p&&p&对博弈论感兴趣的，可以在 &a href=&/?target=http%3A///movie/2007/7/L/H/M6GOEJOME_M7KDCJHLH.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&网易公开课&i class=&icon-external&&&/i&&/a& 参加耶鲁大学博弈论公开课。&/p&&h2&Black box optimization基础&/h2&&p&了解完Game theory，第二个需要了解的是Black box optimization，也就是黑盒优化。我们知道优化就是根据给定的数据集找到更好的选择，例如机器学习就是典型的优化过程，但我们用的机器学习算法如LR、SVM、DNN都不是黑盒，而是根据数学公式推导通过对函数求导等方式进行的优化。如果我们能把问题描述成一个函数或者凸优化问题，那么我们通过数学上的求导就可以找到最优解，这类问题并不需要用到MCTS等搜索算法，但实际上很多问题例如围棋就无法找到一个描述输赢的函数曲线，这样就无法通过纯数学的方法解决。&/p&&p&这类问题统称为黑盒优化问题，我们不能假设知道这个场景内部的函数或者模型结构，只能通过给定模型输入得到模型输出结果来优化。例如多臂老虎机（Multi-arm Bandit）问题，我们有多台老虎机可以投币，但不知道每一台输赢的概率，只能通过多次投币来测试，根据观察的结果预估每台机器的收益分布，最终选择认为收益最大的，这种方法一般会比随机方法效果好。&/p&&p&黑盒优化的算法也有很多，例如进化算法、贝叶斯优化、MCTS也算是，而这些算法都需要解决如何权衡探索和利用（Exploration and Exploitation）的问题。如果我们只有一个投币，那么当前会选择期望收益最高的老虎机来投（Exploitation），但如果我们有一万个投币，我们不应该只投一个老虎机，而应该用少量币来探索一下其他老虎机（Exploration），说不定能跳过局部最优解找到更优解，当然我们也不能全部投币都用来探索了。&/p&&p&对于Exploration和Exploitation，我在 &a href=&/p/& class=&internal&&一种更好的超参数调优方式&/a& 有更详细的剖析，感兴趣可以关注下 。&/p&&h2&UCB算法基础&/h2&&p&前面讲了Game theory和Black box optimization，这里再补充一个UCB算法基础，这是MCTS的经典实现UCT（Upper Confidence bounds for Trees）里面用到的算法。&/p&&p&算法本身很简单，公式如下。&/p&&figure&&img src=&/v2-2d346fa93431c4feb77c52a_b.jpg& data-caption=&& data-rawwidth=&626& data-rawheight=&136& class=&origin_image zh-lightbox-thumb& width=&626& data-original=&/v2-2d346fa93431c4feb77c52a_r.jpg&&&/figure&&p&其中v'表示当前树节点，v表示父节点，Q表示这个树节点的累计quality值，N表示这个树节点的visit次数，C是一个常量参数（可以控制exploitation和exploration权重）。&/p&&p&这个公式的意思时，对每一个节点求一个值用于后面的选择，这个值有两部分组成，左边是这个节点的平均收益值（越高表示这个节点期望收益好，越值得选择，用于exploitation），右边的变量是这个父节点的总访问次数除以子节点的访问次数（如果子节点访问次数越少则值越大，越值得选择，用户exploration），因此使用这个公式是可以兼顾探索和利用的。&/p&&p&用Python也很容易实现这个算法，其中C常量我们可以使用 &img src=&/equation?tex=1+%2F+%5Csqrt%7B2%7D& alt=&1 / \sqrt{2}& eeimg=&1&& ，这是Kocsis、Szepesvari提出的经验值，完整代码如下。&/p&&figure&&img src=&/v2-34dfa622e17f3b33973e_b.jpg& data-caption=&& data-rawwidth=&1852& data-rawheight=&446& class=&origin_image zh-lightbox-thumb& width=&1852& data-original=&/v2-34dfa622e17f3b33973e_r.jpg&&&/figure&&p&这样我们就有了MCTS的最基础选择算法实现了，下面讨论完整的MCTS算法实现。&/p&&h2&MCTS算法原理&/h2&&p&首先，MCTS的完整实现代码在 &a href=&/?target=https%3A///tobegit3hub/ml_implementation/tree/master/monte_carlo_tree_search& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&tobegit3hub/ml_implementation&i class=&icon-external&&&/i&&/a& ，想直接看源码或者测试的可以去下载运行。&/p&&p&然后，我们需要知道MCTS的算法步骤，可以参考论文 A Survey of Monte Carlo Tree Search Methods &a href=&/?target=http%3A//pubs.doc.ic.ac.uk/survey-mcts-methods/survey-mcts-methods.pdf& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&pubs.doc.ic.ac.uk/surve&/span&&span class=&invisible&&y-mcts-methods/survey-mcts-methods.pdf&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& 。&/p&&p&MCTS的算法分为四步，第一步是Selection，就是在树中找到一个最好的值得探索的节点，一般策略是先选择未被探索的子节点，如果都探索过就选择UCB值最大的子节点。第二步是Expansion，就是在前面选中的子节点中走一步创建一个新的子节点，一般策略是随机自行一个操作并且这个操作不能与前面的子节点重复。第三步是Simulation，就是在前面新Expansion出来的节点开始模拟游戏，直到到达游戏结束状态，这样可以收到到这个expansion出来的节点的得分是多少。第四步是Backpropagation，就是把前面expansion出来的节点得分反馈到前面所有父节点中，更新这些节点的quality value和visit times，方便后面计算UCB值。&/p&&p&基本思路就是这样的，通过不断的模拟得到大部分节点的UCB值，然后下次模拟的时候根据UCB值有策略得选择值得利用和值得探索的节点继续模拟，在搜索空间巨大并且计算能力有限的情况下，这种启发式搜索能更集中地、更大概率找到一些更好的节点。下面是论文的伪代码实现。&/p&&figure&&img src=&/v2-fa50d56d14f560cba37fdc98be1824e0_b.jpg& data-caption=&& data-rawwidth=&884& data-rawheight=&1652& class=&origin_image zh-lightbox-thumb& width=&884& data-original=&/v2-fa50d56d14f560cba37fdc98be1824e0_r.jpg&&&/figure&&p&其中TREE_POLICY就是实现了Selection和和Expansion两个阶段，DEFAULT_POLICY实现了Simulation阶段，BACKUP实现了Backpropagation阶段，基本思路和前面介绍的一样。&/p&&h2&MCTS算法实现&/h2&&p&最后我们看一下前面基于Python的MCTS代码实现，源码在 &a href=&/?target=https%3A///tobegit3hub/ml_implementation/tree/master/monte_carlo_tree_search& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&tobegit3hub/ml_implementation&i class=&icon-external&&&/i&&/a& ，这是整理的代码实现架构图。&/p&&figure&&img src=&/v2-753ebca93da86afd4aa225_b.jpg& data-caption=&& data-rawwidth=&4000& data-rawheight=&3000& class=&origin_image zh-lightbox-thumb& width=&4000& data-original=&/v2-753ebca93da86afd4aa225_r.jpg&&&/figure&&p&由于这是一棵树，我们需要定义N叉树的Node数据结构。&/p&&figure&&img src=&/v2-54dd9b161ca06c78a585cec6dbb56278_b.jpg& data-caption=&& data-rawwidth=&2022& data-rawheight=&514& class=&origin_image zh-lightbox-thumb& width=&2022& data-original=&/v2-54dd9b161ca06c78a585cec6dbb56278_r.jpg&&&/figure&&p&首先Node包含了parent和children属性，还有就是用于计算UCB值的visit times和quality value，为了关联游戏状态，我们还需要为每个Node绑定一个State对象。Node需要实现增加节点、删除节点等功能，还有需要提供函数判断子节点的个数和是否有空闲的子节点位置。&/p&&p&而State的定义与我们使用MCTS的游戏定义有关，我们定义下面的数据结构。&/p&&figure&&img src=&/v2-423f3be3b05cf46e7dccb21_b.jpg& data-caption=&& data-rawwidth=&1930& data-rawheight=&430& class=&origin_image zh-lightbox-thumb& width=&1930& data-original=&/v2-423f3be3b05cf46e7dccb21_r.jpg&&&/figure&&p&每一个State都需要包含当前的游戏得分，可以继续当前游戏玩到第几轮，还有每一轮的选择是什么。当然更重要的，它还需要实现is_terminal()方法判断游戏是否结局，实现compute_reward()方法告诉用户当前得分是多少，还有提供get_next_state()方法用户进行游戏得到新的状态，几个函数与游戏场景游戏，这里简单实现了一个“选择数字保证累加和为1”的游戏。&/p&&figure&&img src=&/v2-293784fdebd468c9f791b_b.jpg& data-caption=&& data-rawwidth=&1392& data-rawheight=&718& class=&origin_image zh-lightbox-thumb& width=&1392& data-original=&/v2-293784fdebd468c9f791b_r.jpg&&&/figure&&p&要实现伪代码提到的几个方法，我们直接定义一个monte_carlo_tree_search()函数，然后依次调用tree_policy()、default_policy()、backup()这些方法实现即可。&/p&&figure&&img src=&/v2-06fa5f47acde9a73e17804df_b.jpg& data-caption=&& data-rawwidth=&2244& data-rawheight=&1098& class=&origin_image zh-lightbox-thumb& width=&2244& data-original=&/v2-06fa5f47acde9a73e17804df_r.jpg&&&/figure&&p&为了避免程序无限搜索下去，我们需要定义一个computation budget，限制搜索次数或者搜索时间，这里限制只能向下搜索1000次，然后通过下面的方法来找到expansion node、计算reward、并且backpropation到所有有关的节点中。我们继续看一下tree_policy()实现。&/p&&figure&&img src=&/v2-b2a85fa8dd0a03b9727223_b.jpg& data-caption=&& data-rawwidth=&2262& data-rawheight=&712& class=&origin_image zh-lightbox-thumb& width=&2262& data-original=&/v2-b2a85fa8dd0a03b9727223_r.jpg&&&/figure&&p&这里代码很简洁，实现了一个策略，就是检查如果一个节点下面还有未探索的子节点，那么先expansion下面的子节点就可以了，如果没有子节点，那么就用best_child()函数（其实也就是UCB算法）来得到下一个子节点，然后便利下直到有未探索的节点可以探索。&/p&&figure&&img src=&/v2-5cbf1b57ed24f1aa5e023_b.jpg& data-caption=&& data-rawwidth=&1818& data-rawheight=&1004& class=&origin_image zh-lightbox-thumb& width=&1818& data-original=&/v2-5cbf1b57ed24f1aa5e023_r.jpg&&&/figure&&p&best_child()算法很简单，就是根据Node的State获取quality value和visit times，然后计算出UCB值，然后比较返回UCB值最大的子节点而已。&/p&&figure&&img src=&/v2-8ed8f022bbd1c75c273cabd100b90d56_b.jpg& data-caption=&& data-rawwidth=&2060& data-rawheight=&750& class=&origin_image zh-lightbox-thumb& width=&2060& data-original=&/v2-8ed8f022bbd1c75c273cabd100b90d56_r.jpg&&&/figure&&p&expand()函数实现稍微复杂些，实际上就是在当前节点下，选择一个未被执行的Action来执行即可，策略就是随机选，如果有随机选中之前已经执行过的则重新选。&/p&&p&因此tree_policy()方法就是根据是否有未探索子节点和UCB值（也就是权衡和exploration和exploitation）后选出了expansion节点，然后就是用default_policy()来模拟剩下的游戏了。&/p&&figure&&img src=&/v2-0c03ddb7af1c622cfbf8b_b.jpg& data-caption=&& data-rawwidth=&1684& data-rawheight=&684& class=&origin_image zh-lightbox-thumb& width=&1684& data-original=&/v2-0c03ddb7af1c622cfbf8b_r.jpg&&&/figure&&p&在这个游戏种模拟也很简单，我们直接调用State类中实现的随机玩游戏策略，一直玩到最后得到一个reward值即可，当然对于AlphaGo等其他游戏可能需要实现一个更优的快速走子网络实现类似的功能，后面会细谈区别与AlphaGo的区别。&/p&&p&那么最后我们就需要把前面计算的这个reward反馈到“相关的”的节点上了，这个相关的意思是从根节点开始一直到这个expansion节点经过的所有节点，他们的quality value和visit times都需要更新，backup()函数实现如下。&/p&&figure&&img src=&/v2-4cbc1c775db56ca5c6d33bf7_b.jpg& data-caption=&& data-rawwidth=&2218& data-rawheight=&568& class=&origin_image zh-lightbox-thumb& width=&2218& data-original=&/v2-4cbc1c775db56ca5c6d33bf7_r.jpg&&&/figure&&p&这就是实现一个典型MCTS算法的完整实现，大概两百多行代码即可，可以通过它来玩搜索空间很大的游戏，并且在给定一定计算能力的基础上找到较优的解。感兴趣的还可以关注下 &a href=&/?target=https%3A///tobegit3hub/ml_implementation& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&tobegit3hub/ml_implementation&i class=&icon-external&&&/i&&/a&，里面有更多机器学习算法的实现源码，也可以提Pull-request贡献更多的算法代码。&/p&&h2&AlphaGo算法区别&/h2&&p&前面我们实现的这种基于UCB的MCTS算法，实际上离训练围棋机器人的算法还是比较远的，其中AlphaGo也是基于MCTS算法，但做了很多优化。&/p&&p&我简单看了下 &a href=&/?target=http%3A///alphago-zero-notes& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://www.&/span&&span class=&visible&&/alphag&/span&&span class=&invisible&&o-zero-notes&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& 的介绍，AlphaGo不仅替换了经典实现的UCB算法，而是使用policy network的输出替换父节点访问次数，同样使用子节点访问次数作为分母保证exploration，Q值也改为从快速走子网络得到的所有叶子节点的均值，神经网络也是从前代的CNN改为最新的ResNet，这样复杂的神经网络模型比一般的UCB算法效果会好更多。&/p&&p&首先，AlphaGo每个节点可选action太多了，selection阶段不能像前面先遍历完所有子节点再expansion，这里是用改进的UCB算法来找到最优的需要expansion子节点，算法基本类似也是有控制exploration/exploitation的常量C并且与该子节点visit times成反比。&/p&&p&其次，进行expansion时不会像前面这样直接random选择任意的action，而是这里也考虑到exploration/exploitation，一般前30步根据visit times成正比来选择，这样可以尽可能得先探索（根节点加入了狄利克雷分布保证所有点都经过），后面主要是根据visit times来走了。&/p&&p&第三，新版AlphaGo Zero去掉了基于handcraft规则的rollout policy，也就是快速走子网络，以前是必须有快速走子直到完成比赛才能得到反馈，现在是直接基于神经网络计算预估的winer value概率值，然后平均得到每个子节点的state-action value也就是Q值。&/p&&p&第四，AlphaGo在MCTS基础上收集最终的比赛结果作为label，MCTS作为policy evalution和policy iteration来实现增强学习。&/p&&p&当然AlphaGo在MCTS上还可以做更懂优化，只是一旦我们理解了MCTS的核心原理，看这些paper和介绍就更加清晰明了。&/p&&h2&总结&/h2&&p&最后再次推荐蒙特卡罗树搜索的论文 A Survey of Monte Carlo Tree Search Methods &a href=&/?target=http%3A//pubs.doc.ic.ac.uk/survey-mcts-methods/survey-mcts-methods.pdf& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&pubs.doc.ic.ac.uk/surve&/span&&span class=&invisible&&y-mcts-methods/survey-mcts-methods.pdf&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& ，里面提到MCTS适用于各种Combinatorial game的场景，当然也提到它的不足，例如在象棋游戏种就不如围棋效果好。&/p&&p&希望大家看完有所启发，也能用蒙特卡罗树搜索做出更有意思的东西！！！&/p&&p&&br&&/p&&p&------------------------------- Updated -------------------------------&/p&&p&更新，经 @聂风 提醒，“exploitation”翻译为“利用”。&/p&&p&更新，经 &a class=&member_mention& href=&/people/5bbed775b9097eedbb974e& data-hash=&5bbed775b9097eedbb974e& data-hovercard=&p$b$5bbed775b9097eedbb974e&&@李树槐&/a& 提醒，AlphaGo算法区别章节有错漏，重新编写。&/p&&p&更新，经 &a class=&member_mention& href=&/people/a2e55f3fe779a094e91e& data-hash=&a2e55f3fe779a094e91e& data-hovercard=&p$b$a2e55f3fe779a094e91e&&@Jin Wang&/a& 提醒，更新对示例游戏的描述。&/p&
简介最近AlphaGo Zero又火了一把，paper和各种分析文章都有了，有人看到了说不就是普通的Reinforcement learning吗，有人还没理解估值网络、快速下子网络的作用就放弃了。实际上，围棋是一种零和、信息对称的combinatorial game，因此AlphaGo用的是蒙特卡罗…
&figure&&img src=&/v2-8cc09c2cfcf1c981eead68_b.jpg& data-rawwidth=&504& data-rawheight=&254& class=&origin_image zh-lightbox-thumb& width=&504& data-original=&/v2-8cc09c2cfcf1c981eead68_r.jpg&&&/figure&&p&在 AlphaGo Zero 论文发布几天后，著名免费围棋程序 Leela 的作者就已开源了 &a href=&/?target=https%3A///gcp/leela-zero& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&gcp/leela-zero&i class=&icon-external&&&/i&&/a& 项目，基本复制了 AlphaGo Zero 方法（其中还对特征层做了个小改进可能会让黑白棋力更一致）。感兴趣的读者可点击看看。&/p&&p&但是 AlphaGo Zero 的难点不在于它的方法，它的方法是特别简单，我从前在这个专栏的文章也说过应该用 MCTS 去直接强化网络。关键是 DeepMind 的论文其实有点狡猾，没有说训练时的精确配置，结果所有新闻报道都把训练过程说成特别轻而易举。&/p&&p&实际上：&/p&&ol&&li&对弈时只需 4 个 TPU v2（估计相当于 40 张 GTX 1080 Ti？）就可实现超强的实力。&/li&&li&&b&从自我对弈棋谱训练网络，也不需要很强的算力。DeepMind 论文中的 64 个 GPU worker，完全足够。请评论中的朋友看清楚这一点。&/b&&/li&&li&&b&但生成自我对弈的棋谱，需要大量算力，需要的 TPU v2 数未知，经大家估算，需要 10000 张 GTX 1080 Ti 的算力。&/b&&/li&&/ol&&p&如 CGI 团队所计算的：&/p&&figure&&img src=&/v2-ddbd1ce84a8f8_b.jpg& data-caption=&& data-rawwidth=&580& data-rawheight=&1031& class=&origin_image zh-lightbox-thumb& width=&580& data-original=&/v2-ddbd1ce84a8f8_r.jpg&&&/figure&&figure&&img src=&/v2-c28d13fd91eea4dea743e879_b.jpg& data-caption=&& data-rawwidth=&580& data-rawheight=&1031& class=&origin_image zh-lightbox-thumb& width=&580& data-original=&/v2-c28d13fd91eea4dea743e879_r.jpg&&&/figure&&figure&&img src=&/v2-ce34cca8c183b634e66e7d_b.jpg& data-caption=&& data-rawwidth=&580& data-rawheight=&693& class=&origin_image zh-lightbox-thumb& width=&580& data-original=&/v2-ce34cca8c183b634e66e7d_r.jpg&&&/figure&&p&而 Leela 的作者也有类似的估算。&b&所以这需要许多人通力合作，把自我对弈过程做成一个分布式项目。估计除非把虚拟货币和这个挂上钩才会有这么多的算力。&/b&&/p&&p&此外，AlphaGo Zero 的 39 层（20 block）和 79 层（40 block）版本的棋力也有一定区别。下面是 20 block 版本，看上去极限小于 5000 ELO：&/p&&figure&&img src=&/v2-ce7cc14d316_b.jpg& data-caption=&& data-rawwidth=&273& data-rawheight=&238& class=&content_image& width=&273&&&/figure&&p&下面是 40 block 版本，看上去极限在 5500 ELO 或以上：&/p&&figure&&img src=&/v2-6ed0bf1ddf411c017e431c7e252d773d_b.jpg& data-caption=&& data-rawwidth=&510& data-rawheight=&252& class=&origin_image zh-lightbox-thumb& width=&510& data-original=&/v2-6ed0bf1ddf411c017e431c7e252d773d_r.jpg&&&/figure&&p&据 Zen 的作者所言，DeepMind 团队曾告诉他 Master 使用的是 20 block 版本的网络，而 ELO 在 4858。&b&所以 Zero 和 Master 在相同架构下棋力并没有区别，人类棋谱并没有反作用&/b&。&/p&
在 AlphaGo Zero 论文发布几天后，著名免费围棋程序 Leela 的作者就已开源了
项目，基本复制了 AlphaGo Zero 方法（其中还对特征层做了个小改进可能会让黑白棋力更一致）。感兴趣的读者可点击看看。但是 AlphaGo Zero 的难点不在于它的方法…
我来讲一讲Random Forest和Gradient Tree Boosting这两个模型是如何调参的好了，以下引自于我的博文：&br&&a href=&///?target=http%3A///jasonfreak/p/5720137.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&使用sklearn进行集成学习——实践&i class=&icon-external&&&/i&&/a&&br&&b&系列&/b&&ul&&li&&a href=&///?target=http%3A///jasonfreak/p/5657196.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&《使用sklearn进行集成学习——理论》&i class=&icon-external&&&/i&&/a&&/li&&li&&a href=&///?target=http%3A///jasonfreak/p/5720137.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&《使用sklearn进行集成学习——实践》&i class=&icon-external&&&/i&&/a&&/li&&/ul&&b&目录&/b&&p&1 Random Forest和Gradient Tree Boosting参数详解&br&2 如何调参？&br& 2.1 调参的目标：偏差和方差的协调&br& 2.2 参数对整体模型性能的影响&br& 2.3 一个朴实的方案：贪心的坐标下降法&br& 2.3.1 Random Forest调参案例：Digit Recognizer&br& 2.3.1.1 调整过程影响类参数&br& 2.3.1.2 调整子模型影响类参数&br& 2.3.2 Gradient Tree Boosting调参案例：Hackathon3.x&br& 2.3.2.1 调整过程影响类参数&br& 2.3.2.2 调整子模型影响类参数&br& 2.3.2.3 杀一记回马枪&br& 2.4 “局部最优解”（温馨提示：看到这里有彩蛋！）&br& 2.5 类别不均衡的陷阱&br&3 总结&br&4 参考资料&br&&/p&&b&1 Random Forest和Gradient Tree Boosting参数详解&/b&&p& 在sklearn.ensemble库中，我们可以找到Random Forest分类和回归的实现：RandomForestClassifier和RandomForestRegression，Gradient Tree Boosting分类和回归的实现：GradientBoostingClassifier和GradientBoostingRegression。有了这些模型后，立马上手操练起来？少侠请留步！且听我说一说，使用这些模型时常遇到的问题：&/p&&ul&&li&明明模型调教得很好了，可是效果离我的想象总有些偏差？——模型训练的第一步就是要定好目标，往错误的方向走太多也是后退。&/li&&li&凭直觉调了某个参数，可是居然没有任何作用，有时甚至起到反作用？——定好目标后，接下来就是要确定哪些参数是影响目标的，其对目标是正影响还是负影响，影响的大小。&/li&&li&感觉训练结束遥遥无期，sklearn只是个在小数据上的玩具？——虽然sklearn并不是基于分布式计算环境而设计的，但我们还是可以通过某些策略提高训练的效率。&/li&&li&模型开始训练了，但是训练到哪一步了呢？——饱暖思淫欲啊，目标，性能和效率都得了满足后，我们有时还需要有别的追求，例如训练过程的输出，袋外得分计算等等。&/li&&/ul&&p& 通过总结这些常见的问题，我们可以把模型的参数分为4类：目标类、性能类、效率类和附加类。下表详细地展示了4个模型参数的意义：&/p&&figure&&img src=&/69e2dda971db9dc79d3ff2_b.png& data-rawwidth=&1117& data-rawheight=&2391& class=&origin_image zh-lightbox-thumb& width=&1117& data-original=&/69e2dda971db9dc79d3ff2_r.png&&&/figure&&p&&em&# ★：默认值&/em&&/p&&p& 不难发现，基于bagging的Random Forest模型和基于boosting的Gradient Tree Boosting模型有不少共同的参数，然而某些参数的默认值又相差甚远。在&a href=&///?target=http%3A///jasonfreak/p/5657196.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&《使用sklearn进行集成学习——理论》&i class=&icon-external&&&/i&&/a&一文中，我们对bagging和boosting两种集成学习技术有了初步的了解。Random Forest的子模型都拥有较低的偏差，整体模型的训练过程旨在降低方差，故其需要较少的子模型（n_estimators默认值为10）且子模型不为弱模型（max_depth的默认值为None），同时，降低子模型间的相关度可以起到减少整体模型的方差的效果（max_features的默认值为auto）。另一方面，Gradient Tree Boosting的子模型都拥有较低的方差，整体模型的训练过程旨在降低偏差，故其需要较多的子模型（n_estimators默认值为100）且子模型为弱模型（max_depth的默认值为3），但是降低子模型间的相关度不能显著减少整体模型的方差（max_features的默认值为None）。&/p&&b&2 如何调参？&/b&&p& 聪明的读者应当要发问了：”博主，就算你列出来每个参数的意义，然并卵啊！我还是不知道无从下手啊！”&/p&&p& 参数分类的目的在于缩小调参的范围，首先我们要明确训练的目标，把目标类的参数定下来。接下来，我们需要根据数据集的大小，考虑是否采用一些提高训练效率的策略，否则一次训练就三天三夜，法国人孩子都生出来了。然后，我们终于进入到了重中之重的环节：调整那些影响整体模型性能的参数。&/p&&b&2.1 调参的目标：偏差和方差的协调&/b&&p& 同样在&a href=&///?target=http%3A///jasonfreak/p/5657196.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&《使用sklearn进行集成学习——理论》&i class=&icon-external&&&/i&&/a&中，我们已讨论过偏差和方差是怎样影响着模型的性能——准确度。调参的目标就是为了达到整体模型的偏差和方差的大和谐！进一步，这些参数又可分为两类：过程影响类及子模型影响类。在子模型不变的前提下，某些参数可以通过改变训练的过程，从而影响模型的性能，诸如：“子模型数”（n_estimators）、“学习率”（learning_rate）等。另外，我们还可以通过改变子模型性能来影响整体模型的性能，诸如：“最大树深度”（max_depth）、“分裂条件”（criterion）等。正由于bagging的训练过程旨在降低方差，而boosting的训练过程旨在降低偏差，过程影响类的参数能够引起整体模型性能的大幅度变化。一般来说，在此前提下，我们继续微调子模型影响类的参数，从而进一步提高模型的性能。&/p&&b&2.2 参数对整体模型性能的影响&/b&&p& 假设模型是一个多元函数F，其输出值为模型的准确度。我们可以固定其他参数，从而对某个参数对整体模型性能的影响进行分析：是正影响还是负影响，影响的单调性？&/p&&p& 对Random Forest来说，增加“子模型数”（n_estimators）可以明显降低整体模型的方差，且不会对子模型的偏差和方差有任何影响。模型的准确度会随着“子模型数”的增加而提高。由于减少的是整体模型方差公式的第二项，故准确度的提高有一个上限。在不同的场景下，“分裂条件”（criterion）对模型的准确度的影响也不一样，该参数需要在实际运用时灵活调整。调整“最大叶节点数”（max_leaf_nodes）以及“最大树深度”（max_depth）之一，可以粗粒度地调整树的结构：叶节点越多或者树越深，意味着子模型的偏差越低，方差越高；同时，调整“分裂所需最小样本数”（min_samples_split）、“叶节点最小样本数”（min_samples_leaf）及“叶节点最小权重总值”（min_weight_fraction_leaf），可以更细粒度地调整树的结构：分裂所需样本数越少或者叶节点所需样本越少，也意味着子模型越复杂。一般来说，我们总采用bootstrap对样本进行子采样来降低子模型之间的关联度，从而降低整体模型的方差。适当地减少“分裂时考虑的最大特征数”（max_features），给子模型注入了另外的随机性，同样也达到了降低子模型之间关联度的效果。但是一味地降低该参数也是不行的，因为分裂时可选特征变少，模型的偏差会越来越大。在下图中，我们可以看到这些参数对Random Forest整体模型性能的影响：&/p&&p&&figure&&img src=&/1a914a6cb136d042d6d8efef78800c0c_b.jpg& data-rawwidth=&1781& data-rawheight=&1263& class=&origin_image zh-lightbox-thumb& width=&1781& data-original=&/1a914a6cb136d042d6d8efef78800c0c_r.jpg&&&/figure& 对Gradient Tree Boosting来说，“子模型数”（}
我要回帖
更多关于 knn是聚类吗 的文章
更多推荐
- ·宜春寺庙排名的慈化寺庙和仰山栖隐禅寺哪个更好逛 祈福更灵验？
- ·《视频英语朗诵未选择的路路》英文怎样？?
- ·3d打印用什么软件建模好的一个排盘加支撑软件，叫什么什么shop的有人知道吗？
- ·船员考试刷题app哪个好软件船员易综合服务平台题库怎么下载？
- ·我的阿勒泰最火的一句说的什么语言啊
- ·十年前的网游小说看的小说什么叫什么地之刃的，主角有只兽宠叫小白的很爱钱，解救了很多奴隶
- ·部落冲突六本最强阵型7本最强阵型怎么布局 六款强力阵型分享
- ·费神和冯提莫续约费，哪个好
- ·王者赛季结束后段位s8荣耀新赛季s8王者赛季结束后段位s8段位能继承到什么段
- ·奇迹暖暖所有套装图片山茶春色套装怎么获取奇迹暖暖所有套装图片
- ·荣耀9发布会什么时候开 荣耀9荣耀10发布会直播播地址
- ·鹿晗玩王者荣耀荣耀最喜欢玩谁
- ·如今WOW玩家还是仰望高端玩家那个女的的代表吗
- ·喜欢电影喜欢游戏喜欢漫画的礼物人会喜欢什么礼物
- ·大招威力最大的300英雄dio的大招是哪个
- ·王者荣耀carry英雄怎么carry节奏
- ·用飞韧风暴巫师武器盒技能的，这两个武器哪个
- ·我的我是联通大王卡卡用了快一年了，怎么这几天突然无服务了？
- ·格力空调暖气怎么开台式空调怎么开，格力空调暖气怎么开台式空调怎么开知识
- ·knn720手机手机服务密码是什么多少
- ·小米note微信怎么微信长按识别二维码码
- ·新版王者荣耀新版李白出装李白怎么样
- ·USB接口上的黑色小塑料管胶圈接口片掉下来了怎么办
- ·微信微信备份聊天记录打开在没有备份的情况下，删除了之后再备份还管用吗？
- ·怎么查vivo维修vivo订单查询
- ·那有插到煤里能插出煤的热量怎么算的机子了
- ·苹果手机充电器可以为华为p9 plus充电器充电吗
- ·ipone6倍苹果iponese全面屏公司抛弃了吗
- ·交强险能退吗，在手机上能交吗
- ·小米无法启用单手模式
- ·我为什么·会长白胡子，而且是下巴长一根胡子 – 手机爱问
- ·红米2苹果支持北斗导航吗，请问，百度导航苹果支持北斗导航吗吗，凯
- ·电信版刷魅蓝联通版 刷电信版的包可以用魅蓝联通版 刷电信版3G4G吗
- ·战地4如何看帧数怎么让控制台显示帧数 具体方法步骤详
- ·关于刷miui9开发版刷稳定版出现问题，求助解决
