sklearn机器学习的常用知识点（二）

已于 2023-09-05 13:28:51 修改
阅读量246 收藏 3
点赞数 1
文章标签： 机器学习 sklearn 人工智能 python
于 2023-07-18 20:18:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64206944/article/details/131794494
版权
本文介绍了机器学习中的模型调参方法，包括线性回归、随机梯度下降、岭回归的调优，以及K近邻、逻辑回归、决策树、朴素贝叶斯和支持向量机的分类模型。此外，还讨论了无监督学习中的聚类模型和关联模型。文章强调了参数选择和交叉验证的重要性，提供了使用GridSearchCV进行调优的示例。
摘要由CSDN通过智能技术生成

上一篇文章说完了 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 使用随机梯度下降算法进行优化，下面是一些常用的调参方法：

  1. alpha 参数控制正则化项的强度，用于防止过拟合。较大的 alpha 值会增加正则化的影响。可以通过交叉验证或使用网格搜索等方法来确定最佳的 alpha 值。通常，较小的 alpha 值可以得到更接近原始线性回归的解，而较大的 alpha 值可以提高模型的稳定性。
  2. learning_rate 参数控制每个样本的学习速率。可选的值包括 “constant”、“invscaling” 和 “adaptive”。你可以根据问题的特点选择合适的学习速率策略。例如，如果样本的特征具有不同的尺度，你可以选择 “invscaling” 来自适应地调整学习速率。
  3. penalty 参数用于选择惩罚项的类型，常见的取值有 “l2” 和 “l1”。默认情况下是 “l2”，即岭回归。选择合适的惩罚项取决于数据的性质和特点。通过交叉验证等方法尝试不同的惩罚项，并选择能够提高模型效果的那个。
  4. 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 是一种使用岭回归的线性回归模型，下面是一些常用的调参方法：

  1. alpha 参数用于控制正则化项的强度。像 SGDRegressor 一样，可以通过交叉验证或使用网格搜索等方法来选择最佳的 alpha 值。
  2. solver 参数控制求解最小二乘问题的算法。常用的取值有 “auto”、“svd”、“cholesky” 和 “sparse_cg”。可以根据数据集的大小和特征维度选择合适的求解算法。通常情况下，默认值 “auto” 即可满足大多数问题的需求。
  3. normalize 参数用于标准化特征。默认情况下是 False，不进行标准化。如果特征具有不同的尺度，你可以将其设置为 True 进行特征归一化。
  4. 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时，可以使用各种调优方法来提高模型性能和泛化能力。以下是一些常见的调优方法：

  1. 调整树的深度或最大深度（max_depth）： 决策树的深度控制树的复杂度和拟合能力。通过限制树的深度，可以防止过拟合。可以尝试不同的深度值，并选择在验证集上获得最佳性能的深度。

  2. 调整节点分裂的最小样本数（min_samples_split）： 决策树分裂节点所需的最小样本数。通过增加最小样本数，可以控制树的生长，减少过拟合的风险。

  3. 调整叶节点的最小样本数（min_samples_leaf）： 定义叶节点所需的最小样本数。增加这个值可以使叶节点更多样化，防止模型对训练数据过度拟合。

  4. 使用特征选择方法（max_features）： 决策树在每个节点选择分裂特征时，可以考虑的最大特征数量。可以通过尝试不同的max_features值来调整特征的选择策略。

  5. 使用剪枝方法： 剪枝是一种常见的决策树调优技术，用于减少过拟合。可以应用预剪枝（在树的生长过程中提前停止分裂）或后剪枝（对已经生成的树进行修剪）。

  6. 使用交叉验证进行模型选择： 通过使用交叉验证，可以评估不同超参数组合的模型性能，并选择具有最佳性能的模型。可以使用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：随机数生成器的种子值，用于确定初始簇中心。

