机器学习算法一览表

杨利霞

- {- Q) ?4 r0 ^) L8 X5 E$ i3 C# O机器学习算法一览表
, \4 Y  |0 Y$ k$ K" V; w1.引言

提起笔来写这篇博客，突然有点愧疚和尴尬。愧疚的是，工作杂事多，加之懒癌严重，导致这个系列一直没有更新，向关注该系列的同学们道个歉。尴尬的是，按理说，机器学习介绍与算法一览应该放在最前面写，详细的应用建议应该在讲完机器学习常用算法之后写，突然莫名奇妙在中间插播这么一篇，好像有点打乱主线。
7 I6 Z% p7 G& _! U0 w% G& S老话说『亡羊补牢，为时未晚』，前面开头忘讲的东西，咱在这块儿补上。我们先带着大家过一遍传统机器学习算法，基本思想和用途。把问题解决思路和方法应用建议提前到这里的想法也很简单，希望能提前给大家一些小建议，对于某些容易出错的地方也先给大家打个预防针，这样在理解后续相应机器学习算法之后，使用起来也有一定的章法。

2.机器学习算法简述

按照不同的分类标准，可以把机器学习的算法做不同的分类。

2.1 从机器学习问题角度分类

我们先从机器学习问题本身分类的角度来看，我们可以分成下列类型的算法：

• 监督学习算法
  : @* s9 M: y. A/ S' _& G- ~8 H$ U

机器学习中有一大部分的问题属于『监督学习』的范畴，简单口语化地说明，这类问题中，给定的训练样本中，每个样本的输入xx都对应一个确定的结果yy，我们需要训练出一个模型(数学上看是一个x→yx→y的映射关系ff)，在未知的样本x′x′给定后，我们能对结果y′y′做出预测。

这里的预测结果如果是离散值(很多时候是类别类型，比如邮件分类问题中的垃圾邮件/普通邮件，比如用户会/不会购买某商品)，那么我们把它叫做分类问题(classification problem)；如果预测结果是连续值(比如房价，股票价格等等)，那么我们把它叫做回归问题(regression problem)。

有一系列的机器学习算法是用以解决监督学习问题的，比如最经典的用于分类问题的朴素贝叶斯、逻辑回归、支持向量机等等；比如说用于回归问题的线性回归等等。

• 无监督学习
  / s9 q$ T2 ~3 L5 h# w  c; u

有另外一类问题，给我们的样本并没有给出『标签/标准答案』，就是一系列的样本。而我们需要做的事情是，在一些样本中抽取出通用的规则。这叫做『无监督学习』。包括关联规则和聚类算法在内的一系列机器学习算法都属于这个范畴。

• 半监督学习
  2 f; n4 F8 R! }( x# W

这类问题给出的训练数据，有一部分有标签，有一部分没有标签。我们想学习出数据组织结构的同时，也能做相应的预测。此类问题相对应的机器学习算法有自训练(Self-Training)、直推学习(Transductive Learning)、生成式模型(Generative Model)等。

总体说来，最常见是前两类问题，而对应前两类问题的一些机器学习算法如下：

2.2 从算法的功能角度分类

我们也可以从算法的共性(比如功能，运作方式)角度对机器学习算法分类。下面我们根据算法的共性去对它们归个类。不过需要注意的是，我们下面的归类方法可能对分类和回归有比较强的倾向性，而这两类问题也是最常遇到的。

2.2.1 回归算法(Regression Algorithms)

4 q. l( _) Q- V8 P& k, A% F

& e) ^7 I9 i" @# }: R回归算法是一种通过最小化预测值与实际结果值之间的差距，而得到输入特征之间的最佳组合方式的一类算法。对于连续值预测有线性回归等，而对于离散值/类别预测，我们也可以把逻辑回归等也视作回归算法的一种，常见的回归算法如下：

• Ordinary Least Squares Regression (OLSR)
• Linear Regression
• Logistic Regression
• Stepwise Regression
• Locally Estimated Scatterplot Smoothing (LOESS)
• Multivariate Adaptive Regression Splines (MARS)
  5 m  Z- y, q1 Y

2.2.2 基于实例的算法(Instance-based Algorithms)

这里所谓的基于实例的算法，我指的是我们最后建成的模型，对原始数据样本实例依旧有很强的依赖性。这类算法在做预测决策时，一般都是使用某类相似度准则，去比对待预测的样本和原始样本的相近度，再给出相应的预测结果。常见的基于实例的算法有：

• k-Nearest Neighbour (kNN)
• Learning Vector Quantization (LVQ)
• Self-Organizing Map (SOM)
• Locally Weighted Learning (LWL)
  

2.2.3 决策树类算法(Decision Tree Algorithms)

+ t% Q! l& s& g0 X0 e2 [& J7 T决策树类算法，会基于原始数据特征，构建一颗包含很多决策路径的树。预测阶段选择路径进行决策。常见的决策树算法包括：

• Classification and Regression Tree (CART)
• Iterative Dichotomiser 3 (ID3)
• C4.5 and C5.0 (different versions of a powerful approach)
• Chi-squared Automatic Interaction Detection (CHAID)
• M5
• Conditional Decision Trees
  2 Z6 V0 x+ Y' I1 Z, v2 M$ W

2.2.4 贝叶斯类算法(Bayesian Algorithms)
0 ~* i4 G. |  d3 j: ^6 J: n
这里说的贝叶斯类算法，指的是在分类和回归问题中，隐含使用了贝叶斯原理的算法。包括：

• Naive Bayes
• Gaussian Naive Bayes
• Multinomial Naive Bayes
• Averaged One-Dependence Estimators (AODE)
• Bayesian Belief Network (BBN)
• Bayesian Network (BN)
  

2.2.5 聚类算法(Clustering Algorithms)

聚类算法做的事情是，把输入样本聚成围绕一些中心的『数据团』，以发现数据分布结构的一些规律。常用的聚类算法包括：

• k-Means
• Hierarchical Clustering
• Expectation Maximisation (EM)
  

2.2.6 关联规则算法(Association Rule Learning Algorithms)
/ K- d$ P; r: @' H$ B
关联规则算法是这样一类算法：它试图抽取出，最能解释观察到的训练样本之间关联关系的规则，也就是获取一个事件和其他事件之间依赖或关联的知识，常见的关联规则算法有：

• Apriori algorithm
• Eclat algorithm
  

2.2.7 人工神经网络类算法(Artificial Neural Network Algorithms)

这是受人脑神经元工作方式启发而构造的一类算法。需要提到的一点是，我把『深度学习』单拎出来了，这里说的人工神经网络偏向于更传统的感知算法，主要包括：

• Perceptron
• Back-Propagation
• Radial Basis Function Network (RBFN)
  3 A4 G# b' R& L

2.2.8 深度学习(Deep Learning Algorithms)
1 }3 p& P: G1 P) w7 @
# C" O! b: Y! d/ {深度学习是近年来非常火的机器学习领域，相对于上面列的人工神经网络算法，它通常情况下，有着更深的层次和更复杂的结构。有兴趣的同学可以看看我们另一个系列机器学习与计算机视觉，最常见的深度学习算法包括：

• Deep Boltzmann Machine (DBM)
• Deep Belief Networks (DBN)
• Convolutional Neural Network (CNN)
• Stacked Auto-Encoders
  

