【机器学习】1.6w字超全汇总！56个sklearn核心操作！！！

最新推荐文章于 2024-05-23 18:00:05 发布
最新推荐文章于 2024-05-23 18:00:05 发布
阅读量27 收藏 1
点赞数
文章标签： 机器学习 sklearn 人工智能 python
原文链接：https://mp.weixin.qq.com/s?__biz=MzIwODI2NDkxNQ==&mid=2247517683&idx=2&sn=5fb177e50a20df383c5fcb7440fbe135&chksm=9698c84a087e5b35687ee3e538501f8c87e107c615461a2c2015060666da5afd738a93a2f504&scene=126&sessionid=0
版权

核心点：关于1.6w字，56个sklearn核心操作！！

整体涉及到56个函数的说明和使用~

14eb4448259df494f0b3a2036049d0a8.png

简单来说，scikit-learn 是一个非常非常常用的机器学习库，提供了许多用于数据预处理、模型选择、评估和部署的功能。

今天所有的内容建议初学者花一天时间实操一遍，具体咱们一起来看看~

数据预处理

数据集划分

train_test_split

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

其中，X是特征数据，y是目标数据，test_size是测试集的比例（可以是0到1之间的值），random_state是随机种子，用于保证每次划分的结果一致。

使用train_test_split：

import numpy as np
from sklearn.model_selection import train_test_split

# 创建一个数据集
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
y = np.array([0, 1, 0, 1])

# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

print("训练集 X：\n", X_train)
print("测试集 X：\n", X_test)
print("训练集 y：\n", y_train)
print("测试集 y：\n", y_test)

这个示例创建了一个特征矩阵X和目标向量y，然后使用train_test_split函数将数据集划分为训练集和测试集。

标准化/归一化

StandardScaler

用于标准化特征数据，使其具有标准正态分布（均值为0，方差为1）。

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

其中，fit_transform方法用于计算训练集的均值和标准差，并进行标准化转换。transform方法用于在测试集上应用相同的转换。

使用StandardScaler：

import numpy as np
from sklearn.preprocessing import StandardScaler

# 创建一个特征矩阵
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]], dtype=np.float64)

# 创建一个StandardScaler对象并进行标准化转换
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

print("原始数据 X：\n", X)
print("标准化后的数据 X_scaled：\n", X_scaled)
print("均值：", scaler.mean_)
print("标准差：", scaler.scale_)

创建了一个特征矩阵X，然后使用StandardScaler进行标准化转换，并输出了转换后的数据以及均值和标准差。

MinMaxScaler

用于将特征数据缩放到给定的最小值和最大值之间，默认情况下，最小值为0，最大值为1。

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

fit_transform方法用于计算训练集的最小值和最大值，并进行缩放转换。transform方法用于在测试集上应用相同的缩放。

import numpy as np
from sklearn.preprocessing import MinMaxScaler

# 创建一个特征矩阵
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]], dtype=np.float64)

# 创建一个MinMaxScaler对象并进行缩放转换
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

print("原始数据 X：\n", X)
print("缩放后的数据 X_scaled：\n", X_scaled)
print("最小值：", scaler.data_min_)
print("最大值：", scaler.data_max_)

代码中，创建了一个特征矩阵X，然后使用MinMaxScaler进行缩放转换，并输出了转换后的数据以及最小值和最大值。

RobustScaler

用于缩放特征数据，使其对异常值具有更好的鲁棒性。与StandardScaler和MinMaxScaler不同，RobustScaler使用中位数和四分位数范围进行缩放。

from sklearn.preprocessing import RobustScaler

scaler = RobustScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

fit_transform方法用于计算训练集的中位数和四分位数范围，并进行缩放转换。transform方法用于在测试集上应用相同的转换。

import numpy as np
from sklearn.preprocessing import RobustScaler

# 创建一个特征矩阵
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]], dtype=np.float64)

# 添加一个异常值
X[0, 0] = 1000

# 创建一个RobustScaler对象并进行缩放转换
scaler = RobustScaler()
X_scaled = scaler.fit_transform(X)

print("原始数据 X：\n", X)
print("缩放后的数据 X_scaled：\n", X_scaled)
print("中位数：", scaler.center_)
print("四分位数范围：", scaler.scale_)

代码中，创建了一个特征矩阵X，其中包含一个异常值，然后使用RobustScaler进行缩放转换，并输出了转换后的数据以及中位数和四分位数范围。

数据变换

FunctionTransformer

对数据应用自定义的函数转换。

from sklearn.preprocessing import FunctionTransformer

# 定义自定义函数
def custom_func(X):
    return X + 10  # 举例：将数据中的每个元素都加上10

# 创建FunctionTransformer对象并进行转换
transformer = FunctionTransformer(func=custom_func)
X_transformed = transformer.fit_transform(X)

fit_transform方法用于对数据进行转换，可以传入自定义的函数。代码中，定义了一个将数据中的每个元素加上10的函数custom_func，然后使用FunctionTransformer进行转换。

import numpy as np
from sklearn.preprocessing import FunctionTransformer

# 创建一个特征矩阵
X = np.array([[1, 2], [3, 4], [5, 6]])

# 定义自定义函数
def custom_func(X):
    return X + 10

# 创建FunctionTransformer对象并进行转换
transformer = FunctionTransformer(func=custom_func)
X_transformed = transformer.fit_transform(X)

print("原始数据 X：\n", X)
print("转换后的数据 X_transformed：\n", X_transformed)

这个示例创建了一个特征矩阵X，然后使用FunctionTransformer将每个元素加上10进行转换。

PowerTransformer

用于对数据进行幂变换，使其更符合高斯分布。PowerTransformer提供了两种幂变换方法：Yeo-Johnson变换和Box-Cox变换。

默认情况下，PowerTransformer使用Yeo-Johnson变换。

from sklearn.preprocessing import PowerTransformer

scaler = PowerTransformer(method='yeo-johnson')
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

fit_transform方法用于计算变换参数并进行变换。对于Yeo-Johnson变换，数据必须严格大于0；对于Box-Cox变换，数据必须严格大于0。

如果数据中存在非正数值，可以使用StandardScaler或RobustScaler等方法先进行缩放。

import numpy as np
from sklearn.preprocessing import PowerTransformer

# 创建一个特征矩阵
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]], dtype=np.float64)

# 创建一个PowerTransformer对象并进行幂变换
scaler = PowerTransformer(method='yeo-johnson')
X_scaled = scaler.fit_transform(X)

print("原始数据 X：\n", X)
print("幂变换后的数据 X_scaled：\n", X_scaled)

代码中，创建了一个特征矩阵X，然后使用PowerTransformer进行幂变换，并输出了转换后的数据。

特征选择

SelectKBest

用于选择与目标变量最相关的特征。SelectKBest基于给定的评分函数选择前k个最佳特征。常用的评分函数包括f_classif（用于分类问题的方差分析法）、mutual_info_classif（用于分类问题的互信息法）、f_regression（用于回归问题的方差分析法）等。

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif

selector = SelectKBest(score_func=f_classif, k=2)
X_train_selected = selector.fit_transform(X_train, y_train)
X_test_selected = selector.transform(X_test)

其中，score_func指定了评分函数，k指定了要选择的特征数量。

import numpy as np
from sklearn.datasets import make_classification
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif

# 创建一个分类数据集
X, y = make_classification(n_samples=100, n_features=4, n_informative=2, random_state=0)

# 使用SelectKBest选择最佳特征
selector = SelectKBest(score_func=f_classif, k=2)
X_selected = selector.fit_transform(X, y)

print("原始数据 X：\n", X[:5])
print("选择的最佳特征 X_selected：\n", X_selected[:5])

代码中，创建了一个分类数据集X，然后使用SelectKBest选择了最佳的2个特征，并输出了选择后的特征数据。

SelectPercentile

接下来是SelectPercentile，它也用于特征选择，但是与SelectKBest不同的是，SelectPercentile选择的是按分位数排名的特征而不是固定数量的特征。同样，它也需要指定评分函数。

from sklearn.feature_selection import SelectPercentile
from sklearn.feature_selection import f_classif

selector = SelectPercentile(score_func=f_classif, percentile=50)
X_train_selected = selector.fit_transform(X_train, y_train)
X_test_selected = selector.transform(X_test)

其中，percentile指定了要选择的特征的百分比。

使用SelectPercentile：

import numpy as np
from sklearn.datasets import make_classification
from sklearn.feature_selection import SelectPercentile
from sklearn.feature_selection import f_classif

