深入解析Python库系列（五）：sklearn在机器学习领域的应用

更新:10-29 名人轶事我要投稿纠错投诉

很多朋友对于深入解析Python库系列（五）：sklearn在机器学习领域的应用和不太懂，今天就由小编来为大家分享，希望可以帮助到大家，下面一起来看看吧！

sklearn icon sklearn是一个基于Python语言的机器学习工具包。它是目前当之无愧的机器学习项目第一工具。

sklearn自带了大量的数据集供我们练习各种机器学习算法。

sklearn集成了数据预处理、数据特征选择、数据特征降维、分类回归聚类模型、模型评估等非常全面的算法。

2.sklearn数据类型机器学习处理的最终数据是数字，但这些数据可能会以不同的形式呈现，比如矩阵、文本、图片、视频、音频等。

3.sklearn总览sklearn 中包含的模块

数据集

image

sklearn.datasets

获取小数据集（本地加载）：datasets.load_xxx() 获取大数据集（在线下载）：datasets.fetch_xxx() 本地生成的数据集（本地）构建）：datasets.make_xxx() 数据集介绍load_iris() 鸢尾花数据集：3个类别，4个特征，150个样本load_boston() 波士顿房价数据集：13个特征，506个样本load_digits() 手写数字数据集：10个类别， 64 个特征，1797 个样本load_breast_cancer() 乳腺癌数据集：2 个类别，30 个特征，569 个样本load_diabets() 糖尿病数据集：10 个特征，442 个样本load_wine() 红酒数据集：3 个类别，13 个特征，178 个样本load_files load_linnerud() 加载自定义文本分类数据集load_linnerud() 物理训练数据集：3 个特征，20 个样本load_sample_image() 加载单个图像样本load_svmlight_file() 加载svmlight 格式数据make_blobs() 生成多类单标签数据集make_biclusters( ) 生成双聚类数据集make_checkerboard( ) 生成用于双聚类的棋盘结构数组make_circles( ) 生成二维二元分类数据集make_classification( ) 生成多类单标签数据集标签数据集make_friedman1 ( ) 使用多项式和正弦变换生成数据集make_gaussian_quantiles( ) 生成高斯分布数据集make_hastie_10_2( ) 生成10 维二元分类数据集make_low_rank_matrix( ) 生成具有钟形奇异值的低阶矩阵make_moons ( ) 生成二维二元分类数据集make_multilabel_classification () 生成多类多标签数据集make_regression () 生成回归任务的数据集make_s_curve () 生成S 曲线数据集make_sparse_coded_signal () 生成信号作为字典元素的稀疏组合make_sparse_spd_matrix ( ) 生成稀疏堆叠正定矩阵make_sparse_uncorrelated( ) 使用稀疏不相关设计生成随机回归问题make_spd_matrix( ) 生成随机堆叠正定矩阵make_swiss_roll( ) 生成用于读取瑞士卷曲线数据集数据集：

从sklearn导入数据集

将matplotlib.pyplot 导入为plt

iris=datasets.load_iris()

特征=iris.data

目标=虹膜.目标

打印（特征.形状，目标.形状）

打印（iris.feature_names）

波士顿=datasets.load_boston()

波士顿特征=波士顿.数据

波士顿_目标=波士顿.目标

打印（波士顿特征.形状，波士顿目标.形状）

打印（波士顿.feature_names）

数字=datasets.load_digits()

数字特征=数字.数据

数字_目标=数字.目标

打印（digits_features.shape，digits_target.shape）

img=datasets.load_sample_image("flower.jpg")

打印（img.形状）

plt.imshow(img)

plt.show()

数据，目标=datasets.make_blobs（n_samples=1000，n_features=2，centers=4，cluster_std=1）

plt.scatter(数据[:0],数据[:1],c=目标)

plt.show()

数据，目标=datasets.make_classification（n_classes=4，n_samples=1000，n_features=2，n_informative=2，n_redundant=0，n_clusters_per_class=1）

打印（数据.形状）

plt.scatter(数据[:0],数据[:1],c=目标)

plt.show()

x,y=datasets.make_regression(n_samples=10,n_features=1,n_targets=1,noise=1.5,random_state=1)

打印（x.形状，y.形状）

plt.scatter(x,y)

plt.show()

数据预处理

image

sklearn.preprocessing

