scikit-learn学习笔记

简介： ...................................................................... 2 主要特点：................................................................... 2 scikit-learn安装：（ubuntu版本14.04.1） ......................................... 2

Classification .............................................................. 2

1.监督学习 ........................................................... 2

1.1广义线性模型： ................................................ 2 1.2 支持向量机 ................................................... 9 1.3 随机梯度下降 ................................................ 10 1.4 最近邻 ...................................................... 10 1.5 Gaussian Processes ............................................. 15 1.6 Cross decomposition ............................................ 16 1.7 Naive Bayes .................................................. 16 1.8 Decision Trees ................................................. 17 1.9 Ensemble methods ............................................. 20 1.10 Multiclass and multilabel algorithms .............................. 25 1.11 Feature selection .............................................. 26 1.14 Isotonic regression ............................................ 29 2. .................................................................. 29

2.3 Clustering .................................................... 29 2.5 Decomposing signals in components (matrix factorization problems) ...... 32 3.Model selection and evaluation ......................................... 32

3.1 Cross-validation: evaluating estimator performance .................... 32 3.2 Grid Search: Searching for estimator parameters ...................... 35 3.3 Pipeline: chaining estimators ..................................... 37 3.4 FeatureUnion: Combining feature extractors ......................... 38 3.5. Model evaluation: quantifying the quality of predictions ............... 38 3.6. Model persistence .............................................. 42 3.7. Validation curves: plotting scores to evaluate models .................. 43 4................................................................... 44

4.2 Preprocessing data .............................................. 44 4.4 Random Projection ............................................. 49

简介：

scikit-learn是一个用于机器学习的Python模块，建立在SciPy基础之上。

主要特点：

操作简单、高效的数据挖掘和数据分析 无访问限制，在任何情况下可重新使用 建立在NumPy、SciPy和matplotlib基础上 使用商业开源协议--BSD许可证

scikit-learn安装：（ubuntu版本14.04.1）

安装依赖：

sudo apt-get install build-essential python-dev python-numpy python-setuptools python-scipy libatlas-dev libatlas3-base python-matplotlib 安装pip

sudo apt-get install python-pip 安装scikit-learn

sudo pip install -U scikit-learn

标准库

Classification

1.监督学习

1.1广义线性模型：

1.1.1普通最小二乘法： 无偏估计的

通过计算最小二乘的损失函数的最小值来求得参数得出模型 通常用在观测有误差的情况，解决线性回归问题

