机器学习常用算法调用集合

一、分类算法

from sklearn.linear_model import Ridge                    # 岭回归
from sklearn.linear_model import Lasso                    # 套索回归
from sklearn.linear_model import LinearRegression         # 线性回归
from sklearn.linear_model import LogisticRegression       # 逻辑斯蒂

from sklearn.tree import DecisionTreeClassifier           # 决策树--分类
from sklearn.tree import DecisionTreeRegressor            # 决策树--回归
from sklearn.ensemble import RandomForestClassifier       # 随机森林--分类
from sklearn.ensemble import RandomForestRegressor        # 随机森林--回归
from sklearn.ensemble import GradientBoostingClassifier   # GBDT--分类
from sklearn.ensemble import GradientBoostingRegressor    # GBDT--回归

import xgboost as gbt
from xgboost import XGBClassifier                         # XGBoost

import lightgbm as lgbm
from lightgbm import LGBMClassifier                       # LightGBM

from sklearn.svm import SVC                               # 支持向量机--分类
from sklearn.svm import SVR                               # 支持向量机--回归

from sklearn.neighbors import KNeighborsClassifier        # KNN--分类
from sklearn.neighbors import KNeighborsRegressor         # KNN--回归

from sklearn.neural_network import MLPClassifier          # 多层感知机

1.1、逻辑回归

1.1.1、示例&调参

from sklearn.linear_model import LogisticRegression         # 逻辑斯蒂（人为指定一个正则化系数）
from sklearn.linear_model import LogisticRegressionCV       # 逻辑斯蒂（使用交叉验证来选择正则化系数C，用法大致相同）
from sklearn.model_selection import GridSearchCV            # 网格搜索

clf_lr = LogisticRegression()       # 定义模型实例
clf_lr.fit(X, y)                    # 训练模型
clf_lr.predict(X)                   # 样本对应各个类别预测标签

param_grid = {"penalty":['l1', 'l2'],
             "C":[0.01, 0.1, 1, 10, 100]}

grid_search_lr = GridSearchCV(clf_lr, param_grid, cv=5, scoring='neg_log_loss')
grid_search_lr.fit(X, y)

grid_search_lr.best_score_   # 获取最高分
grid_search_lr.best_params_   # 获取被搜索的最好参数
grid_search_lr.best_estimator_   # 获取最佳估计器（带所有参数的值）

1.1.2、参数详解（部分）

clf_lr.fit(X, y)                    # 训练模型
clf_lr.get_params([deep])           # 获取模型参数
clf_lr.predict(X)                   # 样本对应各个类别预测标签
clf_lr.predict_proba(X)             # 样本对应各个类别的概率
clf_lr.predict_log_proba(X)         # 样本对应各个类别的概率的对数转化
clf_lr.score(X, y)                  # 模型预测得分（官方文档描述是accuracy准确率）

1.2、随机森林

1.2.1、示例&调参

from sklearn.ensemble import RandomForestClassifier       # 随机森林
from sklearn.model_selection import GridSearchCV          # 网格搜索

clf_rf = RandomForestClassifier()   # 定义模型实例
clf_rf.fit(X, y)                    # 训练模型
clf_rf.predict(X)                   # 样本对应各个类别预测标签
clf_lr.predict_proba(X)             # 样本对应各个类别的概率


param_grid = {'n_estimators':range(10,71,10),
							'max_features':range(3,11,2),
							'max_depth':range(3,14,2), 
							'min_samples_split':range(80,150,20), 
							'min_samples_leaf':range(10,60,10)}
grid_search_rf = GridSearchCV(clf_rf, param_grid = param_grid, scoring='roc_auc',cv=5)
grid_search_rf.fit(X,y)
grid_search_rf.best_score_   # 获取最高分
grid_search_rf.best_params_   # 获取被搜索的最好参数
grid_search_rf.best_estimator_   # 获取最佳估计器（带所有参数的值）

