机器学习之分类算法

NeighborMrSun 2023-02-27 发表于湖南

展开全文

参考链接：

#1. scikit-learn官网 /stable/modules/classes.html

#2. scikit-learn中文手册/docs/master/30.html

#3. 分类方法介绍https://www.cnblogs.com/qiuyuyu/p/11399697.html

如何选择分类分析算法:

文本文类——朴素贝叶斯

训练集较小——朴素贝叶斯、支持向量机，高偏差低方差低分类算法，不容易过拟合

训练集较大——基本都适用

关注模型等计算时间和模型易用性——不用支持向量机和人工神经网络

重视算法准确性——支持向量机、GBDT、XGBoost、Adaboost等基于Boosting等集成方法

重视算法稳定性或模型鲁棒性——随机森林、组合投票模型等基于Bagging的集成方法

预得到预测结果的概率信息，基于预测概率做进一步应用——逻辑回归

担心离群点或数据不可分并且需要清晰的决策规则——决策树

1. Logistic 回归 (对数几率回归)

Logistic Regression不光可以做二元分类，也可以解决多元分类问题。logistic 回归，虽然名字里有 “回归” 二字，但实际上是解决分类问题的一类线性模型。该模型利用函数 logistic function 将单次试验（single trial）的可能结果输出为概率。scikit-learn 中 logistic 回归在 LogisticRegression 类中实现了二分类（binary）、一对多分类（one-vs-rest）及多项式 logistic 回归，并带有可选的 L1 和 L2 正则化。

from sklearn.datasets import load_irisfrom sklearn.linear_model import LogisticRegressionX, y = load_iris(return_X_y=True)clf = LogisticRegression(random_state=0).fit(X, y)##data1=clf.predict(X[:2, :])# array([0, 0])##data2=clf.predict_proba(X[:2, :])# array([[9.8...e-01, 1.8...e-02, 1.4...e-08],#        [9.7...e-01, 2.8...e-02, ...e-08]])##data3=clf.score(X, y)# 0.97...print(data1)print(data2)print(data3)

2. 线性和二次判别分析（LDA和QDA）

线性判别分析（discriminant_analysis.LinearDiscriminantAnalysis）和二次判别分析（discriminant_analysis.QuadraticDiscriminantAnalysis）是两个经典的分类器。正如他们名字所描述的那样，他们分别代表了线性决策平面和二次决策平面。

# LinearDiscriminantAnalysisimport numpy as npfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysisX = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])y = np.array([1, 1, 1, 2, 2, 2])clf = LinearDiscriminantAnalysis()clf.fit(X, y)print(clf.predict([[-0.8, -1]]))

#QuadraticDiscriminantAnalysisfrom sklearn.discriminant_analysis import QuadraticDiscriminantAnalysisimport numpy as npX = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])y = np.array([1, 1, 1, 2, 2, 2])clf = QuadraticDiscriminantAnalysis()clf.fit(X, y)print(clf.predict([[-0.8, -1]]))

#LDA和QDA比对，LDA不同的类使用同一个标准判别，QDA不同的类使用不同的标准判别from scipy import linalgimport numpy as npimport matplotlib.pyplot as pltimport matplotlib as mplfrom matplotlib import colors

from sklearn.discriminant_analysis import LinearDiscriminantAnalysisfrom sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis

# ############################################################################## Colormapcmap = colors.LinearSegmentedColormap( 'red_blue_classes', {'red': [(0, 1, 1), (1, 0.7, 0.7)], 'green': [(0, 0.7, 0.7), (1, 0.7, 0.7)], 'blue': [(0, 0.7, 0.7), (1, 1, 1)]})plt.cm.register_cmap(cmap=cmap)

# ############################################################################## Generate datasetsdef dataset_fixed_cov(): '''Generate 2 Gaussians samples with the same covariance matrix''' n, dim = 300, 2 np.random.seed(0) C = np.array([[0., -0.23], [0.83, .23]]) X = np.r_[np.dot(np.random.randn(n, dim), C), np.dot(np.random.randn(n, dim), C) + np.array([1, 1])] y = np.hstack((np.zeros(n), np.ones(n))) return X, y

