登录 |  注册 |  繁體中文


sklearn库学习

分类: 人工智能&大数据 颜色:橙色 默认  字号: 阅读(14) | 评论(0)

1.主要功能如下:

1.classification分类
2.Regression回归
3.Clustering聚类
4.Dimensionality reduction降维
5.Model selection模型选择
6.Preprocessing预处理

2.主要模块分类:

1.sklearn.base: Base classes and utility function基础实用函数
2.sklearn.cluster: Clustering聚类
3.sklearn.cluster.bicluster: Biclustering 双向聚类
4.sklearn.covariance: Covariance Estimators 协方差估计
5.sklearn.model_selection: Model Selection 模型选择
6.sklearn.datasets: Datasets 数据集
7.sklearn.decomposition: Matrix Decomposition 矩阵分解
8.sklearn.dummy: Dummy estimators 虚拟估计
9.sklearn.ensemble: Ensemble Methods 集成方法
10.sklearn.exceptions: Exceptions and warnings 异常和警告
11.sklearn.feature_extraction: Feature Extraction 特征抽取
12.sklearn.feature_selection: Feature Selection 特征选择
13。sklearn.gaussian_process: Gaussian Processes 高斯过程
14.sklearn.isotonic: Isotonic regression 保序回归
15.sklearn.kernel_approximation: Kernel Approximation 核 逼近
16.sklearn.kernel_ridge: Kernel Ridge Regression 岭回归ridge
17.sklearn.discriminant_analysis: Discriminant Analysis 判别分析
18.sklearn.linear_model: Generalized Linear Models 广义线性模型
19.sklearn.manifold: Manifold Learning 流形学习
20.sklearn.metrics: Metrics 度量 权值
21.sklearn.mixture: Gaussian Mixture Models 高斯混合模型
22.sklearn.multiclass: Multiclass and multilabel classification 多等级标签分类
23.sklearn.multioutput: Multioutput regression and classification 多元回归和分类
24.sklearn.naive_bayes: Naive Bayes 朴素贝叶斯
25.sklearn.neighbors: Nearest Neighbors 最近邻
26.sklearn.neural_network: Neural network models 神经网络
27.sklearn.calibration: Probability Calibration 概率校准
28.sklearn.cross_decomposition: Cross decomposition 交叉求解
29.sklearn.pipeline: Pipeline 管道
30.sklearn.preprocessing: Preprocessing and Normalization 预处理和标准化
31.sklearn.random_projection: Random projection 随机映射
32.sklearn.semi_supervised: Semi-Supervised Learning 半监督学习
33.sklearn.svm: Support Vector Machines 支持向量机
34.sklearn.tree: Decision Tree 决策树
35.sklearn.utils: Utilities 实用工具

3  快速使用

传统的机器学习任务从开始到建模的一般流程就是:获取数据——》数据预处理——》训练模型——》模型评估——》预测,分类。本次我们将根据传统机器学习的流程,看看在每一步流程中都有哪些常用的函数以及他们的用法是怎么样的。那么首先先看一个简单的例子:
     鸢尾花识别是一个经典的机器学习分类问题,它的数据样本中包括了4个特征变量,1个类别变量,样本总数为150。
 
  它的目标是为了根据花萼长度(sepal length)、花萼宽度(sepal width)、花瓣长度(petal length)、花瓣宽度(petal width)这四个特征来识别出鸢尾花属于山鸢尾(iris-setosa)、变色鸢尾(iris-versicolor)和维吉尼亚鸢尾(iris-virginica)中的哪一种。
# 引入数据集,sklearn包含众多数据集
from sklearn import datasets
# 将数据分为测试集和训练集
from sklearn.model_selection import train_test_split
# 利用邻近点方式训练数据
from sklearn.neighbors import KNeighborsClassifier

# 引入数据,本次导入鸢尾花数据,iris数据包含4个特征变量
iris = datasets.load_iris()
# 特征变量
iris_X = iris.data
# print(iris_X)
print(特征变量的长度,len(iris_X))
# 目标值
iris_y = iris.target
print(鸢尾花的目标值,iris_y)
# 利用train_test_split进行训练集和测试机进行分开,test_size占30%
X_train,X_test,y_train,y_test=train_test_split(iris_X,iris_y,test_size=0.3)
# 我们看到训练数据的特征值分为3类
# print(y_train)

[1 1 0 2 0 0 0 2 2 2 1 0 2 0 2 1 0 1 0 2 0 1 0 0 2 1 2 0 0 1 0 0 1 0 0 0 0
 2 2 2 1 1 1 2 0 2 0 1 1 1 1 2 2 1 2 2 2 0 2 2 2 0 1 0 1 0 0 1 2 2 2 1 1 1
 2 0 0 1 0 2 1 2 0 1 2 2 2 1 2 1 0 0 1 0 0 1 1 1 0 2 1 1 0 2 2]
 