1.2.2、参数详解（部分）

1.3、GBDT

1.3.1、示例&调参

from sklearn.ensemble import GradientBoostingClassifier   # GBDT--分类
from sklearn.ensemble import GradientBoostingRegressor    # GBDT--回归
from sklearn.model_selection import GridSearchCV          # 网格搜索

clf_gbdt = GradientBoostingClassifier()   # 定义模型实例
clf_gbdt.fit(X, y)                        # 训练模型
clf_gbdt.predict(X)                       # 样本对应各个类别预测标签
clf_gbdt.predict_proba(X)                 # 样本对应各个类别的概率


param_grid = {'n_estimators':range(20,81,10),
							'learning_rate':[0.01, 0.05,0.1,0.5],
							'max_depth':range(3,14,2), 
							'min_samples_split':range(100,801,200),
							'min_samples_leaf':range(60,101,10),
							'max_features':range(3,11,2),
							'subsample':[0.6,0.7,0.75,0.8,0.85,0.9]}
grid_search_gbdt = GridSearchCV(clf_gbdt, param_grid = param_grid, scoring='roc_auc',cv=5)
grid_search_gbdt.fit(X,y)
grid_search_gbdt.best_score_   # 获取最高分
grid_search_gbdt.best_params_   # 获取被搜索的最好参数
grid_search_gbdt.best_estimator_   # 获取最佳估计器（带所有参数的值）

1.3.2、参数详解（部分）

1.4、XGBoost

1.5、LightGBM

1.5.1、接口调用

# 
import lightgbm as lgb
from lightgbm import plot_importance
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

lightgbm.train(params, train_set, num_boost_round=100, valid_sets=None, valid_names=None, fobj=None, feval=None, init_model=None, feature_name='auto', categorical_feature='auto', early_stopping_rounds=None, evals_result=None, verbose_eval=True, learning_rates=None, keep_training_booster=False, callbacks=None)
"""
params：参数
train_set：训练数据，需要用特定方式转换，详见下文
num_boost_round：最大迭代次数，默认10
valid_sets：用于评估的数据及数据的名称，列表类型，
fobj：指定二阶可导的自定义目标函数
feval：自定义评估函数
categorical_feature：指定哪些是类别特征
early_stopping_rounds：指定迭代多少次没有得到优化则停止训练，默认值为None，表示不提前停止训练。
verbose_eval：可以是bool类型，也可以是整数类型。如果设置为整数，则每间隔verbose_eval次迭代就输出一次信息。
init_model：加载之前训练好的 lgb 模型，用于增量训练。
"""

# 加载鸢尾花数据集
iris = load_iris()
X,y = iris.data,iris.target
# 数据集分割
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=123457)
# 构造训练集
dtrain = lgb.Dataset(X_train,y_train)
dtest = lgb.Dataset(X_test,y_test)

# 参数
params = {
    'booster': 'gbtree',
    'objective': 'multiclass',
    'num_class': 3,
    'num_leaves': 31,
    'subsample': 0.8,
    'bagging_freq': 1,
    'feature_fraction ': 0.8,
    'slient': 1,
    'learning_rate ': 0.01,
    'seed': 0
}
# xgboost模型训练
model = lgb.train(params,dtrain, num_boost_round=100, valid_sets=[dtrain, dtest], 
                  verbose_eval=100, early_stopping_rounds=30)
# 对测试集进行预测
y_pred = model.predict(X_test)
# 计算准确率
accuracy = accuracy_score(y_test, np.argmax(y_pred, axis=1))
print('accuarcy:%.2f%%'%(accuracy*100))
# 显示重要特征
plot_importance(model)

import matplotlib.pyplot as plt
from lightgbm import LGBMClassifier
from lightgbm import plot_importance
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split


# 加载样本数据集
iris = load_iris()
X,y = iris.data,iris.target
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=12343)