def dataset_cov(): '''Generate 2 Gaussians samples with different covariance matrices''' n, dim = 300, 2 np.random.seed(0) C = np.array([[0., -1.], [2.5, .7]]) * 2. X = np.r_[np.dot(np.random.randn(n, dim), C), np.dot(np.random.randn(n, dim), C.T) + np.array([1, 4])] y = np.hstack((np.zeros(n), np.ones(n))) return X, y

# ############################################################################## Plot functionsdef plot_data(lda, X, y, y_pred, fig_index): splot = plt.subplot(2, 2, fig_index) if fig_index == 1: plt.title('Linear Discriminant Analysis') plt.ylabel('Data with\n fixed covariance') elif fig_index == 2: plt.title('Quadratic Discriminant Analysis') elif fig_index == 3: plt.ylabel('Data with\n varying covariances')

tp = (y == y_pred) # True Positive tp0, tp1 = tp[y == 0], tp[y == 1] X0, X1 = X[y == 0], X[y == 1] X0_tp, X0_fp = X0[tp0], X0[~tp0] X1_tp, X1_fp = X1[tp1], X1[~tp1]

# class 0: dots plt.scatter(X0_tp[:, 0], X0_tp[:, 1], marker='.', color='red') plt.scatter(X0_fp[:, 0], X0_fp[:, 1], marker='x', s=20, color='#990000') # dark red

# class 1: dots plt.scatter(X1_tp[:, 0], X1_tp[:, 1], marker='.', color='blue') plt.scatter(X1_fp[:, 0], X1_fp[:, 1], marker='x', s=20, color='#000099') # dark blue

# class 0 and 1 : areas nx, ny = 200, 100 x_min, x_max = plt.xlim() y_min, y_max = plt.ylim() xx, yy = np.meshgrid(np.linspace(x_min, x_max, nx), np.linspace(y_min, y_max, ny)) Z = lda.predict_proba(np.c_[xx.ravel(), yy.ravel()]) Z = Z[:, 1].reshape(xx.shape) plt.pcolormesh(xx, yy, Z, cmap='red_blue_classes', norm=colors.Normalize(0., 1.), zorder=0) plt.contour(xx, yy, Z, [0.5], linewidths=2., colors='white')

# means plt.plot(lda.means_[0][0], lda.means_[0][1], '*', color='yellow', markersize=15, markeredgecolor='grey') plt.plot(lda.means_[1][0], lda.means_[1][1], '*', color='yellow', markersize=15, markeredgecolor='grey')

return splot

def plot_ellipse(splot, mean, cov, color): v, w = linalg.eigh(cov) u = w[0] / linalg.norm(w[0]) angle = np.arctan(u[1] / u[0]) angle = 180 * angle / np.pi # convert to degrees # filled Gaussian at 2 standard deviation ell = mpl.patches.Ellipse(mean, 2 * v[0] ** 0.5, 2 * v[1] ** 0.5, 180 + angle, facecolor=color, edgecolor='black', linewidth=2) ell.set_clip_box(splot.bbox) ell.set_alpha(0.2) splot.add_artist(ell) splot.set_xticks(()) splot.set_yticks(())

def plot_lda_cov(lda, splot): plot_ellipse(splot, lda.means_[0], lda.covariance_, 'red') plot_ellipse(splot, lda.means_[1], lda.covariance_, 'blue')

def plot_qda_cov(qda, splot): plot_ellipse(splot, qda.means_[0], qda.covariance_[0], 'red') plot_ellipse(splot, qda.means_[1], qda.covariance_[1], 'blue')

plt.figure(figsize=(10, 8), facecolor='white')plt.suptitle('Linear Discriminant Analysis vs Quadratic Discriminant Analysis', y=0.98, fontsize=15)for i, (X, y) in enumerate([dataset_fixed_cov(), dataset_cov()]): # Linear Discriminant Analysis lda = LinearDiscriminantAnalysis(solver='svd', store_covariance=True) y_pred = lda.fit(X, y).predict(X) splot = plot_data(lda, X, y, y_pred, fig_index=2 * i + 1) plot_lda_cov(lda, splot) plt.axis('tight')