# 创建一个分类数据集
X, y = make_classification(n_samples=100, n_features=4, n_informative=2, random_state=0)

# 使用SelectPercentile选择最佳特征
selector = SelectPercentile(score_func=f_classif, percentile=50)
X_selected = selector.fit_transform(X, y)

print("原始数据 X：\n", X[:5])
print("选择的最佳特征 X_selected：\n", X_selected[:5])

示例中，创建了一个分类数据集X，使用SelectPercentile选择了最佳的50%特征，并输出了选择后的特征数据。

RFE (Recursive Feature Elimination)

一种递归特征消除方法，用于选择特征的子集。它通过反复训练模型并消除最不重要的特征来进行特征选择。

from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

estimator = LogisticRegression()
selector = RFE(estimator, n_features_to_select=2, step=1)
X_train_selected = selector.fit_transform(X_train, y_train)
X_test_selected = selector.transform(X_test)

其中，estimator是用于训练的基础模型，n_features_to_select是要选择的特征数量，step是每次迭代中要移除的特征数量。

import numpy as np
from sklearn.datasets import make_classification
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

# 创建一个分类数据集
X, y = make_classification(n_samples=100, n_features=4, n_informative=2, random_state=0)

# 使用RFE选择最佳特征
estimator = LogisticRegression()
selector = RFE(estimator, n_features_to_select=2, step=1)
X_selected = selector.fit_transform(X, y)

print("原始数据 X：\n", X[:5])
print("选择的最佳特征 X_selected：\n", X_selected[:5])

代码中，创建了一个分类数据集X，然后使用RFE选择了最佳的2个特征，并输出了选择后的特征数据。

特征降维

PCA (Principal Component Analysis)

用于将高维数据转换为低维数据，同时保留最大的方差。PCA通过找到数据中的主成分（即方差最大的方向）来实现降维。

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)

其中，n_components指定了要保留的主成分数量。

import numpy as np
from sklearn.datasets import load_iris
from sklearn.decomposition import PCA

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

# 使用PCA进行降维
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

print("原始数据 X 的形状：", X.shape)
print("降维后的数据 X_pca 的形状：", X_pca.shape)

这个示例加载了鸢尾花数据集，并使用PCA将数据降至二维，并输出了降维后的数据形状。

TruncatedSVD

一种用于稀疏矩阵的降维技术，类似于PCA，但适用于大型稀疏矩阵。TruncatedSVD通过截断奇异值分解来实现降维。

from sklearn.decomposition import TruncatedSVD

svd = TruncatedSVD(n_components=2)
X_train_svd = svd.fit_transform(X_train)
X_test_svd = svd.transform(X_test)

其中，n_components指定了要保留的成分数量。

import numpy as np
from sklearn.datasets import load_iris
from sklearn.decomposition import TruncatedSVD

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

# 使用TruncatedSVD进行降维
svd = TruncatedSVD(n_components=2)
X_svd = svd.fit_transform(X)

print("原始数据 X 的形状：", X.shape)
print("降维后的数据 X_svd 的形状：", X_svd.shape)

这个示例加载了鸢尾花数据集，并使用TruncatedSVD将数据降至二维，并输出了降维后的数据形状。

FactorAnalysis

一种因子分析方法，用于降低数据的维度并发现潜在的因子结构。FactorAnalysis假设观测数据是由潜在因子和特殊噪声组成的。

from sklearn.decomposition import FactorAnalysis

fa = FactorAnalysis(n_components=2)
X_train_fa = fa.fit_transform(X_train)
X_test_fa = fa.transform(X_test)

其中，n_components指定了要保留的潜在因子数量。

import numpy as np
from sklearn.datasets import load_iris
from sklearn.decomposition import FactorAnalysis

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

# 使用FactorAnalysis进行降维
fa = FactorAnalysis(n_components=2)
X_fa = fa.fit_transform(X)

print("原始数据 X 的形状：", X.shape)
print("降维后的数据 X_fa 的形状：", X_fa.shape)

代码中，加载了鸢尾花数据集，并使用FactorAnalysis将数据降至二维，并输出了降维后的数据形状。

5f1fd1de63ff806b03df0868d6d55cf5.png

监督学习模型

线性模型

LinearRegression

LinearRegression模型通过拟合特征和目标之间的线性关系来进行预测。

from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，X_train是训练集的特征数据，y_train是训练集的目标数据，X_test是测试集的特征数据，y_test是测试集的目标数据。fit方法用于训练模型，predict方法用于进行预测。

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用LinearRegression进行拟合和预测
model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("真实值 y_test：", y_test)
print("预测值 y_pred：", y_pred)

代码中，创建了一个数据集X和y，然后使用LinearRegression进行拟合和预测，并输出了真实值和预测值。

LogisticRegression

LogisticRegression模型使用逻辑函数（logistic function）将线性模型的输出映射到[0, 1]之间，表示样本属于某一类的概率。

from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，X_train是训练集的特征数据，y_train是训练集的目标数据，X_test是测试集的特征数据，y_test是测试集的目标数据。fit方法用于训练模型，predict方法用于进行分类预测。

使用LogisticRegression进行分类预测：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

# 创建一个二分类数据集
X = np.array([[1], [2], [3], [4], [5], [6]])
y = np.array([0, 0, 0, 1, 1, 1])

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

# 使用LogisticRegression进行拟合和预测
model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("真实值 y_test：", y_test)
print("预测值 y_pred：", y_pred)

代码中，创建了一个二分类数据集X和y，然后使用LogisticRegression进行拟合和预测，并输出了真实值和预测值。

Ridge

一种用于回归问题的线性模型，与普通的线性回归相比，Ridge模型通过添加L2正则化项来限制模型参数的大小，从而减少模型的过拟合。

from sklearn.linear_model import Ridge