y(w,x)?w0?w1x1?....?wpxp? 求实际观测值与预测值差的平方最小值 数学公式： 是由sklearn.linear_model模块中的LinearRegression类实现回归 LinearRegression的构造方法： sklearn.linear_model.LinearRegression(fit_intercept=True #默认值为True，表示minwXw?y22 计算随机变量，False表示不计算随机变量 , normalize=False #默认值为False，表示在回归前是否对回归因子X进行归一化，True表示是 , copy_X=True) LinearRegression的属性有：coef_和intercept_。coef_存储w1到wp的值，与X的维数一致。intercept_存储 参考示例： w0的值。 LinearRegression的常用方法有： decision_function(X) #返回X的预测值y fit(X,y[,n_jobs]) #拟合模型 get_params([deep]) #获取LinearRegression构造方法的参数信息 predict(X) #求预测值 #同decision_function ??ytrue?ypre?2?? score(X,y[,sample_weight]) #计算公式为1??2??y?y?truemean???trueset_params(**params) #设置LinearRegression构造方法的参数值 from sklearn import linear_model X= [[0, 0], [1, 1], [2, 2]] y = [0, 1, 2] clf = linear_model.LinearRegression() clf.fit(X, y) print clf.coef_ print clf.intercept_ print clf.predict([[3, 3]]) print clf.decision_function(X) print clf.score(X, y) print clf.get_params() print clf.set_params(fit_intercept = False) 普通最小二乘法的复杂性： 2O(np)假设n?p 假设影响因素x为一个n行p列的矩阵那么其算法复杂度为缺点：要求每个影响因素相互独立，否则会出现随机误差。 回归用于解决预测值问题 1.1.2 Ridge回归 有偏估计的，回归系数更符合实际、更可靠，对病态数据的拟合要强于最小二乘 数学公式：minXw?yw22??w22 ?>=0，?越大，w值越趋于一致 改良的最小二乘法，增加系数的平方和项和调整参数的积 是由sklearn.linear_model模块中的Ridge类实现 Ridge回归用于解决两类问题：一是样本少于变量个数，二是变量间存在共线性 Ridge的构造方法： sklearn.linear_model.Ridge(alpha=1.0 #公式中?的值，默认为1.0 , fit_intercept=True , normalize=False , copy_X=True , max_iter=None #共轭梯度求解器的最大迭代次数 ,tol=0.001 #默认值0.001 , solver='auto') # Ridge回归复杂性：同最小二乘法 使用： from sklearn import linear_model X= [[0, 0], [1, 1], [2, 2]] y = [0, 1, 2] clf = linear_model.Ridge(alpha = 0.1) clf.fit(X, y) print clf.coef_ print clf.intercept_ print clf.predict([[3, 3]]) print clf.decision_function(X) print clf.score(X, y) print clf.get_params() print clf.set_params(fit_intercept = False) 调整参数设置（?）：通过广义交叉验证的方式（RidgeCV）设置调整参数 RidgeCV构造方法： sklearn.linear_model.RidgeCV(alphas=array([ 0.1, 1., 10. ]) , fit_intercept=True , normalize=False , scoring=None #交叉验证发生器 , cv=None , gcv_mode=None , store_cv_values=False) 使用示例： from sklearn import linear_model X= [[0, 0], [1, 1], [2, 2]] y = [0, 1, 2] clf = linear_model.RidgeCV(alpha = [0.1, 1.0, 10.0]) clf.fit(X, y) print clf.coef_ print clf.intercept_ print clf.predict([[3, 3]]) print clf.decision_function(X) print clf.score(X, y) print clf.get_params() print clf.set_params(fit_intercept = False)

1.1.3 Lasso

min数学公式：w12nsamplesXw?y2??w1 2估计稀疏系数的线性模型 适用于参数少的情况，因其产生稀疏矩阵，可用与特征提取 实现类是Lasso，此类用于监督分类 较好的解决回归分析中的多重共线性问题 思想：在回归系数的绝对值之和小于一个常数的约束条件下，使残差平方和最小化 使用：clf = linear_model.Lasso(alpha = 0.1) 设置调整参数（?）： 交叉验证：LassoCV（适用于高维数据集）或LassoLarsCV（适合于样本数据比观察数据小很多） 基于模式选择的信息标准：LassoLarsIC（BIC/AIC） 1.1.4 Elastic Net 是一个使用L1和L2训练的线性模型，适合于在参数很少的情况下（如Lasso）并保持Ridge性能的情况，既是多种影响因素依赖与另外一种因素。继承Ridge的旋转稳定性。 min数学表达式：w12nsamplesXw?y2???w1?2?(1??)2w2 2from sklearn.linear_model import ElasticNet enet = ElasticNet(alpha=alpha, l1_ratio=0.7) 求取?和?的值使用ElasticNetCV 1.1.5 Multi-task Lasso 用于估计y值不是一元的回归问题 用于估计联合多元回归问题的稀疏系数，y是一个2维矩阵（n_samples,n_tasks）。对于所有的回归问题，选的的因素必须相同，也叫tasks。 使用：clf = linear_model.MultiTaskLasso(alpha=0.1) 1.1.6 Least Angle Regression 是一个计算高维数据的回归算法。实现类是sklearn.linear_model中的Lars类 优点： 当维数大于点数的时候在上下文中是有效的 复杂度和最小二乘相同，但计算很快 产生一个分片解决方案路径用于交叉验证或相似的调整模型方法 缺点：

如果两个变量响应相关，则会有相同的增长率 很融合修改变成其他的评估方法

噪声敏感

使用：clf = linear_model.Lars(n_nonzero_coefs=1)

1.1.7 LARS Lasso

是一个使用LARS算法实现的lasso模型。 使用：clf = linear_model.LassoLars(alpha=0.01)

1.1.8 OMP（Orthogonal Matching Pursuit） 通过固定的非零元素数得到最优解

OMP基于贪心算法实现，每一步的原子项都与残余高度相关。 使用：

omp = OrthogonalMatchingPursuit(n_nonzero_coefs=n_nonzero_coefs) omp_cv = OrthogonalMatchingPursuitCV()

1.1.9 贝叶斯回归（Bayesian Regression）

可以再估计过程包含正则化参数，参数可以手动设置，用于估计概率回归问题 优点： 缺点：

耗时

适用于手边数据

可用于在估计过程中包含正规化参数

Bayesian Ridge Regression：BayesianRidge用于估计回归问题的概率模型

用法：clf = linear_model.BayesianRidge() By default

ARD（Automatic Relevance Determination ）：类似于Bayesian Ridge Regression，但可产生稀疏的w值

用法：clf =

ARDRegression(compute_score=True)

1.1.10 逻辑回归

可以做概率预测，也可用于分类

仅能用于线性问题

通过计算真实值与预测值的概率，然后变换成损失函数，求损失函数最小值来计算模型参数从而得出模型 使用：

clf_l1_LR = LogisticRegression(C=C, penalty='l1', tol=0.01) clf_l2_LR = LogisticRegression(C=C, penalty='l2', tol=0.01) clf_l1_LR.fit(X, y) clf_l2_LR.fit(X, y)

1.1.11 SGD（Stochastic Gradient Descent ） 用于样本数据非常大的情况 由SGDClassifier和SGDRegressor 使用：

clf = linear_model.SGDRegressor() clf = linear_model.SGDClassifier()

对于SGDClassifier，当loss=”log”时拟合成一个逻辑回归模型，当loss=”hinge”时拟合成一个线性支持向量机 1.1.12 Perceptron

是另一个大规模学习的算法 不需要学习率 不是正则的

只有错误的时候更新模型 使用：同SGDClassifier

1.1.13 Passive Aggressive Algorithms

不要求学习率的时候同Perceptron，与Perceptron不同的是包含正则参数C 使用：同SGDClassifier

1.1.14 RANSAC（RANdom SAmple Consensus）

是一个从完整数据集中的一个子集中健壮估计参数的迭代算法，是非确定性算法，此算法把数据分成很多子集，根据子集估计 算法步骤：

（1）从原始数据中选择最小的随机样本，并检查数据时候有效（is_data_valid）

（2）根据（1）的随机子集拟合模型（base_estimator.fit），并检查模型是否有效

（is_model_valid） 优模型。

使用：model_ransac = linear_model.RANSACRegressor(linear_model.LinearRegression())

（3）通过计算估计模型的方法来分类数据

（4）如果临近样本数是最大的，并且当前的评估模型有同样的数则保存模型为最

1.1.15多项式回归

机器学习中的常见模式，使用线性模型训练数据的非线性函数

1.2 支持向量机

拟合出来的模型为一个超平面 解决与样本维数无关，适合做文本分类 解决小样本、非线性、高维

是用于分类、回归、孤立点检测的监督学习方法的集合。 优点： 缺点：

不适用于特征数远大于样本数的情况 不直接提供概率估计 有效的高维空间

维数大于样本数的时候仍然有效 在决策函数中使用训练函数的子集

通用（支持不同的内核函数：线性、多项式、s型等）

接受稠密和稀疏的输入

1.2.1 Classification

由SVC、NuSVC或LinearSVC实现，可进行多类分类 LinearSVC只支持线性分类

SVC和NuSVC实现一对一，LinearSVC实现一对多 使用：

clf = svm.SVC()

lin_clf = svm.LinearSVC()

SVC、NuSVC和LinearSVC均无support_、support_vectors_和n_support_属性 1.2.2 回归

支持向量分类的方法也支持向量回归，有SVR和NuSVR，同分类一样，只是y向量需要是浮点数

使用：clf = svm.SVR()

1.2.3 Density estimation, novelty detection

由OneClassSVM实现，是非监督学习，只需要一个X矩阵，没有类标签

1.2.4 Complexity

and

1.3 随机梯度下降

应用于大量稀疏的机器学习问题，输入数据为稀疏的 常用于文本分类和自然语言处理 是处理大样本数据的非常有效的方法 优点： 缺点： 需要一些调整参数 对尺度特征敏感 高效 易于实施 1.3.1 Classification 使用SGDClassifier实现，拟合参数为X[n_samples,n_features]和y[N_samples] 可以实现多类分类，此时是通过多个binary分类实现实现方式是one-vs-all（OVA），每一个binary分类把其中一个分出来，剩下的作为一个。测试的时候计算每一个分类器的得分并选择得分最高的 1.3.2 Regression 由SGDRegressor实现 1.3.3 复杂度 X为(n,p)，则复杂度为O(knp) 1.4 最近邻

无监督的最近邻是其他学习方法的基础，监督的近邻学习分为：分类（数据有离散标记）和回归（数据有连续标记）

最近邻分类：计算待分类样本与训练样本中各个类的距离，求出距离最小的

K紧邻是求出k个最小的，然后计算分别属于某一类的个数，选个数最大的类，若相等则选择跟训练集中的序列有关

近邻分类：解决离散数据 近邻回归：解决连续数据

1.4.1 无监督的最近邻

由NearestNeighbors实现，在sklearn.neighbors中，有三种算法：ball_tree（BallTree）、kd_tree（KDTree）、brute（brute-force）、auto（默认） from sklearn.neighbors import NearestNeighbors

sklearn.neighbors.NearestNeighbors(n_neighbors=5 #邻居数，默认为5 , radius=1.0 #参数空间范围,默认值为1.0 , algorithm='auto' #用于计算最近邻的算法（ball_tree、kd_tree、brute、auto）

, leaf_size=30 #传递给BallTree或KDTree叶大小 , metric='minkowski' , p=2

, metric_params=None , **kwargs) 使用：

nbrs = NearestNeighbors(n_neighbors=2, algorithm='ball_tree').fit(X) distances, indices = nbrs.kneighbors(X)

1.4.1.2 KDTree and BallTree 使用：

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]) kdt = KDTree(X, leaf_size=30, metric='euclidean') kdt.query(X, k=2, return_distance=False)