# 训练数据
# 引入训练方法
knn = KNeighborsClassifier()
# 进行填充测试数据进行训练
knn.fit(X_train,y_train)

params = knn.get_params()
print(params)

{algorithm: auto, leaf_size: 30, metric: minkowski,
 metric_params: None, n_jobs: None, n_neighbors: 5, 
 p: 2, weights: uniform}



score = knn.score(X_test,y_test)
print("预测得分为:%s"%score)

预测得分为:0.9555555555555556
[1 2 1 1 2 2 1 0 0 0 0 1 2 0 1 0 2 0 0 0 2 2 0 2 2 2 2 1 2 2 2 1 2 2 1 2 0
 2 1 2 1 1 0 2 1]
[1 2 1 1 2 2 1 0 0 0 0 1 2 0 1 0 2 0 0 0 1 2 0 2 2 2 2 1 1 2 2 1 2 2 1 2 0
 2 1 2 1 1 0 2 1]


# 预测数据,预测特征值
print(knn.predict(X_test))

[0 2 2 2 2 0 0 0 0 2 2 0 2 0 2 1 2 0 2 1 0 2 1 0 1 2 2 0 2 1 0 2 1 1 2 0 2
 1 2 0 2 1 0 1 2]

# 打印真实特征值
print(y_test)

[1 2 2 2 2 1 1 1 1 2 1 1 1 1 2 1 1 0 2 1 1 1 0 2 0 2 0 0 2 0 2 0 2 0 2 2 0
 2 2 0 1 0 2 0 0]


下面,我们开始一步步介绍

 

4. 获取数据

4.1 导入sklearn数据集
  sklearn中包含了大量的优质的数据集,在你学习机器学习的过程中,你可以通过使用这些数据集实现出不同的模型,从而提高你的动手实践能力,同时这个过程也可以加深你对理论知识的理解和把握。 
 
首先呢,要想使用sklearn中的数据集,必须导入datasets模块:
	from sklearn import datasets
 
上图中包含了大部分sklearn中数据集,调用方式也在图中给出,这里我们拿iris的数据来举个例子:
iris = datasets.load_iris() # 导入数据集
X = iris.data # 获得其特征向量
y = iris.target # 获得样本label

3.2 创建数据集

  你除了可以使用sklearn自带的数据集,还可以自己去创建训练样本,具体用法参见《Dataset loading utilities》,这里我们简单介绍一些,sklearn中的samples generator包含的大量创建样本数据的方法,下面我们拿分类问题的样本生成器举例子:
from sklearn.datasets.samples_generator import make_classification

X, y = make_classification(n_samples=6, n_features=5, n_informative=2, 
    n_redundant=2, n_classes=2, n_clusters_per_class=2, scale=1.0, 
    random_state=20)

# n_samples:指定样本数
# n_features:指定特征数
# n_classes:指定几分类
# random_state:随机种子,使得随机状可重

5.数据预处理:

4.1 标准化处理函数

标准化:在机器学习中,我们可能要处理不同种类的资料,例如,音讯和图片上的像素值,这些资料可能是高纬度的,资料标准化后会使得每个特征中的数值平均变为0(将每个特征的值都减掉原始资料中该特征的平均),标准差变为1,这个方法被广泛的使用在许多机器学习算法中(例如:支持向量机,逻辑回归和类神经网络)。
 
  StandardScaler计算训练集的平均值和标准差,以便测试数据及使用相同的变换。
 
  变换后各维特征有0均值,单位方差,也叫z-score规范化(零均值规范化),计算方式是将特征值减去均值,除以标准差。
from sklearn import preprocessing 
		
	 
#将数据转化为标准正态分布(均值为0,方差为1)
preprocessing.scale(X,axis=0, with_mean=True, with_std=True, copy=True) 
	 
#将数据在缩放在固定区间,默认缩放到区间 [0, 1]
preprocessing.minmax_scale(X,feature_range=(0, 1), axis=0, copy=True) 
	 
#数据的缩放比例为绝对值最大值,并保留正负号,即在区间 [-1.0, 1.0] 内。唯一可用于稀疏数据 scipy.sparse的标准化 
preprocessing.maxabs_scale(X,axis=0, copy=True) 
	 
#通过 Interquartile Range (IQR) 标准化数据,即四分之一和四分之三分位点之间 
preprocessing.robust_scale(X,axis=0, with_centering=True, with_scaling=True,copy=True) 

4.2 标准化正态分布类