crf_lgbm = LGBMClassifier(
    max_depth=3,
    learning_rate=0.1,
    n_estimators=200, # 使用多少个弱分类器
    objective='multiclass',
    num_class=3,
    booster='gbtree',
    min_child_weight=2,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0,
    reg_lambda=1,
    seed=0 # 随机数种子
)
crf_lgbm.fit(X_train,y_train, eval_set=[(X_train, y_train), (X_test, y_test)],    # [(X_test, y_test)]
          verbose=100, early_stopping_rounds=50)

# 对测试集进行预测
y_pred = crf_lgbm.predict(X_test)
y_proba = crf_lgbm.predict_proba(X_test)


# 计算平均 auc
n_classes = y_true.shape[1]  # 类别数
auc_scores = []        # 存储每个二分类子问题的AUC值
for i in range(n_classes):
    y_true_binary = np.array(pd.get_dummies(y_test))[:, i]  # 将第i个类别设为正例，将标签独热编码
    y_pred_binary = y_proba[:, i]  # 第i个类别的预测概率或分数
    # 计算第i个二分类子问题的AUC值
    auc = roc_auc_score(y_true_binary, y_pred_binary)
    auc_scores.append(auc)
# 计算AUCµ的值
auc_micro = np.mean(auc_scores)


#计算准确率
accuracy = accuracy_score(y_test,y_pred)
print('accuracy:%3.f%%'%(accuracy*100))

# 显示重要特征
plot_importance(model)
plt.show()

1.5.2、参数详解

1.5.3、调参实例

clf_lgbm = lgbm.LGBMClassifier(
                              boosting_type='gbdt',      # 第一步 根据场景固定部分参数
                              objective='binary',
                              metric='auc',
                              verbose=-1,
                              learning_rate=0.1,       # 第二步 学习率和迭代次数一起调   0.666700429456532
                              n_estimators=200,        
                              max_depth=5,            # 第三步调 {max_depth,num_leaves}, 0.6708004303847365
                              num_leaves=20,
                              min_data_in_leaf=50,     # 第四步调 min_data_in_leaf, 0.6728529685838128
                              bagging_fraction=0.7,    # 第五步调 {bagging_fraction,feature_fraction}, 0.6728529685838128
                              feature_fraction=1,
                            #   lambda_l1=1,             # 第六步调 {lambda_l1,lambda_l2}, 0.6714313656366919
                            #   lambda_l2=1,
                            #   learning_rate=0.1,       # 第七步调, learning_rate, 最佳0.1, 0.6714313656366919
                              )
param_grid = {
    # 'n_estimators': range(100,501 ,100),
    # 'max_depth': range(1, 6, 1),
    # 'num_leaves':range(15, 36, 5),
    # 'min_data_in_leaf': range(20, 80, 10),
    # 'feature_fraction': [0.7,0.8,0.9,1.0],
    # 'bagging_fraction': [0.7,0.8,0.9,1.0],
    'lambda_l1': [1e-5,1e-1,0.0,0.1,0.5,1.0],
    'lambda_l2': [1e-5,1e-1,0.0,0.1,0.5,1.0],
    # 'learning_rate': [0.01, 0.015, 0.025, 0.05, 0.1]
}
gs_lgbm = GridSearchCV(clf_lgbm, param_grid=param_grid, scoring='roc_auc')
gs_lgbm.fit(train_data_array, train_label)
print('最优参数组合:',gs_lgbm.best_params_)
print('最优参数分数:',gs_lgbm.best_score_)
# print(gs_lgbm.scorer_)

1.5.4、特征重要性

boost = clf_lgbm.booster_
pd.DataFrame({
        'column': train_data_value_all_df.columns,
        'importance': boost.feature_importance(),
    }).sort_values(by='importance')

1.5.5、参考文档

稀疏矩阵分类

1.6、集成学习分类器 VotingClassifier

sklearn.ensemble.VotingClassifier(estimators, voting='hard', weights=None, n_jobs=None, flatten_transform=True)

