十、模型选择

作者：Chris Albon

译者：飞龙

协议：CC BY-NC-SA 4.0

在模型选择期间寻找最佳预处理步骤

在进行模型选择时，我们必须小心正确处理预处理。 首先，GridSearchCV使用交叉验证来确定哪个模型表现最好。 然而，在交叉验证中，我们假装作为测试集被留出的一折是不可见的，因此不适合一些预处理步骤（例如缩放或标准化）。 出于这个原因，我们无法预处理数据然后运行GridSearchCV。

其次，一些预处理方法有自己的参数，通常必须由用户提供。 通过在搜索空间中包括候选成分值，可以像对待任何想要搜索其他超参数一样对待它们。

  1. # 加载库
  2. import numpy as np
  3. from sklearn import datasets
  4. from sklearn.feature_selection import SelectKBest
  5. from sklearn.linear_model import LogisticRegression
  6. from sklearn.model_selection import GridSearchCV
  7. from sklearn.pipeline import Pipeline, FeatureUnion
  8. from sklearn.decomposition import PCA
  9. from sklearn.preprocessing import StandardScaler
  11. # 设置随机种子
  12. np.random.seed(0)
  14. # 加载数据
  15. iris = datasets.load_iris()
  16. X = iris.data
  17. y = iris.target

我们包括两个不同的预处理步骤：主成分分析和 k 最佳特征选择。

  1. # 创建组合预处理对象
  2. preprocess = FeatureUnion([('pca', PCA()), ("kbest", SelectKBest(k=1))])
  4. # 创建流水线
  5. pipe = Pipeline([('preprocess', preprocess), ('classifier', LogisticRegression())])
  7. # 创建候选值空间
  8. search_space = [{'preprocess__pca__n_components': [1, 2, 3],
  9.                  'classifier__penalty': ['l1', 'l2'],
  10.                  'classifier__C': np.logspace(0, 4, 10)}]
  12. # 创建网格搜索
  13. clf = GridSearchCV(pipe, search_space, cv=5, verbose=0, n_jobs=-1)
  15. # 拟合网格搜索
  16. best_model = clf.fit(X, y)
  18. # 查看最佳超参数
  19. print('Best Number Of Princpal Components:', best_model.best_estimator_.get_params()['preprocess__pca__n_components'])
  20. print('Best Penalty:', best_model.best_estimator_.get_params()['classifier__penalty'])
  21. print('Best C:', best_model.best_estimator_.get_params()['classifier__C'])
  23. '''
  24. Best Number Of Princpal Components: 3
  25. Best Penalty: l1
  26. Best C: 59.9484250319 
  27. '''

使用网格搜索的超参数调优

十、模型选择 - 图1

  1. # 加载库
  2. import numpy as np
  3. from sklearn import linear_model, datasets
  4. from sklearn.model_selection import GridSearchCV
  6. # 加载数据
  7. iris = datasets.load_iris()
  8. X = iris.data
  9. y = iris.target
  11. # 创建逻辑回归
  12. logistic = linear_model.LogisticRegression()
  14. # 创建正则化惩罚空间
  15. penalty = ['l1', 'l2']
  17. # 创建正则化超参数空间
  18. C = np.logspace(0, 4, 10)
  20. # 创建超参数选项
  21. hyperparameters = dict(C=C, penalty=penalty)
  23. # 使用 5 折交叉验证创建网格搜索
  24. clf = GridSearchCV(logistic, hyperparameters, cv=5, verbose=0)
  26. # 拟合网格搜索
  27. best_model = clf.fit(X, y)
  29. # 查看最佳超参数
  30. print('Best Penalty:', best_model.best_estimator_.get_params()['penalty'])
  31. print('Best C:', best_model.best_estimator_.get_params()['C'])
  32. '''
  33. Best Penalty: l1
  34. Best C: 7.74263682681 
  35. '''
  37. # 预测目标向量
  38. best_model.predict(X)
  39. '''
  40. array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  41.        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  42.        0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  43.        1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
  44.        1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  45.        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2,
  46.        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]) 
  47. '''

使用随机搜索的超参数调优

  1. # 加载库
  2. from scipy.stats import uniform
  3. from sklearn import linear_model, datasets
  4. from sklearn.model_selection import RandomizedSearchCV
  6. # 加载数据
  7. iris = datasets.load_iris()
  8. X = iris.data
  9. y = iris.target
  11. # 创建逻辑回归
  12. logistic = linear_model.LogisticRegression()
  14. # 创建正则化惩罚空间
  15. penalty = ['l1', 'l2']
  17. # 使用均匀分布创建正则化超参数分布
  18. C = uniform(loc=0, scale=4)
  20. # 创建超参数选项
  21. hyperparameters = dict(C=C, penalty=penalty)
  23. # 使用 5 折交叉验证和 100 个迭代
  24. clf = RandomizedSearchCV(logistic, hyperparameters, random_state=1, n_iter=100, cv=5, verbose=0, n_jobs=-1)
  26. # 拟合随机搜索
  27. best_model = clf.fit(X, y)
  29. # 查看最佳超参数
  30. print('Best Penalty:', best_model.best_estimator_.get_params()['penalty'])
  31. print('Best C:', best_model.best_estimator_.get_params()['C'])
  32. '''
  33. Best Penalty: l1
  34. Best C: 1.66808801881 
  35. '''
  37. # 预测目标向量
  38. best_model.predict(X)
  39. '''
  40. array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  41.        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  42.        0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  43.        1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
  44.        1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  45.        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2,
  46.        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]) 
  47. '''

