机器学习---sklearn

1.Sklearn简介

sklearn (全称 Scikit-Learn) 是基于 python 语言的机器学习工具,Sklea是处理机器学习 (有监督学习和无监督学习) 的包。它建立在 NumPy, SciPy, pandas 和 Matplotlib 之上，其主要集成了数据预处理、数据特征选择，sklearn有六个任务模块和一个数据引入模块：

• 有监督学习的分类任务
• 有监督学习的回归任务
• 无监督学习的聚类任务
• 无监督学习的降维任务
• 数据预处理任务
• 模型选择任务
• 数据引入

具体流程如下：
下载 sklearn。

// 已经下载过Anacondaconda install scikit-learn

2.Sklearn数据

2.1 数据格式

在 Sklean 里，模型能即用的数据有两种形式：

1. Numpy 二维数组 (ndarray) 的稠密数据 (dense data)，通常都是这种格式。
2. SciPy 矩阵 (scipy.sparse.matrix) 的稀疏数据 (sparse data)，比如文本分析每个单词 (字典有 100000 个词) 做独热编码得到矩阵有很多 0，这时用 ndarray 就不合适了，太耗内存。
   上述数据在机器学习中通常用符号 X 表示，是模型自变量。它的大小 = [样本数, 特征数]，有监督学习除了需要特征 X 还需要标签 y，而 y 通常就是 Numpy 一维数组，无监督学习没有 y。

2.2 自带数据集

引入数据集的方法：

1. 获取小数据：load_dataname
2. 获取大数据：fetch_dataname
3. 构造随机数据：make_dataname

Load一个数字小数据集 digits

digits=datasets.load_digits()digits.keys()

Fetch 一个加州房屋大数据集 california_housing

housing=datasets.fetch_california_housing()housing.keys()

Make 一个高斯分位数数据集 gaussian_quantile

gaussian=datasets.make_gaussian_quantiles()type(gaussian),len(gaussian)

引入数据集的两种代码：

from sklearn import datasets#使用数据集时,以鸢尾花数据集为例iris=datasets.load_iris()

from sklearn.datasets import load_iris#使用数据集时,以鸢尾花数据集为例iris=load_iris()iris.keys()#结果dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename'])

键里面的名称解释如下：

data：特征值 (数组)target：标签值 (数组)target_names：标签 (列表)DESCR：数据集描述feature_names：特征 (列表)filename：iris.csv 文件路径

将数据集转换为DataFram:

import pandas as pdiris_data=pd.DataFrame(iris.data,                      columns=iris.feature_names)iris_data['species']=iris.target_names[iris.target]iris_data.head(3).append(iris_data.tail(3))

可视化seaborn

import seaborn as snssns.pairplot(iris_data,hue='species',palette='husl')

3.核心api

三大API：
1.估计器(estimator) ：拟合器（fitter）可把它当成一个模型 (用来回归、分类、聚类、降维)。
2. 预测器 (predictor) 是具有预测功能的估计器
3.转换器 (transfORMer) 是具有转换功能的估计器

3.1 估计器

定义：任何可以基于数据集对一些参数进行估计的对象都被称为估计器
拟合估计器:在有监督学习中的代码范式为

model.fit( X_train, y_train )

在无监督学习中的代码范式为

model.fit( X_train )

拟合之后可以访问 model 里学到的参数，比如线性回归里的特征前的系数 coef_，或 K 均值里聚类标签 labels_。

model.coef_model.labels_

线性回归

from sklearn.linear_model import LinearRegressionmodel=LinearRegression(normalize=True)model

创建一个简单的数据集

import matplotlib.pyplot as pltx=np.arange(10)y=2*x+1plt.plot(x,y,'o')X=x[:,np.newaxis] #Sklearn 里模型要求特征 X 是个两维变量么 (样本数×特征数),但在本例中 X 是一维，因为我们用 np.newaxis 加一个维度，就是把一维 [1, 2, 3] 转成 [[1],[2],[3]]model.fit(X,y)print(model.coef_)print(model.intercept_)

K均值

from sklearn.cluster import KMeansmodel=KMeans(n_clusters=3)X=iris.data[:,0:2]model.fit(X)print(model.cluster_centers_,'\n')print(model.labels_,'\n')print(model.inertia_,'\n')print(iris.target)

解释一下 KMeans 模型这几个参数：
model.cluster_centers_：簇中心。三个簇那么有三个坐标。

model.labels_：聚类后的标签model.inertia_：所有点到对应的簇中心的距离平方和 (越小越好)

左图是根据聚类得到的标签画出散点图，而右图是根据真实标签画出散点图，对比两幅图看很像，聚类的效果还不错。