• estimators：一个列表或字典，其中包含要结合的分类器。列表的每个元素都是一个元组，包含一个分类器的名称（字符串）和一个分类器对象。字典的键是分类器的名称，值是分类器对象。

• voting：指定投票策略的字符串。可以是以下三个值之一：
• 'hard'：选取预测结果中的多数类别作为最终预测结果。
• 'soft'：对预测结果进行加权平均，然后根据平均值确定最终的预测结果。
• 'uniform'：对预测结果进行加权平均，并对所有权重进行归一化。

• weights：一个列表或字典，包含每个分类器的权重。列表的长度必须与estimators中的分类器数量相同。如果未指定权重，则所有分类器的权重默认相等。

• n_jobs：并行运行分类器的数量。默认为None，表示不并行运行。

• flatten_transform：指定是否将输入数据展平为二维数组。默认为True，表示将输入数据展平。

• estimators_：一个字典，包含所有分类器的名称和对象。

• classes_：一个数组，包含训练数据中的所有类别。

• named_estimators_：一个字典，包含所有分类器的名称和对象。

• fit(X, y)：使用训练数据X和标签y来拟合集成分类器。

• predict(X)：对输入数据X进行预测。

• predict_proba(X)：对输入数据X返回每个类别的概率。

• score(X, y)：计算使用输入数据X和标签y的分类器的准确率。

二、聚类算法

# 划分聚类
from sklearn.cluster import KMeans            # KMeans聚类
from sklearn.cluster import MiniBatchKMeans   # KMeans聚类大样本优化

# 层次聚类
from sklearn.cluster import Birch

# 密度聚类
from sklearn.cluster import DBSCAN
from sklearn.cluster import OPTICS

# 谱聚类
from sklearn.cluster import SpectralClustering

2.1、KMeans聚类

2.1.1、概述

2.1.2、示例&调参

from sklearn.cluster import KMeans
from sklearn import datasets

iris = datasets.load_iris()   # 加载数据
X = iris.data
y = iris.target
est = KMeans(n_clusters=3)   # 定义模型
y_pred = est.fit_predict(X)   # 聚类

"""
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2,
       2, 2, 2, 1, 1, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 1, 2, 2, 2, 2,
       2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 1], dtype=int32)
"""

2.1.3、参数详解（部分）

2.1.4、大样本优化Mini Batch K-Means

from sklearn.cluster import MiniBatchKMeans
import numpy as np
X = np.array([[1, 2], [1, 4], [1, 0],
              [4, 2], [4, 0], [4, 4],
              [4, 5], [0, 1], [2, 2],
              [3, 2], [5, 5], [1, -1]])

# manually fit on batches
kmeans = MiniBatchKMeans(n_clusters=2,
                         random_state=0,
                         batch_size=6,
                         n_init="auto")
kmeans = kmeans.partial_fit(X[0:6,:])         # 增量学习
kmeans = kmeans.partial_fit(X[6:12,:])        # 增量学习 
print(kmeans.cluster_centers_)                # 打印聚类中心，每个聚类中心是一个二维坐标

kmeans.predict([[0, 0], [4, 4]])              # 聚类预测

2.1.5、参考文章

2.2、BIRCH聚类

2.2.1、概述

2.2.2、示例&调参

from sklearn.cluster import Birch
X = [[0, 1], [0.3, 1], [-0.3, 1], [0, -1], [0.3, -1], [-0.3, -1]]
brc = Birch(n_clusters=None)
brc.fit(X)

brc.predict(X)

2.2.3、参数详解

2.2.4、参考文章：

2.3、DBSCAN聚类

2.3.1、概述

2.3.2、示例&调参

from sklearn.cluster import DBSCAN

y_pred = DBSCAN(eps=0.1, min_samples=10).fit_predict(X)

2.3.3、参数详解

2.3.4、OPTICS聚类

2.3.5、参考文章

2.4、谱聚类