model = Ridge(alpha=1.0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，alpha是正则化参数，控制正则化的强度。较大的alpha值表示更强的正则化。

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用Ridge进行拟合和预测
model = Ridge(alpha=1.0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("真实值 y_test：", y_test)
print("预测值 y_pred：", y_pred)

创建了一个数据集X和y，然后使用Ridge进行拟合和预测，并输出了真实值和预测值。

Lasso

用于回归问题的线性模型，与普通的线性回归相比，Lasso模型通过添加L1正则化项来限制模型参数的大小，从而可以实现特征选择（即将一些特征的权重调整为0）。

from sklearn.linear_model import Lasso

model = Lasso(alpha=1.0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，alpha是正则化参数，控制正则化的强度。较大的alpha值表示更强的正则化。

使用Lasso进行回归预测：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Lasso

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用Lasso进行拟合和预测
model = Lasso(alpha=1.0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("真实值 y_test：", y_test)
print("预测值 y_pred：", y_pred)

创建了一个数据集X和y，然后使用Lasso进行拟合和预测，并输出了真实值和预测值。

ElasticNet

结合了L1和L2正则化的线性模型，用于回归问题。ElasticNet通过添加L1和L2正则化项来限制模型参数的大小，并可以实现特征选择。

from sklearn.linear_model import ElasticNet

model = ElasticNet(alpha=1.0, l1_ratio=0.5)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，alpha是总的正则化参数，l1_ratio是L1正则化项在总正则化中的比例。

使用ElasticNet进行回归预测：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import ElasticNet

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用ElasticNet进行拟合和预测
model = ElasticNet(alpha=1.0, l1_ratio=0.5)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("真实值 y_test：", y_test)
print("预测值 y_pred：", y_pred)

代码中，创建了一个数据集X和y，然后使用ElasticNet进行拟合和预测，并输出了真实值和预测值。

决策树

DecisionTreeClassifier

基于树结构的分类模型，用于解决分类问题。决策树通过对数据集进行递归划分，使得每个叶节点都包含一个类别标签，从而构建一个分类模型。

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，X_train是训练集的特征数据，y_train是训练集的目标数据，X_test是测试集的特征数据，y_test是测试集的目标数据。fit方法用于训练模型，predict方法用于进行分类预测。

使用DecisionTreeClassifier进行分类预测：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
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)

# 使用DecisionTreeClassifier进行拟合和预测
model = DecisionTreeClassifier()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算模型准确率
accuracy = accuracy_score(y_test, y_pred)
print("模型准确率：", accuracy)

代码中，加载了鸢尾花数据集，并使用DecisionTreeClassifier进行拟合和预测，并计算了模型的准确率。

DecisionTreeRegressor

基于树结构的回归模型，用于解决回归问题。与分类树类似，决策树回归模型通过对数据集进行递归划分，使得每个叶节点都包含一个目标值，从而构建一个回归模型。使用方法与分类树相似：

from sklearn.tree import DecisionTreeRegressor

model = DecisionTreeRegressor()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，X_train是训练集的特征数据，y_train是训练集的目标数据，X_test是测试集的特征数据，y_test是测试集的目标数据。fit方法用于训练模型，predict方法用于进行回归预测。

使用DecisionTreeRegressor进行回归预测：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用DecisionTreeRegressor进行拟合和预测
model = DecisionTreeRegressor()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算均方误差
mse = mean_squared_error(y_test, y_pred)
print("均方误差：", mse)

代码中，创建了一个数据集X和y，然后使用DecisionTreeRegressor进行拟合和预测，并计算了均方误差。

集成方法

RandomForestClassifier

一种集成学习方法，通过构建多个决策树来提高分类性能。随机森林通过在每棵树的训练过程中引入随机性（如随机选择特征和样本），减少了模型的方差，从而提高了泛化能力。

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，n_estimators指定了森林中树的数量，random_state是随机种子，用于控制每次运行时随机性的一致性。

使用RandomForestClassifier进行分类预测：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
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)

# 使用RandomForestClassifier进行拟合和预测
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算模型准确率
accuracy = accuracy_score(y_test, y_pred)
print("模型准确率：", accuracy)

代码中，加载了鸢尾花数据集，并使用RandomForestClassifier进行拟合和预测，并计算了模型的准确率。

RandomForestRegressor

一种集成学习方法，通过构建多个决策树来提高回归性能。随机森林通过在每棵树的训练过程中引入随机性（如随机选择特征和样本），减少了模型的方差，从而提高了泛化能力。使用方法与分类器相似：

from sklearn.ensemble import RandomForestRegressor

model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，n_estimators指定了森林中树的数量，random_state是随机种子，用于控制每次运行时随机性的一致性。

使用RandomForestRegressor进行回归预测：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用RandomForestRegressor进行拟合和预测
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算均方误差
mse = mean_squared_error(y_test, y_pred)
print("均方误差：", mse)

代码中，创建了一个数据集X和y，然后使用RandomForestRegressor进行拟合和预测，并计算了均方误差。

GradientBoostingClassifier

一种集成学习方法，通过构建多个弱分类器（通常是决策树），然后组合它们来提高分类性能。梯度提升分类器通过迭代地训练新的模型来纠正前序模型的错误，从而逐步提高模型性能。

from sklearn.ensemble import GradientBoostingClassifier

model = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，n_estimators指定了要构建的树的数量，learning_rate是每个树的贡献缩放因子，random_state是随机种子，用于控制每次运行时随机性的一致性。

使用GradientBoostingClassifier进行分类预测：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
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)

# 使用GradientBoostingClassifier进行拟合和预测
model = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算模型准确率
accuracy = accuracy_score(y_test, y_pred)
print("模型准确率：", accuracy)

代码中，加载了鸢尾花数据集，并使用GradientBoostingClassifier进行拟合和预测，并计算了模型的准确率。

GradientBoostingRegressor

一种集成学习方法，通过构建多个弱回归器（通常是决策树），然后组合它们来提高回归性能。梯度提升回归器通过迭代地训练新的模型来纠正前序模型的错误，从而逐步提高模型性能。

from sklearn.ensemble import GradientBoostingRegressor

model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，n_estimators指定了要构建的树的数量，learning_rate是每个树的贡献缩放因子，random_state是随机种子，用于控制每次运行时随机性的一致性。

使用GradientBoostingRegressor进行回归预测：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用GradientBoostingRegressor进行拟合和预测
model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算均方误差
mse = mean_squared_error(y_test, y_pred)
print("均方误差：", mse)

代码中，创建了一个数据集X和y，然后使用GradientBoostingRegressor进行拟合和预测，并计算了均方误差。

AdaBoostClassifier

一种集成学习方法，通过组合多个弱分类器（通常是决策树）来构建一个强分类器。AdaBoost通过对每个样本调整权重，使得在前一个分类器中被错误分类的样本在后续分类器中得到更多关注，从而提高整体模型的性能。

from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，n_estimators指定了要构建的弱分类器的数量，random_state是随机种子，用于控制每次运行时随机性的一致性。

使用AdaBoostClassifier进行分类预测：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier
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)

# 使用AdaBoostClassifier进行拟合和预测
model = AdaBoostClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算模型准确率
accuracy = accuracy_score(y_test, y_pred)
print("模型准确率：", accuracy)

这个示例加载了鸢尾花数据集，并使用AdaBoostClassifier进行拟合和预测，并计算了模型的准确率。

AdaBoostRegressor

一种集成学习方法，通过组合多个弱回归器（通常是决策树）来构建一个强回归器。AdaBoost通过对每个样本调整权重，使得在前一个回归器中预测错误的样本在后续回归器中得到更多关注，从而提高整体模型的性能。

from sklearn.ensemble import AdaBoostRegressor

model = AdaBoostRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，n_estimators指定了要构建的弱回归器的数量，random_state是随机种子，用于控制每次运行时随机性的一致性。

使用AdaBoostRegressor进行回归预测：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostRegressor
from sklearn.metrics import mean_squared_error

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用AdaBoostRegressor进行拟合和预测
model = AdaBoostRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算均方误差
mse = mean_squared_error(y_test, y_pred)
print("均方误差：", mse)

代码中，创建了一个数据集X和y，然后使用AdaBoostRegressor进行拟合和预测，并计算了均方误差。

支持向量机

SVC

支持向量机（Support Vector Classifier）的缩写，用于解决分类问题。支持向量机通过在特征空间中找到最佳的超平面来实现分类。在实际应用中，通常使用核函数来将数据映射到高维空间，以处理线性不可分的情况。

from sklearn.svm import SVC

model = SVC(kernel='rbf', C=1.0, gamma='scale', random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，kernel指定了核函数的类型，常用的有线性核（linear）、多项式核（poly）、高斯核（rbf）等；C是正则化参数，控制模型的复杂度；gamma是核函数的系数。

使用SVC进行分类预测：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
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)

# 使用SVC进行拟合和预测
model = SVC(kernel='rbf', C=1.0, gamma='scale', random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算模型准确率
accuracy = accuracy_score(y_test, y_pred)
print("模型准确率：", accuracy)

这个示例加载了鸢尾花数据集，并使用SVC进行拟合和预测，并计算了模型的准确率。

SVR

支持向量机（Support Vector Regressor）的缩写，用于解决回归问题。与分类问题类似，支持向量机回归通过在特征空间中找到最佳的超平面来实现回归。

同样地，支持向量机回归也可以使用核函数处理线性不可分的情况。

from sklearn.svm import SVR

model = SVR(kernel='rbf', C=1.0, gamma='scale')
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，kernel指定了核函数的类型，常用的有线性核（linear）、多项式核（poly）、高斯核（rbf）等；C是正则化参数，控制模型的复杂度；gamma是核函数的系数。

使用SVR进行回归预测：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.svm import SVR
from sklearn.metrics import mean_squared_error

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用SVR进行拟合和预测
model = SVR(kernel='rbf', C=1.0, gamma='scale')
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算均方误差
mse = mean_squared_error(y_test, y_pred)
print("均方误差：", mse)

这个示例创建了一个数据集X和y，然后使用SVR进行拟合和预测，并计算了均方误差。

最近邻

KNeighborsClassifier

一种基于邻居的分类模型，通过将每个样本的类别预测为其最近邻居的类别来实现分类。

KNeighborsClassifier需要指定一个参数n_neighbors，表示要考虑的最近邻居的数量。

from sklearn.neighbors import KNeighborsClassifier

model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，n_neighbors是一个超参数，需要根据数据集的特点进行调优。

使用KNeighborsClassifier进行分类预测：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
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)

# 使用KNeighborsClassifier进行拟合和预测
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算模型准确率
accuracy = accuracy_score(y_test, y_pred)
print("模型准确率：", accuracy)

代码中，加载了鸢尾花数据集，并使用KNeighborsClassifier进行拟合和预测，并计算了模型的准确率。

KNeighborsRegressor

一种基于K近邻的回归模型，通过将每个样本的目标值预测为其最近邻的平均值来实现回归。KNeighborsRegressor也需要指定一个参数n_neighbors，表示要考虑的最近邻的数量。