BallTree用法同KDTree

1.4.2 最近邻分类

是基于实例的非泛华学习，有两种不同的最近邻分类：KNeighborsClassifier和RadiusNeighborsClassifier（非均匀采样时比较合适）

KNeighborsClassifier：实现k近邻，k是一个用户输入的整数，k高度依赖与数据 sklearn.neighbors.KNeighborsClassifier(n_neighbors=5 #邻居数，默认为5

, weights='uniform' #用于预测的权重方法

, algorithm='auto' #用于计算最近邻的算法（ball_tree、kd_tree、brute、auto）

, leaf_size=30 #传递给BallTree或KDTree叶大小

, p=2

#

, metric='minkowski' #用于树的度量距离 , metric_params=None #度量参数 , **kwargs) 使用：

RadiusNeighborsClassifier：实现基于给定的半径r内的邻居数。用于不是均匀采样的数据，不适合高维参数空间的数据

sklearn.neighbors.RadiusNeighborsClassifier(radius=1.0

, weights='uniform' #参数空间范围 from sklearn.neighbors import KNeighborsClassifier neigh = KNeighborsClassifier(n_neighbors=3) neigh.fit(X, y)

, algorithm='auto' #用于计算最近邻的算法（ball_tree、kd_tree、brute、auto）

, leaf_size=30 #传递给BallTree或KDTree叶大小

, p=2

, metric='minkowski' #用于树的度量距离 , outlier_label=None #离散群体的标签 , metric_params=None #度量参数 , **kwargs) 使用：

from sklearn.neighbors import RadiusNeighborsClassifier

neigh = RadiusNeighborsClassifier(radius=1.0) neigh.fit(X, y)

1.4.3 近邻回归

近邻回归用于标记数据是连续的情况，有两种不同的最近邻分类：KNeighborsRegressor和RadiusNeighborsRegressor

KNeighborsRegressor：实现k近邻，k是一个用户输入的整数

sklearn.neighbors.KNeighborsRegressor(n_neighbors=5

, weights='uniform' 法

, algorithm='auto' 法（ball_tree、kd_tree、brute、auto）

, leaf_size=30 KDTree叶大小

, p=2

, metric='minkowski' , metric_params=None , **kwargs) 使用： from sklearn.neighbors import KNeighborsRegressor neigh = KNeighborsRegressor(n_neighbors=3)

neigh.fit(X, y)

RadiusNeighborsRegressor：实现基于给定的半径r内的邻居数。sklearn.neighbors.RadiusNeighborsRegressor(radius=1.0

, weights='uniform' , algorithm='auto' 算法（ball_tree、kd_tree、brute、auto）

, leaf_size=30 KDTree叶大小

, p=2

, metric='minkowski' , outlier_label=None , metric_params=None #邻居数，默认为5 #用于预测的权重方

#用于计算最近邻的算 #传递给BallTree或 #

#用于树的度量距离 #度量参数 #参数空间范围

#用于计算最近邻的 #传递给BallTree或 #用于树的度量距离 #离散群体的标签 #度量参数

, **kwargs) 使用：

1.4.4 最近邻算法

1.4.4.1 Brute Force

搜索时通过sklearn.neighbors中的algorithm参数设置为‘brute’实现，计算是通过sklearn.metrics.pairwise

此种方法计算效率低，D维空间的N个样本时间复杂度为1.4.4.2 K-D Tree

为了解决BruteForce计算效率低的问题，通过减少计算距离所需的数据实现，思想是：如果A距离B非常远，B距离C非常近，那么认为A与C距离非常远而不需要进行计算。相比于BruteForce，时间复杂度降低为1.4.4.3 BallTree

解决K-DTree高维空间效率低的问题

1.4.4.4 最近邻算法选择

N为样本数，D为维数，k表示邻居数 当N《=30的时候选择BruteForce比较合适 数据集结构化的时候，选择K-D Tree或K-D Tree 当k相当于与N来说变得非常大时选择BruteForce 如果查询点数少时BruteForce

1.4.4.5 leaf_size的影响

1)影响构建树的时间，leaf_size越大，构建树时间越短 2)影响查询时间，leaf_size最合适的值为30 3)影响内存，随着leaf_size的增大，存储内存减小

1.4.5 Nearest Centroid Classifier

构造方法：sklearn.neighbors.NearestCentroid(metric='euclidean'

, shrink_threshold=None)

，但高维数据空间效率低

from sklearn.neighbors import RadiusNeighborsRegressor neigh = RadiusNeighborsRegressor(radius=1.0) neigh.fit(X, y)

用法：

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]) y = np.array([1, 1, 1, 2, 2, 2]) clf = NearestCentroid() clf.fit(X, y)

1.5 Gaussian Processes

GPML是一种监督学习方法，主要用于解决回归问题，已经扩展到概率分类，但目前的研究只是一个回归练习的后处理 优点： 缺点：