# Quadratic Discriminant Analysis qda = QuadraticDiscriminantAnalysis(store_covariance=True) y_pred = qda.fit(X, y).predict(X) splot = plot_data(qda, X, y, y_pred, fig_index=2 * i + 2) plot_qda_cov(qda, splot) plt.axis('tight')# plt.tight_layout()# plt.subplots_adjust(top=0.92)# plt.show()

. 贝叶斯分类

我们可以使用最大后验概率(Maximum A Posteriori, MAP) 来估计 P(y) 和 P(x_i \mid y) ; 前者是训练集中类别 y 的相对频率。各种各样的的朴素贝叶斯分类器的差异大部分来自于处理 P(x_i \mid y) 分布时的所做的假设不同。GaussianNB 实现了运用于分类的高斯朴素贝叶斯算法。特征的可能性(即概率)假设为高斯分布

import numpy as npX = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])Y = np.array([1, 1, 1, 2, 2, 2])from sklearn.naive_bayes import GaussianNBclf = GaussianNB()clf.fit(X, Y)print(clf.predict([[-0.8, -1]]))
clf_pf = GaussianNB()clf_pf.partial_fit(X, Y, np.unique(Y))  #增量拟合，适合数据量特别大的情况下
print(clf_pf.predict([[-0.8, -1]]))

4. 分类树¶

决策树（Decision Tree）可分为分类树与回归树。分类树使用信息增益或信息增益比率来划分节点，每个节点样本的类别情况投票（voting）决定测试样本的类别。

decision tree

ID3（Iterative Dichotomiser）迭代二分器

最优划分属性方法：信息增益（Information Gain)

C4.5

最优划分属性方法：信息增益率 (Gain ratio)

CART (分类与回归树：Classification and Regression Tree)

可做分类也可做回归分析
最优划分属性方法：基尼指数 (Gini index)

DecisionTreeClassifier 是能够在数据集上执行多分类的类,与其他分类器一样，DecisionTreeClassifier 采用输入两个数组：数组X，用 [n_samples, n_features] 的方式来存放训练样本。整数值数组Y，用 [n_samples] 来保存训练样本的类标签。DecisionTreeClassifier 既能用于二分类（其中标签为[-1,1]）也能用于多分类（其中标签为[0,…,k-1]）。

import numpy as npfrom matplotlib import pyplot as plt

from sklearn.model_selection import train_test_splitfrom sklearn.datasets import load_irisfrom sklearn.tree import DecisionTreeClassifierfrom sklearn import tree

iris = load_iris()X = iris.datay = iris.targetX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

clf = DecisionTreeClassifier(max_leaf_nodes=3, random_state=0)clf.fit(X_train, y_train)data=clf.predict(X_test)print(data)

5. 支持向量机（Support Vector Machine）

(SVC, NuSVC 和 LinearSVC 能在数据集中实现多元分类.)

SVM可通过升维来解决在低维中线性不可分的问题，旨在找到一个超平面(Hyperlane)作为线性决策边界(decision boundry),最大化分类边界，将特征空间中的数据更好的分隔开。SVM有着优秀的泛化能力，但更适用于小样本训练，因为svm对于内存消耗很大。若数据量很大，训练时间会较长。且SVM在小样本上能够得到比其他算法好很多的结果。

SVC 和 NuSVC 是相似的方法, 但是接受稍许不同的参数设置并且有不同的数学方程(在这部分看数学公式). 另一方面, LinearSVC 是另一个实现线性核函数的支持向量分类. 记住 LinearSVC 不接受关键词 kernel, 因为它被假设为线性的. 它也缺少一些 SVC 和 NuSVC 的成员(members) 比如 support_ .

支持向量机 (SVMs) 可用于以下监督学习算法: 分类, 回归和异常检测.

支持向量机的优势在于:

