获取数据

导入sklearn数据集

sklearn中包含了大量的优质的数据集，在你学习机器学习的过程中，你可以通过使用这些数据集实现出不同的模型，从而提高你的动手实践能力，同时这个过程也可以加深你对理论知识的理解和把握。

  1. #要想使用sklearn中的数据集，必须导入datasets模块：
  2. from sklearn import datasets 
  3. iris = datasets.load_iris() # 导入数据集
  4. X = iris.data # 获得其特征向量
  5. y = iris.target # 获得样本label

创建数据集

除了可以使用sklearn自带的数据集，还可以自己去创建训练样本，下面我们拿分类问题的样本生成器举例子：

  1. from sklearn.datasets.samples_generator import make_classification
  3. X, y = make_classification(n_samples=6, n_features=5, n_informative=2, 
  4.     n_redundant=2, n_classes=2, n_clusters_per_class=2, scale=1.0, 
  5.     random_state=20)
  7. # n_samples：指定样本数
  8. # n_features：指定特征数
  9. # n_classes：指定几分类
  10. # random_state：随机种子，使得随机状可重
  13. >>> for x_,y_ in zip(X,y):
  14.     print(y_,end=': ')
  15.     print(x_)
  18. 0: [-0.6600737  -0.0558978   0.82286793  1.1003977  -0.93493796]
  19. 1: [ 0.4113583   0.06249216 -0.90760075 -1.41296696  2.059838  ]
  20. 1: [ 1.52452016 -0.01867812  0.20900899  1.34422289 -1.61299022]
  21. 0: [-1.25725859  0.02347952 -0.28764782 -1.32091378 -0.88549315]
  22. 0: [-3.28323172  0.03899168 -0.43251277 -2.86249859 -1.10457948]
  23. 1: [ 1.68841011  0.06754955 -1.02805579 -0.83132182  0.93286635]

数据预处理

数据预处理阶段是机器学习中不可缺少的一环，它会使得数据更加有效的被模型或者评估器识别。下面我们来看一下sklearn中有哪些平时我们常用的函数：

  1. from sklearn import preprocessing

数据归一化

为了使得训练数据的标准化规则与测试数据的标准化规则同步，preprocessing中提供了很多Scaler：

  1. data = [[0, 0], [0, 0], [1, 1], [1, 1]]
  2. # 1. 基于mean和std的标准化
  3. scaler = preprocessing.StandardScaler().fit(train_data)
  4. scaler.transform(train_data)
  5. scaler.transform(test_data)
  7. # 2. 将每个特征值归一化到一个固定范围
  8. scaler = preprocessing.MinMaxScaler(feature_range=(0, 1)).fit(train_data)
  9. scaler.transform(train_data)
  10. scaler.transform(test_data)
  11. #feature_range: 定义归一化范围，注用（）括起来

正则化

当你想要计算两个样本的相似度时必不可少的一个操作，就是正则化。其思想是：首先求出样本的p-范数，然后该样本的所有元素都要除以该范数，这样最终使得每个样本的范数都为1。

  1. >>> X = [[ 1., -1.,  2.],
  2. ...      [ 2.,  0.,  0.],
  3. ...      [ 0.,  1., -1.]]
  4. >>> X_normalized = preprocessing.normalize(X, norm='l2')
  6. >>> X_normalized                                      
  7. array([[ 0.40..., -0.40...,  0.81...],
  8.        [ 1.  ...,  0.  ...,  0.  ...],
  9.        [ 0.  ...,  0.70..., -0.70...]])

one-hot编码

one-hot编码是一种对离散特征值的编码方式，在LR模型中常用到，用于给线性模型增加非线性能力。

  1. data = [[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]]
  2. encoder = preprocessing.OneHotEncoder().fit(data)
  3. enc.transform(data).toarray()

数据拆分

在得到训练数据集时，通常我们经常会把训练数据集进一步拆分成训练集和验证集，这样有助于我们模型参数的选取。

  1. # 作用：将数据集划分为 训练集和测试集
  2. # 格式：train_test_split(*arrays, **options)
  3. from sklearn.mode_selection import train_test_split
  5. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
  6. """
  7. 参数
  8. ---
  9. arrays：样本数组，包含特征向量和标签
  11. test_size：
  12. 　　float-获得多大比重的测试样本 （默认：0.25）
  13. 　　int - 获得多少个测试样本
  15. train_size: 同test_size
  17. random_state:
  18. 　　int - 随机种子（种子固定，实验可复现）
  19. 　　
  20. shuffle - 是否在分割之前对数据进行洗牌（默认True）
  22. 返回
  23. ---
  24. 分割后的列表，长度=2*len(arrays), 
  25. 　　(train-test split)
  26. """

定义模型