from sklearn.neighbors import KNeighborsRegressor

model = KNeighborsRegressor(n_neighbors=5)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

其中，n_neighbors是一个超参数，需要根据数据集的特点进行调优。

使用KNeighborsRegressor进行回归预测：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_squared_error

# 创建一个数据集
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# 使用KNeighborsRegressor进行拟合和预测
model = KNeighborsRegressor(n_neighbors=5)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算均方误差
mse = mean_squared_error(y_test, y_pred)
print("均方误差：", mse)

这个示例创建了一个数据集X和y，然后使用KNeighborsRegressor进行拟合和预测，并计算了均方误差。

2cd4563661754e83ca8e01688c6c2417.png

无监督学习模型

聚类

KMeans

一种聚类算法，用于将数据集分成不同的组（簇），使得同一组内的数据点彼此更加相似，而不同组之间的数据点更加不同。KMeans需要指定一个参数n_clusters，表示要分成的簇的数量。

from sklearn.cluster import KMeans

model = KMeans(n_clusters=3, random_state=42)
model.fit(X)
y_pred = model.predict(X)

其中，n_clusters是一个超参数，需要根据数据集的特点进行调优。

使用KMeans进行聚类：

import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# 创建一个数据集
X = np.array([[1, 2], [5, 8], [1.5, 1.8], [8, 8], [1, 0.6], [9, 11]])

# 使用KMeans进行聚类
model = KMeans(n_clusters=2, random_state=42)
y_pred = model.fit_predict(X)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis')
plt.show()

这个示例创建了一个二维数据集X，然后使用KMeans进行聚类，并使用散点图将聚类结果可视化出来。

AgglomerativeClustering

一种层次聚类算法，通过将数据点逐渐合并为越来越大的簇来构建聚类。AgglomerativeClustering的主要思想是将每个数据点视为一个簇，然后逐渐合并相似的簇，直到达到预定的簇的数量。

from sklearn.cluster import AgglomerativeClustering

model = AgglomerativeClustering(n_clusters=3)
y_pred = model.fit_predict(X)

其中，n_clusters是要分成的簇的数量。

使用AgglomerativeClustering进行聚类：

import numpy as np
from sklearn.cluster import AgglomerativeClustering
import matplotlib.pyplot as plt

# 创建一个数据集
X = np.array([[1, 2], [5, 8], [1.5, 1.8], [8, 8], [1, 0.6], [9, 11]])

# 使用AgglomerativeClustering进行聚类
model = AgglomerativeClustering(n_clusters=2)
y_pred = model.fit_predict(X)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis')
plt.show()

这个示例创建了一个二维数据集X，然后使用AgglomerativeClustering进行聚类，并使用散点图将聚类结果可视化。

DBSCAN

一种密度聚类算法，能够将具有足够高密度的区域划分为簇，并能够识别噪声点。DBSCAN需要指定两个参数：eps（ε）和min_samples。eps是一个距离阈值，表示两个样本之间的最大距离，min_samples是一个整数，表示一个簇中所需的最小样本数。

from sklearn.cluster import DBSCAN

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

其中，eps和min_samples是需要根据数据集的特点进行调优的参数。

使用DBSCAN进行聚类：

import numpy as np
from sklearn.cluster import DBSCAN
import matplotlib.pyplot as plt

# 创建一个数据集
X = np.array([[1, 2], [5, 8], [1.5, 1.8], [8, 8], [1, 0.6], [9, 11]])

# 使用DBSCAN进行聚类
model = DBSCAN(eps=2, min_samples=2)
y_pred = model.fit_predict(X)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis')
plt.show()

这个示例创建了一个二维数据集X，然后使用DBSCAN进行聚类，并使用散点图将聚类结果可视化出来。

密度估计

KernelDensity

用于估计数据的概率密度函数。Kernel Density Estimation（KDE）是一种非参数统计方法，它通过在每个数据点周围放置一个核函数并将它们加和来估计概率密度。KernelDensity可以用于生成新的样本，异常检测等应用。

from sklearn.neighbors import KernelDensity

model = KernelDensity(bandwidth=0.5, kernel='gaussian')
model.fit(X)

其中，bandwidth是核密度估计的带宽参数，kernel是核函数的类型，常用的有高斯核（gaussian）等。

使用KernelDensity进行概率密度估计：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import KernelDensity

# 创建一个数据集
np.random.seed(0)
X = np.concatenate((np.random.normal(0, 1, 1000), np.random.normal(4, 1, 1000)))[:, np.newaxis]

# 使用KernelDensity进行概率密度估计
model = KernelDensity(bandwidth=0.5, kernel='gaussian')
model.fit(X)

# 生成新的样本
new_samples = model.sample(1000)

# 绘制原始数据和估计的概率密度函数
plt.hist(X, bins=50, density=True, alpha=0.5, color='blue')
plt.hist(new_samples, bins=50, density=True, alpha=0.5, color='red')
plt.show()

这个示例创建了一个包含两个高斯分布的简单数据集X，然后使用KernelDensity进行概率密度估计，并生成了新的样本。最后，使用直方图将原始数据和估计的概率密度函数可视化出来。

异常检测

IsolationForest

一种用于检测异常值的算法。Isolation Forest通过随机选择特征和随机选择切割值来构建一棵孤立树（Isolation Tree），并通过计算样本在树中的深度来识别异常值。由于异常值通常比正常值更容易被隔离，因此Isolation Forest能够有效地检测异常值。

from sklearn.ensemble import IsolationForest

model = IsolationForest(contamination=0.1, random_state=42)
model.fit(X)
y_pred = model.predict(X)

其中，contamination是一个参数，表示数据中异常样本的比例。

使用IsolationForest进行异常值检测：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForest

# 创建一个数据集
np.random.seed(42)
X = 0.3 * np.random.randn(100, 2)
X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))
X = np.vstack([X, X_outliers])

# 使用IsolationForest进行异常值检测
model = IsolationForest(contamination=0.1, random_state=42)
y_pred = model.fit_predict(X)

# 可视化异常值检测结果
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis')
plt.show()

这个示例创建了一个包含正常值和异常值的简单数据集X，然后使用IsolationForest进行异常值检测，并使用散点图将异常值检测结果可视化出来。

OneClassSVM

一种支持向量机算法的变体，用于检测数据中的异常值。与传统的支持向量机不同，OneClassSVM的目标是找到一个超平面，将数据点分为两个部分：正常值和异常值。

from sklearn.svm import OneClassSVM

model = OneClassSVM(nu=0.1, kernel='rbf', gamma='scale')
model.fit(X)
y_pred = model.predict(X)

其中，nu是一个参数，表示异常值的比例；kernel是核函数的类型，常用的有高斯核（rbf）；gamma是核函数的系数。

使用OneClassSVM进行异常值检测：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import OneClassSVM

# 创建一个数据集
np.random.seed(42)
X = 0.3 * np.random.randn(100, 2)
X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))
X = np.vstack([X, X_outliers])

# 使用OneClassSVM进行异常值检测
model = OneClassSVM(nu=0.1, kernel='rbf', gamma='scale')
y_pred = model.fit_predict(X)

# 可视化异常值检测结果
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis')
plt.show()

代码中，创建了一个包含正常值和异常值的简单数据集X，然后使用OneClassSVM进行异常值检测，并使用散点图将异常值检测结果可视化出来。

04ca2aa95842d85f9628326109c9b7e3.png

模型评估

交叉验证

cross_val_score

用于评估模型性能的函数，通常与交叉验证一起使用。交叉验证是一种用于评估模型性能的统计学方法，它将数据集分成训练集和测试集，然后多次训练和测试模型，最终得到模型性能的评估指标。cross_val_score可以帮助我们轻松地进行交叉验证并计算评估指标，如准确率、精确度、召回率等。

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')

其中，model是要评估的模型，X是特征数据，y是目标数据，cv是交叉验证的折数，scoring是评估指标，可以是accuracy、precision、recall等。

使用cross_val_score进行交叉验证评估模型的准确率：

from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression

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

# 创建一个Logistic回归模型
model = LogisticRegression()

# 使用交叉验证评估模型的准确率
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print("准确率:", scores.mean())

这个示例加载了鸢尾花数据集，并使用cross_val_score对LogisticRegression模型进行交叉验证评估，最后打印出模型的平均准确率。

StratifiedKFold