在高维空间中非常高效.
即使在数据维度比样本数量大的情况下仍然有效.
在决策函数（称为支持向量）中使用训练集的子集,因此它也是高效利用内存的.
通用性: 不同的核函数 核函数 与特定的决策函数一一对应.常见的 kernel 已经提供,也可以指定定制的内核.

支持向量机的缺点包括:

如果特征数量比样本数量大得多,在选择核函数 核函数 时要避免过拟合, 而且正则化项是非常重要的.
支持向量机不直接提供概率估计,这些都是使用昂贵的五次交叉验算计算的. (详情见 得分和概率).

# svcimport numpy as npfrom sklearn.pipeline import make_pipelinefrom sklearn.preprocessing import StandardScalerX = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])y = np.array([1, 1, 2, 2])from sklearn.svm import SVCclf = make_pipeline(StandardScaler(), SVC(gamma='auto'))clf.fit(X, y)print(clf.predict([[-0.8, -1]]))

# nusvcimport numpy as npX = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])y = np.array([1, 1, 2, 2])from sklearn.pipeline import make_pipelinefrom sklearn.preprocessing import StandardScalerfrom sklearn.svm import NuSVCclf = make_pipeline(StandardScaler(), NuSVC())clf.fit(X, y)# Pipeline(steps=[('standardscaler', StandardScaler()), ('nusvc', NuSVC())])print(clf.predict([[-0.8, -1]]))

#LinearSVCfrom sklearn.svm import LinearSVCfrom sklearn.pipeline import make_pipelinefrom sklearn.preprocessing import StandardScalerfrom sklearn.datasets import make_classificationX, y = make_classification(n_features=4, random_state=0)clf = make_pipeline(StandardScaler(),                     LinearSVC(random_state=0, tol=1e-5))clf.fit(X, y)# Pipeline(steps=[('standardscaler', StandardScaler()),#                 ('linearsvc', LinearSVC(random_state=0, tol=1e-05))])print(clf.named_steps['linearsvc'].coef_)print(clf.named_steps['linearsvc'].intercept_)print(clf.predict([[0, 0, 0, 0]]))

6. KNN（K-Nearest Negihbour）

K近邻是基于实例的分类(instance-based learning) ，属于惰性学习 (lazy learning) 。比如在现实中，预测某一个房子的价格，就参考最相似的K个房子的价格，比如距离最近、户型最相似等等。KNN没有明显的训练学习过程，不同K值的选择都会对KNN算法的结果造成重大影响。如下图所示，k=1与k=3预测的类别是不同的。

sklearn.neighbors 提供了 neighbors-based (基于邻居的) 无监督学习以及监督学习方法的功能。无监督的最近邻是许多其它学习方法的基础，尤其是 manifold learning (流形学习) 和 spectral clustering (谱聚类)。neighbors-based (基于邻居的) 监督学习分为两种：classification （分类）针对的是具有离散标签的数据，regression （回归）针对的是具有连续标签的数据。

最近邻方法背后的原理是从训练样本中找到与新点在距离上最近的预定数量的几个点，然后从这些点中预测标签。这些点的数量可以是用户自定义的常量（K-最近邻学习），也可以根据不同的点的局部密度（基于半径的最近邻学习）确定。距离通常可以通过任何度量来衡量：standard Euclidean distance（标准欧式距离）是最常见的选择。Neighbors-based（基于邻居的）方法被称为非泛化机器学习方法，因为它们只是简单地”记住”了其所有的训练数据（可能转换为一个快速索引结构，如 Ball Tree 或 KD Tree）。

尽管它简单，但最近邻算法已经成功地适用于很多的分类和回归问题，例如手写数字或卫星图像的场景。作为一个 non-parametric（非参数化）方法，它经常成功地应用于决策边界非常不规则的分类情景下。

X = [[0], [1], [2], [3]]y = [0, 0, 1, 1]from sklearn.neighbors import KNeighborsClassifierneigh = KNeighborsClassifier(n_neighbors=3)neigh.fit(X, y)print(neigh.predict([[1.1]]))print(neigh.predict_proba([[0.9]]))