非离散 高维空间效率低 分类仅仅是一个后处理 预测插值观测

预测是概率的，可以预测经验置信空间，改变预测值 通用

实现类是GaussianProcess

构造方法：sklearn.gaussian_process.GaussianProcess(regr='constant' #回归函数返回信息 关信息

, beta0=None 权重向量

, storage_mode='full' , verbose=False , theta0=0.1 , thetaL=None , thetaU=None

, optimizer='fmin_cobyla' , random_start=1 , normalize=True

, nugget=2.2204460492503131e-15 , random_state=None)

#回归

, corr='squared_exponential' #自相

使用：

import numpy as np

from sklearn.gaussian_process import GaussianProcess X = np.array([[1., 3., 5., 6., 7., 8.]]).T y = (X * np.sin(X)).ravel()

gp = GaussianProcess(theta0=0.1, thetaL=.001, thetaU=1.) gp.fit(X, y)

1.6 Cross decomposition

包括两类算法PLS和CCA，用于计算两个多变数据集的线性相关，需要拟合的多变集X和Y是2D数组

当预测矩阵比实际数据有更多的变量时适合用PLS

1.7 Naive Bayes

Naive Bayes方法是监督学习的集合基于假设每对特征之间都是独立的贝叶斯理论 朴素贝叶斯方法是基于贝叶斯理论并假设每个特征都是独立的 应用于文档分类和垃圾邮件过滤 需要训练数据比较少

朴素贝叶斯通过计算属于每个类的概率并取概率最大的类作为预测类 naive Bayes is a decent classifier, but a bad estimator 1.7.1 Gaussian Naive Bayes

实现分类的是高斯贝叶斯算法是实现类GaussianNB 构造方法：sklearn.naive_bayes.GaussianNB GaussianNB类构造方法无参数，属性值有： 示例：

import numpy as np

X = 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 GaussianNB clf = GaussianNB()

class_prior_ #每一个类的概率

theta_ #每个类中各个特征的平均 sigma_ #每个类中各个特征的方差

clf.fit(X, Y)

GaussianNB类无score方法 1.7.2 Multinomial Naive Bayes 用于文本分类

用于处理多项离散数据集的Naive Bayes算法的类是Multinomial NB 构造方法：sklearn.naive_bayes.MultinomialNB(alpha=1.0 #平滑参数 示例：

import numpy as np

X = np.random.randint(5, size=(6, 100)) y = np.array([1, 2, 3, 4, 5, 6])

from sklearn.naive_bayes import MultinomialNB clf = MultinomialNB() clf.fit(X, y)

1.7.3 Bernoulli Naive Bayes

处理根据multivariate Bernoulli离散的训练和分类数据算法，实现类是BernoulliNB 构造方法：sklearn.naive_bayes.BernoulliNB(alpha=1.0 #平滑参数

, binarize=0.0

#样本特征

, fit_prior=True #学习类的先验概率

, class_prior=None) #类的先验概率

阈值二值比

, fit_prior=True #学习类的先验概率

, class_prior=None) #类的先验概率 示例：

import numpy as np

X = np.random.randint(2, size=(6, 100)) Y = np.array([1, 2, 3, 4, 4, 5])

from sklearn.naive_bayes import BernoulliNB clf = BernoulliNB() clf.fit(X, Y)

1.8 Decision Trees

是一个无参数的分类和回归的监督学习方法，目标是创建一个模型用于预测目标变量的值，通过学习从数据特征中推断出来的简单规则。 优点： 缺点：

可以创建复杂树但不能很好的推广 不稳定 是NP问题 有很难学习的概念

如果一些类占主导地位创建的树就有偏差 易于理解

只需要很少的准备数据 复杂度是数据点数的对数 能够同时处理数值和分类数据 能够处理多输出问题 采用白盒模型

使用统计测试可以验证模型 即使假设有点错误也可以表现很好

1.8.1 分类

实现类是DecisionTreeClassifier，能够执行数据集的多类分类

输入参数为两个数组X[n_samples,n_features]和y[n_samples],X为训练数据，y为训练数据的标记数据

DecisionTreeClassifier构造方法为：

sklearn.tree.DecisionTreeClassifier(criterion='gini'

, splitter='best' , max_depth=None , min_samples_split=2 , min_samples_leaf=1 , max_features=None , random_state=None , min_density=None , compute_importances=None , max_leaf_nodes=None)

DecisionTreeClassifier示例：

from sklearn import tree X = [[0, 0], [1, 1]]

Y = [0, 1]

clf = tree.DecisionTreeClassifier() clf = clf.fit(X, Y)

1.8.2 回归

实现类是DecisionTreeRegressor，输入为X，y同上，y为浮点数 DecisionTreeRegressor构造方法为：

sklearn.tree.DecisionTreeRegressor(criterion='mse'

, splitter='best' , max_depth=None , min_samples_split=2 , min_samples_leaf=1 , max_features=None , random_state=None , min_density=None , compute_importances=None , max_leaf_nodes=None)

DecisionTreeRegressor示例：

from sklearn import tree X = [[0, 0], [2, 2]] y = [0.5, 2.5]

clf = tree.DecisionTreeRegressor() clf = clf.fit(X, y) clf.predict([[1, 1]])

1.8.3 多输出问题

实现类有：DecisionTreeClassifier和DecisionTreeRegressor. DecisionTreeClassifier构造方法：

sklearn.tree.DecisionTreeClassifier(criterion='gini'

, splitter='best' , max_depth=None , min_samples_split=2 , min_samples_leaf=1 , max_features=None , random_state=None

, min_density=None , compute_importances=None , max_leaf_nodes=None)

DecisionTreeClassifier示例：

from sklearn.datasets import load_iris

from sklearn.cross_validation import cross_val_score from sklearn.tree import DecisionTreeClassifier clf = DecisionTreeClassifier(random_state=0) iris = load_iris()

cross_val_score(clf, iris.data, iris.target, cv=10)

DecisionTreeRegressor构造方法：

sklearn.tree.DecisionTreeRegressor(criterion='mse'

, splitter='best' , max_depth=None , min_samples_split=2 , min_samples_leaf=1 , max_features=None , random_state=None , min_density=None , compute_importances=None , max_leaf_nodes=None)

DecisionTreeRegressor示例：

from sklearn.datasets import load_boston

from sklearn.cross_validation import cross_val_score from sklearn.tree import DecisionTreeRegressor boston = load_boston()