2.2.9 降维算法(Dimensionality Reduction Algorithms)
1 o! L. a+ i( s+ ]7 Q& c  b
+ {* P2 }; ^: y- }1 t( |从某种程度上说，降维算法和聚类其实有点类似，因为它也在试图发现原始训练数据的固有结构，但是降维算法在试图，用更少的信息(更低维的信息)总结和描述出原始信息的大部分内容。
- U$ `+ ~* S0 [0 C5 Z+ B4 u8 y' U有意思的是，降维算法一般在数据的可视化，或者是降低数据计算空间有很大的作用。它作为一种机器学习的算法，很多时候用它先处理数据，再灌入别的机器学习算法学习。主要的降维算法包括：

• Principal Component Analysis (PCA)
• Principal Component Regression (PCR)
• Partial Least Squares Regression (PLSR)
• Sammon Mapping
• Multidimensional Scaling (MDS)
• Linear Discriminant Analysis (LDA)
• Mixture Discriminant Analysis (MDA)
• Quadratic Discriminant Analysis (QDA)
• Flexible Discriminant Analysis (FDA)
  ; v! \  w' l" ?3 d8 b; V

2.2.10 模型融合算法(Ensemble Algorithms)

严格意义上来说，这不算是一种机器学习算法，而更像是一种优化手段/策略，它通常是结合多个简单的弱机器学习算法，去做更可靠的决策。拿分类问题举个例，直观的理解，就是单个分类器的分类是可能出错，不可靠的，但是如果多个分类器投票，那可靠度就会高很多。常用的模型融合增强方法包括：

• Random Forest
• Boosting
• Bootstrapped Aggregation (Bagging)
• AdaBoost
• Stacked Generalization (blending)
• Gradient Boosting Machines (GBM)
• Gradient Boosted Regression Trees (GBRT)
  

2.3 机器学习算法使用图谱

scikit-learn作为一个丰富的python机器学习库，实现了绝大多数机器学习的算法，有相当多的人在使用，于是我这里很无耻地把machine learning cheat sheet for sklearn搬过来了，原文可以看这里。哈哈，既然讲机器学习，我们就用机器学习的语言来解释一下，这是针对实际应用场景的各种条件限制，对scikit-learn里完成的算法构建的一颗决策树，每一组条件都是对应一条路径，能找到相对较为合适的一些解决方法，具体如下：

首先样本量如果非常少的话，其实所有的机器学习算法都没有办法从里面『学到』通用的规则和模式，so多弄点数据是王道。然后根据问题是有/无监督学习和连续值/离散值预测，分成了分类、聚类、回归和维度约减四个方法类，每个类里根据具体情况的不同，又有不同的处理方法。

3. 机器学习问题解决思路

上面带着代价走马观花过了一遍机器学习的若干算法，下面我们试着总结总结在拿到一个实际问题的时候，如果着手使用机器学习算法去解决问题，其中的一些注意点以及核心思路。主要包括以下内容：

• 拿到数据后怎么了解数据(可视化)
• 选择最贴切的机器学习算法
• 定位模型状态(过/欠拟合)以及解决方法
• 大量极的数据的特征分析与可视化
• 各种损失函数(loss function)的优缺点及如何选择
  

多说一句，这里写的这个小教程，主要是作为一个通用的建议和指导方案，你不一定要严格按照这个流程解决机器学习问题。

3.1 数据与可视化

我们先使用scikit-learn的make_classification函数来生产一份分类数据，然后模拟一下拿到实际数据后我们需要做的事情。

• 
  + m& v$ B7 x0 P) S9 g9 w$ B9 S
  5 _8 X; H% E7 D. i# c8 o#numpy科学计算工具箱
  
  9 _. b5 @% d$ E% J  t
• 
  8 B6 }" }+ l  U" e, _
  6 j" y4 y- [" l: limport numpy as np
  
  
• 
  
  #使用make_classification构造1000个样本，每个样本有20个feature
  6 z3 E& Q! y2 P% ?0 C. S8 k
  
• 
  
  from sklearn.datasets import make_classification
  5 K8 o" F, i6 @$ a
  
• 
  2 _) K" C0 d+ r: y. J1 k8 `
  X, y = make_classification(1000, n_features=20, n_informative=2,
  8 t0 ?, G$ M; v
  
• 
  
                             n_redundant=2, n_classes=2, random_state=0)
  & y9 G6 A/ n8 N7 t
  
• 
  6 V: ]/ j; D- T% O+ S
  #存为dataframe格式
  
  
• 
  
  from pandas import DataFrame
  
  4 b& p' P- p. H
• 
  
  6 }# s5 W4 W* ]( ^  T1 D5 ^. @df = DataFrame(np.hstack((X, y[:, None])),columns = range(20) + ["class"])
  
  ! `5 m. s  x2 k5 R
  

我们生成了一份包含1000个分类数据样本的数据集，每个样本有20个数值特征。同时我们把数据存储至pandas中的DataFrame数据结构中。我们取前几行的数据看一眼：

df[:6]

不幸的是，肉眼看数据，尤其是维度稍微高点的时候，很有可能看花了也看不出看不出任何线索。幸运的是，我们对于图像的理解力，比数字好太多，而又有相当多的工具可以帮助我们『可视化』数据分布。

我们在处理任何数据相关的问题时，了解数据都是很有必要的，而可视化可以帮助我们更好地直观理解数据的分布和特性

数据的可视化有很多工具包可以用，比如下面我们用来做数据可视化的工具包Seaborn。最简单的可视化就是数据散列分布图和柱状图，这个可以用Seanborn的pairplot来完成。以下图中2种颜色表示2种不同的类，因为20维的可视化没有办法在平面表示，我们取出了一部分维度，两两组成pair看数据在这2个维度平面上的分布状况，代码和结果如下：

• 
  
  + h1 t% G% P5 `0 ?4 R& W% Ximport matplotlib.pyplot as plt
  
  
• 
  
  0 S# p" W3 j1 p( iimport seaborn as sns
  5 u: h8 v! u" n1 M; G% p
  
• 
  
  5 e: N% V/ M% H. `1 o, V#使用pairplot去看不同特征维度pair下数据的空间分布状况
  
  , p4 ~& T: y* {. \* L$ K6 t3 x- e
• 
  8 g. x$ Y. R* ~% l9 K) a7 u1 w
  5 t# S' A) k8 }" p0 Q_ = sns.pairplot(df[:50], vars=[8, 11, 12, 14, 19], hue="class", size=1.5)
  
  7 y& a# y1 s1 C' |
• 
  5 c3 m* a6 D/ L& F0 z3 A: E
  % R* D; ~( j# a: R( [plt.show()
  
  
  & M* ^) `  D2 L, h& Z9 i

6 _. v- A* i& C- G

7 y8 e/ Z. B8 X4 G

我们从散列图和柱状图上可以看出，确实有些维度的特征相对其他维度，有更好的区分度，比如第11维和14维看起来很有区分度。这两个维度上看，数据点是近似线性可分的。而12维和19维似乎呈现出了很高的负相关性。接下来我们用Seanborn中的corrplot来计算计算各维度特征之间(以及最后的类别)的相关性。代码和结果图如下：

• 
  
  import matplotlib.pyplot as plt
  * |0 S. u- T  w6 Q  e. T. ?2 a
  9 T1 R1 O. w# P, Y
• 
  
  * b$ M! p' G# j) Kplt.figure(figsize=(12, 10))
  ) z' m  b: n/ P% `
  . I3 ~4 D# p/ f4 r0 l2 e8 \( I# z
• 
  
  , L8 ?4 a8 j! h1 ^' I_ = sns.corrplot(df, annot=False)
  
  
• 
    [9 V/ O# ?8 \2 S+ a- Q
  plt.show()
  
  
  

相关性图很好地印证了我们之前的想法，可以看到第11维特征和第14维特征和类别有极强的相关性，同时它们俩之间也有极高的相关性。而第12维特征和第19维特征却呈现出极强的负相关性。强相关的特征其实包含了一些冗余的特征，而除掉上图中颜色较深的特征，其余特征包含的信息量就没有这么大了，它们和最后的类别相关度不高，甚至各自之间也没什么先惯性。

插一句，这里的维度只有20，所以这个相关度计算并不费太大力气，然而实际情形中，你完全有可能有远高于这个数字的特征维度，同时样本量也可能多很多，那种情形下我们可能要先做一些处理，再来实现可视化了。别着急，一会儿我们会讲到。

3.2 机器学习算法选择

数据的情况我们大致看了一眼，确定一些特征维度之后，我们可以考虑先选用机器学习算法做一个baseline的系统出来了。这里我们继续参照上面提到过的机器学习算法使用图谱。
我们只有1000个数据样本，是分类问题，同时是一个有监督学习，因此我们根据图谱里教的方法，使用LinearSVC(support vector classification with linear kernel)试试。注意，LinearSVC需要选择正则化方法以缓解过拟合问题；我们这里选择使用最多的L2正则化，并把惩罚系数C设为10。我们改写一下sklearn中的学习曲线绘制函数，画出训练集和交叉验证集上的得分：

• 
  
  - s: c4 X1 {' ~from sklearn.svm import LinearSVC
  
  
• 
  5 D8 L( H  c. y4 m
  ; C) m! d& Z. t8 G. ?from sklearn.learning_curve import learning_curve
  
  
• 
  
  #绘制学习曲线，以确定模型的状况
  
  
• 
  
  def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
  
  ; U; e2 g% V- @* T6 G6 o
• 
  
  ) A3 Y) A# J% S1 I; T  g* g                        train_sizes=np.linspace(.1, 1.0, 5)):
  
  