7. 集成学习（Ensembale Learning）

常见的集成算法：bagging、boosting、stacking

Bagging Bagging这个名字是Boostrap AGGregatING缩写而来的，是并行式集成学习方法的最著名代表。

Random Forest (随机森林) RF随机森林是一个包含多个决策树的分类器，其输出的类别是由各个子树数据类别的众数（majority voting）决定的。当你不知道该用什么算法来处理分类的时候，随机森林都是一个作为尝试的不错的选择。

Boosting Boosting是一族将弱学习器提升为强学习器的算法。

GBDT（Gradient Boost Decision Tree) 增强版叫做xgboost
Adaboost ：梯度提升树模型 sklearn.ensemble 包含了流行的提升算法 AdaBoost, 这个算法是由 Freund and Schapire 在 1995 年提出来的 [FS1995]. AdaBoost 的核心思想是用反复修改的数据（校对者注：主要是修正数据的权重）来训练一系列的弱学习器(一个弱学习器模型仅仅比随机猜测好一点, 比如一个简单的决策树),由这些弱学习器的预测结果通过加权投票(或加权求和)的方式组合, 得到我们最终的预测结果。

stacking

# Random Forest from sklearn.ensemble import RandomForestClassifierfrom sklearn.datasets import make_classificationX, y = make_classification(n_samples=1000, n_features=4,                           n_informative=2, n_redundant=0,                           random_state=0, shuffle=False)clf = RandomForestClassifier(max_depth=2, random_state=0)clf.fit(X, y)
print(clf.predict([[0, 0, 0, 0]]))

# GBDT

# Gradient Tree Boosting 或梯度提升回归树（GBRT）是对于任意的可微损失函数的提升算法的泛化。GBRT 是一个准确高效的现有程序， 它既能用于分类问题也可以用于回归问题。梯度树提升模型被应用到各种领域，包括网页搜索排名和生态领域。

from sklearn.datasets import make_hastie_10_2from sklearn.ensemble import GradientBoostingClassifier

X, y = make_hastie_10_2(random_state=0)X_train, X_test = X[:2000], X[2000:]y_train, y_test = y[:2000], y[2000:]

clf = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0).fit(X_train, y_train)clf.score(X_test, y_test)

#xgboost  from sklearn.datasets import make_hastie_10_2from xgboost import XGBClassifierx, y = make_hastie_10_2(random_state=0)x_train, x_test = x[:2000], x[2000:]y_train, y_test = y[:2000], y[2000:]model = XGBClassifier()               # 载入模型（模型命名为model)model.fit(x_train,y_train)            # 训练模型（训练集）y_pred = model.predict(x_test)        # 模型预测（测试集），y_pred为预测结果print(y_pred)

#Adaboost 梯度提升树from sklearn.ensemble import AdaBoostClassifierfrom sklearn.datasets import make_classificationX, y = make_classification(n_samples=1000, n_features=4, n_informative=2, n_redundant=0, random_state=0, shuffle=False)clf = AdaBoostClassifier(n_estimators=100, random_state=0)clf.fit(X, y)

clf.predict([[0, 0, 0, 0]])

clf.score(X, y)

# Voting Classifier（投票分类器）# VotingClassifier （投票分类器）的原理是结合了多个不同的机器学习分类器,并且采用多数表决（majority vote）（硬投票） 或者平均预测概率（软投票）的方式来预测分类标签。这样的分类器可以用于一组同样表现良好的模型,以便平衡它们各自的弱点。
from sklearn import datasetsfrom sklearn.model_selection import cross_val_scorefrom sklearn.linear_model import LogisticRegressionfrom sklearn.naive_bayes import GaussianNBfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.ensemble import VotingClassifier
iris = datasets.load_iris()X, y = iris.data[:, 1:3], iris.target
clf1 = LogisticRegression(random_state=1)clf2 = RandomForestClassifier(n_estimators=50, random_state=1)clf3 = GaussianNB()
# Voting Classifier（投票分类器）之硬投票# eclf = VotingClassifier(#     estimators=[('lr', clf1), ('rf', clf2), ('gnb', clf3)],#     voting='hard')
# Voting Classifier（投票分类器）之软投票eclf = VotingClassifier(    estimators=[('lr', clf1), ('rf', clf2), ('gnb', clf3)],     voting='soft', weights=[2, 1, 2])
for clf, label in zip([clf1, clf2, clf3, eclf], ['Logistic Regression', 'Random Forest', 'naive Bayes', 'Ensemble']):    scores = cross_val_score(clf, X, y, scoring='accuracy', cv=5)    print('Accuracy: %0.2f (+/- %0.2f) [%s]' % (scores.mean(), scores.std(), label))