regressor = DecisionTreeRegressor(random_state=0) cross_val_score(regressor, boston.data, boston.target, cv=10)

1.8.4 复杂度

1.9 Ensemble methods

目标是结合几种单一的估计方法进行预测值以提高通用和健壮性 两种方式：

1）多种组合方法单独进行估计，平均其得分

2）多种组合方法逐一估计 1.9.1 Bagging meta-estimator

实现类有BaggingClassifier（用于分类） 和BaggingRegressor（用于回归） BaggingClassifier构造方法： sklearn.ensemble.BaggingClassifier(base_estimator=None

, n_estimators=10 , max_samples=1.0 , max_features=1.0 , bootstrap=True

, bootstrap_features=False , oob_score=False , n_jobs=1

, random_state=None, verbose=0)

BaggingClassifier示例： from sklearn.ensemble import BaggingClassifier

from sklearn.neighbors import KNeighborsClassifier

bagging = BaggingClassifier(KNeighborsClassifier(),max_samples=0.5, max_features=0.5) BaggingRegressor构造方法： sklearn.ensemble.BaggingRegressor(base_estimator=None

, n_estimators=10 , max_samples=1.0 , max_features=1.0 , bootstrap=True

, bootstrap_features=False , oob_score=False , n_jobs=1

, random_state=None , verbose=0)

1.9.2 Forests of randomized trees 1.9.2.1 Random Forests

实现类是RandomForestClassifier（分类）和RandomForestRegressor（回归） RandomForestClassifier构造方法： sklearn.ensemble.RandomForestClassifier(n_estimators=10

, criterion='gini' , max_depth=None , min_samples_split=2 , min_samples_leaf=1 , max_features='auto' , max_leaf_nodes=None , bootstrap=True , oob_score=False , n_jobs=1

, random_state=None

, verbose=0

, min_density=None

, compute_importances=None)

RandomForestClassifier示例：

from sklearn.ensemble import RandomForestClassifier

X = [[0, 0], [1, 1]] Y = [0, 1]

clf = RandomForestClassifier(n_estimators=10) clf = clf.fit(X, Y)

RandomForestRegressor构造方法： sklearn.ensemble.RandomForestRegressor(n_estimators=10

, criterion='mse' , max_depth=None , min_samples_split=2 , min_samples_leaf=1 , max_features='auto' , max_leaf_nodes=None , bootstrap=True , oob_score=False , n_jobs=1

, random_state=None , verbose=0

, min_density=None

, compute_importances=None)

1.9.2.2 Extremely Randomized Trees

实现类是ExtraTreesClassifier （分类）和ExtraTreesRegressor（回归） ExtraTreesClassifier构造方法： sklearn.ensemble.ExtraTreesClassifier(n_estimators=10

, criterion='gini' , max_depth=None , min_samples_split=2 , min_samples_leaf=1 , max_features='auto' , max_leaf_nodes=None , bootstrap=False , oob_score=False , n_jobs=1

, random_state=None , verbose=0

, min_density=None

, compute_importances=None)

ExtraTreesRegressor构造方法： sklearn.ensemble.ExtraTreesRegressor(n_estimators=10

, criterion='mse' , max_depth=None , min_samples_split=2 , min_samples_leaf=1 , max_features='auto' , max_leaf_nodes=None , bootstrap=False , oob_score=False , n_jobs=1

, random_state=None , verbose=0

, min_density=None

, compute_importances=None)

1.9.3 AdaBoost

实现类是AdaBoostClassifier（分类）和AdaBoostRegressor（回归） AdaBoostClassifier构造方法： sklearn.ensemble.AdaBoostClassifier(base_estimator=None

, n_estimators=50 , learning_rate=1.0

, algorithm='SAMME.R' , random_state=None)

AdaBoostClassifier示例： from sklearn.cross_validation import cross_val_score

from sklearn.datasets import load_iris

from sklearn.ensemble import AdaBoostClassifier iris = load_iris()

clf = AdaBoostClassifier(n_estimators=100) scores = cross_val_score(clf, iris.data, iris.target) scores.mean()

AdaBoostRegressor构造方法： sklearn.ensemble.AdaBoostRegressor(base_estimator=None

, n_estimators=50 , learning_rate=1.0 , loss='linear'

, random_state=None)

1.9.4 Gradient Tree Boosting

实现类是GradientBoostingClassifier（分类）和GradientBoostingRegressor（回归） GradientBoostingClassifier构造方法：

sklearn.ensemble.GradientBoostingClassifier(loss='deviance'

, learning_rate=0.1 , n_estimators=100

, subsample=1.0 , min_samples_split=2 , min_samples_leaf=1 , max_depth=3, init=None , random_state=None , max_features=None , verbose=0

, max_leaf_nodes=None , warm_start=False)

GradientBoostingClassifier示例：

from sklearn.datasets import make_hastie_10_2

from 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)

GradientBoostingRegressor构造方法：

GradientBoostingRegressor(loss='ls'

, learning_rate=0.1 , n_estimators=100 , subsample=1.0 , min_samples_split=2 , min_samples_leaf=1 , max_depth=3 , init=None

, random_state=None , max_features=None , alpha=0.9 , verbose=0

, max_leaf_nodes=None , warm_start=False)

GradientBoostingRegressor示例：

import numpy as np

from sklearn.metrics import mean_squared_error from sklearn.datasets import make_friedman1

from sklearn.ensemble import GradientBoostingRegressor

X, y = make_friedman1(n_samples=1200, random_state=0, noise=1.0) X_train, X_test = X[:200], X[200:] y_train, y_test = y[:200], y[200:]

est = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1,max_depth=1, random_state=0, loss='ls').fit(X_train, y_train)

mean_squared_error(y_test, est.predict(X_test))

1.10 Multiclass and multilabel algorithms

1.10.1 Multilabel classification format 实现类是MultiLabelBinarizer 使用示例：

from sklearn.datasets import make_multilabel_classification from sklearn.preprocessing import MultiLabelBinarizer X, Y = make_multilabel_classification(n_samples=5, random_state=0,return_indicator=False) Y

MultiLabelBinarizer().fit_transform(Y)

1.10.2 One-Vs-The-Rest 实现类是OneVsRestClassifier. 构造方法：

sklearn.multiclass.OneVsRestClassifier(estimator, n_jobs=1)

使用示例：

from sklearn import datasets

from sklearn.multiclass import OneVsRestClassifier from sklearn.svm import LinearSVC iris = datasets.load_iris() X, y = iris.data, iris.target