Function 函数preprocessing.scale( ) 标准化预处理.MinMaxScaler( ) 最大最小值标准化预处理.StandardScaler( ) 数据标准化预处理.MaxAbsScaler( ) 绝对值最大标准化预处理.RobustScaler( ) 使用异常值预处理对数据集进行标准化。QuantileTransformer( ) 使用分位数信息来转换特征预处理。PowerTransformer( ) 使用幂变换执行到正态分布的映射预处理。Normalizer( ) 正则化预处理。OrdinalEncoder( ) 将分类特征转换为分类值preprocessing.LabelEncoder() 将分类特征转换为分类值preprocessing.MultiLabelBinarizer() 多标签二值化预处理.OneHotEncoder() one-hot 编码预处理.KBinsDiscretizer() 离散化连续数据预处理.FunctionTransformer() 自定义特征处理函数预处理.Binarizer( ) 特征二值化预处理.PolynomialFeatures( ) 创建多项式特征preprocesssing.Normalizer( ) 正则化预处理.Imputer( ) 补偿缺失值数据预处理代码

将numpy 导入为np

从sklearn导入预处理

#标准化：将数据转换为均值为0、方差为1的数据，即标记为正态分布的数据

x=np.array([[1,-1,2],[2,0,0],[0,1,-1]])

x_scale=预处理.scale(x)

打印（x_scale.mean（轴=0），x_scale.std（轴=0））

std_scale=预处理.StandardScaler().fit(x)

x_std=std_scale.transform(x)

打印（x_std.mean（轴=0），x_std.std（轴=0））

#将数据缩放到给定范围（0-1）

mm_scale=预处理.MinMaxScaler()

x_mm=mm_scale.fit_transform(x)

打印(x_mm.mean(轴=0),x_mm.std(轴=0))

#将数据缩放到给定范围（-1-1），适合稀疏数据

mb_scale=预处理.MaxAbsScaler()

x_mb=mb_scale.fit_transform(x)

打印（x_mb.mean（轴=0），x_mb.std（轴=0））

#适合有异常值的数据

rob_scale=预处理.RobustScaler()

x_rob=rob_scale.fit_transform(x)

打印（x_rob.mean（轴=0），x_rob.std（轴=0））

#正则化

nor_scale=预处理.Normalizer()

x_nor=nor_scale.fit_transform(x)

打印（x_nor.mean（轴=0），x_nor.std（轴=0））

#特征二值化：将数值特征转换为布尔值

bin_scale=预处理.Binarizer()

x_bin=bin_scale.fit_transform(x)

打印（x_bin）

#将分类特征或数据标签转换为one-hot编码

ohe=预处理.OneHotEncoder()

x1=([[0,0,3],[1,1,0],[1,0,2]])

x_ohe=ohe.fit(x1).transform([[0,1,3]])

print(x_ohe)导入numpy 作为np

从sklearn.preprocessing 导入多项式特征

x=np.arange(6).reshape(3,2)

poly=多项式特征(2)

x_poly=poly.fit_transform(x)

打印（x）

print(x_poly)导入numpy 作为np

从sklearn.preprocessing 导入FunctionTransformer

#自定义特征转换函数

变压器=FunctionTransformer(np.log1p)

x=np.array([[0,1],[2,3]])

x_trans=变压器.transform(x)

print(x_trans)导入numpy 作为np

导入sklearn.预处理

x=np.array([[-3,5,15],[0,6,14],[6,3,11]])

kbd=preprocessing.KBinsDiscretizer(n_bins=[3,2,2],encode="ordinal").fit(x)

x_kbd=kbd.transform(x)

print(x_kbd)from sklearn.preprocessing 导入MultiLabelBinarizer

#多标签二值化

mlb=MultiLabelBinarizer()

x_mlb=mlb.fit_transform([(1,2),(3,4),(5,)])

print(x_mlb)

sklearn.svm

函数介绍svm.OneClassSVM() 上述预处理类函数的无监督异常值检测方法如下：

Preprocessing.xxx 函数方法介绍xxx.fit() 拟合数据xxx.fit_transform() 拟合变换数据xxx.get_params() 获取函数参数xxx.inverse_transform() 逆变换xxx.set_params() 设置参数transform() 变换数据：010 -1010 image 很多时候我们用于模型训练的数据集包含很多特征，这些特征要么是多余的，要么是与结果关联不大；这时，我们精心挑选一些“好的”特征。训练模型不仅可以减少模型训练时间，还可以提高模型性能。

例如，一个数据集包含四个特征（鼻子长度、眼角长度、额头宽度、血型）；当我们使用这些数据集进行人脸识别时，必须先去除特征（血型）才能进行人脸识别；因为（血型））这个特征对于人脸识别的目标来说是一个无用的特征。

特征选择

