网格搜索
对给定参数进行组合，用某标准进行评价，只适合小数据集
class sklearn.model_selection.GridSearchCV(estimator, param_grid, scoring=None, fit_params=None, n_jobs=None, iid=’warn’, refit=True, cv=’warn’, verbose=0,
pre_dispatch=‘2*n_jobs’, error_score=’raise-deprecating’, return_train_score=’warn’)
参数
estimator：一个学习器对象，它必须有.fit方法用于学习，.predict方法用于预测，.score方法用于评分
param_grid：字典或者字典的列表，每个字典是学习器的一个参数，key是参数名，value是备选参数序列
scoring：评分函数，可以是一个字符串，或一个可调用对象，或者None
如果是None，使用学习器的.score方法，
如果是字符串，可以为如下值：
accuracy：用 metrics.accuracy_score 评分函数
average_precision：用 metrics.average_precision_score 评分函数
f1系列：用 metrics.f1_score 评分函数
f1：用于二分类
f1_micro：micro_averaged
f1_macro：macro_averaged
f1_weighted：weighted average
f1_samples：by multilabel sample
log_loss：用 metrics.log_loss 评分函数
precision：用 metrics.precision_score 评分函数，具体形式类似f1系列
recall：用 metrics.recall_score 评分函数，具体形式类似f1系列
roc_auc：用的是 metrics.roc_auc_score 评分函数
adjusted_rand_score：
mean_absolute_error：
mean_squared_error：
median_absolute_error：
r2：
fit_params：字典形式，用于给学习器的fit传递参数
n_jobs：并行性，默认为-1或None，表示派发任务到所有计算机的cpu上
iid：样本独立同分布，bool值
refit：bool值，如果为True，表示在参数优化之后，使用整个数据集来重新训练该最优的estimator
cv：一个整数，k折交叉生成器，一个迭代器，或者None
如果为None，使用3折交叉验证
如果为整数k，使用k这交叉验证
如果为k折交叉验证生成器
迭代器
verbose：整数，控制输出日志的内容，该值越大，输出越多的内容
pre_dispatch：整数或者字符串，控制并行执行时分发的总的任务量
error_score：
return_train_score：
属性
grid_scores_：命名元组组成的列表，列表中每个元素代表参数组合的得分
best_estimator_：一个学习器对象，代表最后的最优学习器
best_score_：最佳学习器的得分
best_params_：最佳参数组合
方法
fit：执行参数优化
predict：使用学习到的最佳学习器预测数据
predict_log_proba(x)：使用最佳学习器来预测属于每个类别的概率的对数值
predict_proba(x)：使用最佳学习器来预测属于每个类别的概率
score：最佳学习器的评分
示例代码
from sklearn.datasets import load_digits from sklearn.linear_model import LogisticRegression from sklearn.metrics import classification_report from sklearn.model_selection import train_test_split, GridSearchCV ### digits = load_digits() X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0, stratify=digits.target) ### tuned_parameters = [{'penalty':['l1', 'l2'], 'C':[0.01, 0.05, 0.1, 0.5, 1, 5, 10, 50, 100], 'solver':['liblinear'], 'multi_class':['ovr']}, {'penalty':['l2'], 'C':[0.01, 0.05, 0.1, 0.5, 1, 5, 10, 50, 100], 'solver':['lbfgs'], 'multi_class':['ovr', 'multinomial']}] clf = GridSearchCV(LogisticRegression(tol=1e-6), tuned_parameters, cv=10) clf.fit(X_train, y_train) print(clf.best_params_) # {'penalty': 'l2', 'multi_class': 'multinomial', 'C': 0.01, 'solver': 'lbfgs'} for i in clf.grid_scores_: print(i) # mean: 0.93022, std: 0.01571, params: {'penalty': 'l1', 'multi_class': 'ovr', 'C': 0.01, 'solver': 'liblinear'} # mean: 0.96511, std: 0.01095, params: {'penalty': 'l2', 'multi_class': 'ovr', 'C': 0.01, 'solver': 'liblinear'} # mean: 0.96437, std: 0.01082, params: {'penalty': 'l1', 'multi_class': 'ovr', 'C': 0.05, 'solver': 'liblinear'} # mean: 0.96511, std: 0.01164, params: {'penalty': 'l2', 'multi_class': 'ovr', 'C': 0.05, 'solver': 'liblinear'} # ... # mean: 0.95100, std: 0.01262, params: {'penalty': 'l1', 'multi_class': 'ovr', 'C': 1, 'solver': 'liblinear'} # mean: 0.95323, std: 0.01390, params: {'penalty': 'l2', 'multi_class': 'ovr', 'C': 1, 'solver': 'liblinear'} # mean: 0.95249, std: 0.01096, params: {'penalty': 'l1', 'multi_class': 'ovr', 'C': 5, 'solver': 'liblinear'} # mean: 0.95100, std: 0.01237, params: {'penalty': 'l2', 'multi_class': 'ovr', 'C': 5, 'solver': 'liblinear'} # ... # mean: 0.94358, std: 0.01260, params: {'penalty': 'l2', 'multi_class': 'ovr', 'C': 50, 'solver': 'lbfgs'} # mean: 0.95768, std: 0.01487, params: {'penalty': 'l2', 'multi_class': 'multinomial', 'C': 50, 'solver': 'lbfgs'} # mean: 0.93690, std: 0.01520, params: {'penalty': 'l2', 'multi_class': 'ovr', 'C': 100, 'solver': 'lbfgs'} # mean: 0.95620, std: 0.01314, params: {'penalty': 'l2', 'multi_class': 'multinomial', 'C': 100, 'solver': 'lbfgs'} print(clf.score(X_test, y_test)) # 0.973333333333 pred = clf.predict(X_test) print(classification_report(y_test, pred)) # precision recall f1-score support # # 0 1.00 1.00 1.00 45 # 1 0.87 0.98 0.92 46 # 2 1.00 0.98 0.99 44 # 3 1.00 1.00 1.00 46 # 4 1.00 0.96 0.98 45 # 5 0.96 0.98 0.97 46 # 6 1.00 0.98 0.99 45 # 7 1.00 1.00 1.00 45 # 8 0.93 0.88 0.90 43 # 9 1.00 0.98 0.99 45 # # avg / total 0.97 0.97 0.97 450
随机搜索
随机搜索的原理和网格搜索是一致的，只是随机搜索在取参数值时是随机取值，其主要解决以下问题
1. 参数很多
2. 参数取值是连续的，或者参数取值范围很大，或者参数可取值非常多
随机取值其实不是完全随机，如根据参数取值的分布进行采样，其实也可以自己定义
class sklearn.model_selection.RandomizedSearchCV(estimator, param_distributions, n_iter=10, scoring=None, fit_params=None, n_jobs=None, iid=’warn’, refit=True,
cv=’warn’, verbose=0, pre_dispatch=‘2*n_jobs’, random_state=None, error_score=’raise-deprecating’, return_train_score=’warn’)[source]
参数
参数与gridsearchCV大致相同，简单解释下
param_distributions：相当于上面的param_grid，只是字典的值是个分布，通常使用scipy.stats模块提供的分布类，如 scipy.expon 指数分布，scipy.gamma gamma分布，scipy.uniform 均匀分布等
n_iter：整数，指定每个参数采样的数量，通常该值越大，参数优化效果越好，但计算量也越大
{'C': scipy.stats.expon(scale=100), 'gamma': scipy.stats.expon(scale=.1),'kernel': ['rbf'], 'class_weight':['balanced', None]}
属性
cv_results_：不同参数组合的得分
best_params_，best_score_ 等
示例代码
from sklearn.datasets import load_iris from sklearn.neighbors import KNeighborsClassifier # 要估计的是knn里面的参数，包括k的取值和样本权重分布方式 from sklearn.model_selection import GridSearchCV,RandomizedSearchCV iris = load_iris() X = iris.data y = iris.target k_range = range(1, 31) # 优化参数k的取值范围 weight_options = ['uniform', 'distance'] # 代估参数权重的取值范围。uniform为统一取权值，distance表示距离倒数取权值 param_grid = {'n_neighbors':k_range,'weights':weight_options} # 字典中的key值必须是分类算法的函数的参数名 print(param_grid) knn = KNeighborsClassifier(n_neighbors=5) # ================================网格搜索======================================= # 这里GridSearchCV的参数形式和cross_val_score的形式差不多，其中param_grid是parameter grid所对应的参数 # GridSearchCV中的n_jobs设置为-1时，可以实现并行计算（如果你的电脑支持的情况下） grid = GridSearchCV(estimator = knn, param_grid = param_grid, cv=10, scoring='accuracy') #针对每个参数对进行了10次交叉验证。scoring='accuracy'使用准确率为结果的度量指标。可以添加多个度量指标 grid.fit(X, y) print('网格搜索-度量记录：',grid.cv_results_) # 包含每次训练的相关信息 print('网格搜索-最佳度量值:',grid.best_score_) # 获取最佳度量值 print('网格搜索-最佳参数：',grid.best_params_) # 获取最佳度量值时的代定参数的值。是一个字典 print('网格搜索-最佳模型：',grid.best_estimator_) # 获取最佳度量时的分类器模型 # 使用获取的最佳参数生成模型，预测数据 knn = KNeighborsClassifier(n_neighbors=grid.best_params_['n_neighbors'], weights=grid.best_params_['weights']) knn.fit(X, y) print(knn.predict([[3, 5, 4, 2]])) # =====================================随机搜索=========================================== rand = RandomizedSearchCV(knn, param_grid, cv=10, scoring='accuracy', n_iter=10, random_state=5) # rand.fit(X, y) print('随机搜索-度量记录：',grid.cv_results_) # 包含每次训练的相关信息 print('随机搜索-最佳度量值:',grid.best_score_) # 获取最佳度量值 print('随机搜索-最佳参数：',grid.best_params_) # 获取最佳度量值时的代定参数的值。是一个字典 print('随机搜索-最佳模型：',grid.best_estimator_) # 获取最佳度量时的分类器模型 # 使用获取的最佳参数生成模型，预测数据 knn = KNeighborsClassifier(n_neighbors=grid.best_params_['n_neighbors'], weights=grid.best_params_['weights']) knn.fit(X, y) print(knn.predict([[3, 5, 4, 2]])) # =====================================自定义度量=========================================== from sklearn import metrics # 自定义度量函数 def scorerfun(estimator, X, y): y_pred = estimator.predict(X) return metrics.accuracy_score(y, y_pred) rand = RandomizedSearchCV(knn, param_grid, cv=10, scoring=scorerfun, n_iter=10, random_state=5) # rand.fit(X, y) print('随机搜索-最佳度量值:',grid.best_score_) # 获取最佳度量值
参考资料：
https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV
https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RandomizedSearchCV.html
https://blog.csdn.net/luanpeng825485697/article/details/79831703