使用网格搜索的模型选择

十、模型选择 - 图2

  1. # 加载库
  2. import numpy as np
  3. from sklearn import datasets
  4. from sklearn.linear_model import LogisticRegression
  5. from sklearn.ensemble import RandomForestClassifier
  6. from sklearn.model_selection import GridSearchCV
  7. from sklearn.pipeline import Pipeline
  9. # 设置随机种子
  10. np.random.seed(0)
  12. # 加载数据
  13. iris = datasets.load_iris()
  14. X = iris.data
  15. y = iris.target

请注意，我们包括需要搜索的多个可能的学习算法和多个可能的超参数值。

  1. # 创建流水线
  2. pipe = Pipeline([('classifier', RandomForestClassifier())])
  4. # 创建候选学习算法和它们的超参数的空间
  5. search_space = [{'classifier': [LogisticRegression()],
  6.                  'classifier__penalty': ['l1', 'l2'],
  7.                  'classifier__C': np.logspace(0, 4, 10)},
  8.                 {'classifier': [RandomForestClassifier()],
  9.                  'classifier__n_estimators': [10, 100, 1000],
  10.                  'classifier__max_features': [1, 2, 3]}]
  12. # 创建网格搜索
  13. clf = GridSearchCV(pipe, search_space, cv=5, verbose=0)
  15. # 拟合网格搜索
  16. best_model = clf.fit(X, y)
  18. # 查看最佳模型
  19. best_model.best_estimator_.get_params()['classifier']
  20. '''
  21. LogisticRegression(C=7.7426368268112693, class_weight=None, dual=False,
  22.           fit_intercept=True, intercept_scaling=1, max_iter=100,
  23.           multi_class='ovr', n_jobs=1, penalty='l1', random_state=None,
  24.           solver='liblinear', tol=0.0001, verbose=0, warm_start=False) 
  25. '''
  27. # 预测目标向量
  28. best_model.predict(X)
  29. '''
  30. array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  31.        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  32.        0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  33.        1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
  34.        1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  35.        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2,
  36.        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]) 
  37. '''

带有参数选项的流水线

  1. # 导入所需的包
  2. import numpy as np
  3. from sklearn import linear_model, decomposition, datasets
  4. from sklearn.pipeline import Pipeline
  5. from sklearn.model_selection import GridSearchCV, cross_val_score
  6. from sklearn.preprocessing import StandardScaler
  8. # 加载乳腺癌数据集
  9. dataset = datasets.load_breast_cancer()
  11. # 从数据集特征中创建 X
  12. X = dataset.data
  14. # 从数据集目标中创建 y
  15. y = dataset.target
  17. # 创建缩放器对象
  18. sc = StandardScaler()
  20. # 创建 PCA 对象
  21. pca = decomposition.PCA()
  23. # 创建逻辑回归对象，带有 L2 惩罚
  24. logistic = linear_model.LogisticRegression()
  26. # 创建三步流水线。首先，标准化数据。
  27. # 其次，使用 PCA 转换数据。
  28. # 然后在数据上训练逻辑回归。
  29. pipe = Pipeline(steps=[('sc', sc), 
  30.                        ('pca', pca), 
  31.                        ('logistic', logistic)])
  33. # 创建 1 到 30 的一列整数（X + 1，特征序号）
  34. n_components = list(range(1,X.shape[1]+1,1))
  36. # 创建正则化参数的一列值
  37. C = np.logspace(-4, 4, 50)
  39. # 为正则化乘法创建一列选项
  40. penalty = ['l1', 'l2']
  42. # 为所有参数选项创建字典 
  43. # 注意，你可以使用 '__' 来访问流水线的步骤的参数
  44. parameters = dict(pca__n_components=n_components, 
  45.                   logistic__C=C,
  46.                   logistic__penalty=penalty)
  48. # 创建网格搜索对象
  49. clf = GridSearchCV(pipe, parameters)
  51. # 拟合网格搜索
  52. clf.fit(X, y)
  54. # 查看超参数
  55. print('Best Penalty:', clf.best_estimator_.get_params()['logistic__penalty'])
  56. print('Best C:', clf.best_estimator_.get_params()['logistic__C'])
  57. print('Best Number Of Components:', clf.best_estimator_.get_params()['pca__n_components'])
  59. # 使用 3 折交叉验证拟合网格搜索
  60. cross_val_score(clf, X, y)