上一篇文章说完了 sklearn中 数据预处理,特征工程,以及最终的模型评估,这一篇文章将继续讲解剩下最重要的机器学习模型的使用和调参,以及一些扩展
一、机器学习模型
1.1、监督学习
1.1.1、回归模型
1.1.1.1、正规方程线性回归
LinearRegression
是一个用于线性回归的工具,用于建立和训练线性回归模型。
线性回归是一种用于建模和预测连续数值目标变量的统计模型。它建立了输入特征(自变量)和目标变量(因变量)之间的线性关系。线性回归模型的目标是拟合一条最佳拟合直线,以最小化观察值与模型预测值之间的差异。
LinearRegression
类的主要属性和方法如下:
属性:
coef_
:估计的线性回归系数(斜率/权重)。intercept_
:估计的截距项。
方法:
fit(X, y):
通过输入数据 X 和对应的目标变量 y 进行拟合,训练线性回归模型。predict(X):
使用训练好的模型对新的特征数据 X 进行预测。score(X, y):
计算模型在给定测试数据 X 和对应目标变量 y 上的 R² 分数。
from sklearn.linear_model import LinearRegression
import numpy as np
# 创建一个示例数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])
# 创建并拟合线性回归模型
regressor = LinearRegression()
regressor.fit(X, y)
# 使用训练好的模型进行预测
X_new = np.array([[6]])
y_pred = regressor.predict(X_new)
# 输出预测结果
print(y_pred)
[12.]
在这个例子中,我们使用 LinearRegression
创建了一个线性回归模型,并使用原始数据 X
和目标变量 y
进行模型训练。然后,我们使用训练好的模型对新的特征数据 X_new
进行预测,得到预测结果 y_pred
。
请注意,线性回归模型要求输入数据 X
是一个二维数组(或类似结构),其中每个样本的特征值被表示为行中的元素。目标变量 y
是一个一维数组,包含对应的目标值。
LinearRegression 调参方法:LinearRegression
是一个基本的线性回归模型,不涉及太多超参数的调整。主要根据实际问题的特征选择合适的特征提取和预处理方法,以及对数据进行适当的缩放或标准化。
1.1.1.2、随机梯度下降回归
SGDRegressor
是 Scikit-learn(sklearn)库中的一个线性回归模型,它使用随机梯度下降(Stochastic Gradient Descent,SGD)算法来进行参数估计和优化。相比于传统的正规方程解法(如 LinearRegression
),SGD 算法具有一定的优势,特别是在处理大规模数据集时。
SGDRegressor
类的主要属性和方法与 LinearRegression
类相似。它们共享许多相同的方法,如 fit
(拟合)、predict
(预测)和 score
(评估)。然而,SGDRegressor 还有其他一些特定的属性和方法,例如 loss
、penalty
和 learning_rate
等,用于配置和调整随机梯度下降算法。通过设置这些参数,可以控制模型的正则化策略、学习速率和损失函数等。
from sklearn.linear_model import SGDRegressor
import numpy as np
# 创建一个示例数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])
# 创建并拟合 SGDRegressor 模型
regressor = SGDRegressor()
regressor.fit(X, y)
# 使用训练好的模型进行预测
X_new = np.array([[6]])
y_pred = regressor.predict(X_new)
# 输出预测结果
print(y_pred)
[12.00008573]
在这个例子中,我们使用 SGDRegressor
创建了一个线性回归模型,并使用原始数据 X
和目标变量 y
进行模型训练。然后,我们使用训练好的模型对新的特征数据 X_new
进行预测,得到预测结果 y_pred
。
SGDRegressor 调参方法:SGDRegressor 使用随机梯度下降算法进行优化,下面是一些常用的调参方法:
- alpha 参数控制正则化项的强度,用于防止过拟合。较大的 alpha 值会增加正则化的影响。可以通过交叉验证或使用网格搜索等方法来确定最佳的 alpha 值。通常,较小的 alpha 值可以得到更接近原始线性回归的解,而较大的 alpha 值可以提高模型的稳定性。
- learning_rate 参数控制每个样本的学习速率。可选的值包括 “constant”、“invscaling” 和 “adaptive”。你可以根据问题的特点选择合适的学习速率策略。例如,如果样本的特征具有不同的尺度,你可以选择 “invscaling” 来自适应地调整学习速率。
- penalty 参数用于选择惩罚项的类型,常见的取值有 “l2” 和 “l1”。默认情况下是 “l2”,即岭回归。选择合适的惩罚项取决于数据的性质和特点。通过交叉验证等方法尝试不同的惩罚项,并选择能够提高模型效果的那个。
- max_iter 参数是指梯度下降算法的最大迭代次数。你可以根据问题的复杂程度和数据集的大小来调整这个参数。如果模型尚未收敛,你可以增加 max_iter 的值。
1.1.1.3、岭回归
Ridge
是 Scikit-learn 库中的另一个线性回归模型,它使用岭回归算法来进行参数估计和优化。岭回归是一种正则化线性回归方法,通过添加一个正则化项(Ridge regularization term)来控制模型的复杂度和稳定性。
Ridge
类的属性和方法与 LinearRegression
类相似,但它具有一个重要的额外参数 alpha
,用于控制正则化项的强度。较大的 alpha
值会使模型更加稳定,但可能导致模型的拟合能力降低。
from sklearn.linear_model import Ridge
import numpy as np
# 创建一个示例数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])
# 创建并拟合 Ridge 模型
regressor = Ridge(alpha=0.5)
regressor.fit(X, y)
# 使用训练好的模型进行预测
X_new = np.array([[6]])
y_pred = regressor.predict(X_new)
# 输出预测结果
print(y_pred)
[11.64102564]
Ridge 调参方法:Ridge 是一种使用岭回归的线性回归模型,下面是一些常用的调参方法:
- alpha 参数用于控制正则化项的强度。像 SGDRegressor 一样,可以通过交叉验证或使用网格搜索等方法来选择最佳的 alpha 值。
- solver 参数控制求解最小二乘问题的算法。常用的取值有 “auto”、“svd”、“cholesky” 和 “sparse_cg”。可以根据数据集的大小和特征维度选择合适的求解算法。通常情况下,默认值 “auto” 即可满足大多数问题的需求。
- normalize 参数用于标准化特征。默认情况下是 False,不进行标准化。如果特征具有不同的尺度,你可以将其设置为 True 进行特征归一化。
- max_iter 参数指定算法的最大迭代次数。可以根据问题的复杂程度和数据集的大小调整这个参数。
1.1.1.4、LinearRegression, SGDRegressor,Ridge 调优代码
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.linear_model import LinearRegression, SGDRegressor, Ridge
from sklearn.preprocessing import StandardScaler
# 加载数据集
data = load_boston()
X, y = data.data, data.target
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 特征缩放
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# LinearRegression调优
lr_model = LinearRegression()
lr_model.fit(X_train_scaled, y_train)
lr_score = lr_model.score(X_test_scaled, y_test)
# SGDRegressor调优
sgd_model = SGDRegressor()
param_grid = {'alpha': [0.0001, 0.001, 0.01, 0.1],
'max_iter': [1000, 5000, 10000]}
grid_search_sgd = GridSearchCV(sgd_model, param_grid, cv=5)
grid_search_sgd.fit(X_train_scaled, y_train)
sgd_score = grid_search_sgd.score(X_test_scaled, y_test)
# Ridge调优
ridge_model = Ridge()
param_grid = {'alpha': [0.1, 1, 10, 100]}
grid_search_ridge = GridSearchCV(ridge_model, param_grid, cv=5)
grid_search_ridge.fit(X_train_scaled, y_train)
ridge_score = grid_search_ridge.score(X_test_scaled, y_test)
print("LinearRegression得分:", lr_score)
print("SGDRegressor得分:", sgd_score)
print("Ridge得分:", ridge_score)
print("SGDRegressor最优参数:", grid_search_sgd.best_params_)
print("Ridge最优参数:", grid_search_ridge.best_params_)
在上述示例代码中,我们使用波士顿房价数据集(load_boston)作为示例数据集,对LinearRegression、SGDRegressor和Ridge进行调优。通过特征缩放后,我们分别用各个模型进行拟合和预测,并使用GridSearchCV进行超参数的交叉验证调优。
1.1.2、分类模型
1.1.2.1、K近邻算法
sklearn.neighbors.KNeighborsClassifier
是一个用于实现K最近邻(K-Nearest Neighbors,KNN)分类算法的类。KNN是一种基于实例的学习方法,它通过查找最近邻的训练样本来进行预测。
KNN主要包含以下几个重要参数和方法:
n_neighbors
:控制KNN算法中考虑的最近邻居的数量。默认值为5。weights
:指定近邻的权重。常见的选项有 “uniform” 和 “distance”。“uniform” 表示所有最近邻都具有相同的权重,“distance” 表示权重与距离成反比。默认值为 “uniform”。algorithm
:指定用于计算最近邻居的算法。常见的选项有 “brute”、“kd_tree” 和 “ball_tree”。默认值为 “auto”,表示根据输入数据的类型自动选择最合适的算法。leaf_size
:用于构造KD树或球树的叶子节点的大小。默认值为30。p
:用于计算距离的参数。对于p = 1
,使用曼哈顿距离;对于p = 2
,使用欧氏距离。默认值为2(欧氏距离)。fit(X, y)
:用于训练模型,其中X
是训练数据的特征,y
是对应的目标变量。predict(X)
:用学习到的模型对新数据X
进行预测,返回预测结果数组。
K最近邻分类器(KNN) 调参方法:
n_neighbors
参数控制KNN算法中考虑的最近邻居的数量。较小的值可能导致模型过于复杂而容易过拟合,较大的值可能导致模型过于简单而容易欠拟合。你可以通过交叉验证或使用网格搜索等方法来选择最佳的n_neighbors
值。weights
参数用于指定近邻的权重。常见的选项有 “uniform” 和 “distance”。“uniform” 表示所有最近邻都具有相同的权重,“distance” 表示权重与距离成反比。根据问题的特点,你可以选择合适的权重。通过交叉验证等方法来比较它们的效果。metric
参数用于指定计算距离的度量方法。常见的度量方法包括 “euclidean”、“manhattan” 和 “cosine”。你可以根据数据的特点选择合适的距离度量方法。例如,“euclidean” 适用于连续特征,“manhattan” 适用于离散特征,“cosine” 适用于文本数据。通过交叉验证或试验不同的度量方法来确定最佳的选择。
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
# 创建KNN分类器对象
knn = KNeighborsClassifier()
# 定义要调优的参数组合
param_grid = {
'n_neighbors': [3, 5, 7], # 最近邻居的数量
'weights': ['uniform', 'distance'], # 选择权重的方式
'metric': ['euclidean', 'manhattan'] # 距离度量方法
}
# 使用GridSearchCV进行参数搜索
grid_search = GridSearchCV(knn, param_grid, cv=5)
grid_search.fit(X_train, y_train)
# 输出最佳参数组合和对应的模型得分
print("Best Parameters: ", grid_search.best_params_)
print("Best Score: ", grid_search.best_score_)
1.1.2.2、逻辑斯蒂回归
sklearn.linear_model.LogisticRegression
是一个用于实现逻辑回归模型的类。逻辑回归是一种广义线性模型,常用于二分类问题,可以通过调整阈值进行概率预测。
逻辑回归主要包含以下几个重要参数和方法:
penalty
:正则化方法的类型。常见的选项有 “l1” 和 “l2”。默认值为 “l2”。C
:正则化强度的倒数。较小的C
值表示较强的正则化,有助于防止过拟合。默认值为1.0。solver
:优化算法的选择。常见的选项有 “liblinear”、“newton-cg”、“lbfgs”、“sag” 和 “saga”。默认值为 “lbfgs”。fit(X, y)
:用于训练模型,其中X
是训练数据的特征,y
是对应的目标变量。predict(X)
:用学习到的模型对新数据X
进行预测,返回预测结果数组。
逻辑回归(Logistic Regression) 调参方法:
C
参数控制正则化强度,它的倒数(1/C)可以理解为正则化项的权重。较小的C
值会增加正则化的影响,有助于防止过拟合。你可以通过交叉验证或使用网格搜索等方法来选择最佳的C
值。penalty
参数用于选择正则化的类型。常见的选项有 “l1” 和 “l2”。“l1” 正则化倾向于产生稀疏模型,“l2” 正则化倾向于平滑模型的系数。通过交叉验证等方法比较它们的效果,并选择更适合数据的正则化类型。solver
参数用于指定优化算法。常用的取值有 “liblinear”、“lbfgs” 和 “sag”。根据问题的规模和数据的特点进行选择。“liblinear” 适用于小型数据集,“lbfgs” 适用于多类问题,“sag” 适用于大型数据集。你可以根据实际情况进行尝试和选择。max_iter
参数指定算法的最大迭代次数。你可以根据问题的复杂程度和数据集的大小调整这个参数。如果模型没有收敛,你可以增加max_iter
的值。
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV
# 创建逻辑回归模型对象
logreg = LogisticRegression()
# 定义要调优的参数组合
param_grid = {
'C': [0.1, 1.0, 10.0], # 正则化强度的倒数
'penalty': ['l1', 'l2'], # 正则化类型
'solver': ['liblinear', 'lbfgs', 'sag'], # 优化算法
'max_iter': [100, 500, 1000] # 最大迭代次数
}
# 使用GridSearchCV进行参数搜索
grid_search = GridSearchCV(logreg, param_grid, cv=5)
grid_search.fit(X_train, y_train)
# 输出最佳参数组合和对应的模型得分
print("Best Parameters: ", grid_search.best_params_)
print("Best Score: ", grid_search.best_score_)
1.1.2.3、决策树
DecisionTreeClassifier
类是scikit-learn库中的一个分类器,用于创建决策树模型。决策树是一种基于树形结构的监督学习算法,通过对特征进行有序划分来进行预测。DecisionTreeClassifier
使用训练数据拟合决策树模型,并用于进行分类任务。
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 创建一个决策树分类器对象
clf = DecisionTreeClassifier()
# 准备数据集
X = [[0, 0], [1, 1]] # 特征矩阵
y = [0, 1] # 目标变量
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 使用训练集拟合模型
clf.fit(X_train, y_train)
# 使用模型进行预测
y_pred = clf.predict(X_test)
# 计算预测准确率
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
使用DecisionTreeClassifier
时,可以使用各种调优方法来提高模型性能和泛化能力。以下是一些常见的调优方法:
-
调整树的深度或最大深度(
max_depth
): 决策树的深度控制树的复杂度和拟合能力。通过限制树的深度,可以防止过拟合。可以尝试不同的深度值,并选择在验证集上获得最佳性能的深度。 -
调整节点分裂的最小样本数(
min_samples_split
): 决策树分裂节点所需的最小样本数。通过增加最小样本数,可以控制树的生长,减少过拟合的风险。 -
调整叶节点的最小样本数(
min_samples_leaf
): 定义叶节点所需的最小样本数。增加这个值可以使叶节点更多样化,防止模型对训练数据过度拟合。 -
使用特征选择方法(
max_features
): 决策树在每个节点选择分裂特征时,可以考虑的最大特征数量。可以通过尝试不同的max_features
值来调整特征的选择策略。 -
使用剪枝方法: 剪枝是一种常见的决策树调优技术,用于减少过拟合。可以应用预剪枝(在树的生长过程中提前停止分裂)或后剪枝(对已经生成的树进行修剪)。
-
使用交叉验证进行模型选择: 通过使用交叉验证,可以评估不同超参数组合的模型性能,并选择具有最佳性能的模型。可以使用scikit-learn库中的交叉验证方法,例如
GridSearchCV
和RandomizedSearchCV
。
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
# 加载鸢尾花数据集
iris = 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)
# 创建一个决策树分类器对象
clf = DecisionTreeClassifier()
# 设置超参数的候选值
param_grid = {
'max_depth': [3, 5, 7],
'min_samples_split': [2, 4, 6],
'min_samples_leaf': [1, 2, 3]
}
# 创建网格搜索对象
grid_search = GridSearchCV(clf, param_grid, cv=5)
# 在训练集上拟合模型和参数搜索
grid_search.fit(X_train, y_train)
# 输出最佳参数和得分
print("Best parameters:", grid_search.best_params_)
print("Best score:", grid_search.best_score_)
# 使用最佳参数的模型进行预测
best_clf = DecisionTreeClassifier(**grid_search.best_params_)
best_clf.fit(X_train, y_train)
y_pred = best_clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
1.1.2.4、朴素贝叶斯
sklearn.naive_bayes.MultinomialNB
是一种朴素贝叶斯(Naive Bayes)分类器,适用于多项式分布的特征。朴素贝叶斯方法基于贝叶斯定理和特征之间的条件独立性假设,可以在文本分类、垃圾邮件过滤等任务中表现良好。
朴素贝叶斯主要包含以下几个重要参数和方法:
alpha
:平滑参数,用于处理可能的零概率问题。较大的值对应较强的平滑。默认值为1.0。fit(X, y)
:用于训练模型,其中X
是训练数据的特征,y
是对应的目标变量。predict(X)
:用学习到的模型对新数据X
进行预测,返回预测结果数组。
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split
# 准备数据
X = ["I am happy", "I am sad", "You are happy", "You are sad"]
y = ["positive", "negative", "positive", "negative"]
# 将文本数据转换为特征向量
vectorizer = CountVectorizer()
X_vectorized = vectorizer.fit_transform(X)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X_vectorized, y, test_size=0.2, random_state=42)
# 构建朴素贝叶斯模型
model = MultinomialNB()
# 使用训练集进行模型训练
model.fit(X_train, y_train)
# 在测试集上进行预测
y_pred = model.predict(X_test)
# 输出预测结果
print("结果:", y_pred)
对于朴素贝叶斯方法,由于其假设特征之间的条件独立性,所以参数调优相对较少。
1.1.2.5、支持向量机
sklearn.svm.SVC
是支持向量机(Support Vector Machine)分类器的实现类。支持向量机是一种强大的机器学习算法,常用于分类和回归任务。它通过找到一个最优的超平面来实现分类,使得两个不同类别的样本分布在超平面两侧,并尽可能保持最大的间隔。
支持向量机主要包含以下几个重要参数和方法:
C
:惩罚系数,用于控制误分类样本的惩罚力度。较小的值对应较强的正则化,有助于防止过拟合。默认值为1.0。kernel
:核函数的类型。常见的选项有 “linear”(线性核)、“rbf”(径向基函数核)、“poly”(多项式核)等。默认值为 “rbf”。gamma
:核函数的参数。较大的值会产生复杂的决策边界,较小的值会产生简单的决策边界。默认值为 “scale”,表示根据特征进行自动缩放。fit(X, y)
:用于训练模型,其中X
是训练数据的特征,y
是对应的目标变量。predict(X)
:用学习到的模型对新数据X
进行预测,返回预测结果数组。
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC
# 定义参数网格
param_grid = {
'C': [0.1, 1, 10],
'kernel': ['linear', 'rbf'],
'gamma': [0.1, 1, 10]
}
# 创建支持向量机分类器
svm = SVC()
# 使用 GridSearchCV 进行参数搜索
grid_search = GridSearchCV(svm, param_grid, cv=5)
grid_search.fit(X_train, y_train)
# 输出最佳参数组合和对应的模型得分
print("Best Parameters: ", grid_search.best_params_)
print("Best Score: ", grid_search.best_score_)
上述代码中,我们定义了一个参数网格 param_grid
,包含了多个 C、kernel 和 gamma 的取值。然后,使用 GridSearchCV 对支持向量机分类器进行参数搜索,指定了交叉验证的折数为 5。最后,可以输出最佳参数组合和对应的最佳得分。
1.2、无监督学习
1.2.1、聚类模型
sklearn.cluster.KMeans
是一种常用的聚类算法,用于将样本数据划分为不同的簇。K-Means 算法通过迭代优化来找到最优的簇中心,使得样本到其所属簇中心的距离最小化。
KMeans
类的主要参数和方法如下所示:
n_clusters
:要分成的簇的数量。init
:簇中心初始化的方法,默认为'k-means++'
,表示使用智能初始化。n_init
:尝试不同初始簇中心的次数,默认为 10。max_iter
:最大迭代次数,默认为 300。random_state
:随机数生成器的种子值,用于确定初始簇中心。
调参方法:
-
聚类数量
n_clusters
:这是最重要的参数之一,它决定了我们要将数据划分为多少个簇。通常需要通过先验知识、业务需求或者使用其他指标(如轮廓系数)进行评估来选择最优的聚类数量。 -
初始化方法
init
:初始化方法指定了簇中心的初始位置。可以选择'k-means++'
、'random'
或者自定义一个 numpy 数组。一般情况下,使用默认的'k-means++'
就可以获得较好的结果。 -
迭代次数
max_iter
:控制算法的最大迭代次数。一般情况下,K-Means 算法会在达到最大迭代次数前收敛,所以大部分情况下无需改变这个参数。 -
尝试不同初始簇中心的次数
n_init
:由于 K-Means 是一个基于初始随机簇中心的迭代算法,它可能会收敛到局部最优解。通过尝试多次不同的初始簇中心,可以提高找到全局最优解的机会。默认值为 10,通常可以适当增加这个值。
为了选择最佳的参数组合,可以使用以下方法之一:
- 使用肘部法(Elbow Method)来评估不同聚类数量下的损失函数值,并选择拐点处的聚类数量作为最佳值。
- 使用轮廓系数(Silhouette Score)来评估聚类结果的紧密度和分离度,并选择具有最大轮廓系数的聚类数量作为最佳值。
- 使用网格搜索(Grid Search)方法尝试不同的参数组合,并通过交叉验证来评估每个组合的性能,选择具有最佳性能的参数组合。
from sklearn.cluster import KMeans
from sklearn.model_selection import GridSearchCV
# 准备数据
X = ...
# 定义参数网格
param_grid = {
'n_clusters': [2, 3, 4, 5],
'init': ['k-means++', 'random']
}
# 创建 KMeans 聚类器
kmeans = KMeans()
# 使用 GridSearchCV 进行参数搜索
grid_search = GridSearchCV(kmeans, param_grid, cv=5)
grid_search.fit(X)
# 输出最佳参数组合和对应的模型得分
print("Best Parameters: ", grid_search.best_params_)
print("Best Score: ", grid_search.best_score_)
1.2.2、关联模型
在Scikit-learn(sklearn)中,并没有直接提供专门的关联模型算法。Scikit-learn主要关注于传统的监督学习、无监督学习和降维等任务。然而,对于关联模型,有一些相关的技术和算法可以在Scikit-learn中使用。下面我将为您介绍一些常用的关联模型和在Scikit-learn中使用它们的方法。
-
Apriori算法:Apriori算法是一种频繁项集挖掘算法,用于寻找数据集中的频繁项集和关联规则。虽然Scikit-learn中没有直接实现Apriori算法,但可以使用第三方包,如mlxtend来实现。Mlxtend是一个Scikit-learn的扩展包,提供了Apriori算法的实现。
-
FP-growth算法:FP-growth算法也是一种用于频繁项集挖掘的算法,与Apriori算法相比,在处理大规模数据时具有更高的效率。同样,Scikit-learn中没有直接实现FP-growth算法,但可以使用第三方包,如pyfpgrowth来实现。
-
关联规则学习:Scikit-learn中的关联规则学习技术主要是通过使用无监督学习的方法进行实现。例如,可以使用聚类算法(如K-means)来对数据进行分组,然后通过分析每个聚类中的频繁项集来发现关联规则。
1.3、集成学习
1.3.1、bagging
1.3.1.1、随机森林
sklearn.ensemble.RandomForestRegressor
是一种基于随机森林算法的回归模型。随机森林通过构建多个决策树并对它们的预测结果进行平均来进行回归任务。
RandomForestRegressor
类的主要参数和方法如下所示:
n_estimators
:决策树的数量,默认为 100。criterion
:衡量分裂质量的准则,可以是 “mse”(均方误差)或 “mae”(平均绝对误差)。默认为 “mse”。max_depth
:决策树的最大深度。默认为None
,表示决策树可以无限制地生长。min_samples_split
:拆分内部节点所需的最小样本数,默认为 2。min_samples_leaf
:叶节点所需的最小样本数,默认为 1。max_features
:寻找最佳分割时要考虑的特征数量,可以是整数或浮点数。默认为 “auto”,表示考虑所有特征。random_state
:随机数生成器的种子值,用于控制随机性。
调参方法:
-
决策树数量
n_estimators
:决策树的数量是随机森林中的一个重要参数。较多的决策树可以提供更好的性能,但也会增加计算成本。可以通过交叉验证来评估不同数量的决策树,并选择性能最佳的数量。 -
决策树的最大深度
max_depth
:决策树的最大深度控制了决策树的复杂度和模型的容量。较深的树可以更好地适应训练数据,但也容易过拟合。可以尝试不同的最大深度值,并使用交叉验证来选择最合适的深度。 -
最小拆分样本数
min_samples_split
和最小叶节点样本数min_samples_leaf
:这两个参数控制了决策树的生长停止条件。增大这两个参数可以防止过拟合,但可能会导致欠拟合。可以通过网格搜索等方法选择合适的取值。 -
最大特征数量
max_features
:决定训练每棵决策树时考虑的特征数量。较小的值可以减少方差,但可能会增加偏差。可以尝试不同的取值并选择性能最佳的数量。
为了选择最佳的参数组合,可以使用以下方法之一:
- 使用网格搜索(Grid Search)方法尝试不同的参数组合,并通过交叉验证来评估每个组合的性能,选择具有最佳性能的参数组合。
- 使用随机搜索(Random Search)方法在参数空间中随机选择组合,并通过交叉验证来评估每个组合的性能,选择具有最佳性能的参数组合。
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import GridSearchCV
# 准备数据
X = ...
y = ...
# 定义参数网格
param_grid = {
'n_estimators': [100, 200, 300],
'max_depth': [None, 5, 10],
'min_samples_split': [2, 5, 10],
'min_samples_leaf': [1, 2, 4],
'max_features': ['auto', 'sqrt']
}
# 创建随机森林回归器
rf = RandomForestRegressor()
# 使用 GridSearchCV 进行参数搜索
grid_search = GridSearchCV(rf, param_grid, cv=5)
grid_search.fit(X, y)
# 输出最佳参数组合和对应的模型得分
print("Best Parameters: ", grid_search.best_params_)
print("Best Score: ", grid_search.best_score_)
1.3.2、boosting
1.3.2.1、XGBoost
from xgboost import XGBClassifier
是导入 XGBoost 库中的分类器模型 XGBClassifier
。XGBoost 是一种基于梯度提升算法的集成学习模型,它在各类机器学习竞赛和实际应用中表现出色。XGBClassifier
用于解决分类问题,可以有效地处理高维特征和大规模数据集。
XGBClassifier
类的一些重要参数和方法如下:
n_estimators
:树的数量,默认为 100。max_depth
:树的最大深度,默认为 6。learning_rate
:学习率,控制每个决策树贡献的影响,默认为 0.3。subsample
:每棵树用于训练的样本比例,默认为 1(使用所有样本)。colsample_bytree
:每棵树用于训练的特征比例,默认为 1(使用所有特征)。objective
:用于定义损失函数的目标函数,默认为二分类问题的逻辑回归损失函数。eval_metric
:用于评估模型性能的指标,默认为二分类问题的错误率。random_state
:随机数生成器的种子值,用于控制随机性。
调参方法:
-
决策树数量
n_estimators
和学习率learning_rate
:这两个参数是 XGBoost 中最重要的参数。增加树的数量(较大的n_estimators
)可以提高模型性能,但可能增加过拟合的风险。较小的学习率可以使每棵树的贡献更小,有助于提高模型的泛化能力。可以使用交叉验证来选择最佳的树的数量和学习率。 -
最大深度
max_depth
:决策树的最大深度控制了模型的复杂度和容量。较深的树可以更好地拟合训练数据,但可能导致过拟合。可以通过交叉验证选择最佳的最大深度。 -
子样本比例
subsample
和特征比例colsample_bytree
:这两个参数可以控制每棵树的样本和特征的随机采样比例。较小的比例可以降低方差,但可能增加偏差。可以通过交叉验证选择最佳的取值。 -
其他参数:XGBoost 还有许多其他参数,如正则化参数
gamma
、列采样参数colsample_bylevel
、随机种子random_state
等。可以根据具体问题调整这些参数,并使用交叉验证来评估不同参数组合的性能。
from xgboost import XGBClassifier
from sklearn.model_selection import GridSearchCV
# 准备数据
X = ...
y = ...
# 定义参数网格
param_grid = {
'n_estimators': [100, 200, 300],
'max_depth': [3, 5, 7],
'learning_rate': [0.1, 0.01, 0.001],
'subsample': [0.8, 1.0],
'colsample_bytree': [0.8, 1.0]
}
# 创建 XGBoost 分类器
xgb = XGBClassifier()
# 使用 GridSearchCV 进行参数搜索
grid_search = GridSearchCV(xgb, param_grid, cv=5)
grid_search.fit(X, y)
# 输出最佳参数组合和对应的模型得分
print("Best Parameters: ", grid_search.best_params_)
print("Best Score: ", grid_search.best_score_)
1.3.2.2、LightGBM
from lightgbm import LGBMRegressor
语句导入了 LightGBM 库中的回归模型 LGBMRegressor
。LightGBM 是一种基于梯度提升算法的高性能梯度提升框架,它在许多机器学习任务中都表现出色。
LGBMRegressor
是用于解决回归问题的类,可以根据输入的特征和目标变量来建立回归模型。它具有高效的训练速度和内存利用,能够处理大规模数据集和高维特征。
LGBMRegressor
类的一些重要参数和方法如下:
n_estimators
:树的数量,默认为 100。max_depth
:树的最大深度,默认为 -1,表示不限制最大深度。learning_rate
:学习率,控制每个决策树贡献的影响,默认为 0.1。subsample
:每棵树用于训练的样本比例,默认为 1(使用所有样本)。colsample_bytree
:每棵树用于训练的特征比例,默认为 1(使用所有特征)。objective
:用于定义损失函数的目标函数,默认为均方根误差(RMSE)。random_state
:随机数生成器的种子值,用于控制随机性。
调参方法与 XGBoost 相似,可以使用以下方法进行调参:
-
决策树数量
n_estimators
和学习率learning_rate
:这两个参数是模型性能的关键因素。增加树的数量(较大的n_estimators
)可以提高模型性能,但可能增加过拟合的风险。较小的学习率可以使每棵树的贡献更小,有助于提高模型的泛化能力。可以使用交叉验证来选择最佳的树的数量和学习率。 -
最大深度
max_depth
:决策树的最大深度控制了模型的复杂度和容量。较深的树可以更好地拟合训练数据,但可能导致过拟合。可以通过交叉验证选择最佳的最大深度。 -
子样本比例
subsample
和特征比例colsample_bytree
:这两个参数控制每棵树的样本和特征的随机采样比例。较小的比例可以降低方差,但可能增加偏差。可以通过交叉验证选择最佳的取值。 -
其他参数:LightGBM 还有许多其他参数,如正则化参数
reg_alpha
和reg_lambda
、随机种子random_state
、特征重要性计算方法importance_type
等。可以根据具体问题调整这些参数,并使用交叉验证来评估不同参数组合的性能。
from lightgbm import LGBMRegressor
from sklearn.model_selection import GridSearchCV
# 准备数据
X = ...
y = ...
# 定义参数网格
param_grid = {
'n_estimators': [100, 200, 300],
'max_depth': [3, 5, 7],
'learning_rate': [0.1, 0.01, 0.001],
'subsample': [0.8, 1.0],
'colsample_bytree': [0.8, 1.0]
}
# 创建 LightGBM 回归器
lgbm = LGBMRegressor()
# 使用 GridSearchCV 进行参数搜索
grid_search = GridSearchCV(lgbm, param_grid, cv=5)
grid_search.fit(X, y)
# 输出最佳参数组合和对应的模型得分
print("Best Parameters: ", grid_search.best_params_)
print("Best Score: ", grid_search.best_score_)
1.3.2.3、stacking
在Scikit-learn(sklearn)中,"stacking"是一种集成学习的技术,用于将多个基础学习器(也称为“弱学习器”)的预测结果结合起来,形成一个更强大的模型。Stacking的基本思想是使用训练数据集的预测结果作为新的特征,然后训练一个元学习器来整合这些预测结果,从而提升整体的性能。下面我将详细介绍Scikit-learn中stacking的实现方式和步骤:
-
创建基础学习器:首先,您需要选择多个不同类型的基础学习器,例如决策树、支持向量机、随机森林等。每个基础学习器都会在采用不同的算法或参数设置的情况下训练,并生成预测结果。
-
创建元学习器:接下来,您需要选择一个元学习器来整合基础学习器的预测结果。通常,元学习器是一个简单而高效的模型,比如逻辑回归、支持向量机等。您可以使用Scikit-learn中的任何分类器或回归器作为元学习器。
-
创建Stacking模型:使用Scikit-learn中的StackingClassifier(用于分类问题)或StackingRegressor(用于回归问题)类来创建Stacking模型。这些类提供了对Stacking的封装,并且具有与其他分类器和回归器类似的接口。您需要指定基础学习器和元学习器作为参数传递给Stacking模型。
-
训练Stacking模型:使用训练数据集拟合Stacking模型。在训练过程中,基础学习器被分别训练,并且它们的预测结果被用作元学习器的输入特征。
-
进行预测:使用训练好的Stacking模型对新的数据样本进行预测。在预测过程中,基础学习器会生成预测结果,然后元学习器会利用这些结果生成最终的预测。
Stacking是一种有效的集成学习技术,可以通过结合多个学习器的优势,提高模型的泛化能力和性能。通过在Scikit-learn中使用Stacking模型,您能够方便地实现这一技术,并根据自己的需求和数据特征进行调整和优化。
rom sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.ensemble import StackingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
# 加载数据
data = load_iris()
X, y = data.data, data.target
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 定义基础学习器
estimators = [
('dt', DecisionTreeClassifier()),
('knn', KNeighborsClassifier())
]
# 定义元学习器
meta_learner = LogisticRegression()
# 定义Stacking模型
model = StackingClassifier(estimators=estimators, final_estimator=meta_learner)
# 交叉验证评估模型性能
scores = cross_val_score(model, X_train, y_train, cv=5)
mean_score = scores.mean()
# 训练模型
model.fit(X_train, y_train)
# 在测试集上进行预测
y_pred = model.predict(X_test)
print("交叉验证得分:", mean_score)
print("测试集准确率:", model.score(X_test, y_test))
在上面的示例代码中,我们使用了鸢尾花数据集(load_iris)作为示例数据集,使用决策树(DecisionTreeClassifier)和K近邻分类器(KNeighborsClassifier)作为基础学习器,使用逻辑回归(LogisticRegression)作为元学习器。通过交叉验证评估模型性能,并在测试集上进行模型评估。
二、扩展
2.1、分类中解决类别不平衡问题
pip3 install imbalanced-learn
关于类别不平衡的问题,主要有两种处理⽅式:
- 过采样⽅法: 增加数量较少那⼀类样本的数量,使得正负样本⽐例均衡。
- 对训练集⾥的少数类进⾏“过采样”(oversampling),即增加⼀些少数类样本使得正、反例数⽬接近,然后再进⾏学习。
# 使⽤imblearn进⾏随机过采样
from imblearn.over_sampling import SMOTE
smote= SMOTE(random_state=0)
X_resampled, y_resampled = smote.fit_resample(X, y)
#查看结果
Counter(y_resampled)
- ⽋采样⽅法: 减少数量较多那⼀类样本的数量,使得正负样本⽐例均衡
- 直接对训练集中多数类样本进⾏“⽋采样”(undersampling),即去除⼀些多数类中的样本使得正例、反例数⽬接近,然后再进⾏学习。
# 随机⽋采样
from imblearn.under_sampling import RandomUnderSampler
rus = RandomUnderSampler(random_state=0)
X_resampled, y_resampled = rus.fit_resample(X, y)
Counter(y_resampled)
2.2、相关系数
2.2.1、⽪尔逊相关系数
相关系数的值介于–1与+1之间,即–1≤ r ≤+1。其性质如下:
- 当r>0时,表示两变量正相关,r<0时,两变量为负相关
- 当|r|=1时,表示两变量为完全相关,当r=0时,表示两变量间⽆相关关系
- 当0<|r|<1时,表示两变量存在⼀定程度的相关。且|r|越接近1,两变量间线性关系越密切;|r|越接近于0,表示两变量的线性相关越弱
- ⼀般可按三级划分:|r|<0.4为低度相关;0.4≤|r|<0.7为显著性相关;0.7≤|r|<1为⾼度线性相关
x1 = [12.5, 15.3, 23.2, 26.4, 33.5, 34.4, 39.4, 45.2, 55.4, 60.9]
x2 = [21.2, 23.9, 32.9, 34.1, 42.5, 43.2, 49.0, 52.8, 59.4, 63.5]
ret = pearsonr(x1, x2)
print("皮尔逊相关系数:\n ", ret)
2.2.2、斯⽪尔曼相关系数
x1 = [12.5, 15.3, 23.2, 26.4, 33.5, 34.4, 39.4, 45.2, 55.4, 60.9]
x2 = [21.2, 23.9, 32.9, 34.1, 42.5, 43.2, 49.0, 52.8, 59.4, 63.5]
ret = spearmanr(x1, x2)
print("斯⽪尔曼相关系数:\n ", ret)
谢谢观看,希望本篇文章对你有帮助