• 
  2 n& j5 @5 T" E  |/ d: \% B4 e
      """
  
  
• 
  
      画出data在某模型上的learning curve.
  
  $ C/ Z% q, I7 Z4 G
• 
  0 m# W9 E' C4 Q
  ! U; Q& Z/ j* k0 |' L    参数解释
  / E% h6 I/ [1 E
  
• 
  
      ----------
  
  / q0 R# u- D* S. y% F
• 
  6 o0 b3 n" ?9 {* S& F5 ~( b( Q7 s
      estimator : 你用的分类器。
  
  , E; R/ S4 c9 G9 i! _
• 
  
      title : 表格的标题。
  + c( l: J9 X$ X) G
  7 h) A8 T& K. R' I, f" i8 H
• 
  , {) j; ^( Q3 O6 h
      X : 输入的feature，numpy类型
  & r% ^9 d$ u" E5 M" l: _
  
• 
  % l" q7 H& X0 a/ o+ |
      y : 输入的target vector
  
  
• 
  
  ) q! U0 E* ]1 o! ?4 R4 z. I    ylim : tuple格式的(ymin, ymax), 设定图像中纵坐标的最低点和最高点
  $ J: R# e" ~. S/ d5 e  C
  
• 
  " o# k0 q2 w' i) r! I0 S5 Z
    ~% [- |2 y: W7 E, l# r4 f. s, _  y    cv : 做cross-validation的时候，数据分成的份数，其中一份作为cv集，其余n-1份作为training(默认为3份)
  
  % `) C9 N% H% L( F
• 
  9 R" T4 ^  d1 {; e, h0 w
      """
  
  
• 
  
    _! W! `/ c2 y8 D: B: F
  
  
• 
  
  + T8 N% W$ l$ N. l: b% Q( w9 |    plt.figure()
  " B9 @5 i2 \( o3 g: M; R% b9 }. Q
  7 s& x2 K  f: u* d- f
• 
  " S$ Z( G; {* \- M8 l
  ! G' _( J- g4 ]5 q    train_sizes, train_scores, test_scores = learning_curve(
  
  1 B2 u. w1 f/ r
• 
  
  % x% v0 P; _5 w+ h- e6 u        estimator, X, y, cv=5, n_jobs=1, train_sizes=train_sizes)
  ! G0 \/ S4 X& N5 q- V/ {9 a+ Z
  + n6 h$ B# v+ T, d2 C! q8 W- V
• 
  
  * ^1 g. r7 H; B0 q    train_scores_mean = np.mean(train_scores, axis=1)
  & c  o* {5 {7 d# ]6 x5 T
  & N7 h% G9 I2 }$ {- y3 q
• 
  
  & e' Y) k) M2 }  R/ [0 k    train_scores_std = np.std(train_scores, axis=1)
  5 O0 E6 D0 i, p8 Y  Y: s  l
  3 m/ a* j# m: z( d' V
• 
  . n0 Z; j4 X2 [" S$ o7 X
  , v" Y! c8 z0 M5 r, c+ x    test_scores_mean = np.mean(test_scores, axis=1)
  . {6 e5 ~8 ]4 K3 n# n7 }
  
• 
  
      test_scores_std = np.std(test_scores, axis=1)
  
  * o' t; T; \. \" P
• 
  / j6 `% C, x2 _. j4 E1 \: r
  
  $ K' W5 V- `1 h; X, @! s
  
• 
  
      plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
    V6 C$ \* s* N9 G( Q3 n
  
• 
  
  & ~1 C# Z8 j" [3 y- P/ X  S+ o                     train_scores_mean + train_scores_std, alpha=0.1,
  
  
• 
  1 s. Z# Q$ |# ~+ z0 u
                       color="r")
  6 Y1 S" g" o) ]& n! \  \
  
• 
  5 |) {$ w! R! G2 c0 W' E
  1 d5 r1 i& x) O9 F! P( w    plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
    f5 L2 C' V4 D7 y/ _
  
• 
  - Y- H2 v& s1 d
                       test_scores_mean + test_scores_std, alpha=0.1, color="g")
  
  
• 
  + L$ Q% z  o7 S; w# d9 t7 F6 ^) U
      plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
  * q  S  @. l- ]4 Z6 Z: p# G, |
  
• 
  % k5 t% g" U/ d$ V+ `" ]. ]
               label="Training score")
  $ X* j" A- W$ f  Z( k: L7 e
  
• 
  ' l3 y. r) C0 F; |( h* K5 t
      plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
  
  # r. w) p  e$ `
• 
  
  % n( k4 q- }- j# f- ~" H' x             label="Cross-validation score")
  
  
• 
  : V+ B4 Q" e. D, g
  
  8 ^* R7 M8 [- m' }# m) _  L
  
• 
  " ?5 R$ |. E# d
  1 @, v: e9 \3 n    plt.xlabel("Training examples")
  6 N9 Q4 E$ j6 ]# |# U( i; @  Z
  
• 
  ; F! e- V* p: ~# I+ C8 t
  . U$ x' w( @- ]( D, B# Z    plt.ylabel("Score")
  
  
• 
    c/ M, S+ w% e' V; K/ z
  7 b0 q( H& H; b5 o0 Q    plt.legend(loc="best")
  
  
• 
  
      plt.grid("on")
  ! H3 Y. T7 U8 u. C: p5 S
  
• 
  ) ]) c/ S( z( ?
      if ylim:
  . t6 u9 M, z; K" e! B8 g
  ' L: e' i$ n, v
• 
  - G" w+ @# |) B& Z* o% H3 N" ?1 {
  - v' u9 d. Q$ k4 B        plt.ylim(ylim)
  7 a3 y; H' c! p3 b! w/ G7 S$ @% r
  
• 
  4 w7 I7 M+ v8 C$ J) t# b, r
  / U! S3 W9 q: [7 s* K    plt.title(title)
  
  ; M* X* H; y# Z* z, V
• 
  
      plt.show()
  ! t% ?) L% F, C5 i
  
• 
  + _+ N- M+ ~% S5 t) t" t
  % c/ q' H. u4 x8 v
  
  
• 
  * B( l9 y% y4 m& P* X+ o
  #少样本的情况情况下绘出学习曲线
  * H; I% z8 }! M* f& R7 P
  0 j+ M% y" C2 j# [& B/ F' V! r
• 
  
  plot_learning_curve(LinearSVC(C=10.0), "LinearSVC(C=10.0)",
  : F3 k6 `) p4 |; R
  
• 
  * {3 f/ _4 k8 D$ q* f
  & I0 G, v2 Z6 K) e2 D                    X, y, ylim=(0.8, 1.01),
  
  / L' |4 M3 l; p4 K* z9 Z! h
• 
  + B1 e8 a& t- S6 F
  ( O& L4 Z* L: N' E3 p! j# Q                    train_sizes=np.linspace(.05, 0.2, 5))
  2 o% x" P! B+ g5 u4 O7 D
  
  

这幅图上，我们发现随着样本量的增加，训练集上的得分有一定程度的下降，交叉验证集上的得分有一定程度的上升，但总体说来，两者之间有很大的差距，训练集上的准确度远高于交叉验证集。这其实意味着我们的模型处于过拟合的状态，也即模型太努力地刻画训练集，一不小心把很多噪声的分布也拟合上了，导致在新数据上的泛化能力变差了。

3.2.1 过拟合的定位与解决

问题来了，过拟合咋办？
针对过拟合，有几种办法可以处理：

• 增大样本量
  8 l( ?% n/ _* ~( Y( V5 I

这个比较好理解吧，过拟合的主要原因是模型太努力地去记住训练样本的分布状况，而加大样本量，可以使得训练集的分布更加具备普适性，噪声对整体的影响下降。恩，我们提高点样本量试试：

• 
  . y( c1 l' h  Y5 M- l  ^/ o" o6 s
  0 X* V2 w7 m2 T: E#增大一些样本量
  2 ?4 ]) a$ I5 j
  6 x+ {" {0 I; B. {0 I" w
• 
  * w  `3 v2 O+ _7 Q9 u7 ?) D" n
  ' Y7 T/ B+ ?. V0 splot_learning_curve(LinearSVC(C=10.0), "LinearSVC(C=10.0)",
  
  
• 
  : }/ z' a- m2 N, H' m6 B
  ' M2 W4 F- R+ C: P4 A; y                    X, y, ylim=(0.8, 1.1),
  7 V3 _0 k4 @6 b9 {
  
• 
  
  : T' E, F. l0 I/ A; A" E                    train_sizes=np.linspace(.1, 1.0, 5))
  
  
  2 |6 d2 x- c; q0 k

是不是发现问题好了很多？随着我们增大训练样本量，我们发现训练集和交叉验证集上的得分差距在减少，最后它们已经非常接近了。增大样本量，最直接的方法当然是想办法去采集相同场景下的新数据，如果实在做不到，也可以试试在已有数据的基础上做一些人工的处理生成新数据(比如图像识别中，我们可能可以对图片做镜像变换、旋转等等)，当然，这样做一定要谨慎，强烈建议想办法采集真实数据。

• 减少特征的量(只用我们觉得有效的特征)
  

比如在这个例子中，我们之前的数据可视化和分析的结果表明，第11和14维特征包含的信息对识别类别非常有用，我们可以只用它们。

plot_learning_curve(LinearSVC(C=10.0), "LinearSVC(C=10.0) Features: 11&14", X[:, [11, 14]], y, ylim=(0.8, 1.0), train_sizes=np.linspace(.05, 0.2, 5))

从上图上可以看出，过拟合问题也得到一定程度的缓解。不过我们这是自己观察后，手动选出11和14维特征。那能不能自动进行特征组合和选择呢，其实我们当然可以遍历特征的组合样式，然后再进行特征选择(前提依旧是这里特征的维度不高，如果高的话，遍历所有的组合是一个非常非常非常耗时的过程！！)：

• 
  ' v2 Z9 e3 T5 C1 N. {7 @
  7 }! u+ r5 T! i7 {) b& j6 X; S0 lfrom sklearn.pipeline import Pipeline
  
  