from  matplotlib.colors import ListedColormapcmap_light=ListedColormap(['#FFAAAA','#AAFFAA','#AAAAFF'])cmap_bold1=ListedColormap(['#FFAAAA','#AAFFAA','#AAAAFF'])cmap_bold2=ListedColormap(['#FFAAAA','#AAFFAA','#AAAAFF'])centroid=model.cluster_centers_label=iris.targettrue_centroid=np.vstack((X[label==0,:].mean(axis=0),                         X[label==1,:].mean(axis=0),                         X[label==2,:].mean(axis=0)))plt.figure(figsize=(12,6))plt.subplot(1,2,1)plt.scatter(X[:,0],X[:,1],c=model.labels_,cmap=cmap_bold1)plt.scatter(centroid[:,0],centroid[:,1],marker='o',s=200,            edgecolors='k',c=[0,1,2],cmap=cmap_light)plt.xlabel('sepal length')plt.ylabel('sepal width')plt.title('Cluster class')plt.subplot(1,2,2)plt.scatter(X[:,0],X[:,1],c=model.labels_,cmap=cmap_bold2)plt.scatter(centroid[:,0],centroid[:,1],marker='o',s=200,            edgecolors='k',c=[0,1,2],cmap=cmap_light)plt.xlabel('sepal length')plt.ylabel('sepal width')plt.title('Cluster class')plt.show()

3.2 预测器

最常见的就是 predict() 函数：

• model.predict(X_test)：评估模型在新数据上的表现
• model.predict(X_train)：确认模型在老数据上的表现
  做预测之前，将数据分为8:2的的训练集 (X_train, y_train) 和测试集 (X_test, y_test)，用从训练集上拟合 fit() 的模型在测试集上预测 predict()。

from sklearn.datasets import load_irisfrom sklearn.model_selection import train_test_splitiris=load_iris()x_train,x_text,y_train,y_test=train_test_split(iris['data'],iris['target'],                  test_size=0.2)print(x_train.shape)print(y_train.shape)print(x_text.shape)print(y_test.shape)

监督学习的对率回顾。

from sklearn.linear_model import LoGISticRegressionmodel=LogisticRegression(solver='lbfgs',multi_class='multinomial')model.fit(x_train,y_train)y_pred=model.predict(x_text)p_pred=model.predict_proba(x_text)print(y_test,'\n')print(y_pred,'\n')print(p_pred,'\n')

其中predict & predict_proba，前者是预测的类别，后者是只预测的准确度

预测器里还有额外的两个函数可以使用。在分类问题中

• score() 返回的是分类准确率
• decision_function() 返回的是每个样例在每个类下的分数值
  监督学习的K均值。

from sklearn.cluster import KMeansmodel=KMeans(n_clusters=3)model.fit(x_train[:,0:2])pred=model.predict(x_text[:,0:2])print(pred)print(y_test)model.score(x_text[:,0:2])

以上例子是以有监督学习的 LinearRegression 和无监督学习的 KMeans 举例，在实际应用时可以替换成其他模型。使用的通用伪代码如下
有监督学习。

#有监督学习from sklearn.xxx import SomeModel#xxx 可以是 linear_model 或 ensemble 等model = SomeModel( hyperparameter )model.fit( X, y )y_pred = model.predict( X_new )s = model.score( X_new )

无监督学习。

from sklearn.xxx import SomeModel# xxx 可以是 cluster 或 decomposition 等model = SomeModel( hyperparameter )model.fit( X )idx_pred = model.predict( X_new )s = model.score( X_new )

3.3 转换器

定义：转换器也是一种估计器，两者都带拟合功能，但估计器做完拟合来预测，而转换器做完拟合来转换
估计器里：fit+predict
转换器：fit+transform
preprocessing.scale( ) 标准化
preprocessing.MinMaxScaler( ) 最大最小值标准化
preprocessing.StandardScaler( ) 数据标准化
preprocessing.MaxAbsScaler( ) 绝对值最大标准化
preprocessing.RobustScaler( ) 带离群值数据集标准化
preprocessing.QuantileTransformer( ) 使用分位数信息变换特征
preprocessing.PowerTransformer( ) 使用幂变换执行到正态分布的映射
preprocessing.Normalizer( ) 正则化
preprocessing.OrdinalEncoder( ) 将分类特征转换为分类数值
preprocessing.LabelEncoder( ) 将分类特征转换为分类数值
preprocessing.MultiLabelBinarizer( ) 多标签二值化
preprocessing.OneHotEncoder( ) 独热编码
preprocessing.KBinsDiscretizer( ) 将连续数据离散化
preprocessing.FunctionTransformer( ) 自定义特征处理函数
preprocessing.Binarizer( ) 特征二值化
preprocessing.PolynomialFeatures( ) 创建多项式特征
preprocesssing.Normalizer( ) 正则化
preprocessing.Imputer( ) 弥补缺失值
下面展示一些 预处理代码。

