基于有向图深度优先遍历的组合反馈环路检测算法_word文档在线阅读与下载_文档网
文档网可免积分在线阅读和下载文档
包括资格考试、应用文书等大量word文档免费下载
基于有向图深度优先遍历的组合反馈环路检测算法
简要介绍资料的主要内容,以获得更多的关注
第６期倪韬雍等：基于有向图深度优先遍历的组合反馈环路检测算法
端１２１。组合依赖关系从本地输出表达式传递到外部变量。
ｍｏｄｅｕｈ
ｍｏｄｕｌｅ
Ｍ１（ｉｌ。０１）
ｒｅｇｉ０，００；ｉｎｐｕｔｉｌ；
ｍｌ（ｉＯ，０１）；
ｏｕｔｐｕｔ
ｅｎｄｍｏｄｕｈｅｎｄｍｏｄｕｌｅ
从上面这个例子中可以得出：ｉｌ依赖于ｉ０，００依赖于０１。正因为存在模块之间相互实例化的调用，所以组合逻辑反馈环路也就不仅仅局限在一个模块中。要采集ａｌｗａｙｓ引导的语句块中的组合逻辑变量依赖关系，首先需要区分组合逻辑和时序逻辑，ＩＥＥＥ
１３６４．１Ｖｅｒｉｌｏｇ
ＲＴＬ综合标准对哪些ａｌｗａｙｓ引导语句
块能生成组合逻辑电路有如下规定：
１）敏感列表不能含有边沿触发，必须都是电平触发；２）Ａｌｗａｙｓ语句块中不能阻塞赋值和非阻塞赋值混用；３）不能含有变量隐式的赋值。
ａ）ａｌｗａｙｓ＠（ｅｎａｂｌｅ
ｄ）ｂ）ａｌｗａｙｓ＠（ｅｎａｂｌｅ
ｉｆ（ｅｎａｂｌｅ）
ｉｆ（ｅｎａｂｌｅ）
ｑ＝ｄ；ｅｌｓｅｑ＝”ｂ０；
代码ａ）会生成一个电平触发存储器（１ｅｖｅｌ―ｓｅｎｓｉｔｉｖｅ
ｓｔｏｒａｇｅ
ｄｅｖｉｃｅ），当ｅｎａｂｌｅ为０时，ｑ将保存原有的值。如果生成组合逻辑，就必须将条件写全（代码ｂ），每次执行ａｌｗａｙｓ语句块时，ｑ都被赋值，这样就是一个组合逻辑电路。
为了方便判断ａｌｗａｙｓ引导的语句块是组合逻辑还是时序逻辑，本文引入Ｊｕｌｉａｎｏ∞１的三元组范式方法进行处理判断。通过判断在什么情况下一个变量会保持它原有的值来确定是否需锁存器，三元组的定义是：ｅｘｐｒ：＝ｅｘｐｒ。？ｅｘｐｒ。：ｅｘｐｒｆ。其中ｅｘｐｒ。和ｅｘｐｒｔ是一般表达式或三元组的形式。如果在三元组中出现了赋值等号左边的变量，则要通过一系列转换将其暴露在赋值号右边三元组中的最右端。根据Ｊｕｌｉａｎｏ口１的范式法则对转化出来的三元组进行范式化。这个范式保证如果出现隐式（不完全）赋值，那么最底层的ｅｘｐｒ，就会等于赋值号左边的值ｘ，从而判断是否是组合逻辑。
１．２建立依赖关系图
在Ｖｅｒｉｌｏｇ中，每个变量都有一个独有的层次路径名，它包含模块层次关系以及模块内部定义的命名块（ｎａｍｅｄｂｌｏｃｋ）。这个层次名称可以视作一个树形结构，每一个模块实例、ｔａｓｋ、ｆｕｎｃｔｉｏｎ以及命名的ｂｅｇｉｎ．．ｅｎｄ和ｆｏｒｋ…ｊｏｉｎ块都将在这棵树中生成新的一个分层层次。
ｍｏｄｕｌｅ
ｔｏｐ；ｒａｇａ。ｌｏ；
ｍｌ（１０）；
ａｌｗａｙｓ＠（ａ）ｂｅｇｉｎ：ｂｌ
ｂ，ｃ；Ｃ＝ａ：
ｂ＝８：图１模块中的层次
ｅｎｄｅｎｄｍｏｄｕｌｅｍｏｄｕｌｅ
Ｍ１（ｒ１）；
ｏｕｔｐｕｔ
ｅｎｄｍｏｄｕｌｅ上述代码中各个变量的层次路径名可以表示为图１中的树形结构。在对依赖关系进行处理的过程中，使用变量的层次名
方数据称代价过大，所以在建立依赖关系图之前要对层次名进行编码，使之变成整型变量。层次名根据“．”分开，依次插入兄弟．儿子二叉编码树。
ｔｙｐｅｄｅｆ
ｓｔｒｕｃｔ
ｎｏｄｅ｛／／树结点ｓｔｒｕｃｔ
ｎｏｄｅ ｂｒｏｔｈｅｒ；
／／兄弟链域ｓｔｒｕｃｔ
ｎｏｄｅ ｃｈｉｌｄ；
／／儿子链域ｉｎｔｉｄ；
／／变量的ｉｄ号
｝ＰａｔｈＴｒｅｅ；
完成了变量名编码后，就可以根据之前采集到的组合逻辑变量依赖关系建立有向图，被依赖变量指向依赖变量，使用邻接表。４３来存放有向图，邻接表形式说明：
ｔｙｐｅｄｅｆｓｔｒｕｃｔ
ｎｏｄｅ｛
／／出边结ｊｎｔ
／／邻接点域
ｓｔｒｕｃｔ
ｎｏｄｅ ｎｅｘｔ；
｝ＥｄｇｅＮｏｄｅ；
ｔｙｐｅｄｅｆｓｔｒｕｃｔｖｎｏｄｅ｛
／／顶点表结点ＥｄｇｅＮｏｄｅ ｃｕｒＥｄｇｅ；
／／当前边指针
ｓｔｒｉｎｇｎａｍｅ；
／／节点所对应的变量名
ｃｈａｒｆｌａｇ；
／／遍历标志位
｝ＶｅｒｔｅｘＮｏｄｅ；
ｔｙｐｅｄｅｆＶｅｒｔｅｘＮｏｄｅＡＬｉｓｔ［ＭａｘＶｅｒｔｅｘＮｕｍ］；
／／ＡＬｉｓｔ是邻接表
在上述标准邻接表结构中，我们另外加入一个ｆｌａｇ标志位用于记录组合依赖关系图遍历过程中的状态。
１．３组合逻辑反馈环路检测
我们将组合逻辑反馈环路可以归结为了判断组合逻辑变量Ｆｉｒｓｔ
Ｔｒａｖｅｒｓａｌ）的方法为基础算法，在遍历的过程中对每个点加
１：已出栈或在ｌｏｏｐ中，１：仍在在堆栈中。对于标记为一１的节又一次访问到它，则说明发现了回路。在对依赖图进行搜索遍ｖｏｉｄ
ＬｏｏｐＳｅａｒｃｈ（ＡＬＧｒａｐｈ Ｇ１
｛ｓｔａｃｋ ｓ；
ＶｅｒｔｅｘＮｏｄｅ＋ｐ；Ｖ
Ｇ．Ａ“ｓｔ［ｉ］．ｎ丑ｇ＝Ｏ；ｗｈｉｌｅｊ
ｉ，Ｇ．ＡＬｉｓｔ［ｉ］＝０
｛Ｐ＝Ｇ一＞ＡＬｉｓｔ［ｊ］；（】）
Ｐ．ｆｌａｇ＝１；８．ｐｕｓｈ（ｐ）；ｗｈｉｌｅ！ｅｍｐｔｙ（８）
｛ｉｆＰ一＞ｃｕｒＥｄｇｅ；ｎｕｌｌ
＝＞Ｐ．ｆｌａｇ＝一１：ｓ．ＰＯＰ；Ｐ
ｓ．ｔｏｐ；
Ｇ一＞ＡＬｉ８ｔ［Ｐ一＞ｃｕｒＥｄｇｅ．ｉｄ］．ｆｌａｇ＝１
＝＞Ｇ一＞ＡＬｉｓｔ［Ｐ＾＞ｃｕｒＥｄｇｅ．ｉｄ］．ｆｌａｇ＝一１；
ｓ．ｐｏｐ（１００ｐ）；ｐ；ｓ．ｔｏｐ；
Ｇ一＞ＡＬｉｓｔ［Ｐ一＞ｃｕｒＥｄｇｅ．ｉｄ］．ｆｌａｇ＝一１
＝＞Ｐ一＞ｃｕｒＥｄｇｅ＝Ｐ一＞ｃｕｒＥｄｇｅ一＞ｎｅｘｔ；
Ｇ一＞Ａ“ｓｔ［Ｐ一＞ｃｕｒＥｄｇｅ．ｉｄ］．ｔｌａｇ＝Ｏ（５）
＝＞Ｇ一＞ＡＬｉｓｔ［Ｐ一＞ｃｕｒＥｄｇｅ．ｉｄ］．ｆｌａｇ＝ｌ；８．ｐｕｓｈ（Ｇ一＞ＡＬｉｓｔ［Ｐ一＞ｃｕｒＥｄｇｅ．ｉｄ］）；
Ｐ一＞ｃｕｒＥｄｇｅ５Ｐ一＞ｃｕｒＥｄｇｅ一＞ｎｅｘｔ；ｐ
Ｓ．ｔｏｐ；
ｆｉ｝｝｝
代码分析：
（下转第踟页）
依赖关系图中是否有强连通回路，这里以深度优先遍历（Ｄｅｐｔｈ―
入相应的标志，找出回路。标志位共有三种，０：未被访问过，一点我们将不再进行访问，对于标记为１的节点如果遍历过程中历的过程中，使用一个临时栈，用于记录当前遍历的轨迹，每个元素为指向顶点表中顶点的指针。具体算法’４１为：
Word文档免费下载： （共4页，当前第2页）
的相关文档搜索
基于图的深度优先遍历编写一个算法,判别以邻接表方式存储的有向图中是否存在由 ...(G); } 3、测试数据与实验结果分析(可以用组合键 Alt+Print Screen 截图) ...但基于效率上的考 虑,选择指针类型的参数为宜。 4、深度优先遍历序列 对图...5、算法分析 对于具有 n 个顶点和 e 条边的无向图或有向图,遍历算法 ...图的遍历(深度优先遍历和广度优先遍历 )_IT/计算机_专业资料。深度优先遍历和广度优先遍历图的遍历 数据结构与算法 ---第二十讲北方民族大学 计算机科学与工程学院...详细的分析了图中以邻接表为存储结构进行的图的深度优先搜索遍历的算法,并且在 VC++环境中实现其算法的过程,对 运行记过做了一定量的分析,最后介绍了基于该算法...图的遍历 数据结构与算法 ---第二十讲北方民族大学...的深度优先和广度优先遍历 的性质和方法,以及基于...例如,对图 20-1给出的有向图与无向图,一些遍历 ...;如要提出功能问题或意见建议,请点击此处进行反馈。...提出一种基于深度优先遍历的梯度分割算法,这种算法...通常有两条遍历图的路径:深度优先搜索7 (D印lllFiIst Search)和广度优先搜索(...7基于掘算法的应用(1)求无向图中连通分量的个数 求解该问题只要在算法豳扛a...基于深度优先遍历算法的配电网拓扑动态检测_专业资料。在配网重构或故障恢复等网架优化问题中,为寻找最优目标网架,首先需要检测配电网拓扑结构是否正常.利用深度优先遍历...掌握图的两种遍历算法深度优先搜索和广度优先搜索算_...无向图和有向图都 有两条遍历图的路径:深度优先...并对图中每个顶点进行 检测.若某顶点已被访问,则...&p&谢邀。&/p&&p&首先，对于大部分程序员而言，&b&在工作中不是必须的&/b&，但是你要找工作，特别是刚毕业参加校招的学生，想进入一些比较大的公司（BAT之流），是&b&必须要学好算法的&/b&。&/p&&p&此外，我认为在提高自我技术水平的过程中，比如去阅读一些优秀的代码的时候，也是需要算法功底的，就像去看leveldb、redis源码的时候，起码得知道跳表是个啥吧，看Linux内核文件系统的代码得知道红黑树是个啥吧。&/p&&p&再就是有一个很重要的影响：算法学的好的话，&b&不论对你思考问题的方式还是对你编程的思维都会有很大的好处。&/b&&/p&&p&另外关于刷题的网站还是首推&b&Leetcode。&/b&&/p&&p&如果有一些算法基础的话，推荐&b&Codeforces。&/b&&/p&&p&至于资料书籍的话，其实没有太多要求，网上的资料很多，随便谷歌一下就能找到很多详细的资料。&/p&&p&&b&算法导论的话不推荐，不推荐初学者看。&/b&这本书是本神书，但是这本书的门槛比较高，需要有一定数学基础和算法基础的人去研究，如果你没有一定的基础或者对算法狂热的学习兴趣，你很难啃下去。&/p&&p&改了一下知识列表的结构，分了下类，可能更加清楚一点。这里面基础是我觉得必须应该掌握的，中等的是有如有余力最好学习的，高级的可以了解，可以了解一下，对于个别感兴趣的可以深入学习一下。&/p&&p&&b&这里面仅仅根据我个人的学习经历去区分难易度，不代表知识本身难易度的精确定位&/b&。另外如果大家有什么比较好的补充或者一些问题，可以私信我，我再修改~&/p&&p&&br&&/p&&p&&b&1.【数据结构部分】&/b&&/p&&p&数据结构我觉得在算法这个概念里的地位是非常重要的，因此还是花一定的精力去学习和练习，看完理论可以刷题，刷完题可以看一些工业级的代码，比如STL源码等，去了解各种数据结构现实应用。&/p&&p&【基础】&/p&&p&链表（单双向链表、循环链表等）、队列（单双向队列）、栈、大/小顶堆、多叉树、排序二叉树（主要熟悉树的前中后序遍历）&/p&&p&【中级】&/p&&p&并查集、树状数组、RMQ、字典树、跳表（非常好用的数据结构，被leveldb、redis等key-value数据库采用）、B/B+树（文件系统中非常常用的数据结构了）、AVL树（平衡二叉树、看懂了为后面的伸展树和红黑树做基础）、线段树（在logn的时间级别内解决区间问题）&/p&&p&【高级】&/p&&p&DLX数独问题、AC自动机（KMP+字典树的结合，在解决大量字符串模板匹配问题上非常好用）、树链剖分（高级数据结构，解决树上的路径更新问题）、伸展树、红黑树（非常出名的数树形据结构、比较复杂，Linux内核中的文件系统基于这个实现）&/p&&p&&br&&/p&&p&&b&2.【图论部分】&/b&&/p&&p&图论的话主要是DFS和BFS这两个搜索策略的学习，多熟悉熟悉，不同的实现方法都有什么，比如递归的写法和非递归的写法等等。此外就是最短路的问题，至于一些网络流、图匹配等问题，因为不是打竞赛，仅仅是考虑学习，可以不需要深究。&/p&&p&【基础】&/p&&p&DFS（深度优先遍历）、BFS（广度优先遍历）、拓扑图、最短路问题（Dijkstra）、拓扑排序问题&/p&&p&【中级】&/p&&p&最短路问题（Bellman-Ford、SPFA等）、最小/大割问题、最小生成树、欧拉回路、最近公共祖先（LCA）&/p&&p&【高级】&/p&&p&网络流问题、二分图匹配问题&/p&&p&&br&&/p&&p&&b&3.【字符串部分】&/b&&/p&&p&字符串的问题其实也在日常应用挺多的，重点了解一下KMP和Hash。&/p&&p&【基础】&/p&&p&字符串哈希（Hash）、回文问题、子串问题&/p&&p&【中级】&/p&&p&KMP算法&/p&&p&【高级】&/p&&p&后缀数组、AC自动机（前面说到过）&/p&&p&&br&&/p&&p&&b&4.【数学部分】&/b&&/p&&p&数学问题其实没有太多好说的，在学校的同学们还是&b&尽量学好高数、概率论和线性代数&/b&吧，这个是一个积累的问题，以后如果进一步的研究和学习，数学肯定是不能太差的，这里就不分类了，只列举一些简单的数学问题。&/p&&p&快速GCD，最大公约数、扩展欧几里得、中国余数定理、求逆元、素数问题&/p&&p&&br&&/p&&p&&b&5.【动态规划部分】&/b&&/p&&p&动态规划可以说在各种公司的面试中深受广大面试官喜爱，动规(DP)主要还算是一种解决问题的思想，并不是像一个数据结构模型的成型算法，学好的话很难，但是学好动规可以说对你思考问题的方式有很大的提高，这里列一些常见的动规问题的分类。&/p&&p&【基础】&/p&&p&背包问题（0/1背包、完全背包）、最长递增字串问题（LIS）、最长公共子序列（LCS）&/p&&p&【中级】&/p&&p&区间DP、树形DP、数位DP、概率DP、状态压缩DP&/p&&p&【高级】&/p&&p&复杂的DP（经过各种数据结构优化或者各种开脑洞的DP）&/p&&p&&br&&/p&&p&&b&6.【几何问题】&/b&&/p&&p&这个我有点忘了，本身之前学习的少，改天查查资料再补。&/p&&p&&br&&/p&&p&&b&7.【其他】&/b&&/p&&p&二分查找、贪心问题、各种排序（冒泡排序、归并排序、快速排序、堆排序等）、分治。&/p&&p&&br&&/p&&p&最后，也是最重要的：&/p&&p&&b&算法的学习不只是理论的支持，更需要你不断的在理论的基础上去code，去思考。&/b&&/p&
谢邀。首先，对于大部分程序员而言，在工作中不是必须的，但是你要找工作，特别是刚毕业参加校招的学生，想进入一些比较大的公司（BAT之流），是必须要学好算法的。此外，我认为在提高自我技术水平的过程中，比如去阅读一些优秀的代码的时候，也是需要算法…
&img src=&/v2-87cafe55dd5_b.png& data-rawwidth=&560& data-rawheight=&318& class=&origin_image zh-lightbox-thumb& width=&560& data-original=&/v2-87cafe55dd5_r.png&&&p&&b&数学是达成目的的工具, 理解才是达成目的桥梁, 所以这篇文章用浅显易懂的动画阐述了复杂的机器学习概念.&/b&&/p&&blockquote&强烈推荐通过动画的形式了解.&br&所以首先放视频链接: &a href=&/?target=https%3A///watch%3Fv%3DBEquIwfEXes& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Youtube&i class=&icon-external&&&/i&&/a& 或者 &a href=&/?target=http%3A///v_show/id_XMjk0NzE0MjgxNg%3D%3D.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&优酷&i class=&icon-external&&&/i&&/a&.&br&更多通熟易懂的知识请访问: &a href=&/?target=https%3A//morvanzhou.github.io/tutorials/machine-learning/ML-intro/5-01-genetic-algorithm/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&莫烦 Python&i class=&icon-external&&&/i&&/a&&/blockquote&&a class=&video-box& href=&/?target=http%3A///v_show/id_XMjk0NzE0MjgxNg%3D%3D.html& target=&_blank& data-video-id=&249344& data-video-playable=&true& data-name=&什么是遗传算法? Genetic Algorithm& data-poster=&/v2-a93a83e3c4dc54cd73a914ef27d0dbfc.jpg& data-lens-id=&&&
&img class=&thumbnail& src=&/v2-a93a83e3c4dc54cd73a914ef27d0dbfc.jpg&&&span class=&content&&
&span class=&title&&什么是遗传算法? Genetic Algorithm&span class=&z-ico-extern-gray&&&/span&&span class=&z-ico-extern-blue&&&/span&&/span&
&span class=&url&&&span class=&z-ico-video&&&/span&/v_show/id_XMjk0NzE0MjgxNg==.html&/span&
&/a&&p&&br&&/p&&p&这次我们尝试踏足机器学习中的另外一个领域, 用进化理论来解决复杂的问题. 遗传算法是进化算法的一个分支. 它将达尔文的进化理论搬进了计算机.&/p&&p&&br&&/p&&h2&进化算法&/h2&&p&&br&&/p&&img src=&/v2-9da4e8a800b20c881eed3a098a9c1fc6_b.png& data-rawwidth=&375& data-rawheight=&393& class=&content_image& width=&375&&&p&所以你会发现在程序中, 我们还时不时出现什么染色体, DNA, 遗传, DNA交叉, 变异 这些东西. 不过想想也能明白, 在自然界中, 优胜劣汰, 我们人类也是靠着这些手段一步步从猴子&/p&&img src=&/v2-e37c9c7d1f62c0ebbcacc317e424cf97_b.png& data-rawwidth=&559& data-rawheight=&314& class=&origin_image zh-lightbox-thumb& width=&559& data-original=&/v2-e37c9c7d1f62c0ebbcacc317e424cf97_r.png&&&p&~变成会敲键盘, 会唱歌, 会读书, 会干坏事的猴子了. 哈哈. 重点不是这些. 我们应该正儿八经地想想, 我们是怎么样一步一步变成后面这些猴子的.&/p&&h2&猴子的进化&/h2&&img src=&/v2-b81cf1d633_b.png& data-rawwidth=&795& data-rawheight=&439& class=&origin_image zh-lightbox-thumb& width=&795& data-original=&/v2-b81cf1d633_r.png&&&p&想象我们的祖先是这么一群一直在树上的猴子. 某一天他们诞下了一只可能是因为某种变异而总喜欢呆在地上的猴子. 因为总喜欢在地上, 地上又有很多石头, 他开始用石头作为自己的工具, 比如砸开坚硬的果实或者做武器. 会使用石头的猴子变的比其他猴子更容易吃到东西, 也更有能力抵御外人. 所以这样的猴子活得越久, 繁衍得越多. 所以我们的祖先慢慢地变成了地上的猴子. 离变成人类也进了一步. 我们看到上面的线路, 可以总结一下这整套流程.&/p&&p&&br&&/p&&h2&种群的进化&/h2&&img src=&/v2-8c8ece25c8dafbf6b3d7_b.png& data-rawwidth=&664& data-rawheight=&444& class=&origin_image zh-lightbox-thumb& width=&664& data-original=&/v2-8c8ece25c8dafbf6b3d7_r.png&&&p&首先有一整个种族, 然后种族里不断的繁衍后代, 有时候会突然间产生一些变异, 这些变异中有一些天生畸形, 一些有了新的能力, 不适应环境的人们, (包括畸形)被当下的环境淘汰掉了, 适应环境的人们, (包括哪些变异出新能力的人)被保留, 并且还能繁衍出更多这种新能力的人. 这就变成了我们下一代的种族. 接着继续这个循环. 其实计算机也能套用这一套体系, 这就有了我们的遗传算法.&/p&&h2&电脑里的 DNA&/h2&&img src=&/v2-ce5a497fd1e6b86892c4bb_b.png& data-rawwidth=&793& data-rawheight=&399& class=&origin_image zh-lightbox-thumb& width=&793& data-original=&/v2-ce5a497fd1e6b86892c4bb_r.png&&&p&每个人都会有他独有的遗传信息比如 DNA, 种群的繁衍也就是这些 DNA 的传承, 所以遗传算法把握住了这一条定律. 我们就尝试着在电脑中用某些途径来代替这些生物形式的 DNA. 我们如果仔细看看这些 DNA, 就会发现, 他们其实是由一组组固定的结构构成, 如果你还没有忘记初高中学的生物, 这种小的结构就叫做碱基对. 在程序中, 我们也可以模拟这些结构, 将这些结构遗传给下一代或者变异一下. 最常用的一种替换方式是: 我们直接使用0和1来代替, 因为在电脑中, 所有东西都是01, 01 就是电脑的语言. 我们的手脚都是从这些最基本的 DNA 信息里翻译出来的, 那么我们也能用一定的规则将01这类信息用电脑翻译成其他的信息.&/p&&p&&br&&/p&&img src=&/v2-02bfebb364d4de_b.png& data-rawwidth=&725& data-rawheight=&425& class=&origin_image zh-lightbox-thumb& width=&725& data-original=&/v2-02bfebb364d4de_r.png&&&p&&br&&/p&&p&有了这些电脑能懂的 DNA 形式, 我们就能模拟生物中的繁衍后代了, 假设我们有两个来自父母的 DNA 信息. 我们只需要选取他们各自一段信息就能组成新的宝宝的DNA信息. 生物繁衍中, 还会存在时不时的变异, 我们也能从这套01 的系统中体现出来, 只要将某些地方将0变成1, 1变成0就好了. 有了这些遗传变异, 加上那一套适者生存,不适者淘汰的理论, 你的电脑里就能有一群渐渐成长壮大的小生物了.&/p&&p&&br&&/p&&h2&别人的实验&/h2&&p&&br&&/p&&img src=&/v2-df4a04fa2d96_b.png& data-rawwidth=&771& data-rawheight=&442& class=&origin_image zh-lightbox-thumb& width=&771& data-original=&/v2-df4a04fa2d96_r.png&&&p&我们来看看别人都在拿电脑里喂养了哪些生物吧. 比如进化出会自己闯关的马里奥, 自动驾驶的汽车, 还能模拟微生物的行为. 看上去是不是真有那么一回事. 我会将这些视频的链接附在我”莫烦Python”的网页中, 有兴趣的朋友们可以观看一下.&/p&&p&视频里别人的实验: &a href=&/?target=https%3A///watch%3Fv%3Dqv6UVOQ0F44& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&马里奥&i class=&icon-external&&&/i&&/a& , &a href=&/?target=https%3A///watch%3Fv%3D5lJuEW-5vr8%26t%3D109s& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&自动驾驶&i class=&icon-external&&&/i&&/a&, &a href=&/?target=https%3A///watch%3Fv%3D2kupe2ZKK58& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&微生物进化&i class=&icon-external&&&/i&&/a&.&/p&&p&&br&&/p&&blockquote&&a href=&/?target=https%3A//morvanzhou.github.io/tutorials/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&莫烦 Python&i class=&icon-external&&&/i&&/a& 里还有很多精彩, 通俗易懂的机器学习介绍和 Python 算法实践.&/blockquote&
数学是达成目的的工具, 理解才是达成目的桥梁, 所以这篇文章用浅显易懂的动画阐述了复杂的机器学习概念.强烈推荐通过动画的形式了解. 所以首先放视频链接:
或者 . 更多通熟易懂的知识请访问:
这次我们尝试踏足机器学习中的另外一个…
&img src=&/v2-7b8f98ebdacc04e51e4c_b.png& data-rawwidth=&476& data-rawheight=&269& class=&origin_image zh-lightbox-thumb& width=&476& data-original=&/v2-7b8f98ebdacc04e51e4c_r.png&&&p&&b&数学是达成目的的工具, 理解才是达成目的桥梁, 所以这篇文章用浅显易懂的动画阐述了复杂的机器学习概念.&/b&&/p&&blockquote&强烈推荐通过动画的形式了解.&br&所以首先放视频链接: &a href=&/?target=https%3A///watch%3Fv%3DEtj_gclFFFo& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Youtube&i class=&icon-external&&&/i&&/a& 或者 &a href=&/?target=http%3A///v_show/id_XMjk3OTcyMTU1Mg%3D%3D.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&优酷&i class=&icon-external&&&/i&&/a&.&br&更多通熟易懂的知识请访问: &a href=&/?target=https%3A//morvanzhou.github.io/tutorials/machine-learning/ML-intro/5-02-evolution-strategy/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&莫烦 Python&i class=&icon-external&&&/i&&/a&&/blockquote&&p&&br&&/p&&a class=&video-box& href=&/?target=http%3A///v_show/id_XMjk3OTcyMTU1Mg%3D%3D.html& target=&_blank& data-video-id=&730304& data-video-playable=&true& data-name=&进化策略& data-poster=&/v2-c6c45a8cc6.jpg& data-lens-id=&&&
&img class=&thumbnail& src=&/v2-c6c45a8cc6.jpg&&&span class=&content&&
&span class=&title&&进化策略&span class=&z-ico-extern-gray&&&/span&&span class=&z-ico-extern-blue&&&/span&&/span&
&span class=&url&&&span class=&z-ico-video&&&/span&/v_show/id_XMjk3OTcyMTU1Mg==.html&/span&
&/a&&p&&br&&/p&&p&Hello 大家好, 欢迎观看这一次的机器学习简介系列视频, 进化是大自然赋予我们的礼物, 我们也能学习自然界的这份礼物, 将它放入计算机, 让计算机也能用进化来解决问题. 我们接着上回提到的遗传算法, 来说一说另一种使用进化理论的优化模式-进化策略 (Evolution Strategy).&/p&&p&&br&&/p&&h2&进化算法&/h2&&p&&br&&/p&&img src=&/v2-b5587e7be087f0a4db88_b.png& data-rawwidth=&449& data-rawheight=&223& class=&origin_image zh-lightbox-thumb& width=&449& data-original=&/v2-b5587e7be087f0a4db88_r.png&&&p&遗传算法和进化策略共享着一些东西. 他们都用遗传信息, 比如 DNA 染色体, 一代代传承, 变异. 来获取上一代没有的东西.&/p&&p&&br&&/p&&img src=&/v2-3c21a6b07fd7b031b1aa_b.png& data-rawwidth=&479& data-rawheight=&224& class=&origin_image zh-lightbox-thumb& width=&479& data-original=&/v2-3c21a6b07fd7b031b1aa_r.png&&&p&然后通过适者生存, 不适者淘汰的这一套理论不断进化着. 我们的祖先, 通过不断变异, 生存淘汰, 从猴子变成人也就是这么回事.既然进化策略或遗传算法都用到了进化的原则, 他们到底有哪些不同呢? 他们各自又适用于哪些问题呢?&/p&&h2&遗传算法&/h2&&p&&br&&/p&&img src=&/v2-71ac2e1ecbde6e63a4d5f_b.png& data-rawwidth=&454& data-rawheight=&257& class=&origin_image zh-lightbox-thumb& width=&454& data-original=&/v2-71ac2e1ecbde6e63a4d5f_r.png&&&p&我们之前说到, 一般的遗传算法使用的 DNA 是二进制编码的, 爸妈的 DNA 通过交叉配对, 组成宝宝的 DNA, 宝宝也会通过一定的变异获得新的功能. 但一般的进化策略却有些不同.&/p&&h2&进化策略&/h2&&img src=&/v2-94d2b3ac47a2ab07abbfe1e_b.png& data-rawwidth=&698& data-rawheight=&451& class=&origin_image zh-lightbox-thumb& width=&698& data-original=&/v2-94d2b3ac47a2ab07abbfe1e_r.png&&&p&爸妈的 DNA 不用再是 01 的这种形式, 我们可以用实数来代替, 咋一看, 觉得牛逼了起来, 因为我们抛开了二进制的转换问题, 从而能解决实际生活中的很多由实数组成的真实问题. 比如我有一个关于 x 的公式, 而这个公式中其他参数, 我都能用 DNA 中的实数代替, 然后进化我的 DNA, 也就是优化这个公式啦. 这样用起来, 的确比遗传算法方便. 同样, 在制造宝宝的时候, 我们也能用到交叉配对, 一部分来自爸爸, 一部分来自妈妈. 可是我们应该如何变异呢? 遗传算法中简单的翻牌做法貌似在这里行不通. 不过进化策略中的另外一个因素起了决定性的作用. 这就是变异强度. 简单来说, 我们将爸妈遗传下来的值看做是正态分布的平均值, 再在这个平均值上附加一个标准差, 我们就能用正态分布产生一个相近的数了. 比如在这个8.8位置上的变异强度为1, 我们就按照1的标准差和8.8的均值产生一个离8.8的比较近的数, 比如8.7. 然后对宝宝每一位上的值进行同样的操作. 就能产生稍微不同的宝宝 DNA 啦. 所以, 变异强度也可以被当成一组遗传信息从爸妈的 DNA 里遗传下来. 甚至遗传给宝宝的变异强度基因也能变异. 进化策略的玩法也能多种多样.&/p&&h2&总结&/h2&&p&&br&&/p&&img src=&/v2-60f3f7afee03cf838bf48_b.png& data-rawwidth=&440& data-rawheight=&203& class=&origin_image zh-lightbox-thumb& width=&440& data-original=&/v2-60f3f7afee03cf838bf48_r.png&&&p&&br&&/p&&p&我们总结一下, 在进化策略中, 可以有两种遗传性系被继承给后代, 一种是记录所有位置的均值, 一种是记录这个均值的变异强度, 有了这套体系, 我们就能更加轻松自在的在实数区间上进行变异了. 这种思路甚至还能被用在神经网络的参数优化上, 因为这些参数本来就是一些实数. 在之后的视频中我们会继续提到当今比较流行的将人工神经网络结合上遗传算法或者进化策略的方法.&/p&&p&&br&&/p&&p&&a href=&/?target=https%3A//morvanzhou.github.io/tutorials/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&莫烦 Python&i class=&icon-external&&&/i&&/a& 里还有很多精彩, 通俗易懂的机器学习介绍和 Python 算法实践.&/p&
数学是达成目的的工具, 理解才是达成目的桥梁, 所以这篇文章用浅显易懂的动画阐述了复杂的机器学习概念.强烈推荐通过动画的形式了解. 所以首先放视频链接:
或者 . 更多通熟易懂的知识请访问:
Hello 大家好, 欢迎观看这一次的机器学…
&img src=&/v2-57d6db88bab63f92bcbfe_b.jpg& data-rawwidth=&1012& data-rawheight=&683& class=&origin_image zh-lightbox-thumb& width=&1012& data-original=&/v2-57d6db88bab63f92bcbfe_r.jpg&&&p&本文章选自与&a href=&/?target=http%3A//Github.io& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&Github.io&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a&，作者：Sadanand Singh，由机器之心编译团队整理编译。&a href=&/?target=https%3A//sadanand-singh.github.io/posts/treebasedmodels/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&原文链接点这里即可跳转。&i class=&icon-external&&&/i&&/a&&/p&&blockquote&基于树（Tree based）的学习算法在数据科学竞赛中是相当常见的。这些算法给预测模型赋予了准确性、稳定性以及易解释性。和线性模型不同，它们对非线性关系也能进行很好的映射。常见的基于树的模型有：决策树（decision trees）、随机森林（random forest）和提升树（boosted trees）。 &/blockquote&&p&在本篇文章中，我们将会介绍决策树的数学细节（以及各种 Python 示例）及其优缺点。你们将会发现它们很简单，并且这些内容有助于理解。然而，与最好的监督学习方法相比，它们通常是没有竞争力的。为了克服决策树的各种缺点，我们将会聚焦于各种概念（附有 Python 实例），比如自助聚集或袋装（Bootstrap Aggregating or Bagging），还有随机森林（Random Forests）。另一种广泛使用的提升方法会在以后进行单独讨论。每种方法都包括生成多种树，这些树被联合起来，生成一个单一的一致性预测结果，并且经常带来预测精度的显著提升。&/p&&p&&br&&/p&&p&在本篇文章中，我们将会介绍决策树的数学细节（以及各种 Python 示例）及其优缺点。你们将会发现它们很简单，并且这些内容有助于理解。然而，与最好的监督学习方法相比，它们通常是没有竞争力的。为了克服决策树的各种缺点，我们将会聚焦于各种概念（附有 Python 实例），比如自助聚集或袋装（Bootstrap Aggregating or Bagging），还有随机森林（Random Forests）。另一种广泛使用的提升方法会在以后进行单独讨论。每种方法都包括生成多种树，这些树被联合起来，生成一个单一的一致性预测结果，并且经常带来预测精度的显著提升。&/p&&p&&br&&/p&&h2&&b&决策树&/b&&/h2&&p&决策树是一种监督学习算法。它适用于类别和连续输入（特征）和输出（预测）变量。基于树的方法把特征空间划分成一系列矩形，然后给每一个矩形安置一个简单的模型（像一个常数）。从概念上来讲，它们是简单且有效的。首先我们通过一个例子来理解决策树。然后用一种正规分析方法来分析创建决策树的过程。考虑一个简单的借贷公司顾客的数据集合。我们给定了所有客户的查询账户余额、信用记录、任职年限和先前贷款状况。相关任务是预测顾客的风险等级是否可信。该问题可以使用下列决策树来解决：&/p&&p&&br&&/p&&img src=&/v2-49257fda48fc0c62324ddb5_b.png& data-rawwidth=&640& data-rawheight=&312& class=&origin_image zh-lightbox-thumb& width=&640& data-original=&/v2-49257fda48fc0c62324ddb5_r.png&&&p&&br&&/p&&p&分类和回归树（简称 CART）是 Leo Breiman 引入的术语，指用来解决分类或回归预测建模问题的决策树算法。它常使用 scikit 生成并实现决策树： sklearn.tree.DecisionTreeClassifier 和 sklearn.tree.DecisionTreeRegressor 分别构建分类和回归树。&/p&&p&&br&&/p&&p&&b&CART 模型&/b&&/p&&p&CART 模型包括选择输入变量和那些变量上的分割点，直到创建出适当的树。使用贪婪算法（greedy algorithm）选择使用哪个输入变量和分割点，以使成本函数（cost function）最小化。&/p&&p&树建造的结尾使用了一个预定义的停止准则，比如分配到树上每一个叶结点的训练样本达到最小数量。&/p&&p&&br&&/p&&p&其他决策树算法：&/p&&ul&&li&ID3：Iterative Dichotomiser 3&/li&&li&C4.5：ID3 算法的改进&/li&&li&CHAID：Chi-squared Automatic Interaction Detector&/li&&li&MARS：决策树的扩展式，以更好地解决数值型预测。&/li&&li&条件推断树&/li&&/ul&&p&&br&&/p&&p&&b&回归树&/b&&/p&&p&我们现在关注一下回归树的 CART 算法的细节。简要来说，创建一个决策树包含两步：&/p&&p&1. 把预测器空间，即一系列可能值 X_1，X_2，...，X_p 分成 J 个不同的且非重叠的区域 R_1，R_2，...，R_J。&/p&&p&2. 对进入区域 R_J 的每一个样本观测值都进行相同的预测，该预测就是 R_J 中训练样本预测值的均值。&/p&&p&&br&&/p&&p&为了创建 J 个区域 R_1，R_2，...，R_J，预测器区域被分为高维度的矩形或盒形。其目的在于通过下列式子找到能够使 RSS 最小化的盒形区域 R_1，R_2，...，R_J，&/p&&img src=&/v2-98e5ff2adb5f65631a92_b.png& data-rawwidth=&269& data-rawheight=&105& class=&content_image& width=&269&&&p&其中，yhat_Rj 即是第 j 个盒形中训练观测的平均预测值。&/p&&p&&br&&/p&&p&鉴于这种空间分割在计算上是不可行的，因此我们常使用贪婪方法（greedy approach）来划分区域，叫做递归二元分割（recursive binary splitting）。&/p&&p&&br&&/p&&p&它是贪婪的（greedy），这是因为在创建树过程中的每一步骤，最佳分割都会在每个特定步骤选定，而不是对未来进行预测，并选取一个将会在未来步骤中出现且有助于创建更好的树的分隔。注意所有的划分区域 R_j 都是矩形。为了进行递归二元分割，首先选取预测器 X_j 和切割点 s &/p&&p&&br&&/p&&img src=&/v2-5ce7cc83_b.png& data-rawwidth=&563& data-rawheight=&95& class=&origin_image zh-lightbox-thumb& width=&563& data-original=&/v2-5ce7cc83_r.png&&&p&其中 yhat_R1 为区域 R_1(j,s) 中观察样本的平均预测值，yhat_R2 为区域 R_2(j,s) 的观察样本预测均值。这一过程不断重复以搜寻最好的预测器和切分点，并进一步分隔数据以使每一个子区域内的 RSS 最小化。然而，我们不会分割整个预测器空间，我们只会分割一个或两个前面已经认定的区域。这一过程会一直持续，直到达到停止准则，例如我们可以设定停止准则为每一个区域最多包含 m 个观察样本。一旦我们创建了区域 R_1、R_2、...、R_J，给定一个测试样本，我们就可以用该区域所有训练样本的平均预测值来预测该测试样本的值。&/p&&p&&br&&/p&&p&&b&分类树&/b&&/p&&p&分类树和回归树十分相似，只不过它是定性地预测响应值而非定量预测。从上文可知，回归树对一个观察值所预测的连续型数值就是属于同一叶结点训练样本观察值的均值。但是对于分类树来说，我们所预测的类别是训练样本观察值在某区域下最常见的类别，即训练观察值的模式响应（mode response）。为了达到分类目的，很多时候系统并不会只预测一个类别，它常常预测一组类别及其出现的概率。&/p&&p&&br&&/p&&p&分类树的生成和回归树的生成十分相似。正如在回归树中那样，我们一般使用递归性的二元分割来生成分类树。然而在分类树中，RSS 不能作为二元分割的标准。我们需要定义叶结点的不纯度量 Q_m 来替代 RSS，即一种可以在子集区域 R_1,R_2,...,R_j 度量目标变量同质性的方法。在结点 m 中，我们可以通过 N_m 个样本观察值表示一个区域 R_m 所出现类别的频率，第 k 个类别在第 m 个区域下训练所出现的频率可表示为：&/p&&img src=&/v2-d74fc128ecef_b.png& data-rawwidth=&342& data-rawheight=&106& class=&content_image& width=&342&&&p&其中，I(y_i=k) 为指示函数，即如果 y_i = k，则取 1，否则取零。&/p&&p&&br&&/p&&p&不纯性度量 Q_m 一个比较自然的方法是分类误差率。分类误差率描述的是训练观察值在某个区域内不属于最常见类别的概率：&/p&&img src=&/v2-ed29c3a44bd1c49cf90bf_b.png& data-rawwidth=&234& data-rawheight=&60& class=&content_image& width=&234&&&p&考虑到该函数不可微，因此它不能实现数值优化。此外，该函数在结点概率改变上并不敏感，因此这种分类误差率对于生成树十分低效。我们一般使用 Gini 指数和交叉熵函数来衡量结点的误差度量。&/p&&p&&br&&/p&&p&Gini 指数可以衡量 k 个类别的总方差，它一般定义为：&/p&&img src=&/v2-049f650cbc26b70c7595c0_b.png& data-rawwidth=&296& data-rawheight=&107& class=&content_image& width=&296&&&p&较小的 Gini 指数值表示结点包含了某个类别大多数样本观察值。&/p&&p&&br&&/p&&p&在信息论里面，交叉熵函数用来衡量系统的混乱度。对于二元系统来说，如果系统包含了一个类别的所有内容，那么它的值为零，而如果两个类别的数量一样多，那么交叉熵达到最大为 1。因此，和 Gini 指数一样，交叉熵函数同样能用于度量结点的不纯度：&/p&&img src=&/v2-2f94b01e260e7f910b47af_b.png& data-rawwidth=&312& data-rawheight=&99& class=&content_image& width=&312&&&p&和 G 一样，较小的 S 值表示区域内结点包含了单个类别中的大多数观察值。&/p&&p&&br&&/p&&p&&b&决策树常见参数和概念&/b&&/p&&p&如果我们希望以数学的方式理解决策树，我们首先需要了解决策树和树型学习算法的一般概念。理解以下的术语同样能帮助我们调整模型。&/p&&p&&br&&/p&&ul&&li&根结点：表示所有数据样本并可以进一步划分为两个或多个子结点的父结点。&/li&&li&分裂（Splitting）：将一个结点划分为两个或多个子结点的过程。&/li&&li&决策结点：当一个子结点可进一步分裂为多个子结点，那么该结点就称之为决策结点。&/li&&li&叶/终止结点：不会往下进一步分裂的结点，在分类树中代表类别。&/li&&li&分枝/子树：整棵决策树的一部分。&/li&&li&父结点和子结点：如果一个结点往下分裂，该结点称之为父结点而父结点所分裂出来的结点称之为子结点。&/li&&li&结点分裂的最小样本数：在结点分裂中所要求的最小样本数量（或观察值数量）。这种方法通常可以用来防止过拟合，较大的最小样本数可以防止模型对特定的样本学习过于具体的关系，该超参数应该需要使用验证集来调整。&/li&&li&叶结点最小样本数：叶结点所要求的最小样本数。和结点分裂的最小样本数一样，该超参数同样也可以用来控制过拟合。对于不平衡类别问题来说，我们应该取较小的值，因为属于较少类别的样本可能数量上非常少。&/li&&li&树的最大深度（垂直深度）：该超参数同样可以用来控制过拟合问题，较小的深度可以防止模型对特定的样本学习过于具体的关系，该超参数同样需要在验证集中调整。&/li&&li&叶结点的最大数量：叶结点的最大个数可以替代数的最大深度这一设定。因为生成一棵深度为 n 的二叉树，它所能产生的最大叶结点个数为 2^n。&/li&&li&分裂所需要考虑的最大特征数：即当我们搜索更好分离方案时所需要考虑的特征数量，我们常用的方法是取可用特征总数的平方根为最大特征数。&/li&&/ul&&p&&br&&/p&&p&&b&分类树的实现&/b&&/p&&p&为了展示不同的前文所述的决策树模型，我们将使用 Kaggle 上的美国收入数据集，我们都可以在 &a href=&/?target=http%3A//& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a& 上下载该数据集。下面的代码可以展示该数据集的导入过程和部分内容：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&import pandas as pdimport numpy as npfrom plotnine import *import matplotlib.pyplot as pltfrom sklearn.preprocessing import LabelEncoderfrom sklearn_pandas import DataFrameMapperfrom sklearn.tree import DecisionTreeClassifierfrom sklearn.ensemble import RandomForestClassifier
training_data = './adult-training.csv'test_data = './adult-test.csv'columns = ['Age','Workclass','fnlgwt','Education','EdNum','MaritalStatus','Occupation','Relationship','Race','Sex','CapitalGain','CapitalLoss','HoursPerWeek','Country','Income']
df_train_set = pd.read_csv(training_data, names=columns)
df_test_set = pd.read_csv(test_data, names=columns, skiprows=1)
df_train_set.drop('fnlgwt', axis=1, inplace=True)
df_test_set.drop('fnlgwt', axis=1, inplace=True)
&/code&&/pre&&/div&&p&在上面的代码中，我们首先需要导入所有需要的库和模块，然后再读取数据和结构到训练数据和验证数据中。我们同样去除 fnlgwt 列，因为该数据行对于模型的训练并不重要。&/p&&p&&br&&/p&&p&输入以下语句可以看到训练数据的前五行：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&df_train_set.head()
&/code&&/pre&&/div&&p&&br&&/p&&p&如下所示，我们还需要做一些数据清洗。我们需要将所有列的的特殊字符移除，此外任何空格或者「.」都需要移除。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&#replace the special character to &Unknown&for i in df_train_set.columns:
df_train_set[i].replace(' ?', 'Unknown', inplace=True)
df_test_set[i].replace(' ?', 'Unknown', inplace=True)for col in df_train_set.columns:if df_train_set[col].dtype != 'int64':
df_train_set[col] = df_train_set[col].apply(lambda val: val.replace(& &, &&))
df_train_set[col] = df_train_set[col].apply(lambda val: val.replace(&.&, &&))
df_test_set[col] = df_test_set[col].apply(lambda val: val.replace(& &, &&))
df_test_set[col] = df_test_set[col].apply(lambda val: val.replace(&.&, &&))
&/code&&/pre&&/div&&p&&br&&/p&&p&正如上图所示，有两行描述了个人的教育：Eduction 和 EdNum。我们假设这两个特征十分相关，因此我们可以移除 Education 列。Country 列对预测收入并不会起到什么作用，所以我们需要移除它。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&df_train_set.drop([&Country&, &Education&], axis=1, inplace=True)
df_test_set.drop([&Country&, &Education&], axis=1, inplace=True)
&/code&&/pre&&/div&&p&&br&&/p&&p&Age 和 EdNum 列是数值型的，我们可以将连续数值型转化为更高效的方式，例如将年龄换为 10 年的整数倍，教育年限换为 5 年的整数倍，实现的代码如下：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&colnames = list(df_train_set.columns)
colnames.remove('Age')
colnames.remove('EdNum')
colnames = ['AgeGroup', 'Education'] + colnames
labels = [&{0}-{1}&.format(i, i + 9) for i in range(0, 100, 10)]
df_train_set['AgeGroup'] = pd.cut(df_train_set.Age, range(0, 101, 10), right=False, labels=labels)
df_test_set['AgeGroup'] = pd.cut(df_test_set.Age, range(0, 101, 10), right=False, labels=labels)
labels = [&{0}-{1}&.format(i, i + 4) for i in range(0, 20, 5)]
df_train_set['Education'] = pd.cut(df_train_set.EdNum, range(0, 21, 5), right=False, labels=labels)
df_test_set['Education'] = pd.cut(df_test_set.EdNum, range(0, 21, 5), right=False, labels=labels)
df_train_set = df_train_set[colnames]
df_test_set = df_test_set[colnames]
&/code&&/pre&&/div&&p&&br&&/p&&p&现在我们已经清理了数据，下面语句可以展示我们数据的概况：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&df_train_set.Income.value_counts()
Name: Income, dtype: int64
df_test_set.Income.value_counts()
Name: Income, dtype: int64
&/code&&/pre&&/div&&p&&br&&/p&&p&在训练集和测试集中，我们发现 &=50K 的类别要比&50K 的多 3 倍。从这里我们就可以看出来样本数据并不是均衡的数据，但是在这里为了简化问题，我们在这里将该数据集看作常规问题。&/p&&p&&br&&/p&&h2&&b&EDA&/b&&/h2&&p&现在，让我们以图像的形式看一下训练数据中的不同特征的分布和相互依存（inter-dependence）关系。首先看一下关系（Relationships）和婚姻状况（MaritalStatus）特征是如何相互关联的。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&(ggplot(df_train_set, aes(x = &Relationship&, fill = &MaritalStatus&))+ geom_bar(position=&fill&)+ theme(axis_text_x = element_text(angle = 60, hjust = 1)))
&/code&&/pre&&/div&&img src=&/v2-6aafdeb8d7ae0f573c35e_b.png& data-rawwidth=&640& data-rawheight=&410& class=&origin_image zh-lightbox-thumb& width=&640& data-original=&/v2-6aafdeb8d7ae0f573c35e_r.png&&&p&&br&&/p&&p&让我们首先看一下不同年龄组中，教育对收入的影响（用受教育的年数进行衡量）。&/p&&p&&br&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&(ggplot(df_train_set, aes(x = &Education&, fill = &Income&))+ geom_bar(position=&fill&)+ theme(axis_text_x = element_text(angle = 60, hjust = 1))+ facet_wrap('~AgeGroup'))
&/code&&/pre&&/div&&p&&br&&/p&&img src=&/v2-26c04112c_b.png& data-rawwidth=&640& data-rawheight=&443& class=&origin_image zh-lightbox-thumb& width=&640& data-original=&/v2-26c04112c_r.png&&&p&&br&&/p&&p&最近，有很多关于性别对收入差距的影响的相关说法。我们可以分别看见男性和女性的教育程度和种族间的影响。&/p&&p&&br&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&(ggplot(df_train_set, aes(x = &Education&, fill = &Income&))+ geom_bar(position=&fill&)+ theme(axis_text_x = element_text(angle = -90, hjust = 1))+ facet_wrap('~Sex'))
&/code&&/pre&&/div&&p&&br&&/p&&img src=&/v2-6c9d78f4a0c74944bff5dfd_b.png& data-rawwidth=&640& data-rawheight=&442& class=&origin_image zh-lightbox-thumb& width=&640& data-original=&/v2-6c9d78f4a0c74944bff5dfd_r.png&&&p&&br&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&(ggplot(df_train_set, aes(x = &Race&, fill = &Income&))+ geom_bar(position=&fill&)+ theme(axis_text_x = element_text(angle = -90, hjust = 1))+ facet_wrap('~Sex'))
&/code&&/pre&&/div&&img src=&/v2-b02e4b51f2f_b.png& data-rawwidth=&640& data-rawheight=&525& class=&origin_image zh-lightbox-thumb& width=&640& data-original=&/v2-b02e4b51f2f_r.png&&&p&&br&&/p&&p&直到现在，我们仅关注了非数值特征（non-numeric）的相互关系。现在我们看一下资本收益（CapitalGain）和资本损失（CapitalLoss）对收入的影响。&/p&&p&&br&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&(ggplot(df_train_set, aes(x=&Income&, y=&CapitalGain&))+ geom_jitter(position=position_jitter(0.1)))
&/code&&/pre&&/div&&img src=&/v2-fd58eeccd7c_b.png& data-rawwidth=&592& data-rawheight=&433& class=&origin_image zh-lightbox-thumb& width=&592& data-original=&/v2-fd58eeccd7c_r.png&&&p&&br&&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&(ggplot(df_train_set, aes(x=&Income&, y=&CapitalLoss&))+ geom_jitter(position=position_jitter(0.1)))
&/code&&/pre&&/div&&p&&br&&/p&&img src=&/v2-0d8fe373b8fab6b9dcd1c_b.png& data-rawwidth=&577& data-rawheight=&433& class=&origin_image zh-lightbox-thumb& width=&577& data-original=&/v2-0d8fe373b8fab6b9dcd1c_r.png&&&p&&br&&/p&&h2&&b&树分类器&/b&&/h2&&p&现在我们理解了我们数据中的一些关系，所以就可以使用 sklearn.tree.DecisionTreeClassifier 创建一个简单的树分类器模型。然而，为了使用这一模型，我们需要把所有我们的非数值数据转化成数值型数据。我们可以直接在 Pandas 数据框架中使用sklearn.preprocessing.LabeEncoder 模块和 sklearn_pandas 模块就可以轻松地完成这一步骤。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&mapper = DataFrameMapper([('AgeGroup', LabelEncoder()),('Education', LabelEncoder()),('Workclass', LabelEncoder()),('MaritalStatus', LabelEncoder()),('Occupation', LabelEncoder()),('Relationship', LabelEncoder()),('Race', LabelEncoder()),('Sex', LabelEncoder()),('Income', LabelEncoder())], df_out=True, default=None)
cols = list(df_train_set.columns)
cols.remove(&Income&)
cols = cols[:-3] + [&Income&] + cols[-3:]
df_train = mapper.fit_transform(df_train_set.copy())
df_train.columns = cols
df_test = mapper.transform(df_test_set.copy())
df_test.columns = cols
cols.remove(&Income&)
x_train, y_train = df_train[cols].values, df_train[&Income&].values
x_test, y_test = df_test[cols].values, df_test[&Income&].values
&/code&&/pre&&/div&&p&&br&&/p&&p&现在我们用正确的形式对数据进行了训练和测试，已创建了我们的第一个模型！&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&treeClassifier = DecisionTreeClassifier()
treeClassifier.fit(x_train, y_train)
treeClassifier.score(x_test, y_test)
&/code&&/pre&&/div&&p&&br&&/p&&p&最简单的且没有优化的概率分类器模型可以达到 83.5% 的精度。在分类问题中，混淆矩阵（confusion matrix）是衡量模型精度的好方法。使用下列代码我们可以绘制任意基于树的模型的混淆矩阵。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&import itertoolsfrom sklearn.metrics import confusion_matrixdef plot_confusion_matrix(cm, classes, normalize=False):&&&
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
cmap = plt.cm.Blues
title = &Confusion Matrix&if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
cm = np.around(cm, decimals=3)
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
thresh = cm.max() / 2.for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment=&center&,
color=&white& if cm[i, j] & thresh else &black&)
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
&/code&&/pre&&/div&&p&&br&&/p&&p&现在，我们可以看到第一个模型的混淆矩阵：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&y_pred = treeClassifier.predict(x_test)
cfm = confusion_matrix(y_test, y_pred, labels=[0, 1])
plt.figure(figsize=(10,6))
plot_confusion_matrix(cfm, classes=[&&=50K&, &&50K&], normalize=True)
&/code&&/pre&&/div&&p&&br&&/p&&img src=&/v2-19bb93ce9ebd629c1093_b.png& data-rawwidth=&501& data-rawheight=&438& class=&origin_image zh-lightbox-thumb& width=&501& data-original=&/v2-19bb93ce9ebd629c1093_r.png&&&p&我们发现多数类别（&=50K）的精度为 90.5%，少数类别（&50K）的精度只有 60.8%。&/p&&p&&br&&/p&&p&让我们看一下调校此简单分类器的方法。我们能使用带有 5 折交叉验证的 GridSearchCV() 来调校树分类器的各种重要参数。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&from sklearn.model_selection import GridSearchCV
parameters = {'max_features':(None, 9, 6),'max_depth':(None, 24, 16),'min_samples_split': (2, 4, 8),'min_samples_leaf': (16, 4, 12)}
clf = GridSearchCV(treeClassifier, parameters, cv=5, n_jobs=4)
clf.fit(x_train, y_train)
clf.best_score_, clf.score(x_test, y_test), clf.best_params_
{'max_depth': 16,
'max_features': 9,
'min_samples_leaf': 16,
'min_samples_split': 8})
&/code&&/pre&&/div&&p&&br&&/p&&p&经过优化，我们发现精度上升到了 85.9%。在上方，我们也可以看见最优模型的参数。现在，让我们看一下 已优化模型的混淆矩阵（confusion matrix）：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&y_pred = clf.predict(x_test)
cfm = confusion_matrix(y_test, y_pred, labels=[0, 1])
plt.figure(figsize=(10,6))
plot_confusion_matrix(cfm, classes=[&&=50K&, &&50K&], normalize=True)
&/code&&/pre&&/div&&p&&br&&/p&&img src=&/v2-7d4f2c1bae_b.png& data-rawwidth=&501& data-rawheight=&438& class=&origin_image zh-lightbox-thumb& width=&501& data-original=&/v2-7d4f2c1bae_r.png&&&p&&br&&/p&&p&经过优化，我们发现在两种类别下，预测精度都有所提升。&/p&&p&&br&&/p&&p&&b&决策树的局限性&/b&&/p&&p&决策树有很多优点，比如：&/p&&ul&&li&易于理解、易于解释&/li&&li&可视化&/li&&li&无需大量数据准备。不过要注意，sklearn.tree 模块不支持缺失值。&/li&&li&使用决策树（预测数据）的成本是训练决策时所用数据的对数量级。&br&&/li&&/ul&&p&但这些模型往往不直接使用，决策树一些常见的缺陷是：&/p&&ul&&li&构建的树过于复杂，无法很好地在数据上实现泛化。&/li&&li&数据的微小变动可能导致生成的树完全不同，因此决策树不够稳定。&/li&&li&决策树学习算法在实践中通常基于启发式算法，如贪婪算法，在每一个结点作出局部最优决策。此类算法无法确保返回全局最优决策树。&/li&&li&如果某些类别占据主导地位，则决策树学习器构建的决策树会有偏差。因此推荐做法是在数据集与决策树拟合之前先使数据集保持均衡。&/li&&li&某些类别的函数很难使用决策树模型来建模，如 XOR、奇偶校验函数（parity）和数据选择器函数（multiplexer）。&/li&&/ul&&p&大部分限制可以通过改善决策树轻易解决。在下面的内容中，我们将介绍相关的几个概念，重点介绍袋装和随机森林。&/p&&p&&br&&/p&&p&&b&剪枝&/b&&/p&&p&由于决策树容易对数据产生过拟合，因此分支更少（即减少区域 R_1, … ,R_J）的小树虽然偏差略微高一点，但其产生的方差更低，可解释性更强。处理上述问题的一种方法是构建一棵树，每个分支超过某个（高）阈值造成叶结点误差率 Qm 下降，则结束构建。但是，由于分裂算法的贪婪本质，它其实很短视。决策树早期看似无用的一次分裂有可能会导致之后一次优秀的分裂，并使得 Qm 大幅下降。&/p&&p&因此，更好的策略是构建一个非常大的树 T_0，然后再剪枝，得到一棵子树。剪枝可以使用多种策略。代价复杂度剪枝（Cost complexity pruning），又叫最弱连接剪枝（weakest link pruning），就是其中一种行之有效的策略。除了考虑每一个可能的子树之外，还需要考虑由非负调参（nonnegative tuning parameter）α 索引的树序列。每一个 α 值都对应一个尽可能小的子树 T?T_0。&/p&&img src=&/v2-6de2c02f3af828d0616f_b.png& data-rawwidth=&388& data-rawheight=&116& class=&content_image& width=&388&&&p&这里∣T∣代表树 T 中叶结点的数量，R_m 代表第 m 个叶结点对应的矩形（预测器空间的子集），yhat_Rm 是 Rm 的预测值，即 Rm 中训练样本预测值的均值（或分类树中的模式响应）。调整参数 α 控制子树复杂度之间的权衡，对训练数据进行拟合。当 α= 0 的时候，子树 T 等同于 T_0。当α的值增长时，构建具备多个子结点的树需要付出代价，这样，要想得到更小的子树，上述公式将达到最小化。我们可以使用某种交叉验证方法选择剪枝参数 α 。&/p&&p&&br&&/p&&p&注意，目前 sklearn.tree 决策树分类器（和回归器）不支持剪枝。&/p&&p&&br&&/p&&h2&&b&袋装（Bootstrap Aggregating——Bagging）&/b&&/h2&&p&&br&&/p&&p&在统计学中，Bootstrap 是依靠替换随机采样的任意试验或度量。我们从上文可以看见，决策树会受到高方差的困扰。这意味着如果我们把训练数据随机分成两部分，并且给二者都安置一个决策树，我们得到的结果可能就会相当不同。Bootstrap 聚集，或者叫做袋装，是减少统计学习方法的方差的通用过程。&/p&&p&&br&&/p&&p&给定一组 n 个独立的样本观测值 Z_1，Z_2，...，Z_n，每一个值的方差均为 *σ^*2，样本观测值的均值方差为 *σ^*2/*n*。换句话说，对一组观测值取平均会减小方差。因此一种减小方差的自然方式，也就是增加统计学习方法预测精度的方式，就是从总体中取出很多训练集，使用每一个训练集创建一个分离的预测模型，并且对预测结果求取平均值。&/p&&p&&br&&/p&&p&这里有一个问题，即我们不能获取多个训练数据集。相反，我们可以通过从（单一）训练数据集提取重复样本进行自助法（bootstrap）操作。在这种方法中，我们生成了 B 个不同的自助训练数据集。我们随后在第 b 个自助训练数据集得到了一个预测结果&/p&&p&，从而获得一个聚集预测（aggregate prediction）。&/p&&p&&br&&/p&&img src=&/v2-6964cca0d33e595bfde829ea1f4a9b95_b.png& data-rawwidth=&640& data-rawheight=&170& class=&origin_image zh-lightbox-thumb& width=&640& data-original=&/v2-6964cca0d33e595bfde829ea1f4a9b95_r.png&&&p&&br&&/p&&p&这就叫做袋装（bagging）。注意，聚集（aggregating）在回归和分类问题中可能有不同的均值。当平均预测值在回归问题中的效果很好时，我们将会需要使用多数票决（majority vote）：由于分类问题中的聚集机制，整体预测就是在 B 个预测值中最常出现的那个主要类别。&/p&&p&&br&&/p&&p&&b&Out-of-Bag（OOB）误差&/b&&/p&&p&Bagging 方法最大的优势是我们可以不通过交叉验证而求得测试误差。回想一下，Bagging 方法的精髓是多棵树可以重复地拟合观察样本的自助子集。平均而言，每一个袋装树可以利用 2/3 的观察样本。而剩下的 1/3 观察样本就可以称为 out-of-bag (OOB) 观察样本，它们并不会拟合一一棵给定袋装树。我们可以使用每一棵树的 OOB 观察样本而计算第 i 个观察样本的预测值，这将会导致大约有 B/3 的预测值可以预测第 i 个观察样本。现在我们可以使用和 Bagging（平均回归和大多数投票分类）类似的聚集技术，我们能获得第 i 个观察样本的单一预测值。我们可以用这种方式获得 n 个观察样本的 OOB 预测，因此总体的 OOB MSE（回归问题）和分类误差率（分类问题）就能计算出来。OOB 误差结果是 Bagging 模型测试误差的有效估计，因为每一个样本的预测值都是仅仅使用不会进行拟合训练模型的样本。&/p&&p&&br&&/p&&p&&b&特征重要性度量&/b&&/p&&p&通过使用单一树，Bagging 通常会提升预测的精确度。但是，解释最终的模型可能很困难。当我们袋装大量的树时，就不再可能使用单一的树表征最终的统计学习流程，因此，Bagging 是以牺牲阐释性能力为代价来提升预测精确度的。有趣的是，一个人可使用 RSS（用于 bagging 回归树）或者基尼指数（用于 bagging 分类树）得到每一个预测器的整体总结。在 bagging 回归树的情况中，我们可以记录由于所有的 B 树上平均的给定预测分子分裂而造成的 RSS 减少的所有数量。一个大的值表示一个重要的预测器。相似地，在 bagging 分类树的情况下，我们可以添加由于所有的 B 树上平均的给定预测分子分裂而造成的基尼系数降低的所有数量。一旦训练完成，sklearn 模块的不同袋装树（bagged tree）学习方法可直接访问特征的重要性数据作为属性。&/p&&p&&br&&/p&&h2&&b&随机森林模型&/b&&/h2&&p&虽然袋装技术（Bagging）通过降低方差而提高了一般决策树的预测性能，但它还遇到了其他缺点：Bagging 要求我们在自助样本上生成整棵树，这就增加了 B 倍计算复杂度。此外，因为基于 Bagging 的树是相关联的，预测精度会根据 B 而饱和。&/p&&p&&br&&/p&&p&随机森林通过随机扰动而令所有的树去相关，因此随机森林要比 Bagging 性能更好。随机森林不像 Bagging，在构建每一棵树时，每一个结点分割前都是采用随机样本预测器。因为在核心思想上，随机森林还是和 Bagging 树一样，因此其在方差上有所减少。此外，随机森林可以考虑使用大量预测器，不仅因为这种方法减少了偏差，同时局部特征预测器在树型结构中充当重要的决策。&/p&&p&&br&&/p&&p&随机森林可以使用巨量的预测器，甚至预测器的数量比观察样本的数量还多。采用随机森林方法最显著的优势是它能获得更多的信息以减少拟合数值和估计分割的偏差。&/p&&p&&br&&/p&&p&通常我们会有一些预测器能主导决策树的拟合过程，因为它们的平均性能始终要比其他一些竞争预测器更好。因此，其它许多对局部数据特征有用的预测器并不会选定作为分割变量。随着随机森林计算了足够多的决策树模型，每一个预测器都至少有几次机会能成为定义分割的预测器。大多数情况下，我们不仅仅只有主导预测器，特征预测器也有机会定义数据集的分割。&/p&&p&&br&&/p&&p&随机森林有三个主要的超参数调整：&/p&&ul&&li&结点规模：随机森林不像决策树，每一棵树叶结点所包含的观察样本数量可能十分少。该超参数的目标是生成树的时候尽可能保持小偏差。&/li&&li&树的数量：在实践中选择数百棵树一般是比较好的选择。&/li&&li&预测器采样的数量：一般来说，如果我们一共有 D 个预测器，那么我们可以在回归任务中使用 D/3 个预测器数作为采样数，在分类任务中使用 D^(1/2) 个预测器作为抽样。 &br&&/li&&/ul&&p&&b&随机森林模型案例&/b&&/p&&p&使用和上文一样的收入数据，现在我们构建一个包含 500 棵树的简单随机森林分类器模型：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&rclf = RandomForestClassifier(n_estimators=500)
rclf.fit(x_train, y_train)
rclf.score(x_test, y_test)
&/code&&/pre&&/div&&p&&br&&/p&&p&即使没有任何优化，我们仍然发现模型性能可以和已优化决策树分类器相媲美，并且测试分达到了 85.1%。按照下面的混淆矩阵，我们发现简单的随机森林和经过优化的树型分类器表现差不多，其在主要类别（&=50K 收入）的预测精度达到了 92.1%，而在少数类别（&50K 收入）上达到了 62.6%。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&rclf = RandomForestClassifier(n_estimators=500)
rclf.fit(x_train, y_train)
rclf.score(x_test, y_test)
&/code&&/pre&&/div&&p&&br&&/p&&img src=&/v2-bcd7fe5ab73dbcb0204eabc_b.png& data-rawwidth=&501& data-rawheight=&438& class=&origin_image zh-lightbox-thumb& width=&501& data-original=&/v2-bcd7fe5ab73dbcb0204eabc_r.png&&&p&&br&&/p&&p&正如前面所探讨的，随机森林模型还提供了特征重要性的度量方法。我们可以在下图中看到目前模型不同特征的重要性：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&importances = rclf.feature_importances_
indices = np.argsort(importances)
cols = [cols[x] for x in indices]
plt.figure(figsize=(10,6))
plt.title('Feature Importances')
plt.barh(range(len(indices)), importances[indices], color='b', align='center')
plt.yticks(range(len(indices)), cols)
plt.xlabel('Relative Importance')
&/code&&/pre&&/div&&img src=&/v2-3efdac4426e1ece_b.png& data-rawwidth=&640& data-rawheight=&378& class=&origin_image zh-lightbox-thumb& width=&640& data-original=&/v2-3efdac4426e1ece_r.png&&&p&&br&&/p&&p&现在我们可以尝试优化我们的随机森林模型，如下我们可以使用带 5-折交叉验证的 GridSearchCV() 操作来优化随机森林：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&parameters = {'n_estimators':(100, 500, 1000),'max_depth':(None, 24, 16),'min_samples_split': (2, 4, 8),'min_samples_leaf': (16, 4, 12)}
clf = GridSearchCV(RandomForestClassifier(), parameters, cv=5, n_jobs=8)
clf.fit(x_train, y_train)
clf.best_score_, clf.best_params_
{'max_depth': 24, 'min_samples_leaf': 4, 'min_samples_split': 4, 'n_estimators': 1000}
{'max_depth': 24,
'min_samples_leaf': 4,
'min_samples_split': 4,
'n_estimators': 1000}
&/code&&/pre&&/div&&p&&br&&/p&&p&我们可以看到现在的模型要显著地比前面的更好一些，并且预测率达到了 86.6%。按照下面的混淆矩阵，新模型在主要类别的预测精度上有显著的提升，并且在少数类别的预测上精度只稍微降低了一点。这是非平衡数据普遍存在的问题。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&rclf2 = RandomForestClassifier(n_estimators=1000,max_depth=24,min_samples_leaf=4,min_samples_split=8)
rclf2.fit(x_train, y_train)
y_pred = rclf2.predict(x_test)
cfm = confusion_matrix(y_test, y_pred, labels=[0, 1])
plt.figure(figsize=(10,6))
plot_confusion_matrix(cfm, classes=[&&=50K&, &&50K&], normalize=True)
&/code&&/pre&&/div&&p&&br&&/p&&img src=&/v2-1bdea_b.png& data-rawwidth=&501& data-rawheight=&438& class=&origin_image zh-lightbox-thumb& width=&501& data-original=&/v2-1bdea_r.png&&&p&&br&&/p&&p&最后，下面展示了对优化后模型比较重要的特征。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&importances = rclf2.feature_importances_
indices = np.argsort(importances)
cols = [cols[x] for x in indices]
plt.figure(figsize=(10,6))
plt.title('Feature Importances')
plt.barh(range(len(indices)), importances[indices], color='b', align='center')
plt.yticks(range(len(indices)), cols)
plt.xlabel('Relative Importance')
&/code&&/pre&&/div&&img src=&/v2-3d0c914b3a9cd3a1d22d54_b.png& data-rawwidth=&640& data-rawheight=&378& class=&origin_image zh-lightbox-thumb& width=&640& data-original=&/v2-3d0c914b3a9cd3a1d22d54_r.png&&&p&&br&&/p&&p&&b&随机森林的局限性&/b&&/p&&p&除了 Bagging 树模型的一般局限性外，随机森林还有一些局限性：&/p&&ul&&li&当我们需要推断超出范围的独立变量或非独立变量，随机森林做得并不好，我们最好使用如 MARS 那样的算法。&/li&&li&随机森林算法在训练和预测时都比较慢。&/li&&li&如果需要区分的类别十分多，随机森林的表现并不会很好。&br&&/li&&/ul&&p&总的来说，随机森林在很多任务上一般要比提升方法的精度差，并且运行时间也更长。所以在 Kaggle 竞赛上，有很多模型都是使用的梯度提升树算法或其他优秀的提升方法。&/p&&p&&br&&/p&&p&&a href=&/?target=https%3A//mp./s%3Fsrc%3D3%26timestamp%3D%26ver%3D1%26signature%3DgNkHjxyIfDfLuuR8Vmxxt4Q-Lqz0a2MHtWDTW807L%2AOy%2AudtyaVBCTYxHhaJKfM2aWaI12krKXDkjlf7I8clNVocB09Kn5uORzAHwPHbMNe8oZNI8UaUOqj0Mb%2AWdzcsPrCz-FU-ZQaV8DfqaKOj51wWzRxwR8bLixuyjrDSVLs%3D& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&本文来自微信公众号：机器之心（almosthuman2014），如需转载，请私信联系。&i class=&icon-external&&&/i&&/a&&/p&
本文章选自与，作者：Sadanand Singh，由机器之心编译团队整理编译。基于树（Tree based）的学习算法在数据科学竞赛中是相当常见的。这些算法给预测模型赋予了准确性、稳定性以及易解释性。和线性模型不同，它…
&img src=&/v2-aa48c6c408f869bf0fea22a95cd8f1c1_b.jpg& data-rawwidth=&1000& data-rawheight=&450& class=&origin_image zh-lightbox-thumb& width=&1000& data-original=&/v2-aa48c6c408f869bf0fea22a95cd8f1c1_r.jpg&&&p&本页面由&a href=&/?target=http%3A//mp./s/HUXzRKmMy9F0PHcPGjXzIg& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&集智俱乐部&i class=&icon-external&&&/i&&/a&的小仙女为大家整理的代码资源库，收集了大量深度学习项目图像处理领域的代码链接。包括图像识别，图像生成，看图说话等等方向的代码，所有代码均按照所属技术领域建立索引，以便大家查阅使用。&/p&&p&&b&2.1 图像生成&/b& &br&2.1.1 绘画风格到图片的转换：Neural Style &br&2.1.2 图像类比转换：image-analogies &br&2.1.3 根据涂鸦生成图片：Neural Doodle &br&2.1.4 匹根据涂鸦类比图片：Sketchy &br&2.1.5 根据图片生成铅笔画：Pencil &br&2.1.6 手写文字模拟：rnnlib &br&2.1.7 转换风景图片：Transient Attributes for High-Level Understanding and Editing of Outdoor Scenes &br&2.1.8 图片变Emojis表情：What emojis will the Emojini 3000 grant your photos? &br&2.1.9 增加图片分辨率：srez &br&2.1.10 图片自动上色：Colornet &br&2.1.11 生成可爱的动漫头像：AnimeGAN &br&2.1.12 骡子变斑马：CycleGAN and pix2pix in PyTorch &br&2.1.13 强大的图像生成器：DiscoGAN in PyTorch &br&2.1.14 使用RNN生成手写数字：DRAW implmentation &br&2.1.15 使用CNN来放大图片：waifu2x&/p&&p&&b&2.2 看图说话 &/b&&br&2.2.1 根据图片生成一段描述：Show and Tell &br&2.2.2 根据图片讲故事：neural-storyteller &br&2.2.3 根据图片将故事2:NeuralTalk2 &br&2.2.4 识别图片中的文字：CRNN for image-based sequence recognition&/p&&p&&b&2.3 图像识别 &/b&&br&2.3.1 用于物体识别的全卷积网络：PyTorch-FCN &br&2.3.2 引入注意力的卷积网络：Attention Transfer &br&2.3.3 物体识别实例：Deep-Learning &br&2.3.4 物体识别API：Tensorflow Object Detection API &br&2.3.5 推理场景结构：SfMLearner &br&2.3.6 用于分辨色情图像的open_nsfw &br&2.3.7 人脸识别：Open Face &br&2.3.8 易用人脸识别：Face_recognition &br&2.3.9 快速人脸识别：MobileID &br&2.3.10 图像识别框架1：AlexNet & VGG Net & GoogleNet & ResNet &br&2.3.11 图像识别框架2：ResNeXt & RCNN & YOLO & SqueezeNet & SegNet &br&2.3.12 预训练的图像识别模型：functional-zoo &br&2.3.13 预定义的CNN过滤器： PyScatWave &br&2.3.14 计算图片中物体的相似度：Conditional Similarity Networks (CSNs) &br&2.3.15 量子化学中的神经信息传递(?_?;Neural Message Passing for Quantum Chemistry&/p&&p&&b&2.4 图像理解 &/b&&br&2.4.1 Visual Question Answering in Pytorch &br&2.4.2 Facebook看图答题：Clevr-IEP&/p&&p&&br&&/p&&h2&&b&图像生成&/b&&/h2&&h2&&b&绘画风格到图片的转换：Neural Style&/b&&/h2&&p&&a href=&/?target=https%3A///jcjohnson/neural-style& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/jcjohnson/ne&/span&&span class=&invisible&&ural-style&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&这个项目是用 Torch 对 Leon A. Gatys, Alexander S. Ecker, 和 Matthias Bethge 等人的论文“A Neural Algorithm of Artistic Style”的一个实现。论文中提出一种算法，用卷积神经网络将一幅图像的内容与另一幅图像的风格进行组合。&/p&&h2&&b&图像类比转换：image-analogies&/b&&/h2&&p&&a href=&/?target=https%3A///awentzonline/image-analogies& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/awentzonline&/span&&span class=&invisible&&/image-analogies&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&“神经图像类比”（neural image analogies）这个项目基本上是 A. Hertzmann et. al（2001）的论文“Image Analogies”的一个实现。在这个项目中，我们使用了 VGG16 的特征，利用 Chuan Li, Michael Wand (2016) 的论文“Combining Markov Random Fields and Convolutional Neural Networks for Image Synthesis”中描述的方法进行patch的匹配和混合。初始代码改编自 Keras 的“神经风格迁移”示例。&/p&&h2&&b&根据涂鸦生成图片：Neural Doodle&/b&&/h2&&p&&a href=&/?target=https%3A///alexjc/neural-doodle& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/alexjc/neura&/span&&span class=&invisible&&l-doodle&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&使用深度神经网络把你的二流涂鸦变成艺术一般的作品！这个项目是 Champandard（2016）的论文 “Semantic Style Transfer and Turning Two-Bit Doodles into Fine Artworks”的一个实现，基于 Chuan Li 和 Michael Wand（2016）在论文“Combining Markov Random Fields and Convolutional Neural Networks for Image Synthesis”中提出的 Neural Patches 算法。&/p&&h2&&b&匹根据涂鸦类比图片：Sketchy&/b&&/h2&&p&&a href=&/?target=https%3A///janesjanes/sketchy& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/janesjanes/s&/span&&span class=&invisible&&ketchy&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&这个项目可以根据用户手绘的涂鸦，匹配出类似的图片。&/p&&h2&&b&根据图片生成铅笔画：Pencil&/b&&/h2&&p&&a href=&/?target=https%3A///fumin/pencil& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/fumin/pencil&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&把一副图像变成铅笔水粉画。&/p&&h2&&b&手写文字模拟：rnnlib&/b&&/h2&&p&&a href=&/?target=https%3A///szcom/rnnlib& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/szcom/rnnlib&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&这个项目可以做到手写文字模拟。&/p&&h2&&b&转换风景图片：Transient Attributes for High-Level Understanding and Editing of Outdoor Scenes&/b&&/h2&&p&&a href=&/?target=http%3A//transattr.cs.brown.edu/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&http://transattr.cs.brown.edu&i class=&icon-external&&&/i&&/a&&/p&&p&这个项目可以识别和理解图片中的风景，并且可以根据用户提出的条件，定向改变原风景画中的环境（比如more night）&/p&&h2&&b&图片变Emojis表情：What emojis will the Emojini 3000 grant your photos?&/b&&/h2&&p&&a href=&/?target=http%3A////emojinet.html& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&&/span&&span class=&invisible&&//emojinet.html&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&将用户提供的图片转化成相关的表情图标&/p&&h2&&b&增加图片分辨率：srez&/b&&/h2&&p&&a href=&/?target=https%3A///david-gpu/srez& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/david-gpu/sr&/span&&span class=&invisible&&ez&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&srez（super-resolution through deep learning），即通过深度学习实现图像超分辨率。这个项目是利用深度学习将 16x16 的图像分辨率增加 4 倍，基于用来训练神经网络的数据集，所得到的图像具有鲜明的特征。&/p&&h2&&b&图片自动上色：Colornet&/b&&/h2&&p&&a href=&/?target=https%3A///pavelgonchar/colornet& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/pavelgonchar&/span&&span class=&invisible&&/colornet&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&Colornet 是一个给灰度图像自动上色的神经网络。&/p&&h2&&b&生成可爱的动漫头像：AnimeGAN&/b&&/h2&&p&&a href=&/?target=https%3A///jayleicn/animeGAN& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/jayleicn/ani&/span&&span class=&invisible&&meGAN&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&使用PyTorch实现的GAN，可以自定义生成漂亮的动漫妹子头像，附带训练数据集哦！&/p&&p&&br&&/p&&h2&&b&骡子变斑马：CycleGAN and pix2pix in PyTorch&/b&&/h2&&p&&a href=&/?target=https%3A///junyanz/pytorch-CycleGAN-and-pix2pix.git& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/junyanz/pyto&/span&&span class=&invisible&&rch-CycleGAN-and-pix2pix.git&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&图到图的翻译，著名的 CycleGAN 以及 pix2pix 的PyTorch 实现。&/p&&h2&&b&强大的图像生成器：DiscoGAN in PyTorch&/b&&/h2&&p&&a href=&/?target=https%3A///carpedm20/DiscoGAN-pytorch.git& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/carpedm20/Di&/span&&span class=&invisible&&scoGAN-pytorch.git&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&《Learning to Discover Cross-Domain Relations with Generative Adversarial Networks》的 PyTorch 实现。&/p&&h2&&b&使用RNN生成手写数字：DRAW implmentation&/b&&/h2&&p&&a href=&/?target=https%3A///skaae/lasagne-draw& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/skaae/lasagn&/span&&span class=&invisible&&e-draw&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&使用RNN生成手写体数字。&/p&&h2&&b&使用CNN来放大图片：waifu2x&/b&&/h2&&p&&a href=&/?target=https%3A///nagadomi/waifu2x& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/nagadomi/wai&/span&&span class=&invisible&&fu2x&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&使用CNN来放大图片，与普通图片放大不同的是，使用CNN“生成”放大，使低分辨率的图片在放大后也不会出现像素锯齿。&/p&&h2&&b&看图说话&/b&&/h2&&h2&&b&根据图片生成一段描述：Show and Tell&/b&&/h2&&p&&a href=&/?target=https%3A///tensorflow/models/tree/master/im2txt& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/tensorflow/m&/span&&span class=&invisible&&odels/tree/master/im2txt&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&这是 Oriol Vinyals et. al.（2016）的论文“Show and Tell: Lessons learned from the 2015 MSCOCO Image Captioning Challenge”的用TensorFlow实现的 image-to-text 图片说明生成模型。&/p&&h2&&b&根据图片讲故事：neural-storyteller&/b&&/h2&&p&&a href=&/?target=https%3A///ryankiros/neural-storyteller& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/ryankiros/ne&/span&&span class=&invisible&&ural-storyteller&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&Neural-storyteller 是一个能够根据图像内容生成一个小故事的循环神经网络。这个 GitHub 库里包含了使用任意图像生成故事的代码，以及用于训练新模型的说明。&/p&&h2&&b&根据图片将故事2:NeuralTalk2&/b&&/h2&&p&&a href=&/?target=https%3A///karpathy/neuraltalk2& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&/karpathy/neu&/span&&span class=&invisible&&raltalk2&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&p&循环神经网络（RNN）可以用于给图像取标题。NeuralTalk2 比原始版本的 NeuralTalk 更快而且性能更好。与原来的 NeuralTalk 相比，NeuralTalk2 的实现是批量的，可以使用 Torch 在 GPU上运行，并且支持 CNN 微调。这些都使得语言模型（~100x）的训练速度大大加快，但由于我们还有一个 VGGNet，因此总体上的提升没有很多。但是这仍然