Function feature_selection.SelectKBest( ) feature.selection.chi2 feature_selection.f_regressionmutual_info_regression 选择得分最高的K 个特征feature_selection.VarianceThreshold( ) 无监督特征选择feature_selection.REF( ) 递归特征消除feature_selection.REFCV( ) 递归特征消除交叉- 验证方法feature_selection.SelectFromModel()特征选择特征选择实现代码

从sklearn.datasets 导入load_digits

从sklearn.feature_selection 导入SelectKBest,chi2

数字=load_digits()

数据=数字.数据

目标=数字.目标

打印（数据.形状）

data_new=SelectKBest(chi2,k=20).fit_transform(数据，目标)

打印（data_new.shape）从sklearn.feature_selection导入VarianceThreshold

x=[[0,0,1],[0,1,0],[1,0,0],[0,1,1],[0,1,0],[0,1,1] ]

vt=方差阈值(阈值=(0.8*(1-0.8)))

x_new=vt.fit_transform(x)

打印（x）

打印（x_new）从sklearn.svm导入LinearSVC

从sklearn.datasets 导入load_iris

从sklearn.feature_selection 导入SelectFromModel

虹膜=load_iris()

x,y=虹膜.数据，虹膜.目标

lsvc=LinearSVC(C=0.01,penalty="l1",dual=False).fit(x,y)

模型=SelectFromModel(lsvc,prefit=True)

x_new=model.transform(x)

打印（x.形状）

打印（x_new.shape）从sklearn.svm导入SVC

从sklearn.model_selection 导入StratifiedKFold,cross_val_score

从sklearn.feature_selection 导入RFECV

从sklearn.datasets 导入load_iris

虹膜=load_iris()

x,y=虹膜.数据，虹膜.目标

svc=SVC(内核="线性")

rfecv=RFECV(估计器=svc,步长=1,cv=StratifiedKFold(2),评分="准确度",详细=1,n_jobs=1).fit(x,y)

x_rfe=rfecv.transform(x)

打印（x_rfe.shape）

clf=SVC(伽玛="自动", C=0.8)

分数=(cross_val_score(clf, x_rfe, y, cv=5))

打印（分数）

print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), Scores.std()*2))

sklean.feature_selection

特征降维面向特征量巨大的数据集。除了特征选择之外，我们还可以使用特征降维算法来减少特征数量；特征降维与特征选择的区别在于，特征选择是从原始特征中选择特征；而特征降维则从原始特征生成新特征。特征。

很多人都有比较特征选择和特征降维优缺点的心态。事实上，这种脱离实际问题的比较是没有意义的。我们必须明白，每种算法都有自己的专业领域。

特征降维

函数分解.PCA( ) 主成分分析分解.KernelPCA( ) 核主成分分析分解.IncrementalPCA( ) 增量主成分分析分解.MiniBatchSparsePCA( ) 小批量稀疏主成分分析分解.SparsePCA 稀疏主成分分析分解。 FactorAnalysis()因子分析分解.TruncatedSVD()截断奇异值分解分解.FastICA()独立成分分析分解快速算法.DictionaryLearning字典学习分解.MiniBatchDictonaryLearning()小批量字典学习分解.dict_learning()字典学习在线字典学习矩阵分解分解.dict_learning_online( ) 矩阵分解的隐含狄利克雷分布分解.LatentDirichletAllocation( ) 在线变分贝叶斯算法分解.NMF( ) 非负矩阵分解分解.SparseCoder( ) Sparse Coder 特征降维码实现

"""数据降维"""

从sklearn.decomposition 导入PCA

x=np.array([[-1,-1],[-2,-1],[-3,-2],[1,1],[2,1],[3,2]])

pca1=PCA(n_components=2)

pca2=PCA(n_components="mle")

pca1.fit(x)

pca2.fit(x)

x_new1=pca1.transform(x)

x_new2=pca2.transform(x)

打印（x_new1.shape）

print(x_new2.shape)导入numpy 作为np

从sklearn.decomposition 导入KernelPCA

将matplotlib.pyplot 导入为plt

导入数学

#kernelPCA适合数据的非线性降维

x=[]

y=[]

N=500

对于范围(N): 内的i

deg=np.random.randint(0,360)

如果np.random.randint(0,2)%2==0:

x.append([6*math.sin(deg),6*math.cos(deg)])

y.追加(1)

否则：

x.append([15*math.sin(deg),15*math.cos(deg)])

y.追加(0)

y=np.array(y)

x=np.array(x)

kpca=KernelPCA(kernel="rbf",n_components=14)

x_kpca=kpca.fit_transform(x)