一种用于分层抽样的交叉验证方法。在分层抽样中，每个折（fold）中的样本类别比例与整个数据集中的类别比例相同。StratifiedKFold通过保持类别比例来确保在每个折中都有足够的样本来代表每个类别，从而更准确地评估模型性能。

from sklearn.model_selection import StratifiedKFold

skf = StratifiedKFold(n_splits=5, random_state=42, shuffle=True)

for train_index, test_index in skf.split(X, y):
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    # 在这里训练和评估模型

其中，n_splits是折数，random_state用于控制随机性，shuffle表示是否在划分前对数据进行洗牌。

使用StratifiedKFold进行分层交叉验证：

from sklearn.datasets import load_iris
from sklearn.model_selection import StratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

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

# 创建一个Logistic回归模型
model = LogisticRegression()

# 使用StratifiedKFold进行分层交叉验证
skf = StratifiedKFold(n_splits=5, random_state=42, shuffle=True)
for train_index, test_index in skf.split(X, y):
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print("准确率:", accuracy)

代码中，加载了鸢尾花数据集，并使用StratifiedKFold对LogisticRegression模型进行分层交叉验证，并打印每个折的准确率。

RepeatedKFold

一种重复的K折交叉验证方法，即对数据集进行K折交叉验证，重复多次并对每次重复进行不同的随机抽样。这种方法可以帮助减少由于随机性引起的误差，从而更可靠地评估模型的性能。

from sklearn.model_selection import RepeatedKFold

rkf = RepeatedKFold(n_splits=5, n_repeats=3, random_state=42)

for train_index, test_index in rkf.split(X):
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    # 在这里训练和评估模型

其中，n_splits是折数，n_repeats是重复次数，random_state用于控制随机性。

使用RepeatedKFold进行重复的K折交叉验证：

from sklearn.datasets import load_iris
from sklearn.model_selection import RepeatedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

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

# 创建一个Logistic回归模型
model = LogisticRegression()

# 使用RepeatedKFold进行重复的K折交叉验证
rkf = RepeatedKFold(n_splits=5, n_repeats=3, random_state=42)
for train_index, test_index in rkf.split(X):
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print("准确率:", accuracy)

这个示例加载了鸢尾花数据集，并使用RepeatedKFold对LogisticRegression模型进行重复的K折交叉验证，并打印每个折的准确率。

超参数优化

GridSearchCV

GridSearchCV是一种用于超参数调优的方法，通过在指定的参数网格中搜索最佳参数组合来改善模型性能。

GridSearchCV使用交叉验证来评估每个参数组合的性能，并返回具有最佳性能的参数组合。

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 5, 10, 20],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

model = RandomForestClassifier(random_state=42)
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, scoring='accuracy')
grid_search.fit(X, y)

best_params = grid_search.best_params_
best_score = grid_search.best_score_

其中，param_grid是参数网格，包含了要调优的参数及其可能的取值；cv是交叉验证的折数；scoring是评估指标，这里使用准确率（accuracy）。

使用GridSearchCV对RandomForestClassifier模型进行超参数调优：

from sklearn.datasets import load_iris
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

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

# 定义参数网格
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 5, 10, 20],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

# 创建一个RandomForestClassifier模型
model = RandomForestClassifier(random_state=42)

# 使用GridSearchCV进行超参数调优
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, scoring='accuracy')
grid_search.fit(X, y)

best_params = grid_search.best_params_
best_score = grid_search.best_score_

print("最佳参数:", best_params)
print("最佳准确率:", best_score)

代码中，加载了鸢尾花数据集，并使用GridSearchCV对RandomForestClassifier模型进行超参数调优，并打印出最佳参数和最佳准确率。

RandomizedSearchCV

与GridSearchCV类似，也用于超参数调优，但不同之处在于RandomizedSearchCV在参数搜索过程中不是遍历所有可能的参数组合，而是根据指定的参数分布进行随机采样。这样做的好处是可以更快地找到较好的参数组合，尤其是当参数空间非常大时。

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

param_dist = {
    'n_estimators': randint(50, 200),
    'max_depth': [None, 5, 10, 20],
    'min_samples_split': randint(2, 10),
    'min_samples_leaf': randint(1, 5)
}

model = RandomForestClassifier(random_state=42)
random_search = RandomizedSearchCV(estimator=model, param_distributions=param_dist, n_iter=10, cv=5, scoring='accuracy', random_state=42)
random_search.fit(X, y)

best_params = random_search.best_params_
best_score = random_search.best_score_

其中，param_dist是参数分布，用于指定每个参数的可能取值范围或分布；n_iter是随机搜索的迭代次数。

使用RandomizedSearchCV对RandomForestClassifier模型进行超参数调优：

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

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

# 定义参数分布
param_dist = {
    'n_estimators': randint(50, 200),
    'max_depth': [None, 5, 10, 20],
    'min_samples_split': randint(2, 10),
    'min_samples_leaf': randint(1, 5)
}

# 创建一个RandomForestClassifier模型
model = RandomForestClassifier(random_state=42)

# 使用RandomizedSearchCV进行超参数调优
random_search = RandomizedSearchCV(estimator=model, param_distributions=param_dist, n_iter=10, cv=5, scoring='accuracy', random_state=42)
random_search.fit(X, y)

best_params = random_search.best_params_
best_score = random_search.best_score_

print("最佳参数:", best_params)
print("最佳准确率:", best_score)

代码中，加载了鸢尾花数据集，并使用RandomizedSearchCV对RandomForestClassifier模型进行超参数调优，并打印出最佳参数和最佳准确率。

模型评估指标

accuracy_score

用于计算分类模型预测准确率的函数。准确率是指模型正确预测的样本数占总样本数的比例。

from sklearn.metrics import accuracy_score

y_true = [0, 1, 0, 1]
y_pred = [0, 1, 1, 0]

accuracy = accuracy_score(y_true, y_pred)
print("准确率:", accuracy)

其中，y_true是真实的标签，y_pred是模型预测的标签。

使用accuracy_score计算分类模型的预测准确率：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
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)

# 创建一个Logistic回归模型
model = LogisticRegression()

# 在训练集上训练模型
model.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = model.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print("准确率:", accuracy)

代码中，加载了鸢尾花数据集，并使用LogisticRegression模型进行训练和预测，并使用accuracy_score计算模型在测试集上的预测准确率。

precision_score

用于计算分类模型的精确率的函数。精确率是指在所有被分类器判断为正例的样本中，确实为正例的样本数占比。精确率可以帮助我们理解模型在预测为正例的样本中的表现。

from sklearn.metrics import precision_score

y_true = [0, 1, 0, 1]
y_pred = [0, 1, 1, 0]

precision = precision_score(y_true, y_pred)
print("精确率:", precision)

其中，y_true是真实的标签，y_pred是模型预测的标签。

使用precision_score计算分类模型的精确率：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import precision_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)

# 创建一个Logistic回归模型
model = LogisticRegression()

# 在训练集上训练模型
model.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = model.predict(X_test)

# 计算精确率
precision = precision_score(y_test, y_pred, average='weighted')
print("精确率:", precision)

代码中，加载了鸢尾花数据集，并使用LogisticRegression模型进行训练和预测，并使用precision_score计算模型在测试集上的精确率。

recall_score

用于计算分类模型的召回率的函数。召回率是指在所有实际为正例的样本中，被分类器判断为正例的样本数占比。召回率可以帮助我们理解模型对正例样本的识别能力。

from sklearn.metrics import recall_score

y_true = [0, 1, 0, 1]
y_pred = [0, 1, 1, 0]

recall = recall_score(y_true, y_pred)
print("召回率:", recall)

其中，y_true是真实的标签，y_pred是模型预测的标签。

使用recall_score计算分类模型的召回率：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import recall_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)

# 创建一个Logistic回归模型
model = LogisticRegression()

# 在训练集上训练模型
model.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = model.predict(X_test)

# 计算召回率
recall = recall_score(y_test, y_pred, average='weighted')
print("召回率:", recall)

代码中，加载了鸢尾花数据集，并使用LogisticRegression模型进行训练和预测，并使用recall_score计算模型在测试集上的召回率。

f1_score

精确率（precision）和召回率（recall）的调和平均数，用于综合评估分类模型的性能。F1值越高，表示模型在精确率和召回率之间取得了更好的平衡。

from sklearn.metrics import f1_score

y_true = [0, 1, 0, 1]
y_pred = [0, 1, 1, 0]

f1 = f1_score(y_true, y_pred)
print("F1值:", f1)