调参方法：

  1. 聚类数量 n_clusters：这是最重要的参数之一，它决定了我们要将数据划分为多少个簇。通常需要通过先验知识、业务需求或者使用其他指标（如轮廓系数）进行评估来选择最优的聚类数量。

  2. 初始化方法 init：初始化方法指定了簇中心的初始位置。可以选择 'k-means++'、'random' 或者自定义一个 numpy 数组。一般情况下，使用默认的 'k-means++' 就可以获得较好的结果。

  3. 迭代次数 max_iter：控制算法的最大迭代次数。一般情况下，K-Means 算法会在达到最大迭代次数前收敛，所以大部分情况下无需改变这个参数。

  4. 尝试不同初始簇中心的次数 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中使用它们的方法。

  1. Apriori算法：Apriori算法是一种频繁项集挖掘算法，用于寻找数据集中的频繁项集和关联规则。虽然Scikit-learn中没有直接实现Apriori算法，但可以使用第三方包，如mlxtend来实现。Mlxtend是一个Scikit-learn的扩展包，提供了Apriori算法的实现。

  2. FP-growth算法：FP-growth算法也是一种用于频繁项集挖掘的算法，与Apriori算法相比，在处理大规模数据时具有更高的效率。同样，Scikit-learn中没有直接实现FP-growth算法，但可以使用第三方包，如pyfpgrowth来实现。

  3. 关联规则学习：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：随机数生成器的种子值，用于控制随机性。

调参方法：

  1. 决策树数量 n_estimators：决策树的数量是随机森林中的一个重要参数。较多的决策树可以提供更好的性能，但也会增加计算成本。可以通过交叉验证来评估不同数量的决策树，并选择性能最佳的数量。

  2. 决策树的最大深度 max_depth：决策树的最大深度控制了决策树的复杂度和模型的容量。较深的树可以更好地适应训练数据，但也容易过拟合。可以尝试不同的最大深度值，并使用交叉验证来选择最合适的深度。

  3. 最小拆分样本数 min_samples_split 和最小叶节点样本数 min_samples_leaf：这两个参数控制了决策树的生长停止条件。增大这两个参数可以防止过拟合，但可能会导致欠拟合。可以通过网格搜索等方法选择合适的取值。

  4. 最大特征数量 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：随机数生成器的种子值，用于控制随机性。

调参方法：

  1. 决策树数量 n_estimators 和学习率 learning_rate：这两个参数是 XGBoost 中最重要的参数。增加树的数量（较大的 n_estimators）可以提高模型性能，但可能增加过拟合的风险。较小的学习率可以使每棵树的贡献更小，有助于提高模型的泛化能力。可以使用交叉验证来选择最佳的树的数量和学习率。

  2. 最大深度 max_depth：决策树的最大深度控制了模型的复杂度和容量。较深的树可以更好地拟合训练数据，但可能导致过拟合。可以通过交叉验证选择最佳的最大深度。

  3. 子样本比例 subsample 和特征比例 colsample_bytree：这两个参数可以控制每棵树的样本和特征的随机采样比例。较小的比例可以降低方差，但可能增加偏差。可以通过交叉验证选择最佳的取值。

  4. 其他参数：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 相似，可以使用以下方法进行调参：

  1. 决策树数量 n_estimators 和学习率 learning_rate：这两个参数是模型性能的关键因素。增加树的数量（较大的 n_estimators）可以提高模型性能，但可能增加过拟合的风险。较小的学习率可以使每棵树的贡献更小，有助于提高模型的泛化能力。可以使用交叉验证来选择最佳的树的数量和学习率。

  2. 最大深度 max_depth：决策树的最大深度控制了模型的复杂度和容量。较深的树可以更好地拟合训练数据，但可能导致过拟合。可以通过交叉验证选择最佳的最大深度。

  3. 子样本比例 subsample 和特征比例 colsample_bytree：这两个参数控制每棵树的样本和特征的随机采样比例。较小的比例可以降低方差，但可能增加偏差。可以通过交叉验证选择最佳的取值。

  4. 其他参数：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的实现方式和步骤：

  1. 创建基础学习器：首先，您需要选择多个不同类型的基础学习器，例如决策树、支持向量机、随机森林等。每个基础学习器都会在采用不同的算法或参数设置的情况下训练，并生成预测结果。

  2. 创建元学习器：接下来，您需要选择一个元学习器来整合基础学习器的预测结果。通常，元学习器是一个简单而高效的模型，比如逻辑回归、支持向量机等。您可以使用Scikit-learn中的任何分类器或回归器作为元学习器。

  3. 创建Stacking模型：使用Scikit-learn中的StackingClassifier（用于分类问题）或StackingRegressor（用于回归问题）类来创建Stacking模型。这些类提供了对Stacking的封装，并且具有与其他分类器和回归器类似的接口。您需要指定基础学习器和元学习器作为参数传递给Stacking模型。

  4. 训练Stacking模型：使用训练数据集拟合Stacking模型。在训练过程中，基础学习器被分别训练，并且它们的预测结果被用作元学习器的输入特征。

  5. 进行预测：使用训练好的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、分类中解决类别不平衡问题

  当遇到数据类别不平衡的时候，我们该如何处理。在Python 中，有 Imblearn包，它就是为处理数据⽐例失衡⽽⽣的。