打印（x_kpca.shape）从sklearn.datasets导入load_digits

从sklearn.decomposition 导入IncrementalPCA

从scipy 导入稀疏

X, _=load_digits(return_X_y=True)

#增量主成分分析：适合大数据

变换=IncrementalPCA(n_components=7,batch_size=200)

变换.partial_fit(X[:100,])

x_sparse=稀疏.csr_matrix(X)

x_transformed=变换.fit_transform(x_sparse)

x_transformed.shapeimport numpy as np

从sklearn.datasets 导入make_friedman1

从sklearn.decomposition 导入MiniBatchSparsePCA

x,_=make_friedman1(n_samples=200,n_features=30,random_state=0)

变压器=MiniBatchSparsePCA(n_components=5,batch_size=50,random_state=0)

变压器.fit(x)

x_transformed=变压器.transform(x)

打印（x_transformed.shape）从sklearn.datasets导入load_digits

从sklearn.decomposition 导入FactorAnalysis

x,_=load_digits(return_X_y=True)

变压器=因子分析(n_components=7,random_state=0)

x_transformed=Transformer.fit_transform(x)

print(x_transformed.shape)

sklearn.decomposition

函数流形.LocallyLinearEmbedding( ) 局部非线性嵌入流形.Isomap( ) 流形学习流形.MDS( ) 多维缩放方法流形.t-SNE( )t 分布式随机邻域嵌入流形.SpectralEmbedding()光谱嵌入非线性降维

sklearn.manifold

图像分类模型能够从数据集中学习知识，从而提高自我识别能力。

知的一种模型，经过学习后，它能够区分出它所见过的事物；这种模型就非常类似一个识物的小朋友。

sklearn.tree

函数功能tree.DecisionTreeClassifier( )决策树决策树分类 from sklearn.datasets import load_iris from sklearn import tree x,y = load_iris(return_X_y=True) clf = tree.DecisionTreeClassifier() clf = clf.fit(x,y) tree.plot_tree(clf)

sklearn.ensemble

函数功能ensemble.BaggingClassifier()装袋法集成学习ensemble.AdaBoostClassifier( )提升法集成学习ensemble.RandomForestClassifier( )随机森林分类ensemble.ExtraTreesClassifier( )极限随机树分类ensemble.RandomTreesEmbedding( )嵌入式完全随机树ensemble.GradientBoostingClassifier( )梯度提升树ensemble.VotingClassifier( )投票分类法BaggingClassifier #使用sklearn库实现的决策树装袋法提升分类效果。其中X和Y分别是鸢尾花（iris）数据集中的自变量（花的特征）和因变量（花的类别） from sklearn.model_selection import KFold from sklearn.model_selection import cross_val_score from sklearn.ensemble import BaggingClassifier from sklearn.tree import DecisionTreeClassifier from sklearn import datasets #加载iris数据集 iris=datasets.load_iris() X=iris.data Y=iris.target #生成K折交叉验证数据 kfold=KFold(n_splits=9)