2.4.1、概述

2.4.2、示例&调参

import numpy as np
from sklearn import datasets
X, y = datasets.make_blobs(n_samples=500, n_features=6, centers=5, cluster_std=[0.4, 0.3, 0.4, 0.3, 0.4], random_state=11)

from sklearn.cluster import SpectralClustering
y_pred = SpectralClustering().fit_predict(X)

from sklearn import metrics
print("Calinski-Harabasz Score", metrics.calinski_harabasz_score(X, y_pred))

for index, gamma in enumerate((0.01,0.1,1,10)):
    for index, k in enumerate((3,4,5,6)):
        y_pred = SpectralClustering(n_clusters=k, gamma=gamma).fit_predict(X)
        print("Calinski-Harabasz Score with gamma=", gamma, "n_clusters=", k,"score:", metrics.calinski_harabasz_score(X, y_pred))

2.4.3、参数详解

2.4.4、参考文章

2.5、聚类模型评估

2.5.1、CH评估

from sklearn import metrics
metrics.calinski_harabaz_score(X, y_pred)

2.5.2、轮廓系数

from sklearn import metrics
metrics.silhouette_samples(X, y_pred, metric='euclidean')
"""
metric  ： 计算要素阵列中实例之间的距离时使用的度量。默认是euclidean（欧氏距离）。
如果metric是字符串，则必须是允许的选项之一metrics.pairwise.pairwise_distances。如果X是距离数组本身，请使用metric="precomputed"。

"""

三、降维算法

from sklearn.decomposition import PCA
from sklearn.decomposition import KernelPCA
from sklearn.decomposition import IncrementalPCA
from sklearn.decomposition import SparsePCA
from sklearn.decomposition import MiniBatchSparsePCA

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

from sklearn.manifold import LocallyLinearEmbedding

from sklearn.manifold import TSNE

3.1、PCA主成分分析

3.1.1、概述

💡

算法流程：

3.1.2、示例

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
%matplotlib inline
from sklearn.datasets import make_blobs
# X为样本特征，Y为样本簇类别， 共1000个样本，每个样本3个特征，共4个簇
X, y = make_blobs(n_samples=10000, n_features=3, centers=[[3,3, 3], [0,0,0], [1,1,1], [2,2,2]], cluster_std=[0.2, 0.1, 0.2, 0.2], 
                  random_state =9)
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.scatter(X[:, 0], X[:, 1], X[:, 2],marker='o')

from sklearn.decomposition import PCA
pca = PCA(n_components=3)       # 数据本来就是三维，如果降维后的维度也设置为3，则是单纯的对数据投影，可以通过此方法查看特征方差分布
pca.fit(X)

print(pca.explained_variance_ratio_)    # 各特征的方差值占比
print(pca.explained_variance_)          # 各特征的方差值

"""
[0.98318212 0.00850037 0.00831751]
[3.78521638 0.03272613 0.03202212]
"""

3.1.3、参数

3.1.4、PCA对比

3.2、LDA线性判别

import numpy as np
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
y = np.array([1, 1, 1, 2, 2, 2])
lda = LinearDiscriminantAnalysis(n_components=1)
lda.fit(X, y)
X_new = lda.transform(X)

3.3、LLE局部线性嵌入

from sklearn.datasets import load_digits
from sklearn.manifold import LocallyLinearEmbedding
X, _ = load_digits(return_X_y=True)
X.shape

embedding = LocallyLinearEmbedding(n_components=2)
X_transformed = embedding.fit_transform(X[:100])
X_transformed.shape

3.4、tSNE T分布随机近邻嵌入

import numpy as np
from sklearn.manifold import TSNE
X = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 1]])
X_embedded = TSNE(n_components=2, learning_rate='auto',
                  init='random', perplexity=3).fit_transform(X)
X_embedded.shape

四、关联规则算法

4.1、Apriori

4.2、FP Tree

4.3、PrefixSpan

自动化调参