• 
  + a& S7 K% Y& I
  from sklearn.feature_selection import SelectKBest, f_classif
  ' j# S' g! F. X! m  X' f  V
  ( s: o# ?$ x) S0 U8 n
• 
  
  # SelectKBest(f_classif, k=2) 会根据Anova F-value选出 最好的k=2个特征
  
  , h2 f5 m8 V/ d/ }6 s& Y
• 
  
  
  + E( @5 e% ], q/ d
  
• 
  
  plot_learning_curve(Pipeline([("fs", SelectKBest(f_classif, k=2)), # select two features
  ; }* j) F. M4 T# V# L
  + Z2 ?( q+ j& d3 W
• 
  ! Z$ @0 O/ e" m# }6 a
  + t% v! |# v; P+ r% f- V1 p                               ("svc", LinearSVC(C=10.0))]), "SelectKBest(f_classif, k=2) + LinearSVC(C=10.0)", X, y, ylim=(0.8, 1.0), train_sizes=np.linspace(.05, 0.2, 5))
    N8 V: j7 M: x; G) B
  
  2 n8 ?9 i. }, e8 Z0 H4 q

如果你自己跑一下程序，会发现在我们自己手造的这份数据集上，这个特征筛选的过程超级顺利，但依旧像我们之前提过的一样，这是因为特征的维度不太高。
+ N5 V# c$ ]* k& O, i从另外一个角度看，我们之所以做特征选择，是想降低模型的复杂度，而更不容易刻画到噪声数据的分布。从这个角度出发，我们还可以有(1)多项式你和模型中降低多项式次数 (2)神经网络中减少神经网络的层数和每层的结点数 (c)SVM中增加RBF-kernel的bandwidth等方式来降低模型的复杂度。
) k: P) i' y) o' r, ?# ^话说回来，即使以上提到的办法降低模型复杂度后，好像能在一定程度上缓解过拟合，但是我们一般还是不建议一遇到过拟合，就用这些方法处理，优先用下面的方法：

• 增强正则化作用(比如说这里是减小LinearSVC中的C参数)
  4 E! R3 V9 x! G  M+ Q" j正则化是我认为在不损失信息的情况下，最有效的缓解过拟合现象的方法。
  

plot_learning_curve(LinearSVC(C=0.1), "LinearSVC(C=0.1)", X, y, ylim=(0.8, 1.0), train_sizes=np.linspace(.05, 0.2, 5))

调整正则化系数后，发现确实过拟合现象有一定程度的缓解，但依旧是那个问题，我们现在的系数是自己敲定的，有没有办法可以自动选择最佳的这个参数呢？可以。我们可以在交叉验证集上做grid-search查找最好的正则化系数(对于大数据样本，我们依旧需要考虑时间问题，这个过程可能会比较慢):

• 
  4 D. c% c* `4 Z" K& B% j
  9 `$ M  a4 a' N. y' x1 g, Z4 t6 ~from sklearn.grid_search import GridSearchCV
  ( ~% \+ {- G# l' {: s
  
• 
  
  & m. w1 t! ?$ A( y4 L' q: S; jestm = GridSearchCV(LinearSVC(),
  
  
• 
  + Q* O3 E3 g" k! v. z8 V
  7 o* t1 w- H  t# }% Y                   param_grid={"C": [0.001, 0.01, 0.1, 1.0, 10.0]})
  
  
• 
  - n: T* {+ X7 C, b+ K
  . K9 T( l# g1 G6 r# c" z* Gplot_learning_curve(estm, "LinearSVC(C=AUTO)",
  
  # @  c: g& X$ e* Y" h3 Y
• 
  
                      X, y, ylim=(0.8, 1.0),
  
  
• 
  5 t  ^5 ]4 B+ ]5 e3 i, m
  # K) O! U5 m5 h& Q! D2 I                    train_sizes=np.linspace(.05, 0.2, 5))
  1 g' U& f' t, d" i5 N7 Y
  * H7 ^* V+ K4 I0 n: }4 O
• 
  
  ; m/ m1 t) b1 z  u8 k7 a( t/ h, Y7 Bprint "Chosen parameter on 100 datapoints: %s" % estm.fit(X[:500], y[:500]).best_params_
  
  ( d% I- i' E6 b( K- R  z
  8 V4 W; W5 s/ V- F

在500个点得到的结果是：{‘C’: 0.01} 使用新的C参数，我们再看看学习曲线：

对于特征选择的部分，我打算多说几句，我们刚才看过了用sklearn.feature_selection中的SelectKBest来选择特征的过程，也提到了在高维特征的情况下，这个过程可能会非常非常慢。那我们有别的办法可以进行特征选择吗？比如说，我们的分类器自己能否甄别那些特征是对最后的结果有益的？这里有个实际工作中用到的小技巧。

我们知道：

• l2正则化，它对于最后的特征权重的影响是，尽量打散权重到每个特征维度上，不让权重集中在某些维度上，出现权重特别高的特征。
• 而l1正则化，它对于最后的特征权重的影响是，让特征获得的权重稀疏化，也就是对结果影响不那么大的特征，干脆就拿不着权重。
  

那基于这个理论，我们可以把SVC中的正则化替换成l1正则化，让其自动甄别哪些特征应该留下权重。

plot_learning_curve(LinearSVC(C=0.1, penalty='l1', dual=False), "LinearSVC(C=0.1, penalty='l1')", X, y, ylim=(0.8, 1.0), train_sizes=np.linspace(.05, 0.2, 5))

好了，我们一起来看看最后特征获得的权重：

• 
  7 z  y, J. y. a. O
  3 a& \" Y# t' b1 X: ?3 Mestm = LinearSVC(C=0.1, penalty='l1', dual=False)
  $ ^# Y7 z$ S6 A9 y7 i( b0 \
  $ L4 a- y7 r. I" ?  A
• 
  " X6 ^# D# \$ B" T# K* L) u( ?
  estm.fit(X[:450], y[:450])  # 用450个点来训练
  # }& j0 ~0 |) d* ?, O" y
  
• 
  
  print "Coefficients learned: %s" % est.coef_
  
  
• 
  # h6 a/ o  B7 v2 x
  + ?0 _1 h" [! wprint "Non-zero coefficients: %s" % np.nonzero(estm.coef_)[1]
  
  $ ]3 k5 q: Z5 v' i
  - s9 f# [3 m4 E+ P" w

得到结果：

• 
  
  ' Y$ K/ X$ e5 u& m* aCoefficients learned: [[ 0.          0.          0.          0.          0.          0.01857999
  
  
• 
  ; R5 p) z6 i3 ~1 [7 c: ^6 Y) u. d; w
  2 _) S6 g& W! u7 `- {   0.          0.          0.          0.004135    0.          1.05241369
  & E% h( Q- E. C  J0 P$ V; q
  
• 
  7 L% e; I6 r2 g
  6 t5 {4 [6 h/ _/ j% ^) _$ A   0.01971419  0.          0.          0.          0.         -0.05665314
  
  
• 
  7 @& T; d: ~: u, O
  6 y8 b! Y/ N: \+ H  j* v  k   0.14106505  0.        ]]
  5 E/ q  a( ^* ~$ L7 V
  : \4 P0 r) z, N
• 
  $ @# m; J+ h5 R2 }" Q2 V) e. W
  Non-zero coefficients: [5 9 11 12 17 18]
  
  
  

你看，5 9 11 12 17 18这些维度的特征获得了权重，而第11维权重最大，也说明了它影响程度最大。

3.2.2 欠拟合定位与解决

我们再随机生成一份数据[1000*20]的数据(但是分布和之前有变化)，重新使用LinearSVC来做分类。

• 
  # h& K: R2 l% G' C+ }: Q
  1 B9 W9 b! Y0 _* S# t& l) Y#构造一份环形数据
  
  : V1 y- |' a% Y2 p2 R* y8 _" ?
• 
  
  from sklearn.datasets import make_circles
  
  
• 
  * `, I& Z9 U+ t
  % L- F- s1 \7 zX, y = make_circles(n_samples=1000, random_state=2)
  & z. L- _; p6 k$ `! h
  
• 
  
  #绘出学习曲线
  
  
• 
  
  ' e! i0 F5 _# K; g  {plot_learning_curve(LinearSVC(C=0.25),"LinearSVC(C=0.25)",X, y, ylim=(0.5, 1.0),train_sizes=np.linspace(.1, 1.0, 5))
  ! h# u" {, k, c8 N% `+ K3 z
  
  