import numpy as npfrom sklearn import preprocessing#标准化x=np.array([[1,-1,2],[2,0,0],[0,1,-1]])x_scale=preprocessing.scale(x)print(x_scale)print(x_scale.mean(axis=0),x_scale.std(axis=0))

上述preprocessing类函数的方法如下：
name.fit( ) 拟合数据
name.fit_transform( ) 拟合并转换数据
name.get_params( ) 获取函数参数
name.inverse_transform( ) 逆转换
name.set_params( ) 设置参数
name.transform( ) 转换数据

本文主要介绍两大类转换器

1. 将分类型变量 (cateGorical) 编码成数值型变量 (numerical)
2. 规范化 (normalize) 或标准化 (standardize) 数值型变量
   分类型变量编码
   LabelEncoder 和 OrdinalEncoder 都可以将字符转成数字，但是

• LabelEncoder 的输入是一维，比如 1d ndarray
• OrdinalEncoder 的输入是二维，比如 DataFrame

enc = ['win','draw','lose','win']dec = ['draw','draw','win']from sklearn.preprocessing import LabelEncoderle=LabelEncoder()print(le.fit(enc))print(le.classes_)print(le.transform(dec))

OrdinalEncoder

from sklearn.preprocessing import OrdinalEncoderoe=OrdinalEncoder()enc_df=pd.DataFrame(enc)dec_df=pd.DataFrame(dec)print(oe.fit(enc_df))print(oe.categories_)print(oe.transform(dec_df))

独热编码是把一个整数用向量的形式表现。转化器OneHotEncoder可以接受两种类型的输入：
1）用 LabelEncoder 编码好的一维数组 (元素为整数)，重塑 (用 reshape(-1,1)) 成二维数组作为 OneHotEncoder 输入。
转化独热编码。

from sklearn.preprocessing import OneHotEncoderohe=OneHotEncoder()num=le.fit_transform(enc)print(num)#打印编码结果[2 0 1 2]ohe_y=ohe.fit_transform(num.reshape(-1,1))#将其转成独热形式，输出是一个「稀疏矩阵」形式，因为实操中通常类别很多，因此就一步到位用稀疏矩阵来节省内存ohe_y

2） DataFrame作为 OneHotEncoder 输入。
转化独热编码。

ohe=OneHotEncoder()ohe.fit_transform(enc_df).toarray()

特征缩放数据要做的最重要的转换之一是特征缩放 (feature scaling)。当输入的数值的量刚不同时，机器学习算法的性能都不会好。
具体来说，对于某个特征，有两种方法：

• 规范化 (normalization)：每个维度的特征减去该特征最小值，除以该特征的最大值与最小值之差。将数据缩放到0和1之间，用MinMaxScaler函数.
• 标准化 (standardization)：每个维度的特征减去该特征均值，除以该维度的标准差。将数据缩放到以0位中心而分散为1的区间，使用StandardScaler函数
  MinMaxScaler。

from sklearn.preprocessing import MinMaxScalerx=np.array([0,0.5,1,1.5,2,100])x_scale=MinMaxScaler().fit_transform(x.reshape(-1,1))x_scale

StandardScaler。

from sklearn.preprocessing import StandardScalerx_scale=StandardScaler().fit_transform(x.reshape(-1,1))x_scale

4.分类模型

Sklearn.tree	功能
tree.DecisionTreeClassifier	决策树

决策树。

from sklearn.datasets import load_irisfrom sklearn import treefrom sklearn.tree import DecisionTreeClassifierx,y=load_iris(return_X_y=True)clf=DecisionTreeClassifier()clf=clf.fit(x,y)tree.plot_tree(clf)

Ensemble 估计器是用来做集成学习，该估计器里面有若干个分类器 (classifier) 或回归器 (regressor)。其中分类器统计每个子分类器的预测类别数，再用「多数投票」原则得到最终预测。

Sklearn.ensemble	功能
BagginGClassifier()	装袋法集成学习
AdaBoostClassifier( )	提升法集成学习
RandomForestClassifier( )	随机森林分类
ExtraTreesClassifier( )	极限随机树分类
RandomTreesEmbedding( )	嵌入式完全随机树
GradientBoostingClassifier( )	梯度提升树
VotingClassifier( )	投票分类法

BaggingClassifier()。