超参数优化

GridSearchCV：网格搜索

from sklearn.model_selection import GridSearchCV

"""
GridSearchCV(estimator, param_grid, *, scoring=None, n_jobs=None, 
refit=True, cv=None, verbose=0, pre_dispatch='2*n_jobs', error_score=nan, return_train_score=False)
- estimator：所使用的分类器
- param_grid：值为字典或者列表，即需要最优化的参数的取值
- scoring：准确度评价标准，默认None.
	- 常用评分标准设置：‘accuracy’、‘precision’、‘recall’、‘f1’、‘roc_auc’
	- scoring 设置参考：
		- https://blog.csdn.net/qq_41076797/article/details/102755893
		- https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter
- n_jobs：并行数，int，默认1，-1表示使用所有能用的核
- cv：交叉验证次数，int，默认5，
"""

from sklearn import svm, datasets
from sklearn.model_selection import GridSearchCV
iris = datasets.load_iris()
parameters = {'kernel':('linear', 'rbf'), 'C':[1, 10]}
svc = svm.SVC()
grid_search = GridSearchCV(svc, parameters)
grid_search.fit(iris.data, iris.target)

grid_search.best_score_   # 获取最高分
grid_search.best_params_   # 获取被搜索的最好参数
grid_search.best_estimator_   # 获取最佳估计器（带所有参数的值）

RandomizedSearchCV：随机网格搜索

from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier
from scipy.stats import randint

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# 加载数据
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = RandomForestClassifier()
param_dist = {
    'n_estimators': randint(50, 200),  # 树的数量
    'max_features': ['auto', 'sqrt', 'log2'],  # 特征选择策略
    'max_depth': randint(1, 20),  # 树的最大深度
    'min_samples_split': randint(2, 10)  # 内部节点再划分所需的最小样本数
}
random_search = RandomizedSearchCV(model, param_distributions=param_dist, 
                                   n_iter=100, cv=5, verbose=1, 
                                   random_state=42, n_jobs=-1)
random_search.fit(X_train, y_train)
print("Best parameters found: ", random_search.best_params_)
print("Best score found: ", random_search.best_score_)
best_model = random_search.best_estimator_
score = best_model.score(X_test, y_test)
print("Test set score: ", score)


"""
RandomizedSearchCV(
    estimator=model,                    # 要优化的模型（估计器）
    param_distributions=param_dist,     # 字典或列表，指定要调优的超参数及其分布。
    scoring=roc_auc,                    # 评估指标，详见：https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter；设置多个评估指标：scoring = {'accuracy': 'accuracy', 'precision': 'precision', 'recall': 'recall', 'f1': 'f1'}
    n_iter=100,                         # 要随机选择的参数组合的数量。训练次数=min(超参数空间组合数, n_iter)
    cv=5,                               # 指定交叉验证的折数。
    verbose=1,                          # 控制详细程度。0 表示不输出，1 表示输出简单信息，2 或更高则输出更详细的信息。
    random_state=42,                    # 随机数生成器的种子，用于确保结果的可重现性。
    n_jobs=-1,                          # 并行执行的作业数。-1 表示使用所有可用的 CPU 核心，1 表示单线程执行。
    return_train_score=True             # 如果设置为 True，将返回训练集的分数。默认值为 False。
)
"""

from sklearn import datasets
from sklearn.model_selection import RandomizedSearchCV
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from scipy.stats import uniform
from sklearn.metrics import f1_score, make_scorer

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义模型
model = SVC()

# 定义超参数空间
param_distributions = {
    'C': uniform(0.1, 10),  # 正则化参数
    'kernel': ['linear', 'rbf'],  # 核函数类型
    'gamma': ['scale', 'auto'] + list(uniform(0.001, 0.1).rvs(10)),  # 核系数
}

# 定义自定义评分函数
f1_scorer = make_scorer(f1_score, average='weighted')