OneVsRestClassifier(LinearSVC(random_state=0)).fit(X, y).predict(X)

1.10.3 One-Vs-One

实现类是OneVsOneClassifier 构造方法：

sklearn.multiclass.OneVsOneClassifier(estimator, n_jobs=1)

使用示例：

from sklearn import datasets

from sklearn.multiclass import OneVsOneClassifier from sklearn.svm import LinearSVC iris = datasets.load_iris() X, y = iris.data, iris.target

OneVsOneClassifier(LinearSVC(random_state=0)).fit(X, y).predict(X)

1.10.4 Error-Correcting Output-Codes 实现类是OutputCodeClassifier 构造方法：

sklearn.multiclass.OutputCodeClassifier(estimator, code_size=1.5, random_state=None,

n_jobs=1) 使用示例：

from sklearn import datasets

from sklearn.multiclass import OutputCodeClassifier from sklearn.svm import LinearSVC iris = datasets.load_iris() X, y = iris.data, iris.target

clf = OutputCodeClassifier(LinearSVC(random_state=0),code_size=2, random_state=0) clf.fit(X, y).predict(X)

1.11 Feature selection

特征选择可以提高决策精度，提高高维数据性能 1.11.1 Removing features with low variance 实现类是VarianceThreshold VarianceThreshold构造方法是：

sklearn.feature_selection.VarianceThreshold(threshold=0.0)

VarianceThreshold示例：

from sklearn.feature_selection import VarianceThreshold X = [[0, 0, 1], [0, 1, 0], [1, 0, 0], [0, 1, 1], [0, 1, 0], [0, 1, 1]] sel = VarianceThreshold(threshold=(.8 * (1 - .8))) sel.fit_transform(X)

1.11.2 Univariate feature selection

实现类有：SelectKBest 、SelectPercentile和GenericUnivariateSelect SelectKBest构造方法： k=10)

SelectPercentile构造方法：

sklearn.feature_selection.SelectPercentile(score_func=,

0x34fca28>, percentile=10) GenericUnivariateSelect构造方法：

sklearn.feature_selection.GenericUnivariateSelect(score_func=

0x34fca28>, mode='percentile', param=1e-05)

1.11.3 Recursive feature elimination 实现类是RFECV 构造方法为： sklearn.feature_selection.RFECV(estimator, step=1, cv=None, loss_func=None, estimator_params={}, verbose=0) 示例： from sklearn.datasets import make_friedman1

from sklearn.feature_selection import RFECV from sklearn.svm import SVR

X, y = make_friedman1(n_samples=50, n_features=10, random_state=0) estimator = SVR(kernel=\

selector = RFECV(estimator, step=1, cv=5) selector = selector.fit(X, y) selector.support_ selector.ranking_

scoring=None,

1.11.4 L1-based feature selection

1.11.4.1 Selecting non-zero coefficients

实现类是linear_model.LogisticRegression和svm.LinearSVC 1.11.4.2 Randomized sparse models

实现类是RandomizedLasso和RandomizedLogisticRegression

1.11.5 Tree-based feature selection 实现类是ExtraTreesClassifier 示例： from sklearn.ensemble import ExtraTreesClassifier from sklearn.datasets import load_iris iris = load_iris()

X, y = iris.data, iris.target

X.shape

clf = ExtraTreesClassifier()

X_new = clf.fit(X, y).transform(X) clf.feature_importances_ X_new.shape

1.12 Semi-Supervised

半监督的学习方法，用于训练数据中有一部分没有被标记，适用于少量有标记数据和大量已标记数据的的数据集

机器学习提高两种标记传播算法：LabelPropagation和LabelSpreading LabelPropagation构造方法： sklearn.semi_supervised.LabelPropagation(kernel='rbf' , gamma=20 , n_neighbors=7 , alpha=1 , max_iter=30 , tol=0.001) LabelPropagation示例： from sklearn import datasets

from sklearn.semi_supervised import LabelPropagation label_prop_model = LabelPropagation() iris = datasets.load_iris()

random_unlabeled_points = np.where(np.random.random_integers(0, 1,size=len(iris.target))) labels = np.copy(iris.target)

labels[random_unlabeled_points] = -1 label_prop_model.fit(iris.data, labels) LabelSpreading构造方法： sklearn.semi_supervised.LabelSpreading(kernel='rbf' , gamma=20

, n_neighbors=7 , alpha=0.2 , max_iter=30 , tol=0.001) LabelSpreading示例： from sklearn import datasets

from sklearn.semi_supervised import LabelSpreading label_prop_model = LabelSpreading() iris = datasets.load_iris()

random_unlabeled_points = np.where(np.random.random_integers(0, 1,size=len(iris.target))) labels = np.copy(iris.target)

labels[random_unlabeled_points] = -1 label_prop_model.fit(iris.data, labels)

1.13 Linear and quadratic discriminant analysis

线性判别分析（LDA）和二次判别分析（QDA）是两个经典的分类，因为他们的解释闭合的便于计算，LAD适合于判别线性边界，QDA适合于判别二次边界。 LDA构造方法： sklearn.lda.LDA(n_components=None , priors=None) LDA示例： import numpy as np from sklearn.lda import LDA

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]) y = np.array([1, 1, 1, 2, 2, 2]) clf = LDA() clf.fit(X, y)

QDA构造方法： sklearn.qda.QDA(priors=None , reg_param=0.0) QDA示例： from sklearn.qda import QDA import numpy as np

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]) y = np.array([1, 1, 1, 2, 2, 2]) clf = QDA() clf.fit(X, y)

LDA可用于将维。

1.14 Isotonic regression