基于mean和std的标准化

 classpreprocessing.StandardScaler(copy=True, with_mean=True,with_std=True)
 # 属性:
 # scale_:ndarray,缩放比例
 # mean_:ndarray,均值
 # var_:ndarray,方差
 # n_samples_seen_:int,已处理的样本个数,调用partial_fit()时会累加,调用fit()会重设
 # 这里可以根据训练集进行标准化,测试集沿用训练集的标准化方法!
 scaler = preprocessing.StandardScaler().fit(train_data)
 scaler.transform(train_data)
 scaler.transform(test_data)
 # 将每个特征值归一化到一个固定范围
 scaler = preprocessing.MinMaxScaler(feature_range=(0, 1)).fit(train_data)
 scaler.transform(train_data)
 scaler.transform(test_data)

将数据在缩放在固定区间的类,默认缩放到区间 [0, 1]

classpreprocessing.MinMaxScaler(feature_range=(0, 1),copy=True):
 # 属性:
 # min_:ndarray,缩放后的最小值偏移量
 # scale_:ndarray,缩放比例
 # data_min_:ndarray,数据最小值
 # data_max_:ndarray,数据最大值
 # data_range_:ndarray,数据最大最小范围的长度

数据的缩放比例为绝对值最大值,并保留正负号,即在区间 [-1.0, 1.0] 内。可以用于稀疏数据scipy.sparse

classpreprocessing.MaxAbsScaler(copy=True):
 # 属性:
 # scale_:ndarray,缩放比例
 # max_abs_:ndarray,绝对值最大值
 # n_samples_seen_:int,已处理的样本个数

通过 Interquartile Range (IQR) 标准化数据,即四分之一和四分之三分位点之间

classpreprocessing.RobustScaler(with_centering=True,with_scaling=True, copy=True):
 # 属性:
 # center_:ndarray,中心点
 # scale_:ndarray,缩放比例

生成 kernel 矩阵,用于将 svm kernel 的数据标准化

classpreprocessing.KernelCenterer:

以上几个标准化类的方法:

fit(X[,y]):根据数据 X 的值,设置标准化缩放的比例
transform(X[,y, copy]):用之前设置的比例标准化 X
fit_transform(X[, y]):根据 X设置标准化缩放比例并标准化
partial_fit(X[,y]):累加性的计算缩放比例
inverse_transform(X[,copy]):将标准化后的数据转换成原数据比例
get_params([deep]):获取参数
set_params(**params):设置参数

正则化

# 计算两个样本的相似度时必不可少的一个操作,就是正则化。其思想是:首先求出样本的p-范数,然后该样本的所有元素都要除以该范数,这样最终使得每个样本的范数都为1。
# L1 norm 是指对每个样本的每一个元素都除以该样本的L1范数. 使行和为1

 # eg. 0.47619048 = 10 /(10+4+5+2)
 X = np.array([[10,4,5,2], [1,4,5,7]])
 X_normalized = preprocessing.normalize(X, norm='l1')
 X_normalized          
 array([[ 0.47619048, 0.19047619, 0.23809524, 0.0952381 ],
   [ 0.05882353, 0.23529412, 0.29411765, 0.41176471]])

 #L2 norm 是指对每个样本的每一个元素都除以该样本的L2范数. 
 # eg. 0.4 = 1/sqrt(1+1+4)
 X = [[ 1., -1., 2.],
   [ 2., 0., 0.],
   [ 0., 1., -1.]]
 X_normalized = preprocessing.normalize(X, norm='l2')

 X_normalized          
 array([[ 0.40, -0.40, 0.81],
   [ 1. , 0. , 0. ],
   [ 0. , 0.70, -0.70]])

6.数据集:

将数据集分为训练集和测试集

from sklearn.mode_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# arrays:样本数组,包含特征向量和标签

# test_size:
#  float-获得多大比重的测试样本 (默认:0.25)
#  int - 获得多少个测试样本
# train_size: 同test_size

# random_state: int - 随机种子(种子固定,实验可复现)
  
# shuffle - 是否在分割之前对数据进行洗牌(默认True)

7.模型选择:

模型流程:

# 拟合模型
model.fit(X_train, y_train)

# 模型预测
model.predict(X_test)

# 获得这个模型的参数
model.get_params()

# 为模型进行打分
model.score(data_X, data_y) 

线性回归

from sklearn.linear_model import LinearRegression
 # 定义线性回归模型
 model = LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1)
 """
 fit_intercept:是否计算截距。False-模型没有截距

 normalize: 当fit_intercept设置为False时,该参数将被忽略。 如果为真,则回归前的回归系数X将通过减去平均值并除以l2-范数而归一化。

  n_jobs:指定线程数
 """

逻辑回归