# 定义随机搜索
random_search = RandomizedSearchCV(
    model, 
    param_distributions=param_distributions, 
    n_iter=50,  # 采样次数
    cv=5,  # 交叉验证折数
    scoring=f1_scorer,  # 使用自定义评分函数
    random_state=42, 
    n_jobs=-1  # 使用所有CPU核心
)

# 执行随机搜索
random_search.fit(X_train, y_train)

# 输出最佳参数
print("Best parameters found: ", random_search.best_params_)

# 使用最佳参数的模型进行预测
best_model = random_search.best_estimator_
y_pred = best_model.predict(X_test)

# 输出模型性能
from sklearn.metrics import accuracy_score
print("Test accuracy: ", accuracy_score(y_test, y_pred))
print("Test F1 score: ", f1_score(y_test, y_pred, average='weighted'))

Bayesian Optimization：贝叶斯优化

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
from skopt import BayesSearchCV
from skopt.space import Real, Categorical, Integer

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义模型
model = SVC()

# 定义超参数空间
param_space = {
    'C': Real(0.1, 10, prior='log-uniform'),  # 正则化参数
    'kernel': Categorical(['linear', 'rbf']),  # 核函数类型
    'gamma': Real(0.001, 0.1, prior='log-uniform'),  # 核系数
}

# 定义贝叶斯搜索
bayes_search = BayesSearchCV(
    model, 
    param_space, 
    n_iter=50,  # 采样次数
    cv=5,  # 交叉验证折数
    random_state=42, 
    n_jobs=-1  # 使用所有CPU核心
)

# 执行贝叶斯搜索
bayes_search.fit(X_train, y_train)

# 输出最佳参数
print("Best parameters found: ", bayes_search.best_params_)

# 使用最佳参数的模型进行预测
best_model = bayes_search.best_estimator_
y_pred = best_model.predict(X_test)

# 输出模型性能
print("Test accuracy: ", accuracy_score(y_test, y_pred))

• 建议区间：10-50次迭代

• 建议区间：50-200次迭代

• 建议区间：200-500次迭代

Hyperband优化

• 假设优化算法关注n组参数，每组参数训练m轮；

• 在第一时刻n=16，m=25，进行训练；

• 第一时刻训练完成之后保留效果最好的前一半的参数，并加大训练轮数m

• 在第二时刻n=8， m=50，进行训练；

• 循环，直到找到最优参数。

import optuna
from sklearn import datasets
from sklearn.model_selection import cross_val_score
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义目标函数
def objective(trial):
    C = trial.suggest_loguniform('C', 0.1, 10)
    gamma = trial.suggest_loguniform('gamma', 0.001, 0.1)
    kernel = trial.suggest_categorical('kernel', ['linear', 'rbf'])
    
    model = SVC(C=C, gamma=gamma, kernel=kernel)
    scores = cross_val_score(model, X_train, y_train, cv=5)
    return 1.0 - scores.mean()  # 最大化准确率，即最小化1 - 准确率

# 创建 Optuna 研究
study = optuna.create_study(direction='minimize', sampler=optuna.samplers.TPESampler(), pruner=optuna.pruners.HyperbandPruner())

# 运行 Hyperband 优化
study.optimize(objective, n_trials=50)

# 输出最佳参数
print("Best parameters found: ", study.best_params)

# 使用最佳参数的模型进行预测
best_model = SVC(**study.best_params)
best_model.fit(X_train, y_train)
y_pred = best_model.predict(X_test)

# 输出模型性能
from sklearn.metrics import accuracy_score
print("Test accuracy: ", accuracy_score(y_test, y_pred))

网络架构搜索

NAS思路（与超参数优化相似）

• 搜索空间：网络超参数

• 搜索策略：

• 评估方法：

The One-shot Approach

• 只需要考虑架构与架构之间的评估排序，选出更好的架构，不需要要求数据集上精度

调参经验

• 记录调参数据

• 控制变量

• 代码版本控制