安装Imblearn包
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)

谢谢观看，希望本篇文章对你有帮助

迷倒万千少女的Csir
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
【机器学习小论文】sklearn线性回归LinearRegression代码及调参
xiaohutong1991的专栏
08-23 6663
一、前言 最近在写小论文，就是硕士毕业论文的部分成果，需要用到线性回归，所以就把相关代码贴上，便于日后写论文时总结，也顺便给后来者提供思路。小论文的思路主要是，先用线性回归，再用随机森林，最后再用xgboost，来预测房价，最后得出结论。所以，这个会陆续的贴出相关代码。至于数据清洗那一块，暂时不贴上了，主要原因就是数据清洗不容易，并且每个人的清洗方法也不一样，所以主要还是看思路。 二、算法简介 2.1 什么是回归分析 回归分析是一种预测性的建模技术，它研究的是因变量（目标）和自变量（预测器）之间的关
机器学习【线性回归算法2】
weixin_43923463的博客
08-04 979
过拟合：一个假设在训练数据上能够获得比其他假设更好的拟合， 但是在测试数据集上却不能很好地拟合数据，此时认为这个假设出现了过拟合的现象。(模型过于复杂)欠拟合：一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据，此时认为这个假设出现了欠拟合的现象。(模型过于简单)那么是什么原因导致模型复杂？线性回归进行训练学习的时候变成模型会变得复杂，这里就对应前面再说的线性回归的两种关系，非线性关系的数据，也就是存在很多无用的特征或者现实中的事物特征跟目标值的关系并不是简单的线性关系。....
基于Python的Linear Regression实验报告
毕业作品网站
09-15 711
本次数据集为 Boston House Price 数据集，房价影响因素及房价通过sklearn.datasets获取数据数据共506项，数据集有13种影响因素对数据进行拆分，测试集比例test_size=0.2。
sklearn线性回归LinearRegression代码及调参
lyy的博客
09-19 1万+
代码： from sklearn import datasets from sklearn.linear_model import LinearRegression import matplotlib.pyplot as plt # 使用以后的数据集进行线性回归（这里是波士顿房价数据） ##1 数据的加载 from sklearn.model_selection import train_t...
使用线性回归模型SGDRegressor进行预测
weixin_43910854的博客
05-01 3858
读入数据 定义特征与目标值 data_x = data.iloc[:,1:-1] data_y = data[['MPG']] 划分数据集 from sklearn.model_selection import train_test_split x_train ,x_test, y_train, y_test = train_test_split(data_x, data_y, test_si...
机器学习Python算法知识点大全，包含sklearn中的机器学习模型和Python预处理的pandas和numpy知识点
01-22
本篇文章将详细讲解基于Python的机器学习知识点，重点关注sklearn库以及数据预处理中常用的pandas和numpy库。 首先，我们要理解机器学习的基本概念。机器学习是一种让计算机通过数据学习和改进的方法，它不依赖于...
sklearn机器学习 bilibili菜菜_WZB.rar
02-17
《sklearn机器学习教程——基于bilibili菜菜_WZB分享》 在现代数据分析领域，机器学习扮演着至关重要的角色。Python中的scikit-learn（简称sklearn）库是机器学习实践中最常用且功能强大的工具之一。这个教程集合了...
机器学习sklearn
02-01
【标题】"机器学习sklearn" 涉及的核心知识点主要围绕着机器学习以及Python中的Scikit-Learn（sklearn）库展开。Scikit-learn是Python中最常用的机器学习库之一，提供了各种监督和无监督学习算法，以及数据预处理、...
机器学习期末复习题及答案
03-19
以下是机器学习的知识点总结： 单项选择题 1. 机器学习把数据集分成训练集和测试集，用于模型训练和评估。 2. 解决模型欠拟合的方法有增加训练数据量、对模型进行裁剪、增加训练过程的迭代次数、正则化等。 3. K ...
邹博机器学习 - SVM实践
最新发布
04-01
根据给定文件的信息，我们可以提炼出以下几个主要的知识点： ### 1. SVM（支持向量机）概述 - **定义**：支持向量机（Support Vector Machine, SVM）是一种广泛应用于分类与回归分析的监督学习模型。其核心思想是...
linearregression_机器学习算法一：线性回归LinearRegression
weixin_40008946的博客
11-24 248
1.线性模型的基本形式1.1概念给定由 个属性描述的示例 ，其中 是 在第 个属性上的值，线性模型(linear model)试图学得一个通过属性的线性组合来进行预测的函数，即 ，一般用向量形式写成 ,其中 。 和 学得后，模型就得以确定。1.2优点1.线性模型形式简单、易于建模。2.由于直观表达了各属性在预测中的重要性，因此线性模型有很好的可解释性(comprehensibi...
利用线性回归器LinearRegression/SGDRegressor进行回归预测(复习7)
公众号：瑞行AI
01-18 1万+
本文是个人学习笔记，内容主要涉及“基于解析方法估计参数的LinearRegression”和“基于随机梯度下降法估计参数的SGDRegressor”对boston数据集进行线性回归拟合和预测。 当根据数据建模和预测时，如果待预测的目标是连续变量，即为回归问题。回归问题学习时，优化的目标是最小化预测结果与真实值之间的差异，通过优化算法学习到模型参数。预测时，不能苛求回归预测的数值结果要严格地与真实
【机器学习】【线性回归】梯度下降的三种方式(BGD+SGD+MSGD)以及三种调优方法(加快收敛速度)
蔚蓝的天空Tom
03-14 1万+
1.梯度下降算法梯度下降算法的核心思路和公式推导，可以详见前面的文章：梯度下降算法的核心思路和公式推导如果代价函数是凸函数，用梯度下降算法一定可以求得最优解。2.梯度下降的三种方式在ML中，梯度下降有三种方式：1）批量梯度下降(Batch Gradient  Descent，BGD)2）随机梯度下降(Stochastic Gradient Descent，SGD)3）小批量梯度下降(Mini-Ba...
机器学习（十五）回归算法之线性回归
提莫君的博客
03-28 1748
线性回归 线性回归的原理 什么是线性回归 1）定义与公式 线性回归(Linear regression)是利用**回归方程(函数)对一个或多个自变量(特征值)和因变量(目标值)**之间关系进行建模的一种分析方式。 特点：只有一个自变量的情况称为单变量回归，多于一个自变量情况的叫做多元回归 那么怎么理解呢？我们来看几个例子 期末成绩：0.7×考试成绩+0.3×平时成绩 房子价格 = 0.0...
Linear Regression(多变量)
Sarah ~
03-04 2571
波士顿房产数据(完整数据) 波士顿房价数据集（Boston House Price Dataset）（下载地址：http://t.cn/RfHTAgY） 使用sklearn.datasets.load_boston即可加载相关数据。该数据集是一个回归问题。每个类的观察值数量是均等的，共有 506 个观察，13 个输入变量和1个输出变量。 每条数据包含房屋以及房屋周围的详细信息。其中包含城镇犯罪率，...
机器学习经典算法具体解释及Python实现--线性回归（Linear Regression）算法
weixin_33817333的博客
07-31 273
（一）认识回归 回归是统计学中最有力的工具之中的一个。机器学习监督学习算法分为分类算法和回归算法两种，事实上就是依据类别标签分布类型为离散型、连续性而定义的。顾名思义。分类算法用于离散型分布预測，如前面讲过的KNN、决策树、朴素贝叶斯、adaboost、SVM、Logistic回归都是分类算法。回归算法用于连续型分布预測。针对的是数值型的样本，使用回归。能够在给定输入的时候预測出一个数值...
机器学习经典算法详解及Python实现--线性回归（Linear Regression）算法
热门推荐
Adan
12-23 6万+
回归是统计学中最有力的工具之一。回归算法用于连续型分布预测，针对的是数值型的样本，使用回归，可以在给定输入的时候预测出一个数值，这是对分类方法的提升，因为这样可以预测连续型数据而不仅仅是离散的类别标签。回归的目的就是建立一个回归方程用来预测目标值，回归的求解就是求这个回归方程的回归系数。预测的方法当然十分简单，回归系数乘以输入值再全部相加就得到了预测值。说到回归，常常指的也就是线性回归，因此本文阐述的就是多元线性回归方程的求解和应用，通过Python实现。
LinearRegression 预测
Scarlett的博客
12-17 3451
import pandas as pd from sklearn.preprocessing import OneHotEncoder from sklearn.preprocessing import PolynomialFeatures from sklearn.preprocessing import StandardScaler from sklearn.model_selection ...
LinearRegression
beichen0518的博客
06-25 7365
线性回归 f(x) = wx + b 这个函数的导数就是3， 斜率 代表增长率 import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 3 * np.pi, 100) # 正弦函数 y = np.sin(x) plt.plot(x, y) # 余弦 y_daoshu = np.cos(x) p...
sklearn 知识点
01-21
sklearn是一个用于机器学习的Python库，它包含了许多常用的机器学习算法和工具，使得机器学习模型的训练、评估和部署变得更加简单和高效。在sklearn中，有许多重要的知识点，包括数据预处理、特征工程、模型选择和评估等。 首先，数据预处理是sklearn中非常重要的知识点。数据预处理包括数据清洗、数据转换、数据规范化等步骤，它们对于构建高质量的机器学习模型非常关键。在sklearn中，有许多常用的数据预处理工具，例如StandardScaler、MinMaxScaler和OneHotEncoder等。 其次，特征工程也是sklearn中的重要知识点。特征工程包括特征选择、特征转换、特征组合等步骤，它们对于提高模型的性能和泛化能力至关重要。在sklearn中，有许多常用的特征工程工具，例如SelectKBest、PCA和PolynomialFeatures等。 另外，模型选择和评估也是sklearn中不可忽视的知识点。在sklearn中，有许多常用的机器学习模型，例如线性回归、逻辑回归、决策树、支持向量机等，以及许多模型选择和评估工具，例如GridSearchCV、cross_val_score和metrics等。 总之，sklearn是一个非常重要的机器学习库，掌握其中的知识点对于进行机器学习相关的工作至关重要。通过学习sklearn，可以更加高效地构建和部署机器学习模型，提高工作效率和模型性能。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值