参数优化-API

网格搜索

对给定参数进行组合，用某标准进行评价，只适合小数据集

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