在这一步我们首先要分析自己数据的类型，搞清出你要用什么模型来做，然后我们就可以在sklearn中定义模型了。sklearn为所有模型提供了非常相似的接口，这样使得我们可以更加快速的熟悉所有模型的用法。在这之前我们先来看看模型的常用属性和功能：

  1. # 拟合模型
  2. model.fit(X_train, y_train)
  3. # 模型预测
  4. model.predict(X_test)
  6. # 获得这个模型的参数
  7. model.get_params()
  8. # 为模型进行打分
  9. model.score(data_X, data_y) # 线性回归：R square； 分类问题： acc

线性回归

  1. from sklearn.linear_model import LinearRegression
  2. # 定义线性回归模型
  3. model = LinearRegression(fit_intercept=True, normalize=False, 
  4.     copy_X=True, n_jobs=1)
  5. """
  6. 参数
  7. ---
  8.     fit_intercept：是否计算截距。False-模型没有截距
  9.     normalize： 当fit_intercept设置为False时，该参数将被忽略。 如果为真，则回归前的回归系数X将通过减去平均值并除以l2-范数而归一化。
  10.      n_jobs：指定线程数
  11. """

image.png

逻辑回归LR

  1. from sklearn.linear_model import LogisticRegression
  2. # 定义逻辑回归模型
  3. model = LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, C=1.0, 
  4.     fit_intercept=True, intercept_scaling=1, class_weight=None, 
  5.     random_state=None, solver=’liblinear’, max_iter=100, multi_class=’ovr’, 
  6.     verbose=0, warm_start=False, n_jobs=1)
  8. """参数
  9. ---
  10.     penalty：使用指定正则化项（默认：l2）
  11.     dual: n_samples > n_features取False（默认）
  12.     C：正则化强度的反，值越小正则化强度越大
  13.     n_jobs: 指定线程数
  14.     random_state：随机数生成器
  15.     fit_intercept: 是否需要常量
  16. """

朴素贝叶算法NB

  1. from sklearn import naive_bayes
  2. model = naive_bayes.GaussianNB() # 高斯贝叶斯
  3. model = naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)
  4. model = naive_bayes.BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None)
  5. """
  6. 文本分类问题常用MultinomialNB
  7. 参数
  8. ---
  9.     alpha：平滑参数
  10.     fit_prior：是否要学习类的先验概率；false-使用统一的先验概率
  11.     class_prior: 是否指定类的先验概率；若指定则不能根据参数调整
  12.     binarize: 二值化的阈值，若为None，则假设输入由二进制向量组成
  13. """

决策树DT

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

支持向量机SVM

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

K近邻算法KNN

  1. from sklearn import neighbors
  2. #定义kNN分类模型
  3. model = neighbors.KNeighborsClassifier(n_neighbors=5, n_jobs=1) # 分类
  4. model = neighbors.KNeighborsRegressor(n_neighbors=5, n_jobs=1) # 回归
  5. """参数
  6. ---
  7.     n_neighbors： 使用邻居的数目
  8.     n_jobs：并行任务数
  9. """

多层感知机（神经网络）

  1. from sklearn.neural_network import MLPClassifier
  2. # 定义多层感知机分类算法
  3. model = MLPClassifier(activation='relu', solver='adam', alpha=0.0001)
  4. """参数
  5. ---
  6.     hidden_layer_sizes: 元祖
  7.     activation：激活函数
  8.     solver ：优化算法{‘lbfgs’, ‘sgd’, ‘adam’}
  9.     alpha：L2惩罚(正则化项)参数。
  10. """

模型评估与选择

交叉验证

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

检验曲线

使用检验曲线，我们可以更加方便的改变模型参数，获取模型表现。

  1. from sklearn.model_selection import validation_curve
  2. train_score, test_score = validation_curve(model, X, y, param_name, param_range, cv=None, scoring=None, n_jobs=1)
  3. """参数
  4. ---
  5.     model:用于fit和predict的对象
  6.     X, y: 训练集的特征和标签
  7.     param_name：将被改变的参数的名字
  8.     param_range： 参数的改变范围
  9.     cv：k-fold
  11. 返回值
  12. ---
  13.    train_score: 训练集得分（array）
  14.     test_score: 验证集得分（array）
  15. """

保存模型

最后，我们可以将我们训练好的model保存到本地，或者放到线上供用户使用，那么如何保存训练好的model呢？主要有下面两种方式：

保存为pickle文件

  1. import pickle
  3. # 保存模型
  4. with open('model.pickle', 'wb') as f:
  5.     pickle.dump(model, f)
  7. # 读取模型
  8. with open('model.pickle', 'rb') as f:
  9.     model = pickle.load(f)
  10. model.predict(X_test)

sklearn自带方法joblib

  1. from sklearn.externals import joblib
  3. # 保存模型
  4. joblib.dump(model, 'model.pickle')
  6. #载入模型
  7. model = joblib.load('model.pickle')