#决策树及交叉验证 cart=DecisionTreeClassifier(criterion="gini",max_depth=2) cart=cart.fit(X,Y) result=cross_val_score(cart,X,Y,cv=kfold) #采用K折交叉验证的方法来验证算法效果 print("CART数结果:",result.mean()) #装袋法及交叉验证 model=BaggingClassifier(base_estimator=cart,n_estimators=100) #n_estimators=100为建立100个分类模型 result=cross_val_score(model,X,Y,cv=kfold) #采用K折交叉验证的方法来验证算法效果 print("装袋法提升后的结果:",result.mean())AdaBoostClassifier #基于sklearn库中的提升法分类器对决策树进行优化，提高分类准确率，其中load_breast_cancer()方法加载乳腺癌数据集，自变量（细胞核的特征）和因变量（良性、恶性）分别赋给X，Y变量 from sklearn.model_selection import KFold from sklearn.model_selection import cross_val_score from sklearn.ensemble import AdaBoostClassifier from sklearn.tree import DecisionTreeClassifier from sklearn import datasets #加载数据 dataset_all=datasets.load_breast_cancer() X=dataset_all.data Y=dataset_all.target #初始化基本随机数生成器 kfold=KFold(n_splits=10) #决策树及交叉验证 dtree=DecisionTreeClassifier(criterion="gini",max_depth=3) #提升法及交叉验证 model=AdaBoostClassifier(base_estimator=dtree,n_estimators=100) result=cross_val_score(model,X,Y,cv=kfold) print("提升法改进结果:",result.mean())RandomForestClassifier 、ExtraTreesClassifier #使用sklearn库中的随机森林算法和决策树算法进行效果比较，数据集由生成器随机生成 from sklearn.model_selection import cross_val_score from sklearn.datasets import make_blobs from sklearn.ensemble import RandomForestClassifier from sklearn.ensemble import ExtraTreesClassifier from sklearn.tree import DecisionTreeClassifier import matplotlib.pyplot as plt #make_blobs:sklearn中自带的取类数据生成器随机生成测试样本，make_blobs方法中n_samples表示生成的随机数样本数量，n_features表示每个样本的特征数量，centers表示类别数量，random_state表示随机种子 x,y=make_blobs(n_samples=1000,n_features=6,centers=50,random_state=0) plt.scatter(x[:,0],x[:,1],c=y) plt.show() #构造随机森林模型 clf=RandomForestClassifier(n_estimators=10,max_depth=None,min_samples_split=2,random_state=0) #n_estimators表示弱学习器的最大迭代次数，或者说最大的弱学习器的个数。如果设置值太小，模型容易欠拟合；如果太大，计算量会较大，并且超过一定的数量后，模型提升很小 scores=cross_val_score(clf,x,y) print("RandomForestClassifier result:",scores.mean()) #构造极限森林模型 clf=ExtraTreesClassifier(n_estimators=10,max_depth=None,min_samples_split=2,random_state=0) scores=cross_val_score(clf,x,y) print("ExtraTreesClassifier result:",scores.mean()) #极限随机数的效果好于随机森林，原因在于计算分割点方法中的随机性进一步增强；相较于随机森林，其阈值是针对每个候选特征随机生成的，并且选择最佳阈值作为分割规则，这样能够减少一点模型的方程，总体上效果更好GradientBoostingClassifier import pandas as pd from sklearn.model_selection import train_test_split from sklearn.ensemble import GradientBoostingClassifier from sklearn.datasets import make_blobs #make_blobs:sklearn中自带的取类数据生成器随机生成测试样本，make_blobs方法中n_samples表示生成的随机数样本数量，n_features表示每个样本的特征数量，centers表示类别数量，random_state表示随机种子 x,y=make_blobs(n_samples=1000,n_features=6,centers=50,random_state=0) plt.scatter(x[:,0],x[:,1],c=y) plt.show() x_train, x_test, y_train, y_test = train_test_split(x,y) # 模型训练，使用GBDT算法 gbr = GradientBoostingClassifier(n_estimators=3000, max_depth=2, min_samples_split=2, learning_rate=0.1) gbr.fit(x_train, y_train.ravel()) y_gbr = gbr.predict(x_train) y_gbr1 = gbr.predict(x_test) acc_train = gbr.score(x_train, y_train) acc_test = gbr.score(x_test, y_test) print(acc_train) print(acc_test)VotingClassifier import numpy as np import matplotlib.pyplot as plt from sklearn import datasets from sklearn.ensemble import VotingClassifier from sklearn.tree import DecisionTreeClassifier from sklearn.svm import SVC from sklearn.linear_model import LogisticRegression from sklearn.model_selection import train_test_split #VotingClassifier方法是一次使用多种分类模型进行预测，将多数预测结果作为最终结果 x,y = datasets.make_moons(n_samples=500,noise=0.3,random_state=42) plt.scatter(x[y==0,0],x[y==0,1]) plt.scatter(x[y==1,0],x[y==1,1]) plt.show() x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.3) voting_hard = VotingClassifier(estimators=[ ("log_clf", LogisticRegression()), ("svm_clf", SVC()), ("dt_clf", DecisionTreeClassifier(random_state=10)),], voting="hard") voting_soft = VotingClassifier(estimators=[ ("log_clf", LogisticRegression()), ("svm_clf", SVC(probability=True)), ("dt_clf", DecisionTreeClassifier(random_state=10)), ], voting="soft") voting_hard.fit(x_train,y_train) print(voting_hard.score(x_test,y_test)) voting_soft.fit(x_train,y_train) print(voting_soft.score(x_test,y_test))

sklearn.linear_model