8.高斯过程分类 GPC

高斯过程 (GP) 是一种常用的监督学习方法，旨在解决回归问题和概率分类问题。

高斯过程模型的优点如下：

预测内插了观察结果（至少对于正则核）。预测结果是概率形式的（高斯形式的）。这样的话，人们可以计算得到经验置信区间并且据此来判断是否需要修改（在线拟合，自适应）在一些区域的预测值。通用性: 可以指定不同的:内核(kernels)。虽然该函数提供了常用的内核，但是也可以指定自定义内核。

高斯过程模型的缺点包括：

它们不稀疏，例如，模型通常使用整个样本/特征信息来进行预测。高维空间模型会失效，高维也就是指特征的数量超过几十个。

from sklearn.datasets import load_irisfrom sklearn.gaussian_process import GaussianProcessClassifierfrom sklearn.gaussian_process.kernels import RBFX, y = load_iris(return_X_y=True)kernel = 1.0 * RBF(1.0)gpc = GaussianProcessClassifier(kernel=kernel, random_state=0).fit(X, y)gpc.score(X, y)

data=gpc.predict_proba(X[:2,:])print(data)

9.神经网络分类

多层感知器（MLP）是一种监督学习算法，通过在数据集上训练来学习函数 f(\cdot): R^m \rightarrow R^o，其中 m 是输入的维数，o 是输出的维数。给定一组特征 X = {x_1, x_2, ..., x_m} 和标签 y ，它可以学习用于分类或回归的非线性函数。与逻辑回归不同的是，在输入层和输出层之间，可以有一个或多个非线性层，称为隐藏层。图1 展示了一个具有标量输出的单隐藏层 MLP。

此实现不适用于大规模数据应用。特别是 scikit-learn 不支持 GPU。如果想要提高运行速度并使用基于 GPU 的实现以及为构建深度学习架构提供更多灵活性的框架，

from sklearn.neural_network import MLPClassifierfrom sklearn.datasets import make_classificationfrom sklearn.model_selection import train_test_splitX, y = make_classification(n_samples=100, random_state=1)X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y,                                                    random_state=1)clf = MLPClassifier(random_state=1, max_iter=300).fit(X_train, y_train)data1=clf.predict_proba(X_test[:1])
data2=clf.predict(X_test[:5, :])
data3=clf.score(X_test, y_test)print(data1,data2,data3)

10.随机梯度下降(SGD)分类¶

随机梯度下降(SGD) 是一种简单但又非常高效的方法，主要用于凸损失函数下线性分类器的判别式学习，例如(线性) 支持向量机和 Logistic 回归。尽管 SGD 在机器学习社区已经存在了很长时间, 但是最近在 large-scale learning （大规模学习）方面 SGD 获得了相当大的关注。

SGD 已成功应用于在文本分类和自然语言处理中经常遇到的大规模和稀疏的机器学习问题。对于稀疏数据，本模块的分类器可以轻易的处理超过 10^5 的训练样本和超过 10^5 的特征。

Stochastic Gradient Descent （随机梯度下降法）的优势:

高效。
易于实现 (有大量优化代码的机会)。

Stochastic Gradient Descent （随机梯度下降法）的劣势:

SGD 需要一些超参数，例如 regularization （正则化）参数和 number of iterations （迭代次数）。
SGD 对 feature scaling （特征缩放）敏感。