拟合非递归数据集，实现类为IsotonicRegression 构造方法： sklearn.isotonic.IsotonicRegression(y_min=None #可选，默认为None , y_max=None #可选，默认为None , increasing=True , out_of_bounds='nan')

2.

2.3 Clustering

输入数据可以使各种各样的种矩阵 2.3.2 K-means

要求聚类的数目被指定，能很好的扩展到大数据样本，并且应用到不同领域的大范围领域中。 实现类是： KMeans KMeans构造方法：

sklearn.cluster.KMeans(n_clusters=8

, init='k-means++ ', n_init=10 , max_iter=300 , tol=0.0001

,precompute_distances=True , verbose=0

, random_state=None , copy_x=True , n_jobs=1)

参考示例： from sklearn.cluster import KMeans X = [[0],[1],[2]] y = [0,1,2] clf = KMeans(n_clusters=2) clf.fit(X,y) 2.3.2.1 Mini Batch K-Means

是KMeans的一种变换，目的为了减少计算时间 实现类是MiniBatchKMeans MiniBatchKMeans构造方法：

sklearn.cluster.MiniBatchKMeans(n_clusters=8

, init='k-means++' , max_iter=100 , batch_size=100 , verbose=0

,compute_labels=True , random_state=None , tol=0.0

, max_no_improvement=10 , init_size=None , n_init=3

,reassignment_ratio=0.01)

参考示例：

from sklearn.cluster import MiniBatchKMeans X= [[1],[2],[3]] mbk = MiniBatchKMeans(init='k-means++', n_clusters=3, batch_size=batch_size, n_init=10, max_no_improvement=10, verbose=0) mbk.fit(X)

2.3.3 Affinity Propagation

创建集群通过在成对的样本间传递消息 实现类是AffinityPropagation AffinityPropagation构造方法：

sklearn.cluster.AffinityPropagation(damping=0.5

, max_iter=200

, convergence_iter=15 , copy=True

,preference=None , affinity='euclidean' , verbose=False)

参考示例：

from sklearn.cluster import AffinityPropagation X= [[1],[2],[3]] af = AffinityPropagation(preference=-50).fit(X)

2.3.4 Mean Shift

实现类是：MeanShift MeanShift构造方法：

sklearn.cluster.MeanShift(bandwidth=None

, seeds=None

, bin_seeding=False , min_bin_freq=1 ,cluster_all=True)

参考示例：

from sklearn.cluster import MeanShift, estimate_bandwidth from sklearn.datasets.samples_generator import make_blobs centers = [[1, 1], [-1, -1], [1, -1]] X, _ = make_blobs(n_samples=10000, centers=centers, cluster_std=0.6) bandwidth = estimate_bandwidth(X, quantile=0.2, n_samples=500) ms = MeanShift(bandwidth=bandwidth, bin_seeding=True) ms.fit(X)

2.3.5 Spectral clustering 实现类：SpectralClustering SpectralClustering构造方法：

sklearn.cluster.SpectralClustering(n_clusters=8

, eigen_solver=None , random_state=None

, n_init=10,gamma=1.0 , affinity='rbf' , n_neighbors=10 , eigen_tol=0.0

, assign_labels='kmeans' , degree=3 , coef0=1

,kernel_params=None)

2.3.6 Hierarchical clustering

2.3.7 DBSCAN

2.3.8 Clustering performance evaluation

2.5 Decomposing signals in components (matrix factorization problems)

2.5.1 PCA

3.Model selection and evaluation

3.1 Cross-validation: evaluating estimator performance

把数据集自动分成训练集和测试集的方法是 train_test_split 参考示例：

import numpy as np from sklearn import cross_validation from sklearn import datasets from sklearn import svm iris = datasets.load_iris() print iris.data.shape, iris.target.shape X_train, X_test, y_train, y_test = cross_validation.train_test_split(iris.data, iris.target, test_size=0.4, random_state=0) print X_train.shape, y_train.shape print X_test.shape, y_test.shape clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train) clf.score(X_test, y_test)

3.3.1 Computing cross-validated metrics 调用 cross_val_score实现 参考示例：

import numpy as np from sklearn import cross_validation from sklearn import datasets from sklearn import svm iris = datasets.load_iris() print iris.data.shape, iris.target.shape X_train, X_test, y_train, y_test = cross_validation.train_test_split(iris.data, iris.target, test_size=0.4, random_state=0) print X_train.shape, y_train.shape print X_test.shape, y_test.shape clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train) scores = cross_validation.cross_val_score(clf, iris.data, iris.target, cv=5) clf.score(X_test, y_test)

3.1.2 Cross validation iterators 3.1.2.1 K-fold

把所有的样本分成k组 实现类是KFold KFold 构造方法：

sklearn.cross_validation.KFold(n

, n_folds=3 , indices=None , shuffle=False

, random_state=None)

参考示例：

import numpy as np from sklearn.cross_validation import KFold kf = KFold(4, n_folds=2) for train, test in kf: print(\%s\% (train, test))

3.1.2.2 Stratified k-fold 实现类：StratifiedKFold

sklearn.cross_validation.StratifiedKFold(y

, n_folds=3 , indices=None , shuffle=False

, random_state=None)

参考示例：

import numpy as np from sklearn.cross_validation import StratifiedKFold labels = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1] skf = StratifiedKFold(labels, 3) for train, test in kf: print(\%s\% (train, test))

3.1.2.3 Leave-One-Out - LOO 实现类LeaveOneOut LeaveOneOut构造方法：

sklearn.cross_validation.LeaveOneOut(n

, indices=None)

参考示例：

from sklearn.cross_validation import LeaveOneOut loo = LeaveOneOut(4) for train, test in loo: print(\%s\% (train, test)) 3.1.2.4 Leave-P-Out - LPO 实现类：LeavePOut LeavePOut构造方法：

sklearn.cross_validation.LeavePOut(n

, p

, indices=None)

参考示例：

from sklearn.cross_validation import LeavePOut lpo = LeavePOut(4, p=2) for train, test in lpo: print(\%s\% (train, test)) 3.1.2.5 Leave-One-Label-Out - LOLO 实现类：LeaveOneLabelOut LeaveOneLabelOut构造方法：

sklearn.cross_validation.LeaveOneLabelOut(labels

, indices=None)

参考示例：

from sklearn.cross_validation import LeaveOneLabelOut labels = [1, 1, 2, 2]lolo = LeaveOneLabelOut(labels) for train, test in lolo: print(\%s\% (train, test))

3.1.2.6 Leave-P-Label-Out 实现类：LeavePLabelOut LeavePLabelOut构造方法：

sklearn.cross_validation.LeavePLabelOut(labels

, p

, indices=None)

参考示例：

from sklearn.cross_validation import LeavePLabelOut labels = [1, 1, 2, 2, 3, 3]lplo = LeavePLabelOut(labels, p=2) for train, test in lplo: print(\%s\% (train, test))

3.1.2.7 Random permutations cross-validation a.k.a. Shuffle & Split 实现类：ShuffleSplit ShuffleSplit构造方法：

sklearn.cross_validation.ShuffleSplit(n

, n_iter=10 , test_size=0.1 , train_size=None , indices=None

,random_state=None , n_iterations=None)