函数功能linear_model.LogisticRegression( )逻辑回归linear_model.Perceptron( )线性模型感知机linear_model.SGDClassifier( )具有SGD训练的线性分类器linear_model.PassiveAggressiveClassifier( )增量学习分类器LogisticRegression import numpy as np from sklearn import linear_model,datasets from sklearn.model_selection import train_test_split iris = datasets.load_iris() x = iris.data y = iris.target x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.3) logreg = linear_model.LogisticRegression(C=1e5) logreg.fit(x_train,y_train) prepro = logreg.score(x_test,y_test) print(prepro)Perceptron from sklearn.datasets import load_digits from sklearn.linear_model import Perceptron x,y = load_digits(return_X_y=True) clf = Perceptron(tol=1e-3,random_state=0) clf.fit(x,y) clf.score(x,y)SGDClassifier import numpy as np from sklearn.linear_model import SGDClassifier from sklearn.preprocessing import StandardScaler from sklearn.pipeline import make_pipeline x = np.array([[-1,-1],[-2,-1],[1,1],[2,1]]) y = np.array([1,1,2,2]) clf = make_pipeline(StandardScaler(),SGDClassifier(max_iter=1000,tol=1e-3)) clf.fit(x,y) print(clf.score(x,y)) print(clf.predict([[-0.8,-1]]))PassiveAggressiveClassifier from sklearn.linear_model import PassiveAggressiveClassifier from sklearn.datasets import make_classification from sklearn.model_selection import train_test_split x,y = make_classification(n_features=4,random_state=0) x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.3) clf = PassiveAggressiveClassifier(max_iter=1000,random_state=0,tol=1e-3) clf.fit(x_train,y_train) print(clf.score(x_test,y_test))

sklearn.svm

函数功能svm.SVC( )支持向量机分类svm.NuSVC( )Nu支持向量分类svm.LinearSVC( )线性支持向量分类SVC import numpy as np from sklearn.model_selection import GridSearchCV from sklearn.svm import SVC x = [[2,0],[1,1],[2,3]] y = [0,0,1] clf = SVC(kernel="linear") clf.fit(x,y) print(clf.predict([[2,2]]))NuSVC from sklearn import svm from numpy import * x = array([[0],[1],[2],[3]]) y = array([0,1,2,3]) clf = svm.NuSVC() clf.fit(x,y) print(clf.predict([[4]]))LinearSVC import numpy as np import matplotlib.pyplot as plt from sklearn import datasets from sklearn.svm import LinearSVC iris = datasets.load_iris() X = iris.data y = iris.target plt.scatter(X[y==0, 0], X[y==0, 1], color="red") plt.scatter(X[y==1, 0], X[y==1, 1], color="blue") plt.show() svc = LinearSVC(C=10**9) svc.fit(X, y) print(svc.score(X,y))

sklearn.neighbors

函数功能neighbors.NearestNeighbors( )无监督学习临近搜索neighbors.NearestCentroid( )最近质心分类器neighbors.KNeighborsClassifier()K近邻分类器neighbors.KDTree( )KD树搜索最近邻neighbors.KNeighborsTransformer( )数据转换为K个最近邻点的加权图NearestNeighbors import numpy as np from sklearn.neighbors import NearestNeighbors samples = [[0,0,2],[1,0,0],[0,0,1]] neigh = NearestNeighbors(n_neighbors=2,radius=0.4) neigh.fit(samples) print(neigh.kneighbors([[0,0,1.3]],2,return_distance=True)) print(neigh.radius_neighbors([[0,0,1.3]],0.4,return_distance=False))NearestCentroid

from sklearn.neighbors import NearestCentroid 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 = NearestCentroid() clf.fit(x,y) print(clf.predict([[-0.8,-1]]))KNeighborsClassifier from sklearn.neighbors import KNeighborsClassifier x,y = [[0],[1],[2],[3]],[0,0,1,1] neigh = KNeighborsClassifier(n_neighbors=3) neigh.fit(x,y) print(neigh.predict([[1.1]]))KDTree import numpy as np from sklearn.neighbors import KDTree rng = np.random.RandomState(0) x = rng.random_sample((10,3)) tree = KDTree(x,leaf_size=2) dist,ind = tree.query(x[:1],k=3) print(ind)KNeighborsClassifier from sklearn.neighbors import KNeighborsClassifier X = [[0], [1], [2], [3], [4], [5], [6], [7], [8]] y = [0, 0, 0, 1, 1, 1, 2, 2, 2] neigh = KNeighborsClassifier(n_neighbors=3) neigh.fit(X, y) print(neigh.predict([[1.1]]))

sklearn.discriminant_analysis

函数功能discriminant_analysis.LinearDiscriminantAnalysis( )线性判别分析discriminant_analysis.QuadraticDiscriminantAnalysis( )二次判别分析LDA from sklearn import datasets from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA iris = datasets.load_iris() X = iris.data[:-5] pre_x = iris.data[-5:] y = iris.target[:-5] print ("first 10 raw samples:", X[:10]) clf = LDA() clf.fit(X, y) X_r = clf.transform(X) pre_y = clf.predict(pre_x) #降维结果 print ("first 10 transformed samples:", X_r[:10]) #预测目标分类结果 print ("predict value:", pre_y)QDA from sklearn import datasets from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis as QDA from sklearn.model_selection import train_test_split iris = datasets.load_iris() x = iris.data y = iris.target x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.3) clf = QDA() clf.fit(x_train,y_train) print(clf.score(x_test,y_test))