简直烂出翔了有木有，二分类问题，我们做随机猜测，准确率都有0.5，这比随机猜测都高不了多少！！！怎么办？

不要盲目动手收集更多资料，或者调整正则化参数。我们从学习曲线上其实可以看出来，训练集上的准确度和交叉验证集上的准确度都很低，这其实就对应了我们说的『欠拟合』状态。别急，我们回到我们的数据，还是可视化看看：

• 
  
  + {4 P9 f; b0 s) L5 e6 f( Y% a6 Jf = DataFrame(np.hstack((X, y[:, None])), columns = range(2) + ["class"])
  / ~" y9 m8 Y; t  A! k" E1 u
  . F/ w3 @, F7 ]. w% ~" [) x
• 
  
  , P7 X! a/ o9 Y. k5 m% u( T& n6 v8 @( q_ = sns.pairplot(df, vars=[0, 1], hue="class", size=3.5)
  ' l3 ]! W: s3 O8 f' m7 i7 o
  
  

你发现什么了，数据根本就没办法线性分割！！！，所以你再找更多的数据，或者调整正则化参数，都是无济于事的！！！

那我们又怎么解决欠拟合问题呢？通常有下面一些方法：

• 调整你的特征(找更有效的特征！！)
  比如说我们观察完现在的数据分布，然后我们先对数据做个映射：
  ( A- E6 S) d* p( U: c

• 
  * L" e: n- H) o% b0 M7 a' C1 F
  # 加入原始特征的平方项作为新特征
  
  
• 
  
  X_extra = np.hstack((X, X[:, [0]]**2 + X[:, [1]]**2))
  $ k* L9 e' {2 n+ c! p
  3 m* @5 b# d: W9 F3 q1 S" a( S
• 
  # t9 O4 a7 t# k, V
  
  $ {7 U" k9 @4 e7 r: m/ C+ L: X" J% ^
  & \0 t+ }9 W- x5 k  M
• 
  
  plot_learning_curve(LinearSVC(C=0.25), "LinearSVC(C=0.25) + distance feature", X_extra, y, ylim=(0.5, 1.0), train_sizes=np.linspace(.1, 1.0, 5))
  : n# H3 {. l% M% k' u2 _6 _! Q
  
    i% k' n, R+ f' u1 c0 w

卧槽，少年，这准确率，被吓尿了有木有啊！！！所以你看，选用的特征影响太大了，当然，我们这里是人工模拟出来的数据，分布太明显了，实际数据上，会比这个麻烦一些，但是在特征上面下的功夫还是很有回报的。

• 使用更复杂一点的模型(比如说用非线性的核函数)
  我们对模型稍微调整了一下，用了一个复杂一些的非线性rbf kernel：
  6 z2 ?3 d# I' E, q

• 
  
  6 K: M3 e& h! r. u8 `, @from sklearn.svm import SVC
  . G0 l; D1 T/ B! _3 J% r; z7 t! y
  
• 
  
  3 @8 t) X( N, |# ]5 d& s' z' p, S2 Q# note: we use the original X without the extra feature
  5 I  ~7 m: a  }4 P# r
  2 }5 k7 {% ]; ~; U# B
• 
  
  plot_learning_curve(SVC(C=2.5, kernel="rbf", gamma=1.0), "SVC(C=2.5, kernel='rbf', gamma=1.0)",X, y, ylim=(0.5, 1.0), train_sizes=np.linspace(.1, 1.0, 5))
  
  
  + j* C- A- h. H5 w

你看，效果依旧很赞。

3.3 关于大数据样本集和高维特征空间

我们在小样本的toy dataset上，怎么捣鼓都有好的方法。但是当数据量和特征样本空间膨胀非常厉害时，很多东西就没有那么好使了，至少是一个很耗时的过程。举个例子说，我们现在重新生成一份数据集，但是这次，我们生成更多的数据，更高的特征维度，而分类的类别也提高到5。

3.3.1 大数据情形下的模型选择与学习曲线

在上面提到的那样一份数据上，我们用LinearSVC可能就会有点慢了，我们注意到机器学习算法使用图谱推荐我们使用SGDClassifier。其实本质上说，这个模型也是一个线性核函数的模型，不同的地方是，它使用了随机梯度下降做训练，所以每次并没有使用全部的样本，收敛速度会快很多。再多提一点，SGDClassifier对于特征的幅度非常敏感，也就是说，我们在把数据灌给它之前，应该先对特征做幅度调整，当然，用sklearn的StandardScaler可以很方便地完成这一点。

SGDClassifier每次只使用一部分(mini-batch)做训练，在这种情况下，我们使用交叉验证(cross-validation)并不是很合适，我们会使用相对应的progressive validation：简单解释一下，estimator每次只会拿下一个待训练batch在本次做评估，然后训练完之后，再在这个batch上做一次评估，看看是否有优化。

• 
  
  #生成大样本，高纬度特征数据
  
  
• 
  , [, P8 w% Z( c3 v3 }
  X, y = make_classification(200000, n_features=200, n_informative=25, n_redundant=0, n_classes=10, class_sep=2, random_state=0)
  
  
• 
  ( b2 Y9 \5 n2 u7 h# G8 K
  
  : S' f% f' A$ u; o5 K- C
  
• 
  
  ! ^9 y. i$ \* M1 o4 c! C#用SGDClassifier做训练，并画出batch在训练前后的得分差
  
  
• 
  
  from sklearn.linear_model import SGDClassifier
  
  
• 
  
  est = SGDClassifier(penalty="l2", alpha=0.001)
  
  
• 
  
  ; l: K3 [' l: E5 ^progressive_validation_score = []
  
  
• 
  
  0 [8 u# o, F$ f7 b& U! w$ Q& A, ?2 ttrain_score = []
  
  : J2 |' I4 U: ^. ^0 A
• 
  ' h5 j5 C& I: G. `, \3 A
  , D; z6 y( w# afor datapoint in range(0, 199000, 1000):
    Q9 ^  g, L& M
  * x7 k( F0 y% I# e0 ~
• 
  
  ( \) q# H1 [0 ]9 \    X_batch = X[datapoint:datapoint+1000]
  
  
• 
  
      y_batch = y[datapoint:datapoint+1000]
  
  6 H9 ~4 H9 z9 g' z: [
• 
  
  : [( a! R% t" I2 F* N    if datapoint > 0:
  
  
• 
  
  9 k8 ^: u3 {6 h2 G/ Z( {, }        progressive_validation_score.append(est.score(X_batch, y_batch))
  # s/ w. C6 k# f5 ~& @- `/ k
  ! }6 o" C6 J+ J6 F+ @* v
• 
  
      est.partial_fit(X_batch, y_batch, classes=range(10))
  4 e+ [* X) E) c  ~. B+ i' w
  / Y0 `; u( O( ^9 I
• 
  7 I3 [( a# H) z2 E9 Y
  7 v( X8 f& V6 y  L8 }    if datapoint > 0:
  
  1 ]5 O& k& G! _+ H: [( B
• 
  
  1 P; z* A1 q/ w5 C7 A        train_score.append(est.score(X_batch, y_batch))
  ; N9 [! W& o6 ^1 N5 }
  
• 
  
  
  
  - E9 t& K; V. s! \3 c. L2 Z
• 
  
  ; V& `9 Y6 u1 uplt.plot(train_score, label="train score")
  
  4 K3 P( I. h) K* D, {3 |
• 
  3 C: U! e8 J0 I/ i/ b
  plt.plot(progressive_validation_score, label="progressive validation score")
  5 `0 \$ e1 Z$ c5 e
  
• 
  
  6 u2 G9 e7 i6 Z1 F" vplt.xlabel("Mini-batch")
  
  
• 
  
  & J) M$ r  _4 j  _plt.ylabel("Score")
  # ~, B0 n  p, y/ ~, t) L
  ' Z: }# W1 M' n( \" W, l8 ~+ |
• 
  
  plt.legend(loc='best')  
  1 {5 Y* O; Y: ]3 d
  
• 
  $ x; E! _. j: [& f  k1 m' }
  plt.show()                     
  
  
  

得到如下的结果：

从这个图上的得分，我们可以看出在50个mini-batch迭代之后，数据上的得分就已经变化不大了。但是好像得分都不太高，所以我们猜测一下，这个时候我们的数据，处于欠拟合状态。我们刚才在小样本集合上提到了，如果欠拟合，我们可以使用更复杂的模型，比如把核函数设置为非线性的，但遗憾的是像rbf核函数是没有办法和SGDClassifier兼容的。因此我们只能想别的办法了，比如这里，我们可以把SGDClassifier整个替换掉了，用多层感知神经网来完成这个任务，我们之所以会想到多层感知神经网，是因为它也是一个用随机梯度下降训练的算法，同时也是一个非线性的模型。当然根据机器学习算法使用图谱，也可以使用核估计(kernel-approximation)来完成这个事情。

3.3.2 大数据量下的可视化

大样本数据的可视化是一个相对比较麻烦的事情，一般情况下我们都要用到降维的方法先处理特征。我们找一个例子来看看，可以怎么做，比如我们数据集取经典的『手写数字集』，首先找个方法看一眼这个图片数据集。

• 
  ) M& R. v- v. I, ?) g# S7 z
  #直接从sklearn中load数据集
  % P5 O& s! w% Q2 |) @- u* ]0 I6 `
  $ S& |' e! ^! i. d- R9 n
• 
  : n8 y+ ?. g# b9 ?* s; R5 @
  3 t& X. _: p4 [1 o8 G6 t% C; Ffrom sklearn.datasets import load_digits
  
  
• 
  ; `; R/ A. v$ a# O
  digits = load_digits(n_class=6)
  
  
• 
  
  1 v7 F/ }( ~5 ~X = digits.data
  
  3 W; A0 {8 }: V0 _2 b
• 
  + `0 |2 `& n) m- ~9 n# t- c
  8 x; A& a9 h6 b6 O* @y = digits.target
  0 [6 y" o1 b; _7 U6 _  Y
  % Q% |' m" m' @: i6 p7 z$ D
• 
  
  : S" N7 r6 v( ^5 i" r7 Q0 e! hn_samples, n_features = X.shape
  
  1 _6 b3 S$ B( m/ R  i
• 
  
  print "Dataset consist of %d samples with %d features each" % (n_samples, n_features)
  
  0 `2 Z. R4 c3 O! Q3 J$ m2 V
• 
  , z9 ~3 Z6 H% z0 `' E$ `) W  Z/ z
  ! F! H& j" ]; [" g% l% l) G7 A! M+ X
  2 C% _( h1 `: j! S& j8 n- W) _
  
• 
  + E; ?3 o! p$ N; t
  8 I: E3 K* n" |# 绘制数字示意图
  ( ~+ D. r. A* N2 Q: u1 T* M9 b
  
• 
  . |# \8 n1 q6 f% Z* H, g) ]
  % H, a( V- o( l6 Wn_img_per_row = 20
  1 O3 `0 z: X3 v$ d/ n3 b
  8 ?' T& t" G6 K/ h! F8 n
• 
  ; P5 b. A4 T+ z* g1 ^
  % r/ W# J& J6 W8 g1 ~" zimg = np.zeros((10 * n_img_per_row, 10 * n_img_per_row))
  8 h* B- \% Y* _( [0 z4 |
  
• 
  
  1 b2 J  q1 c. d6 _9 T, Z0 {for i in range(n_img_per_row):
  
  / l5 N+ ?6 N$ \
• 
  
      ix = 10 * i + 1
  
  
• 
  
  : ?7 B. [  j+ e8 Y" B9 r4 [    for j in range(n_img_per_row):
  ' G6 D- H2 l: |4 T- U9 W
  + e/ }( D9 O- ~- q
• 
  
  - m/ f* q' G5 D2 u4 ^' ^+ f8 x/ B        iy = 10 * j + 1
  
  - }# n- m/ F! O+ \: ?/ X' \
• 
  3 s( d2 U1 }2 t
  & P- Q& L# c9 p        img[ix:ix + 8, iy:iy + 8] = X[i * n_img_per_row + j].reshape((8, 8))
  
  6 P. q: S8 U$ R0 g( |9 H- Y# ]
• 
  ! x2 v  E, m4 L
  
  
  
• 
  ! V' L3 n! P2 \: b1 Y' o4 y
  : b! T: S6 ~6 k* ~6 R9 ~( X# Bplt.imshow(img, cmap=plt.cm.binary)
  
  
• 
  ! |7 m# X& P+ ?* r6 v$ q
  % G- C  t# M4 J4 x9 P9 F, U0 oplt.xticks([])
  
  % Z; E/ {4 K: a# V6 B/ h
• 
  
  plt.yticks([])
  
  
• 
  ) J# o9 G: ]# J- w' c! E: ?
  _ = plt.title('A selection from the 8*8=64-dimensional digits dataset')
  2 t! ?; H/ x. w
  
• 
  2 a2 w; q9 i0 I3 f7 M6 i
  plt.show()
  
    v: M+ `: j" ~/ V8 M
  

我们总共有1083个训练样本，包含手写数字(0,1,2,3,4,5)，每个样本图片中的像素点平铺开都是64位，这个维度显然是没办法直接可视化的。下面我们基于scikit-learn的示例教程对特征用各种方法做降维处理，再可视化。

随机投射
我们先看看，把数据随机投射到两个维度上的结果：

• 
  6 x2 H. c, k% ~% J. E: C6 C
  0 m" d8 j9 E$ g# o+ f6 s8 r! R6 n' F- L#import所需的package
  0 H0 j: }! a( F
  " P: q$ g& ], q) P( H3 ?+ o
• 
  ' E$ j. Z. b2 e6 A4 E) H
  from sklearn import (manifold, decomposition, random_projection)
  3 v) ~: y+ B& w3 ~
  : \1 Y: ~' B2 V
• 
  * s7 A% P/ Z0 A; r5 p/ N* [
  9 y: `9 x8 N, _' K- f& V& arp = random_projection.SparseRandomProjection(n_components=2, random_state=42)
  
  % b9 A3 \3 K: |' T8 `
• 
  
  
  / G7 A7 }% f/ `7 {) H3 w$ \8 T+ V
  + ]. M3 n7 m( {7 E# I. C; I% r
• 
  
  % o( @9 w  ^' Q% i9 d#定义绘图函数
  
  
• 
  ) v, U- l  g; X
  from matplotlib import offsetbox
  9 C9 a/ @- G& ~5 c7 f
  7 W# `# u, a) Y$ a; n
• 
  
  def plot_embedding(X, title=None):
  
  
• 
  5 A% \0 W. V( |( y
      x_min, x_max = np.min(X, 0), np.max(X, 0)
  
  0 }6 J4 }3 b8 [* Q& K
• 
  / @1 \' ?) k+ D  C
      X = (X - x_min) / (x_max - x_min)
  ( s3 P- f! n, D, ^2 ]
  6 B1 R! L, l  C) q9 @1 s
• 
  6 b. o/ X( r+ ]* d
  9 ~7 u  r. l& d( Y6 d
  7 k# c$ E2 u4 S: {, G( J# g8 M( A
  ) n3 x4 W2 W8 K3 G4 o
• 
  
  5 q, y0 @2 e! m6 F7 @5 r5 Q2 ]    plt.figure(figsize=(10, 10))
  
  & y) d3 }# j; _( a
• 
  
      ax = plt.subplot(111)
  
  - K) d( R$ W  g8 `& w6 N2 d6 k6 \8 q5 ?
• 
  8 |6 E& T: l* a. F
      for i in range(X.shape[0]):
  
  
• 
  ! T* m! k+ p5 T4 _$ W) H5 B
          plt.text(X[i, 0], X[i, 1], str(digits.target),
  ) p* T: i! s7 }. `6 G; ^
  * Y% F* t7 I' n# n- Q6 L
• 
  
  3 W4 G* g' h- t5 [" D- n; ]                 color=plt.cm.Set1(y / 10.),
  1 s7 g( d7 ?. V: n
  
• 
  
                   fontdict={'weight': 'bold', 'size': 12})
  
  ; N* ^$ H' }& g6 V/ @* I
• 
  
  & x" k0 U; r. Q% |1 |% h- P
  - x  Z/ r% y' d; p& W
  * E! N& M' Q) U" u9 F
• 
  * Q' z5 d4 V% }$ }1 {2 D9 P
  1 |5 y( Z! q2 W. Z- O$ Z9 F    if hasattr(offsetbox, 'AnnotationBbox'):
  
    L) |: V% @+ d! Y! G: [
• 
  # l/ r% Y: \5 a1 B- u1 a# P2 w5 k
          # only print thumbnails with matplotlib > 1.0
  
  2 C7 M8 a1 B: h2 s1 f! z
• 
  2 u0 t9 z/ ^; o0 d+ A; M7 u
  & ]& e" c2 h; ?  J" c3 [% m        shown_images = np.array([[1., 1.]])  # just something big
  : n3 I7 i( d& |4 a( Q5 \; y6 r" J
  : ~% R5 z; U" H6 b) }; D
• 
  5 L2 Y% U" C: ~2 w
    J% k6 u1 h% \8 u9 g        for i in range(digits.data.shape[0]):
  0 A; l" V: v9 C, A7 `
  5 }6 [. r: F6 V+ z- b0 {6 q
• 
  
  . z3 R0 _+ n. V$ |" `            dist = np.sum((X - shown_images) ** 2, 1)
  
  ' `; H9 d, F! D
• 
  
              if np.min(dist) < 4e-3:
  4 s1 v0 @) u$ _; K
  . p" e$ ?0 ~2 F, D2 z
• 
  % n) }; \6 F& v, C
                  # don't show points that are too close
  ( f$ f* q' F7 A9 r
  4 s1 C: p% B. l. `, d" `
• 
  
                  continue
  
  6 o( s- N4 T7 U) Y6 Z& p; G+ o. x
• 
  
  0 ~8 L0 k3 g* S            shown_images = np.r_[shown_images, [X]]
  3 h  N- Q& k* t, D6 k8 `) [& d
  ) }$ G6 y, m6 [( J! S5 f
• 
  * E( k8 N$ d% w3 _$ r3 ~+ }$ b
              imagebox = offsetbox.AnnotationBbox(
  : ^1 ]# B4 O! F3 o$ v" B
  5 B6 x6 k% |" F1 w- M$ l1 A9 r5 c
• 
  
  8 P- ~$ F, b8 O5 {& Y4 W8 u                offsetbox.OffsetImage(digits.images, cmap=plt.cm.gray_r),
  
  
• 
  * r; i7 P6 U; V3 i
                  X)
  
  
• 
  + O3 L0 j$ _+ W& B0 \' G$ m# [
  # K' d+ }! Q3 k. O+ T8 K            ax.add_artist(imagebox)
  ( }- R) e) J' A/ z
  . T, i: d4 J) p+ ^" ^) C
• 
  
      plt.xticks([]), plt.yticks([])
  
  & C$ r' I) q. a$ Q% {1 W6 }
• 
  
  ( O$ n  Y: p; y5 G" E    if title is not None:
  3 t) @3 q6 b7 i: V1 [* N
  - V+ B/ Z2 R, {
• 
  8 y0 n' @0 u& z/ H
  / t0 [% j. I5 j2 d; E( l        plt.title(title)
  ' K& N' Z8 `- s; w- m/ u1 Z
  
• 
  
  
  5 f4 @$ p: A, W. t) U6 ~' n
  0 U! x  M/ G2 A' C1 _3 v
• 
  & w% D& @7 s) a
  * a6 e( U) `% k3 }. |6 Z. f#记录开始时间
  
    [* A3 s8 G( `6 }* l5 D
• 
    A; E5 f# F: S9 q6 {& }% S0 S4 U
  $ [4 S, _5 m' e) Q4 n: \start_time = time.time()
  
    ~) B+ b' \- N& b# n
• 
  / D1 \3 ^! |7 w* p9 n' e( A, X
  ; q2 k6 F+ ~2 d2 M$ y% ^5 MX_projected = rp.fit_transform(X)
  
  - t4 U- {6 t4 A/ q& |
• 
  # e7 i% E3 ~$ D8 g/ a& Y
  " z  F" x5 r; jplot_embedding(X_projected, "Random Projection of the digits (time: %.3fs)" % (time.time() - start_time))
  
  
  6 A* X* j2 y/ q0 m; H, Y' I4 N( w! q. x

结果如下：

PCA降维
1 B- V; M1 B) W7 G- s在维度约减/降维领域有一个非常强大的算法叫做PCA(Principal Component Analysis，主成分分析)，它能将原始的绝大多数信息用维度远低于原始维度的几个主成分表示出来。PCA在我们现在的数据集上效果还不错，我们来看看用PCA对原始特征降维至2维后，原始样本在空间的分布状况：

• 
  - t  Q$ M% Z' A  R
  from sklearn import (manifold, decomposition, random_projection)
  5 I+ K9 U$ v; M% K9 w
  
• 
  * @6 {4 z3 X  Y/ b) d+ d
  , i+ W( r1 \. [1 N) K) F#TruncatedSVD 是 PCA的一种实现
  * x! q& G  U9 x, U& z* [' x
  $ n8 f8 N$ Y, j# M
• 
  4 O  m; \% [6 R* G" M
  X_pca = decomposition.TruncatedSVD(n_components=2).fit_transform(X)
  + E; Y6 }: \, m4 R; f7 ^0 |9 i
  + P. F4 |. }+ \/ |. B8 ?; I" B: D5 l
• 
  * w! s% a5 n3 g: \6 y3 M
  8 g% y" v3 [9 K#记录时间
  
  
• 
  8 n# J/ }8 g0 l5 K7 J  r
  start_time = time.time()
  ' j6 N! @. |" P5 E4 u+ z
  
• 
  4 P/ G# R+ ^/ h/ e7 e" l
  plot_embedding(X_pca,"Principal Components projection of the digits (time: %.3fs)" % (time.time() - start_time))
  
  ) |2 ]! @- R( w' z% g% Y1 ^; h
  

得到的结果如下：

/ n; V: _, G2 L9 K; j

我们可以看出，效果还不错，不同的手写数字在2维平面上，显示出了区域集中性。即使它们之间有一定的重叠区域。

如果我们用一些非线性的变换来做降维操作，从原始的64维降到2维空间，效果更好，比如这里我们用到一个技术叫做t-SNE，sklearn的manifold对其进行了实现：

• 
  
  from sklearn import (manifold, decomposition, random_projection)
  % O; ^. x# ~; _& m& u4 B
  
• 
  9 L' m. v7 j5 o5 A1 ?& m
  - ^/ z" w& N8 Z' L6 H3 b#降维
  0 Q0 C* ~  c' M, y. V7 d
  
• 
  
  tsne = manifold.TSNE(n_components=2, init='pca', random_state=0)
  
  
• 
  " Q+ M( V$ [  ~" c
  start_time = time.time()
  , z# [, O4 P$ C2 \
  & D6 W1 X9 h7 M8 A8 O
• 
  ; V9 |1 Z# e$ c/ H  D% M! x. V
  . X0 l) {, N: gX_tsne = tsne.fit_transform(X)
  
  - A, p9 V1 {( a: H
• 
  
  % k, A/ t. H* d' E/ U6 j' G#绘图
  
  
• 
  
  plot_embedding(X_tsne,
  
  ! m" J8 H* |3 c
• 
  3 {9 M  d( }0 ^$ H1 x
  7 k1 ~! x2 g$ a3 V1 q) h               "t-SNE embedding of the digits (time: %.3fs)" % (time.time() - start_time))
  . I& R. H2 [; a+ W/ a4 ?
  8 s" t) j; ?& O( e: F/ u
  

我们发现结果非常的惊人，似乎这个非线性变换降维过后，仅仅2维的特征，就可以将原始数据的不同类别，在平面上很好地划分开。不过t-SNE也有它的缺点，一般说来，相对于线性变换的降维，它需要更多的计算时间。也不太适合在大数据集上全集使用。

3.4 损失函数的选择

损失函数的选择对于问题的解决和优化，非常重要。我们先来看一眼各种不同的损失函数：

• 
  
  import numpy as np
  
  4 n0 R1 l& r- D/ y1 }3 f
• 
  
  . }& G8 F" {, r& y+ dimport matplotlib.plot as plt
  
  
• 
  ( Q. A1 u( F1 Q/ F  k0 k' B0 Z) a" u
  # 改自http://scikit-learn.org/stable/auto_examples/linear_model/plot_sgd_loss_functions.html
  
  
• 
  ) h6 x6 P& ~5 |7 F% S0 B! e% C. R3 V
  xmin, xmax = -4, 4
  
  
• 
  
  xx = np.linspace(xmin, xmax, 100)
  ! k7 C. |: S4 G# {5 p
  0 ?) [" n8 u7 o' x  _% q4 U: @2 Q
• 
  6 B! Q% o; C) n+ Q5 t; _" p' A$ d* x
  plt.plot([xmin, 0, 0, xmax], [1, 1, 0, 0], 'k-',
  
  
• 
  
  " v6 w5 ]/ O6 a- A4 ^( g         label="Zero-one loss")
  
  
• 
  $ U% @) S. i2 k$ [4 F1 i+ B% p9 v
  6 P* S4 G  K) fplt.plot(xx, np.where(xx < 1, 1 - xx, 0), 'g-',
  
  - O7 x9 p3 z" L/ G7 e
• 
  
  * u7 N8 I6 [7 ?' O* \         label="Hinge loss")
  
  / @, O% [) z) y# C4 a
• 
  ; k! I; \& v: J. Q5 s; T
  ) Z. P: ^4 B! m0 p2 E, j- Y6 kplt.plot(xx, np.log2(1 + np.exp(-xx)), 'r-',
  ; G! _- G: o2 _! W: H4 o3 `
  % V6 U/ i+ n# r6 T  I! ?' \2 a
• 
  
  " i/ r5 z1 x: R6 b$ F, e         label="Log loss")
  
  : A7 v* G* t6 B0 w- ?# [: m
• 
  
  ' w& O% C, a: X1 U/ Z  mplt.plot(xx, np.exp(-xx), 'c-',
  
  
• 
  % p3 }$ _+ x6 L8 h7 i) ^
    ^7 _2 N. P& p3 T2 q$ E! f         label="Exponential loss")
  7 \* r8 w1 _6 A- C
  / ?& B3 N/ Y( G  x, ^4 U
• 
  
  plt.plot(xx, -np.minimum(xx, 0), 'm-',
  
  0 f9 m9 v! z. D9 X  t4 d2 f; x
• 
  - E4 ]. Y2 H  y$ c: B) @
  8 }6 {4 J! {) r/ e! f9 y5 E         label="Perceptron loss")
  ' F' s/ L9 J9 s: j: T- J6 ~" }
  3 P6 j& _9 k4 H4 q7 C' b
• 
  & _5 c+ L" ]% Z8 A% J* {: {3 R
  8 f9 m1 k) O+ L9 z/ m" d7 e5 t
  + H* Y& o8 V$ }5 ~/ G
  
• 
  ; T, g- H3 Z/ F
  plt.ylim((0, 8))
  ( l. V( s3 h8 }3 V# s0 j" F& V
  + e4 m* \1 [: O, W
• 
  
    O: o+ Y: |" `# N0 g% _plt.legend(loc="upper right")
  & K7 \6 f# g/ S9 H
  ! x5 c+ F! ^' M" j& I, N
• 
  ; s" C0 \1 y0 f+ ?8 ^
  # O# @$ p$ ^" v. ]% Aplt.xlabel(r"Decision function $f(x)$")
  0 v. q, ^  C3 e
  0 W- i! |% w6 q5 i; r3 ]
• 
  
  plt.ylabel("$L(y, f(x))$")
  4 j, W4 Y7 |/ l* W9 \
  
• 
  
  plt.show()
  
  : p( Y9 t7 `% b. D: S- B; V
  ' \, g( W' M; [3 H$ Q" h! y/ I. [

得到结果图像如下：
. ~4 Z7 U% a; @

不同的损失函数有不同的优缺点：

• 0-1损失函数(zero-one loss)非常好理解，直接对应分类问题中判断错的个数。但是比较尴尬的是它是一个非凸函数，这意味着其实不是那么实用。
• hinge loss(SVM中使用到的)的健壮性相对较高(对于异常点/噪声不敏感)。但是它没有那么好的概率解释。
• log损失函数(log-loss)的结果能非常好地表征概率分布。因此在很多场景，尤其是多分类场景下，如果我们需要知道结果属于每个类别的置信度，那这个损失函数很适合。缺点是它的健壮性没有那么强，相对hinge loss会对噪声敏感一些。
• 多项式损失函数(exponential loss)(AdaBoost中用到的)对离群点/噪声非常非常敏感。但是它的形式对于boosting算法简单而有效。
• 感知损失(perceptron loss)可以看做是hinge loss的一个变种。hinge loss对于判定边界附近的点(正确端)惩罚力度很高。而perceptron loss，只要样本的判定类别结果是正确的，它就是满意的，而不管其离判定边界的距离。优点是比hinge loss简单，缺点是因为不是max-margin boundary，所以得到模型的泛化能力没有hinge loss强。
  # P' q. `4 c9 i( n

4. 总结

全文到此就结束了。先走马观花看了一遍机器学习的算法，然后给出了对应scikit-learn的『秘密武器』机器学习算法使用图谱，紧接着从了解数据(可视化)、选择机器学习算法、定位过/欠拟合及解决方法、大量极的数据可视化和损失函数优缺点与选择等方面介绍了实际机器学习问题中的一些思路和方法。本文和文章机器学习系列(3)_逻辑回归应用之Kaggle泰坦尼克之灾都提及了一些处理实际机器学习问题的思路和方法，有相似和互补之处，欢迎大家参照着看。

- _9 |: ?. z1 D  l