from sklearn.linear_model import LogisticRegression
 # 定义逻辑回归模型
 model = LogisticRegression(penalty='l2', dual=False, tol=0.0001, C=1.0, 
  fit_intercept=True, intercept_scaling=1, class_weight=None, 
  random_state=None, solver='liblinear', max_iter=100, multi_class='ovr', 
  verbose=0, warm_start=False, n_jobs=1)

 """
  penalty:使用指定正则化项(默认:l2)
  dual: n_samples > n_features取False(默认)
  C:正则化强度的反,值越小正则化强度越大
  n_jobs: 指定线程数
  random_state:随机数生成器
  fit_intercept: 是否需要常量
 """

朴素贝叶斯

from sklearn import naive_bayes
 model = naive_bayes.GaussianNB() 
 model = naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)
 model = naive_bayes.BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None)
 """

  alpha:平滑参数
  fit_prior:是否要学习类的先验概率;false-使用统一的先验概率
  class_prior: 是否指定类的先验概率;若指定则不能根据参数调整
  binarize: 二值化的阈值,若为None,则假设输入由二进制向量组成
 """

决策树

from sklearn import tree 
 model = tree.DecisionTreeClassifier(criterion='gini', max_depth=None, 
  min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, 
  max_features=None, random_state=None, max_leaf_nodes=None, 
  min_impurity_decrease=0.0, min_impurity_split=None,
   class_weight=None, presort=False)
 """
  criterion :特征选择准则gini/entropy
  max_depth:树的最大深度,None-尽量下分
  min_samples_split:分裂内部节点,所需要的最小样本树
  min_samples_leaf:叶子节点所需要的最小样本数
  max_features: 寻找最优分割点时的最大特征数
  max_leaf_nodes:优先增长到最大叶子节点数
  min_impurity_decrease:如果这种分离导致杂质的减少大于或等于这个值,则节点将被拆分。
 """

支持向量机SVM

 from sklearn.svm import SVC
 model = SVC(C=1.0, kernel='rbf', gamma='auto')
 """
  C:误差项的惩罚参数C
  gamma: 核相关系数。浮点数,If gamma is ‘auto' then 1/n_features will be used instead.
 """

knn最近邻算法

 from sklearn import neighbors
 #定义kNN分类模型
 model = neighbors.KNeighborsClassifier(n_neighbors=5, n_jobs=1) # 分类
 model = neighbors.KNeighborsRegressor(n_neighbors=5, n_jobs=1) # 回归
 """
  n_neighbors: 使用邻居的数目
  n_jobs:并行任务数
 """

多层感知器

 from sklearn.neural_network import MLPClassifier
 # 定义多层感知机分类算法
 model = MLPClassifier(activation='relu', solver='adam', alpha=0.0001)
 """
  hidden_layer_sizes: 元祖
  activation:激活函数
  solver :优化算法{‘lbfgs', ‘sgd', ‘adam'}
  alpha:L2惩罚(正则化项)参数。
 """
8 模型评估与选择

  评价指标针对不同的机器学习任务有不同的指标,同一任务也有不同侧重点的评价指标。以下方法,sklearn中都在sklearn.metrics类下,务必记住那些指标适合分类,那些适合回归

8.1 交叉验证

 from sklearn.model_selection import cross_val_score
 cross_val_score(model, X, y=None, scoring=None, cv=None, n_jobs=1)
 """
  model:拟合数据的模型
  cv : k-fold
  scoring: 打分参数-‘accuracy'、‘f1'、‘precision'、‘recall' 、‘roc_auc'、'neg_log_loss'等等
 """

检验曲线

from sklearn.model_selection import validation_curve
 train_score, test_score = validation_curve(model, X, y, param_name, param_range, cv=None, scoring=None, n_jobs=1)
 """
  model:用于fit和predict的对象
  X, y: 训练集的特征和标签
  param_name:将被改变的参数的名字
  param_range: 参数的改变范围
  cv:k-fold

 """
 

8. 模型评分

  1,模型的score方法:最简单的模型评估方法就是调用模型自己的方法:
# 预测
y_predict = knnClf.predict(x_test)
print("score on the testdata:",knnClf.score(x_test,y_test))
  2,sklearn的指标函数:库提供的一些计算方法,常用的有classification_report方法
 

9.模型保存:

 

 # 保存为pickle文件
 import pickle

 # 保存模型
 with open('model.pickle', 'wb') as f:
  pickle.dump(model, f)

 # 读取模型
 with open('model.pickle', 'rb') as f:
  model = pickle.load(f)
 model.predict(X_test)

 # sklearn自带方法joblib
 from sklearn.externals import joblib
 # 保存模型
 joblib.dump(model, 'model.pickle')
 #载入模型
 model = joblib.load('model.pickle')

 




姓 名: *
邮 箱:
内 容: *
验证码: 点击刷新 *   

回到顶部