sklearn.gaussian_process

函数功能gaussian_process.GaussianProcessClassifier( )高斯过程分类

sklearn.naive_bayes

函数功能naive_bayes.GaussianNB( )朴素贝叶斯naive_bayes.MultinomialNB( )多项式朴素贝叶斯naive_bayes.BernoulliNB( )伯努利朴素贝叶斯GaussianNB from sklearn import datasets from sklearn.naive_bayes import GaussianNB iris = datasets.load_iris() clf = GaussianNB() clf = clf.fit(iris.data,iris.target) y_pre = clf.predict(iris.data)MultinomialNB from sklearn import datasets from sklearn.naive_bayes import MultinomialNB iris = datasets.load_iris() clf = MultinomialNB() clf = clf.fit(iris.data, iris.target) y_pred=clf.predict(iris.data)BernoulliNB from sklearn import datasets from sklearn.naive_bayes import BernoulliNB iris = datasets.load_iris() clf = BernoulliNB() clf = clf.fit(iris.data, iris.target) y_pred=clf.predict(iris.data)

回归模型

image

sklearn.tree

函数功能tree.DecisionTreeRegress( )回归决策树tree.ExtraTreeRegressor( )极限回归树DecisionTreeRegressor、ExtraTreeRegressor """回归""" from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeRegressor,ExtraTreeRegressor from sklearn.metrics import r2_score,mean_squared_error,mean_absolute_error import numpy as np boston = load_boston() x = boston.data y = boston.target x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.3) dtr = DecisionTreeRegressor() dtr.fit(x_train,y_train) etr = ExtraTreeRegressor() etr.fit(x_train,y_train) yetr_pred = etr.predict(x_test) ydtr_pred = dtr.predict(x_test) print(dtr.score(x_test,y_test)) print(r2_score(y_test,ydtr_pred)) print(etr.score(x_test,y_test)) print(r2_score(y_test,yetr_pred))

sklearn.ensemble

函数功能ensemble.GradientBoostingRegressor( )梯度提升法回归ensemble.AdaBoostRegressor( )提升法回归ensemble.BaggingRegressor( )装袋法回归ensemble.ExtraTreeRegressor( )极限树回归ensemble.RandomForestRegressor( )随机森林回归GradientBoostingRegressor import numpy as np from sklearn.ensemble import GradientBoostingRegressor as GBR from sklearn.datasets import make_regression X, y = make_regression(1000, 2, noise=10) gbr = GBR() gbr.fit(X, y) gbr_preds = gbr.predict(X)AdaBoostRegressor from sklearn.ensemble import AdaBoostRegressor from sklearn.datasets import make_regression x,y = make_regression(n_features=4,n_informative=2,random_state=0,shuffle=False) regr = AdaBoostRegressor(random_state=0,n_estimators=100) regr.fit(x,y) regr.predict([[0,0,0,0]])BaggingRegressor from sklearn.ensemble import BaggingRegressor from sklearn.datasets import make_regression from sklearn.svm import SVR x,y = make_regression(n_samples=100,n_features=4,n_informative=2,n_targets=1,random_state=0,shuffle=False) br = BaggingRegressor(base_estimator=SVR(),n_estimators=10,random_state=0).fit(x,y) br.predict([[0,0,0,0]])ExtraTreesRegressor from sklearn.datasets import load_diabetes from sklearn.model_selection import train_test_split from sklearn.ensemble import ExtraTreesRegressor x,y = load_diabetes(return_X_y=True) x_train,x_test,y_train,y_test = train_test_split(X,y,random_state=0) etr = ExtraTreesRegressor(n_estimators=100,random_state=0).fit(x_train,y_train) print(etr.score(x_test,y_test))RandomForestRegressor from sklearn.ensemble import RandomForestRegressor from sklearn.datasets import make_regression x,y = make_regression(n_features=4,n_informative=2,random_state=0,shuffle=False) rfr = RandomForestRegressor(max_depth=2,random_state=0) rfr.fit(x,y) print(rfr.predict([[0,0,0,0]]))

sklearn.linear_model