其中，y_true是真实的标签，y_pred是模型预测的标签。

使用f1_score计算分类模型的F1值：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_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)

# 创建一个Logistic回归模型
model = LogisticRegression()

# 在训练集上训练模型
model.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = model.predict(X_test)

# 计算F1值
f1 = f1_score(y_test, y_pred, average='weighted')
print("F1值:", f1)

代码中，加载了鸢尾花数据集，并使用LogisticRegression模型进行训练和预测，并使用f1_score计算模型在测试集上的F1值。

roc_auc_score

用于评估二分类模型性能的指标，特别适用于不平衡数据集。ROC曲线是以假阳率（FPR）为横轴，真阳率（TPR，即召回率）为纵轴绘制的曲线，而AUC（Area Under Curve）则是ROC曲线下的面积，用于表示模型的性能。ROC曲线下的面积越大，说明模型性能越好。

from sklearn.metrics import roc_auc_score

y_true = [0, 1, 0, 1]
y_pred_proba = [0.1, 0.9, 0.2, 0.8]  # 预测为正例的概率

roc_auc = roc_auc_score(y_true, y_pred_proba)
print("ROC AUC值:", roc_auc)

其中，y_true是真实的标签，y_pred_proba是模型预测的正例概率。

使用roc_auc_score计算二分类模型的ROC AUC值：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score

# 加载鸢尾花数据集，为了演示二分类问题，只选择两个类别
iris = load_iris()
X = iris.data
y = iris.target
X, y = X[y != 2], y[y != 2]

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

# 创建一个Logistic回归模型
model = LogisticRegression()

# 在训练集上训练模型
model.fit(X_train, y_train)

# 在测试集上获取正例的预测概率
y_pred_proba = model.predict_proba(X_test)[:, 1]

# 计算ROC AUC值
roc_auc = roc_auc_score(y_test, y_pred_proba) 
print("ROC AUC值:", roc_auc)

代码中，加载了鸢尾花数据集，并使用LogisticRegression模型进行训练和预测，并使用roc_auc_score计算模型在测试集上的ROC AUC值。

mean_squared_error

用于评估回归模型预测结果的均方误差（Mean Squared Error，MSE）。均方误差是预测值与真实值之差的平方的均值，用于衡量模型预测结果的精度，MSE越小，表示模型拟合效果越好。

from sklearn.metrics import mean_squared_error

y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]

mse = mean_squared_error(y_true, y_pred)
print("均方误差:", mse)

其中，y_true是真实的目标值，y_pred是模型预测的目标值。

使用mean_squared_error计算回归模型的均方误差：

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# 加载波士顿房价数据集
boston = load_boston()
X = boston.data
y = boston.target

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

# 创建一个线性回归模型
model = LinearRegression()

# 在训练集上训练模型
model.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = model.predict(X_test)

# 计算均方误差
mse = mean_squared_error(y_test, y_pred)
print("均方误差:", mse)

代码中，加载了波士顿房价数据集，并使用线性回归模型进行训练和预测，并使用mean_squared_error计算模型在测试集上的均方误差。

r2_score

用于评估回归模型拟合优度的指标，也称为决定系数（Coefficient of Determination）。R²值可以理解为模型对因变量变化的解释程度，取值范围在0到1之间，越接近1表示模型拟合得越好。

from sklearn.metrics import r2_score

y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]

r2 = r2_score(y_true, y_pred)
print("R²值:", r2)

其中，y_true是真实的目标值，y_pred是模型预测的目标值。

使用r2_score计算回归模型的R²值：

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

# 加载波士顿房价数据集
boston = load_boston()
X = boston.data
y = boston.target

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

# 创建一个线性回归模型
model = LinearRegression()

# 在训练集上训练模型
model.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = model.predict(X_test)

# 计算R²值
r2 = r2_score(y_test, y_pred)
print("R²值:", r2)

这个示例加载了波士顿房价数据集，并使用线性回归模型进行训练和预测，并使用r2_score计算模型在测试集上的R²值。

特征工程

特征构建

PolynomialFeatures

用于生成原始特征的多项式组合的转换器，可以用于多项式回归。例如，对于输入特征 [a, b]，PolynomialFeatures 可以生成 [1, a, b, a^2, ab, b^2]。这种转换可以让线性模型拟合非线性关系。

from sklearn.preprocessing import PolynomialFeatures

X = [[1, 2], [3, 4], [5, 6]]
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)

print(X_poly)

这里的 degree 参数指定生成的多项式的最高次数，include_bias 参数用于指定是否包含截距（常数项）。

使用PolynomialFeatures将输入特征转换为多项式特征：

import numpy as np
from sklearn.preprocessing import PolynomialFeatures

# 创建一些输入特征
X = np.array([[1, 2], [3, 4], [5, 6]])

# 创建一个PolynomialFeatures对象，将输入特征转换为二次多项式特征
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)

print("原始特征:\n", X)
print("多项式特征:\n", X_poly)

这个示例创建了一个二维的输入特征数组 X，然后使用PolynomialFeatures将输入特征转换为二次多项式特征。

KBinsDiscretizer

用于将连续特征按照指定的区间数进行分箱（离散化）的转换器。分箱后，每个特征将被转换为一个多维离散特征，表示每个样本所属的箱子。这种转换可以帮助处理某些模型对连续特征的偏好，同时也可以减少数据中的噪声。

from sklearn.preprocessing import KBinsDiscretizer

X = [[-2, 1, -4,   -1],
     [-1, 2, -3, -0.5],
     [ 0, 3, -2,  0.5],
     [ 1, 4, -1,    2]]

# 创建一个KBinsDiscretizer对象，将特征分为3个区间
est = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')
X_discrete = est.fit_transform(X)

print(X_discrete)

其中，n_bins指定了每个特征的分箱数，encode参数用于指定编码方式（ordinal表示使用整数编码），strategy参数指定了分箱的策略（uniform表示等宽分箱）。

使用KBinsDiscretizer将输入特征进行分箱：

import numpy as np
from sklearn.preprocessing import KBinsDiscretizer

# 创建一些连续特征
X = np.array([[1, -1, 2],
              [2, 0, 0],
              [0, 1, -1]])

# 创建一个KBinsDiscretizer对象，将特征分为3个区间
est = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')
X_discrete = est.fit_transform(X)

print("原始特征:\n", X)
print("分箱后的特征:\n", X_discrete)

这个示例创建了一个二维的输入特征数组 X，然后使用KBinsDiscretizer将输入特征进行等宽分箱，分为3个区间。

特征交互

FeatureUnion

用于将多个特征处理流水线并行地合并为单个流水线的转换器。FeatureUnion可以将每个流水线生成的特征合并为一个特征集，常用于将不同类型的特征处理方法（如文本特征处理和数值特征处理）结合起来。

from sklearn.pipeline import FeatureUnion
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# 假设有两个特征处理流水线：PCA和StandardScaler
pca = PCA(n_components=2)
scaler = StandardScaler()

# 创建FeatureUnion对象，合并两个特征处理流水线
combined_features = FeatureUnion([("pca", pca), ("scaler", scaler)])

# 使用合并后的特征处理流水线进行特征处理
X_features = combined_features.fit_transform(X)

print(X_features)

使用FeatureUnion将两个特征处理流水线合并：

import numpy as np
from sklearn.pipeline import FeatureUnion
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# 创建一些示例数据
X = np.array([[0, 1], [2, 3], [4, 5]])

# 创建两个特征处理流水线：PCA和StandardScaler
pca = PCA(n_components=1)
scaler = StandardScaler()

# 创建FeatureUnion对象，合并两个特征处理流水线
combined_features = FeatureUnion([("pca", pca), ("scaler", scaler)])

# 使用合并后的特征处理流水线进行特征处理
X_features = combined_features.fit_transform(X)

print("原始特征:\n", X)
print("合并后的特征:\n", X_features)

代码中，创建了一个二维的输入特征数组 X，然后使用FeatureUnion将PCA和StandardScaler两个特征处理流水线合并，并将两个流水线生成的特征合并为一个特征集。

特征转换

FunctionTransformer

一个用于对数据集应用自定义转换函数的转换器。FunctionTransformer可以将任意函数应用于数据集的每个样本，例如用于特征工程或数据预处理。

from sklearn.preprocessing import FunctionTransformer

# 自定义转换函数，这里示例函数将每个元素取对数
def custom_func(X):
    import numpy as np
    return np.log1p(X)