#使用sklearn库实现的决策树装袋法提升分类效果。其中X和Y分别是鸢尾花（iris）数据集中的自变量（花的特征）和因变量（花的类别）from sklearn.model_selection import KFoldfrom sklearn.model_selection import cross_val_scorefrom sklearn.ensemble import BaggingClassifierfrom sklearn.tree import DecisionTreeClassifierfrom sklearn import datasets#加载iris数据集iris=datasets.load_iris()X=iris.dataY=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())

Sklearn.linear_model	功能
LogisticRegression( )	逻辑回归
Perceptron( )	线性模型感知机
SGDClassifier( )	具有SGD训练的线性分类器
PassiveAggressiveClassifier( )	增量学习分类器

Sklearn.svm	功能
svm.SVC( )	支持向量机分类
svm.NuSVC( )	Nu支持向量分类
svm.LinearSVC( )	线性支持向量分类

Sklearn.naive_bayes	功能
naive_bayes.GaussianNB( )	朴素贝叶斯
naive_bayes.MultinomialNB( )	多项式朴素贝叶斯
naive_bayes.BernoulliNB( )	伯努利朴素贝叶斯

5.回归模型

GradientBoostingRegressor。

import numpy as npfrom sklearn.ensemble import GradientBoostingRegressor as GBRfrom sklearn.datasets import make_regressionX, y = make_regression(1000, 2, noise=10)#make_regression函数能生成回归样本数据。样本数100，参与的特征2gbr = GBR()gbr.fit(X, y)gbr_preds = gbr.predict(X);

6.超参数调节

超参数的优化或调整是为学习算法选择一组最佳超参数的问题。

6.1 手动调参

在传统调优中，我们通过训练算法来手动检查随机的超参数集，并选择适合我们目标的最佳参数集。

from sklearn.neighbors import KNeighborsClassifierfrom sklearn.model_selection import train_test_splitfrom sklearn.model_selection import KFold , cross_val_scorefrom sklearn.datasets import load_winewine = load_wine()X = wine.datay = wine.target#划分训练集和测试集X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.3,random_state = 14)#声明参数范围k_value = list(range(2,11))algorithm = ['auto','ball_tree','kd_tree','brute']scores = []best_comb = []kfold = KFold(n_splits=5)#超参数循环找最优for algo in algorithm:  for k in k_value:    knn = KNeighborsClassifier(n_neighbors=k,algorithm=algo)    results = cross_val_score(knn,X_train,y_train,cv = kfold)    print(f'Score:{round(results.mean(),4)} with algo = {algo} , K = {k}')    scores.append(results.mean())    best_comb.append((k,algo))best_param = best_comb[scores.index(max(scores))]print(f'\nThe Best Score : {max(scores)}')print(f"['algorithm': {best_param[1]} ,'n_neighbors': {best_param[0]}]")

6.1 网格搜索

网格搜索是一种基本的超参数调整技术。它类似于手动调整，在手动调整中，它为网格中指定的所有给定超参数集合构建一个模型，评估并选择最佳模型。考虑上面的示例，它有两个超参数 k_value = [2,3,4,5,6,7,8,9,10]＆algorithm = [‘auto’，‘ball_tree’，‘kd_tree’，‘brute’] ，在这种情况下，它总共构建了 9 * 4 = 36 个不同的模型。官方文档：网格搜索

from sklearn.model_selection import RandomizedSearchCVknn = KNeighborsClassifier()grid_param = { 'n_neighbors' : list(range(2,11)) ,               'algorithm' : ['auto','ball_tree','kd_tree','brute'] }rand_ser = RandomizedSearchCV(knn,grid_param,n_iter=10)rand_ser.fit(X_train,y_train)#best parameter combinationprint(rand_ser.best_params_)#score achieved with best parameter combinationprint(rand_ser.best_score_)

6.3随机搜索

随机搜索代替网格搜索的动机是，在许多情况下，所有超参数可能都没有同等重要。随机搜索从超参数空间中选择参数的随机组合，参数将以 n_iter 给出的固定迭代次数进行选择。一般情况下，随机搜索比网格搜索可提供更好的结果。
官方文档：随机搜索

from sklearn.model_selection import RandomizedSearchCVknn = KNeighborsClassifier()grid_param = { 'n_neighbors' : list(range(2,11)) ,               'algorithm' : ['auto','ball_tree','kd_tree','brute'] }rand_ser = RandomizedSearchCV(knn,grid_param,n_iter=10)rand_ser.fit(X_train,y_train)rand_ser.best_params_rand_ser.best_score_

来源地址：https://blog.csdn.net/weixin_44838881/article/details/124836755