函数功能linear_model.LinearRegression( )线性回归linear_model.Ridge( )岭回归linear_model.Lasso( )经L1训练后的正则化器linear_model.ElasticNet( )弹性网络linear_model.MultiTaskLasso( )多任务Lassolinear_model.MultiTaskElasticNet( )多任务弹性网络linear_model.Lars( )最小角回归linear_model.OrthogonalMatchingPursuit( )正交匹配追踪模型linear_model.BayesianRidge( )贝叶斯岭回归linear_model.ARDRegression( )贝叶斯ADA回归linear_model.SGDRegressor( )随机梯度下降回归linear_model.PassiveAggressiveRegressor( )增量学习回归linear_model.HuberRegression( )Huber回归import numpy as np from sklearn.linear_model import Ridge from sklearn.linear_model import Lasso np.random.seed(0) x = np.random.randn(10,5) y = np.random.randn(10) clf1 = Ridge(alpha=1.0) clf2 = Lasso() clf2.fit(x,y) clf1.fit(x,y) print(clf1.predict(x)) print(clf2.predict(x))

sklearn.svm

函数功能svm.SVR( )支持向量机回归svm.NuSVR( )Nu支持向量回归svm.LinearSVR( )线性支持向量回归

sklearn.neighbors

函数功能neighbors.KNeighborsRegressor( )K近邻回归neighbors.RadiusNeighborsRegressor( )基于半径的近邻回归

sklearn.kernel_ridge

函数功能kernel_ridge.KernelRidge( )内核岭回归

sklearn.gaussian_process

函数功能gaussian_process.GaussianProcessRegressor( )高斯过程回归GaussianProcessRegressor from sklearn.datasets import make_friedman2 from sklearn.gaussian_process import GaussianProcessRegressor from sklearn.gaussian_process.kernels import DotProduct,WhiteKernel x,y = make_friedman2(n_samples=500,noise=0,random_state=0) kernel = DotProduct()+WhiteKernel() gpr = GaussianProcessRegressor(kernel=kernel,random_state=0).fit(x,y) print(gpr.score(x,y))

sklearn.cross_decomposition

函数功能cross_decomposition.PLSRegression( )偏最小二乘回归import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn import datasets from sklearn.cross_decomposition import PLSRegression from sklearn.model_selection import train_test_split boston = datasets.load_boston() x = boston.data y = boston.target x_df = pd.DataFrame(x,columns=boston.feature_names) y_df = pd.DataFrame(y) pls = PLSRegression(n_components=2) x_train,x_test,y_train,y_test = train_test_split(x_df,y_df,test_size=0.3,random_state=1) pls.fit(x_train,y_train) print(pls.predict(x_test))

聚类模型

sklearn.cluster

函数功能cluster.DBSCAN( )基于密度的聚类cluster.GaussianMixtureModel( )高斯混合模型cluster.AffinityPropagation( )吸引力传播聚类cluster.AgglomerativeClustering( )层次聚类cluster.Birch( )利用层次方法的平衡迭代聚类cluster.KMeans( )K均值聚类cluster.MiniBatchKMeans( )小批量K均值聚类cluster.MeanShift( )平均移位聚类cluster.OPTICS( )基于点排序来识别聚类结构cluster.SpectralClustering( )谱聚类cluster.Biclustering( )双聚类cluster.ward_tree( )集群病房树

模型方法

方法功能xxx.fit( )模型训练xxx.get_params( )获取模型参数xxx.predict( )预测新输入数据xxx.score( )评估模型分类/回归/聚类模型xxx.set_params( )设置模型参数

模型评估

分类模型评估

函数功能metrics.accuracy_score( )准确率metrics.average_precision_score( )平均准确率metrics.log_loss( )对数损失metrics.confusion_matrix( )混淆矩阵metrics.classification_report( )分类模型评估报告:准确率、召回率、F1-scoremetrics.roc_curve( )受试者工作特性曲线metrics.auc( )ROC曲线下面积metrics.roc_auc_score( )AUC值

回归模型评估

函数功能metrics.mean_squared_error( )平均决定误差metrics.median_absolute_error( )中值绝对误差metrics.r2_score( )决定系数

聚类模型评估

函数功能metrics.adjusted_rand_score( )随机兰德调整指数metrics.silhouette_score( )轮廓系数

模型优化

函数功能model_selection.cross_val_score( )交叉验证model_selection.LeaveOneOut( )留一法model_selection.LeavePout( )留P法交叉验证model_selection.GridSearchCV( )网格搜索model_selection.RandomizedSearchCV( )随机搜索model_selection.validation_curve( )验证曲线model_selection.learning_curve( )学习曲线