# 创建FunctionTransformer对象，将自定义函数应用于数据集
transformer = FunctionTransformer(custom_func)

# 使用FunctionTransformer对象对数据集进行转换
X_transformed = transformer.fit_transform(X)

print(X_transformed)

使用FunctionTransformer将对数转换应用于数据集的每个元素：

import numpy as np
from sklearn.preprocessing import FunctionTransformer

# 创建一些示例数据
X = np.array([[1, 2], [3, 4], [5, 6]])

# 自定义转换函数，这里示例函数将每个元素取对数
def custom_func(X):
    return np.log1p(X)

# 创建FunctionTransformer对象，将自定义函数应用于数据集
transformer = FunctionTransformer(custom_func)

# 使用FunctionTransformer对象对数据集进行转换
X_transformed = transformer.fit_transform(X)

print("原始数据:\n", X)
print("转换后的数据:\n", X_transformed)

代码中，创建了一个二维的输入特征数组 X，然后使用FunctionTransformer将对数转换应用于数据集的每个元素。

QuantileTransformer

用于将特征转换为服从均匀或正态分布的转换器。QuantileTransformer通过对每个特征的分位数进行映射来实现这一转换，可以有效地使数据归一化，并减少受异常值影响的影响。

from sklearn.preprocessing import QuantileTransformer

# 创建QuantileTransformer对象，将数据转换为服从均匀分布的形式
transformer = QuantileTransformer(output_distribution='uniform')

# 使用QuantileTransformer对象对数据进行转换
X_transformed = transformer.fit_transform(X)

print(X_transformed)

使用QuantileTransformer将数据转换为服从均匀分布的形式：

import numpy as np
from sklearn.preprocessing import QuantileTransformer

# 创建一些示例数据
X = np.array([[1, 2], [3, 4], [5, 6]])

# 创建QuantileTransformer对象，将数据转换为服从均匀分布的形式
transformer = QuantileTransformer(output_distribution='uniform')

# 使用QuantileTransformer对象对数据进行转换
X_transformed = transformer.fit_transform(X)

print("原始数据:\n", X)
print("转换后的数据:\n", X_transformed)

这个示例创建了一个二维的输入特征数组 X，然后使用QuantileTransformer将数据转换为服从均匀分布的形式。

模型解释

特征重要性

feature_importances_

feature_importances_ 是一些机器学习模型（如决策树、随机森林等）中的属性，用于表示每个特征对模型预测的重要性。对于决策树和随机森林等模型，feature_importances_ 属性可以帮助我们理解模型是如何做出预测的，以及哪些特征对预测的贡献最大。

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

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

# 创建随机森林分类器
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X, y)

# 获取特征重要性
importances = clf.feature_importances_

# 将特征重要性可视化
plt.figure()
plt.bar(range(X.shape[1]), importances)
plt.xticks(range(X.shape[1]), ['sepal length', 'sepal width', 'petal length', 'petal width'], rotation=45)
plt.xlabel('Feature')
plt.ylabel('Importance')
plt.title('Feature Importances')
plt.show()

这个示例使用随机森林模型训练了鸢尾花数据集，并使用 feature_importances_ 属性获取了特征的重要性，然后通过条形图展示了特征重要性。

决策路径可视化

plot_tree

plot_tree 是用于绘制决策树模型的函数，可以帮助我们可视化决策树的结构。plot_tree 函数通常与决策树模型（如 DecisionTreeClassifier 或 DecisionTreeRegressor）一起使用。

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

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

# 创建决策树分类器
clf = DecisionTreeClassifier(random_state=42)
clf.fit(X, y)

# 绘制决策树
plt.figure(figsize=(20, 10))
plot_tree(clf, filled=True, feature_names=iris.feature_names, class_names=iris.target_names)
plt.show()

这个示例使用 DecisionTreeClassifier 训练了鸢尾花数据集，并使用 plot_tree 函数绘制了决策树的结构图。在图中，每个节点表示一个特征或一个决策，箭头表示决策的方向，颜色表示节点所属的类别或决策路径的不纯度程度。

部分依赖图

plot_partial_dependence

plot_partial_dependence 是用于绘制偏依赖图的函数，可以帮助我们理解特征与模型预测之间的关系。偏依赖图显示了特征对模型预测的影响，可以帮助我们识别特征与预测之间的非线性关系。

from sklearn.datasets import load_boston
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.inspection import plot_partial_dependence
import matplotlib.pyplot as plt

# 加载波士顿房价数据集
boston = load_boston()
X = boston.data
y = boston.target

# 创建梯度提升回归模型
model = GradientBoostingRegressor()

# 绘制偏依赖图
plt.figure(figsize=(12, 6))
plot_partial_dependence(model, X, features=[5, 12], feature_names=boston.feature_names)
plt.subplots_adjust(top=0.9)  # 调整子图之间的间距
plt.suptitle('Partial Dependence Plot')  # 设置总标题
plt.show()

这个示例使用 GradientBoostingRegressor 训练了波士顿房价数据集，并使用 plot_partial_dependence函数绘制了两个特征（第5个和第12个特征）的偏依赖图。偏依赖图显示了特征与预测之间的关系，可以帮助我们理解模型是如何利用这些特征进行预测的。

模型部署

模型保存与加载

joblib.dump

joblib.dump 是用于将 Python 对象保存到磁盘的函数，通常用于保存训练好的模型以备后续使用。与 Python 的内置 pickle 模块相比，joblib.dump 在处理大型 NumPy 数组时更有效率。

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from joblib import dump

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

# 创建随机森林分类器
clf = RandomForestClassifier(random_state=42)
clf.fit(X, y)

# 保存模型到文件
dump(clf, 'random_forest_model.joblib')

这个示例使用 RandomForestClassifier 训练了鸢尾花数据集，并使用 joblib.dump 将训练好的模型保存到文件 random_forest_model.joblib。保存模型后，可以使用 joblib.load 函数重新加载模型：

from joblib import load

# 加载模型
clf = load('random_forest_model.joblib')

# 使用模型进行预测
y_pred = clf.predict(X)

这样可以方便地在以后的时间加载模型并使用它进行预测。

最后

喜欢本文的朋友可以收藏、点赞、转发起来！

 
 
 
 
af9889bbfb56321fbbe378ca7317b58c.jpeg
 
 
 
 
 
 
 
 
 
 
往期精彩回顾




适合初学者入门人工智能的路线及资料下载(图文+视频)机器学习入门系列下载机器学习及深度学习笔记等资料打印《统计学习方法》的代码复现专辑
 
 
  • 交流群
 
 
欢迎加入机器学习爱好者微信群一起和同行交流，目前有机器学习交流群、博士群、博士申报交流、CV、NLP等微信群，请扫描下面的微信号加群，备注：”昵称-学校/公司-研究方向“，例如：”张小明-浙大-CV“。请按照格式备注，否则不予通过。添加成功后会根据研究方向邀请进入相关微信群。请勿在群内发送广告，否则会请出群，谢谢理解~（也可以加入机器学习交流qq群772479961）
 
 
188bfb7d0751e69606cc40e6ec511570.png
 


                

        

        

    




    

      

        

            

              
                
                  风度78
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
数据分析师最常用的10个机器学习算法！

				
			

			

				

					02-25
				

			

		

		

			
				
在机器学习领域，有种说法叫做“世上没有免费的午餐”，简而言之，它是指没有任何一种算法能在每个问题上都能有最好的效果，这个理论在监督学习方面体现得尤为重要。举个例子来说，你不能说神经网络永远比决策树好，...

			
		

	



                

              
                



	

		

			

				
					
Python基础（十三） 机器学习sklearn库详解与应用_e anad lib site-packages sklearn linear_model _lo

				
			

			

				

					m0_60607562的博客
				

				

					04-11
					
					552
					
				

			

		

		

			
				
【5】数据集的标准化（本数据集特征比较接近，实际处理过程中未标准化）【6】构建训练集和测试集（本课暂不考虑验证集）

			
		

	



                


  
              

                


	

		

			

				
					
机器学习的1000+篇文章总结

				
			

			

				

					
				

				

					02-28
					
					9033
					
				

			

		

		

			
				
机器学习的1000+篇文章总结

本文收集和总结了有关机器学习的1000+篇文章，由于篇幅有限只能总结近期的内容，想了解更多内容可以访问：http://www.ai2news.com/, 其分享了有关AI的论文、文章、图书。