参考示例：

from sklearn.cross_validation import ShuffleSplit ss = cross_validation.ShuffleSplit(5, n_iter=3, test_size=0.25, random_state=0) for train_index, test_index in ss: print(\%s\% (train_index, test_index)) 3.2 Grid Search: Searching for estimator parameters

3.2.1 Exhaustive Grid Search 实现类是：GridSearchCV GridSearchCV构造方法：

实现方法：precision_recall_curve和 average_precision_score precision_recall_curve原型：

sklearn.metrics.precision_recall_curve(y_true

, probas_pred , pos_label=None

, sample_weight=None)

precision_recall_curve使用示例：

import numpy as npfrom sklearn.metrics import precision_recall_curve y_true = np.array([0, 0, 1, 1]) y_scores = np.array([0.1, 0.4, 0.35, 0.8]) precision, recall, thresholds = precision_recall_curve( y_true, y_scores) print precision print recall print thresholds precision_recall_curve只能用于数据为0或1的情况

average_precision_score原型：

sklearn.metrics.average_precision_score(y_true

, y_score

, average='macro'

, sample_weight=None)

返回值为average_precision

average_precision_score使用示例：

import numpy as np from sklearn.metrics import average_precision_score y_true = np.array([0, 0, 1, 1]) y_scores = np.array([0.1, 0.4, 0.35, 0.8]) print average_precision_score(y_true, y_scores) average_precision_score只能用于数据为0或1的情况

3.5.2.1.7 Hinge loss 实现方法是 hinge_loss hinge_loss原型：

sklearn.metrics.hinge_loss(y_true

, pred_decision , pos_label=None , neg_label=None)

使用示例：

from sklearn import svm from sklearn.metrics import hinge_loss X = [[0], [1]] y = [-1, 1] est = svm.LinearSVC(random_state=0) est.fit(X, y) pred_decision = est.decision_function([[-2], [3], [0.5]]) print pred_decision print hinge_loss([-1, 1, 1], pred_decision)

3.5.2.1.8. Log loss 实现方法：log_loss log_loss原型：

sklearn.metrics.log_loss(y_true

, y_pred , eps=1e-15

, normalize=True)

使用示例：

from sklearn.metrics import log_loss y_true = [0, 0, 1, 1] y_pred = [[.9, .1], [.8, .2], [.3, .7], [.01, .99]] log_loss(y_true, y_pred)

3.6. Model persistence

3.6.1 Persistence example 实现持久化的类是pickle 参考示例：

from sklearn import svm from sklearn import datasets clf = svm.SVC() iris = datasets.load_iris() X, y = iris.data, iris.target clf.fit(X, y) import pickle s = pickle.dumps(clf) clf2 = pickle.loads(s) print clf2.predict(X[0])

3.7. Validation curves: plotting scores to evaluate models

高维空间，模型不直观，因此需要选择曲线验证来验证模型的合理性 3.7.1 Validation curve

参数值对学习分数的影响曲线

这一功能由 validation_curve完成，示例如下 参考示例：

import numpy as np from sklearn.learning_curve import validation_curve from sklearn.datasets import load_iris from sklearn.linear_model import Ridge np.random.seed(0) iris = load_iris() X, y = iris.data, iris.target indices = np.arange(y.shape[0]) np.random.shuffle(indices) X, y = X[indices], y[indices] train_scores, valid_scores = validation_curve(Ridge(), X, y, \ np.logspace(-7, 3, 3)) print train_scores print valid_scores train_scores小 valid_scores大时最好，或者两者都大

3.7.2 Learning curve

通过改变训练样本数目学习分数的影响曲线 训练样本数目对 learning_curve

train_scores远大于 valid_scores比较好 参考例子：

import numpy as np from sklearn.learning_curve import learning_curve from sklearn.datasets import load_iris from sklearn.svm import SVC np.random.seed(0) iris = load_iris() X, y = iris.data, iris.target indices = np.arange(y.shape[0]) np.random.shuffle(indices) X, y = X[indices], y[indices]

train_sizes, train_scores, valid_scores = learning_curve(SVC(kernel='linear'), X, y, train_sizes=[50, 80, 110], cv=5) print train_sizes print train_scores print valid_scores

4.

4.2 Preprocessing data

4.2.1 标准化

标准化方法：scale scale构造方法：

sklearn.preprocessing.scale(X #要进行标准化的数据

, axis=0

, with_mean=True #是否计算均值 , with_std=True #是否计算标准差 , copy=True)

参考示例：

from sklearn import preprocessing import numpy as np X = np.array([[ 1., -1., 2.], [ 2., 0., 0.], [ 0., 1., -1.]]) X_scaled = preprocessing.scale(X) print X_scaled print X_scaled.mean(axis=0) print X_scaled.std(axis=0)

sklearn.preprocessing模块提供StandardScaler 用于实现Transformer API 基于训练数据计算均值和标准差，此类适合于sklearn.pipeline.Pipeline 早期步骤 StandardScaler 的属性为：mean_和std_

StandardScaler 构造方法：

sklearn.preprocessing.StandardScaler(copy=True

, with_mean=True #是否计算平均值 , with_std=True) #是否计算标准差

参考示例：

from sklearn import preprocessing import numpy as np X = np.array([[ 1., -1., 2.], [ 2., 0., 0.], [ 0., 1., -1.]]) scaler = preprocessing.StandardScaler().fit(X) print scaler.mean_ print scaler.std_ scaler.transform(X) scaler.transform([-1., 1., 0.])

把数据缩放到一个范围，常常是0-1的范围，这时可以直接使用MinMaxScaler MinMaxScaler构造方法：

sklearn.preprocessing.MinMaxScaler(feature_range=(0, 1) #要缩放的范围，默认为0-1

, copy=True)

MinMaxScaler有两个属性：min_和scale_ 参考示例：

from sklearn import preprocessing import numpy as np X_train = np.array([[ 1., -1., 2.], [ 2., 0., 0.], [ 0., 1., -1.]]) min_max_scaler = preprocessing.MinMaxScaler() X_train_minmax = min_max_scaler.fit_transform(X_train) print X_train_minmax print min_max_scaler.fit_transform([-3., -1., 4.]) print min_max_scaler.scale_ print min_max_scaler.min_

4.2.2 常规化 计算二次型

常规化方法：normalize normalize构造方法：

sklearn.preprocessing.normalize(X

本文来源：https://www.bwwdw.com/article/y3np.html