import numpy as npfrom sklearn.linear_model import SGDClassifierfrom sklearn.preprocessing import StandardScalerfrom sklearn.pipeline import make_pipelineX = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])Y = np.array([1, 1, 2, 2])# Always scale the input. The most convenient way is to use a pipeline.clf = make_pipeline(StandardScaler(), SGDClassifier(max_iter=1000, tol=1e-3))clf.fit(X, Y)

print(clf.predict([[-0.8, -1]]))

多种分类器比较

print(__doc__)

# Code source: Gaël Varoquaux#              Andreas Müller# Modified for documentation by Jaques Grobler# License: BSD 3 clause
import numpy as npimport matplotlib.pyplot as pltfrom matplotlib.colors import ListedColormapfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.datasets import make_moons, make_circles, make_classificationfrom sklearn.neural_network import MLPClassifierfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.svm import SVCfrom sklearn.gaussian_process import GaussianProcessClassifierfrom sklearn.gaussian_process.kernels import RBFfrom sklearn.tree import DecisionTreeClassifierfrom sklearn.ensemble import RandomForestClassifier, AdaBoostClassifierfrom sklearn.naive_bayes import GaussianNBfrom sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
h = .02  # step size in the mesh
names = ['Nearest Neighbors', 'Linear SVM', 'RBF SVM', 'Gaussian Process',         'Decision Tree', 'Random Forest', 'Neural Net', 'AdaBoost',         'Naive Bayes', 'QDA']
classifiers = [    KNeighborsClassifier(3),    SVC(kernel='linear', C=0.025),    SVC(gamma=2, C=1),    GaussianProcessClassifier(1.0 * RBF(1.0)),    DecisionTreeClassifier(max_depth=5),    RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),    MLPClassifier(alpha=1, max_iter=1000),    AdaBoostClassifier(),    GaussianNB(),    QuadraticDiscriminantAnalysis()]
X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,                           random_state=1, n_clusters_per_class=1)rng = np.random.RandomState(2)X += 2 * rng.uniform(size=X.shape)linearly_separable = (X, y)
datasets = [make_moons(noise=0.3, random_state=0),            make_circles(noise=0.2, factor=0.5, random_state=1),            linearly_separable            ]
figure = plt.figure(figsize=(27, 9))i = 1# iterate over datasetsfor ds_cnt, ds in enumerate(datasets):    # preprocess dataset, split into training and test part    X, y = ds    X = StandardScaler().fit_transform(X)    X_train, X_test, y_train, y_test = \        train_test_split(X, y, test_size=.4, random_state=42)
    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),                         np.arange(y_min, y_max, h))
    # just plot the dataset first    cm = plt.cm.RdBu    cm_bright = ListedColormap(['#FF0000', '#0000FF'])    ax = plt.subplot(len(datasets), len(classifiers) + 1, i)    if ds_cnt == 0:        ax.set_title('Input data')    # Plot the training points    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,               edgecolors='k')    # Plot the testing points    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6,               edgecolors='k')    ax.set_xlim(xx.min(), xx.max())    ax.set_ylim(yy.min(), yy.max())    ax.set_xticks(())    ax.set_yticks(())    i += 1
    # iterate over classifiers    for name, clf in zip(names, classifiers):        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)        clf.fit(X_train, y_train)        score = clf.score(X_test, y_test)
        # Plot the decision boundary. For that, we will assign a color to each        # point in the mesh [x_min, x_max]x[y_min, y_max].        if hasattr(clf, 'decision_function'):            Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])        else:            Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
        # Put the result into a color plot        Z = Z.reshape(xx.shape)        ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)
        # Plot the training points        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,                   edgecolors='k')        # Plot the testing points        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,                   edgecolors='k', alpha=0.6)
        ax.set_xlim(xx.min(), xx.max())        ax.set_ylim(yy.min(), yy.max())        ax.set_xticks(())        ax.set_yticks(())        if ds_cnt == 0:            ax.set_title(name)        ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),                size=15, horizontalalignment='right')        i += 1
# plt.tight_layout()# plt.show()