吴恩达机器学习-9-降维PCA   http://www.ai2news.com/blog/12185/ 
机器学习也有弱点？哪些是机器学习的未解之谜？   http://www.ai2news.com/blog/39473/ 
一站式机器学习平台建设实践   http://www

			
		

	





	

		

			

				
					
机器学习-05-特征工程

				
			

			

				

					IT从业者的成长历程
				

				

					03-19
					
					1192
					
				

			

		

		

			
				
本系列是机器学习课程的系列课程，主要介绍机器学习中特征工程部分。

			
		

	



		

			
		



	

		

			

				
					
Python 机器学习经典实例

				
			

			

				

					GitChat
				

				

					04-12
					
					9517
					
				

			

		

		

			
				
内容介绍
在如今这个处处以数据驱动的世界中，机器学习正变得越来越大众化。它已经被广泛地应用于不同领域，如搜索引擎、机器人、无人驾驶汽车等。本书首先通过实用的案例介绍机器学习的基础知识，然后介绍一些稍微复杂的机器学习算法，例如支持向量机、极端随机森林、隐马尔可夫模型、条件随机场、深度神经网络，等等。
用最火的Python语言、通过各种各样的机器学习算法来解决实际问题！
书中介绍的主要问题如下。

探...

			
		

	





	

		

			

				
					
机器学习和特征工程理论与python代码实现

				
			

			

				

					小知的博客
				

				

					11-20
					
					2134
					
				

			

		

		

			
				
课题：特征工程理论及代码实现
日期：2019.9.21
作者：小知同学


描述：本篇比较详细的介绍了特征工程的理论以及代码实现，涵盖数据预处理、特征选择、特征构造、特征降维、
类别不平衡处理等内容，不仅介绍了相关理论以及公式，而且还根据理论公式编写代码实现功能。
本篇特征工程的内容有些地方还不完善，如果大家觉得哪些地方想要补充、想要完善的请在评论区留言完善，
小知同学也会更新上来，进一步完善这篇特征工程专辑，以便大家更好的学习和掌握知识。

算法知识点一般的必备通用认知流程有以下几点：

概念及工作原理.

			
		

	





	

		

			

				
					
Python基础（十三） 机器学习sklearn库详解与应用_e anad lib site-packages sklearn linear_model _lo(2)

				
			

			

				

					m0_60666921的博客
				

				

					04-12
					
					613
					
				

			

		

		

			
				
【3】可视化。

			
		

	





	

		

			

				
					
新书推荐 |《机器学习即服务：将Python机器学习创意快速转变为云端Web应用程序》...

				
			

			

				

					华章IT官方博客
				

				

					08-08
					
					299
					
				

			

		

		

			
				
新书推荐《机器学习即服务：将Python机器学习创意快速转变为云端Web应用程序》点击上图了解及购买谷歌云和Salesforce首选合作伙伴SpringML数据科学副总裁领衔撰写，讲述如...

			
		

	





	

		

			

				
					
[转载] Python 机器学习经典实例

				
			

			

				

					ld909的博客
				

				

					11-27
					
					1441
					
				

			

		

		

			
				
参考链接： Python中的逻辑门

内容介绍

在如今这个处处以数据驱动的世界中，机器学习正变得越来越大众化。它已经被广泛地应用于不同领域，如搜索引擎、机器人、无人驾驶汽车等。本书首先通过实用的案例介绍机器学习的基础知识，然后介绍一些稍微复杂的机器学习算法，例如支持向量机、极端随机森林、隐马尔可夫模型、条件随机场、深度神经网络，等等。

用最火的 Python 语言、通过各种各样的机器学习算法来解决实际问题！

书中介绍的主要问题如下。

探索分类分析算法并将其应用于收入等级评估问题使用预测建模并将其应用

			
		

	





	

		

			

				
					
【点云、图像】学习中 常见的数学知识及其中的关系与python实战[完]

				
			

			

				

					weixin_56760882的博客
				

				

					01-16
					
					994
					
				

			

		

		

			
				
平均值，方差，协方差，奇异值分解，主成分分析法，最小二乘法 详解

			
		

	





	

		

			

				
					
机器学习，HelloWorldfromJavascript!

				
			

			

				

					02-25
				

			

		

		

			
				
本文旨在通过讲解识别手写字的处理过程，带读者了解机器学习解决问题的一般过程。本文适合以下背景的读者阅读：你不需要具备Python、C++的编程能力：全文使用Javascript作为编程语言，且不依赖任何第三方库实现机器...

			
		

	





	

		

			

				
					
机器学习-学习资源汇总 超详细！

				
			

			

				

					04-10
				

			

		

		

			
				
汇总了关于机器学习领域的详细学习资源，包含c++，python, 机器学习算法，计算机专业课等内容，适用于不同水平层次的机器学习爱好者使用。

			
		

	





	

		

			

				
					
我珍藏的全机器学习，深度学习资源清单，共105个免费资源！1

				
			

			

				

					08-03
				

			

		

		

			
				
1. 导读 2. 新闻资讯 3. 社区交流 4. 优质博文 5. 论文检索 6. 比赛实践 7. 课程学习 8. 资源收集

			
		

	





	

		

			

				
					
【机器学习300问】92、训练集和测试集来自不同分布，如何构建模型？

				
			

			

				

					qq_39780701的博客
				

				

					05-22
					
					358
					
				

			

		

		

			
				
训练集和测试集来自不同分布如何构建模型？

			
		

	





	

		

			

				
					
【机器学习】基于核的机器学习算法（Kernel-based Algorithms）：原理，应用与优化

				
			

			

				

					2301_77509762的博客
				

				

					05-23
					
					2749
					
				

			

		

		

			
				
随着大数据时代的到来，机器学习已成为处理和分析海量数据的重要工具。在机器学习的众多算法中，基于核的算法因其强大的非线性处理能力而备受关注。本文旨在介绍基于核的算法的基本原理、应用领域以及未来的发展趋势。

			
		

	





	

		

			

				
					
9.机器学习-十大算法之一朴素贝叶斯（Naive Bayes）算法案例讲解

				
			

			

				

					weixin_50804299的博客
				

				

					05-23
					
					955
					
				

			

		

		

			
				
机器学习中的朴素贝叶斯（Naive Bayes）算法是一种基于贝叶斯定理和特征条件独立假设的分类算法。该算法通过计算给定特征下各个类别的概率，并选择概率最大的类别作为预测结果。朴素贝叶斯算法因其简单、高效且易于实现的特点，在文本分类、垃圾邮件过滤、情感分析等领域得到广泛应用。以下案例将详细讲解朴素贝叶斯算法的原理、应用及其实践过程中的注意事项。以山河作礼。🎖️🎖️:Python领域新星创作者，CSDN实力新星认证，CSDN内容合伙人，阿里云社区专家博主，新星计划导师，在职数据分析师。

			
		

	





	

		

			

				
					
机器学习 - 特征预处理 - 分箱

					
最新发布

				
			

			

				

					weixin_47552266的博客
				

				

					05-23
					
					1072
					
				

			

		

		

			
				
分箱方法优点缺点特点适用场景卡方分箱- 能处理非线性关系- 计算复杂度高，参数选择困难- 基于类别变量频率目标变量为分类变量的情况

			
		

	





	

		

			

				
					
sklearn监督学习--k近邻算法

				
			

			

				

					lyccomcn的博客
				

				

					05-22
					
					256
					
				

			

		

		

			
				
这一算法对于有很多特征（几百或更多）的数据集往往效果不好，对于大多数特征的大多数取值都为0的数据集来说，这一算法的效果尤其不好。与之相反，如果你的模型过于简单，那么你可能无法抓住数据的全部内容以及数据中的变化，你的模型甚至在训练集上的表现就很差。但是，如果我们的模型过于复杂，我们开始过多关注训练集中每个单独的数据点，模型就不能很好地泛化到新数据上。k-NN算法最简单的版本只考虑一个最近邻，也就是与我们想要预测的数据点最近的训练数据点。可以发现，左上角新数据点的预测结果与只用一个邻居时的预测结果不同。

			
		

	





	

		

			

				
					
sklearn 机器学习

				
			

			

				

					08-10
				

			

		

		

			
				
Sklearn（Scikit-learn）是一个用于机器学习的Python库，提供了一系列简单而有效的工具，用于数据预处理、模型选择、模型评估和模型部署等任务。它建立在NumPy、SciPy和Matplotlib等科学计算库的基础上，为用户提供...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值