集成学习（一）：从理论到实战(附代码)

news2025/2/13 17:59:15

一、引言

在机器学习领域，打造一个独立、强大的算法是解决问题的关键。然而，集成学习提供了一种不同的视角：通过组合多个“弱”学习器来创建一个更强大的模型。本文探讨集成学习的思想、方法及其应用。

二、机器学习 vs 集成学习思想

传统机器学习思想

  • 打造一个独立、强大的算法：传统的机器学习倾向于开发一种能够解决特定问题的高效算法。
  • 单个算法打天下：强调单一算法的能力，试图找到适用于广泛问题的最佳解决方案。
  • 个人英雄主义：注重单个算法的性能和能力。

集成学习思想

  • 群狼打败猛虎的策略：集成学习采用集体智慧战胜单个强者的策略。
  • 管理理念：招募一批二流货色，组合成一个强大的团队，以干掉一流货色。
  • 三个臭皮匠顶个诸葛亮：通过结合多个简单的模型（弱评估器），可以构建出比任何单独模型都更强的预测模型。

三、集成学习要素

  1. 一批弱分类器：这些分类器或回归器各自的表现并不突出，但当它们组合在一起时，能显著提高整体性能。
  2. 组合策略：如何有效地将这些弱学习器的结果结合起来形成最终预测。

四、集成学习策略

4.1 Voting

思想：数据相同，算法不同，对不同算法的结果，采用多数原则

VotingClassifier 和 VotingRegressor 是集成学习中用于分类和回归任务的两种元估计器（meta-estimators）。它们的基本思想是结合多个不同的模型（通常称为“弱学习器”或基础估计器）的预测结果，以期通过集体决策来提高整体模型的性能。这种策略基于的是“群体智慧”的理念，即多个模型的组合可以比单个模型更准确。

4.1.1 VotingClassifier

VotingClassifier 主要用于分类问题，它可以通过两种主要的方式来进行投票：硬投票（hard voting）和软投票（soft voting）。

  1. 硬投票（Hard Voting）：

    • 在硬投票中，每个分类器对输入数据进行分类，并将得票最多的类别作为最终的预测结果。
    • 例如，如果有三个分类器分别预测 [0, 1, 1]，那么最终的预测结果将是 1，因为两个分类器都投了 1。

  2. 软投票（Soft Voting）：

    • 软投票需要所有基础分类器都能够输出概率估计（即支持度），然后根据这些概率计算加权平均值，选择具有最高平均概率的类别作为预测结果。
    • 这种方法考虑了每个类别的置信度，因此在理论上可能比硬投票更精确。

示例代码

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import VotingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# 创建示例数据集
# 这是Scikit-learn中的一个函数，用于生成一个合成的分类数据集。
# n_samples=1000：生成的数据集中包含1000个样本。
# n_features=20：每个样本有20个特征。
# random_state=42：设置随机种子以确保每次运行代码时生成的数据集相同。这对于实验的可重复性非常重要。
# X：形状为 (1000, 20) 的二维数组，表示1000个样本的20个特征。
# y：长度为1000的一维数组，表示每个样本对应的标签（类别）。
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
# 数据集分割
# test_size=0.3：指定测试集占总数据集的比例为30%。因此，70%的数据将被分配给训练集。
# random_state=42：再次设置随机种子，确保每次运行代码时数据集的划分方式相同。
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义基础分类器
# LogisticRegression逻辑回归分类器
# multi_class='multinomial'：指定使用多项式逻辑回归来处理多分类问题。
# random_state=1：设置随机种子，使得结果具有可重复性。
clf1 = LogisticRegression(multi_class='multinomial', random_state=1)
# RandomForestClassifier：随机森林算法，通过构建多个决策树并汇总它们的预测结果来进行分类。
# n_estimators=50：指定随机森林中决策树的数量为50。
# random_state=1：设置随机种子，使得结果具有可重复性。
clf2 = RandomForestClassifier(n_estimators=50, random_state=1)
# GaussianNB：高斯朴素贝叶斯分类器
clf3 = GaussianNB()

# 创建VotingClassifier实例
voting_clf = VotingClassifier(estimators=[('lr', clf1), ('rf', clf2), ('gnb', clf3)], voting='hard') # 或者使用 'soft'

# 训练模型
voting_clf.fit(X_train, y_train)

# 预测
predictions = voting_clf.predict(X_test)

举一个软投票的例子，并说明投票的过程，使用软投票策略进行预测，并为每个分类器指定不同的权重。

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 生成合成数据集
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

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

# 定义基础分类器
clf1 = LogisticRegression(multi_class='multinomial', random_state=1)
clf2 = RandomForestClassifier(n_estimators=50, random_state=1)
clf3 = GaussianNB()

# 创建VotingClassifier实例，设置voting='soft'表示使用软投票，并指定各分类器的权重
voting_clf_soft_weighted = VotingClassifier(estimators=[
    ('lr', clf1), 
    ('rf', clf2), 
    ('gnb', clf3)
], voting='soft', weights=[2, 1, 1])

# 训练模型
voting_clf_soft_weighted.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred_soft_weighted = voting_clf_soft_weighted.predict(X_test)

# 计算并打印准确率
accuracy_soft_weighted = accuracy_score(y_test, y_pred_soft_weighted)
print(f"Soft Voting Classifier with Weights Accuracy: {accuracy_soft_weighted:.4f}")

带权重的软投票的工作原理

在这个例子中，我们为每个分类器指定了不同的权重：

  • 逻辑回归 (LogisticRegression)：权重为2。
  • 随机森林 (RandomForestClassifier)：权重为1。
  • 高斯朴素贝叶斯 (GaussianNB)：权重为1。

这意味着逻辑回归的预测概率将被赋予两倍于其他两个分类器的重要性。

具体步骤如下：

  1. 预测概率：对于每个测试样本，每个分类器都会输出一个概率向量。

    假设我们有一个测试样本 x，三个分类器对其类别 [0, 1, 2] 的预测概率分别为：

    • 逻辑回归：[0.2, 0.5, 0.3]
    • 随机森林：[0.3, 0.4, 0.3]
    • 高斯朴素贝叶斯：[0.1, 0.6, 0.3]

  2. 加权平均：根据指定的权重，对每个类别的概率进行加权平均。例如，假设权重为 [2, 1, 1]，则计算方法如下：

    • 类别0的加权平均概率：(2 * 0.2 + 1 * 0.3 + 1 * 0.1) / (2 + 1 + 1) = (0.4 + 0.3 + 0.1) / 4 = 0.2
    • 类别1的加权平均概率：(2 * 0.5 + 1 * 0.4 + 1 * 0.6) / 4 = (1.0 + 0.4 + 0.6) / 4 = 0.5
    • 类别2的加权平均概率：(2 * 0.3 + 1 * 0.3 + 1 * 0.3) / 4 = (0.6 + 0.3 + 0.3) / 4 = 0.3

  3. 选择最高概率的类别：根据加权平均后的概率向量，选择具有最高概率的类别作为最终预测结果。在这个例子中，类别1的概率最高（0.5），因此最终预测结果为类别1。

带权重的软投票通过结合多个分类器的概率预测结果并考虑不同分类器的重要性来提高整体模型的准确性。

4.1.2 VotingRegressor

VotingRegressor 则适用于回归任务。它的工作原理与 VotingClassifier 类似，但不是通过投票来决定类别，而是通过对各个基础回归器的预测结果取平均值（或其他聚合方式）来得到最终的预测值。

  • 平均法：最简单直接的方法是对所有基础回归器的预测结果求均值作为最终的预测值。
  • 加权平均法：可以为每个回归器分配一个权重，然后根据这些权重计算加权平均值。

示例代码：

from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.svm import SVR
from sklearn.ensemble import VotingRegressor
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split

# 创建示例数据集
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义基础回归器
reg1 = LinearRegression()
reg2 = RandomForestRegressor(n_estimators=50, random_state=1)
reg3 = SVR()

# 创建VotingRegressor实例
voting_reg = VotingRegressor(estimators=[('lr', reg1), ('rf', reg2), ('svr', reg3)])

# 训练模型
voting_reg.fit(X_train, y_train)

# 预测
predictions = voting_reg.predict(X_test)
4.1.3 总结
  • VotingClassifier 和 VotingRegressor 提供了一种简单而有效的方法来集成多个模型，以提高预测性能。
  • 对于分类任务，可以选择硬投票或软投票；对于回归任务，默认采用的是平均预测值的方法。
  • 使用这些集成方法时，重要的是确保所选的基础模型具有一定的多样性，这样可以最大化集成的效果。如果所有模型都非常相似，那么集成可能不会带来显著的性能提升。

4.2 Bagging

  1. Bootstrap Sampling：从原始数据集中随机抽取样本（有放回抽样），创建多个不同的子集。
  2. 独立训练模型：在每个子集上使用相同的算法训练一个模型。
  3. 聚合结果：
    • 对于分类问题，通常采用多数投票的方式决定最终类别（适用于BaggingClassifier）。
    • 对于回归问题，通常采用平均值的方式来决定最终预测值（适用于BaggingRegressor）。

BaggingClassifier 和 BaggingRegressor 是集成学习方法中的一种，它们基于Bootstrap aggregating（简称Bagging）技术。

4.2.1 BaggingClassifier

BaggingClassifier 用于分类任务。它通过构建多个基础分类器，并对这些分类器的预测结果进行投票来确定最终的预测结果。

示例代码

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 生成合成数据集
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

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

# 定义基础分类器
base_classifier = DecisionTreeClassifier()

# 创建BaggingClassifier实例
bagging_clf = BaggingClassifier(base_estimator=base_classifier, 
                                n_estimators=100, 
                                max_samples=0.5, 
                                max_features=0.5,
                                random_state=42)

# 训练模型
bagging_clf.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred = bagging_clf.predict(X_test)

# 计算并打印准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"Bagging Classifier Accuracy: {accuracy:.4f}")
  • base_estimator：指定作为基础模型的分类器，默认为决策树。
  • n_estimators：指定要训练的基础模型的数量。
  • max_samples：每个基础模型使用的样本数比例（可以小于1表示使用部分样本）。
  • max_features：每个基础模型使用的特征数比例（可以小于1表示使用部分特征）。
4.2.2 BaggingRegressor

BaggingRegressor 用于回归任务。它通过构建多个基础回归器，并对这些回归器的预测结果取平均值来确定最终的预测结果。

示例代码

from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# 生成合成数据集
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)

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

# 定义基础回归器
base_regressor = DecisionTreeRegressor()

# 创建BaggingRegressor实例
bagging_reg = BaggingRegressor(base_estimator=base_regressor, 
                               n_estimators=100, 
                               max_samples=0.5, 
                               max_features=0.5,
                               random_state=42)

# 训练模型
bagging_reg.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred = bagging_reg.predict(X_test)

# 计算并打印均方误差
mse = mean_squared_error(y_test, y_pred)
print(f"Bagging Regressor MSE: {mse:.4f}")
  • 参数解释与BaggingClassifier类似，只是基础模型换成了回归器，评估指标也相应地变为了回归任务常用的均方误差（MSE）。
4.2.3 总结
  • BaggingClassifier 和 BaggingRegressor 通过在不同的数据子集上训练多个相同类型的模型，并结合它们的预测结果来提高模型的性能。
  • 在分类问题中，Bagging通过多数投票来决定最终类别；在回归问题中，则通过计算预测值的平均值来得到最终结果。

4.3 Stacking

  1. 基础模型：在第一阶段，使用不同的算法训练多个基础模型。这些模型可以是任何类型的分类器或回归器。
  2. 元模型：在第二阶段，使用一个新的模型（元模型）来学习如何最好地结合基础模型的预测结果。元模型接收的是基础模型对训练数据的预测作为输入特征，并试图学习一个最佳的组合策略。
  3. 交叉验证：为了避免过拟合，通常使用交叉验证的方法来生成用于训练元模型的数据集。也就是说，基础模型的预测不是直接基于整个训练集，而是基于每个基础模型在其未见过的数据上的预测结果。

StackingClassifier 和 StackingRegressor 是集成学习方法中的另一种技术，称为堆叠（Stacking）。堆叠的核心思想是通过训练多个基础模型（也称作第一层模型或弱学习器），然后使用另一个模型（称为元模型或第二层模型）来结合这些基础模型的预测结果，从而生成最终的预测。这种方法允许模型之间进行更复杂的交互，并且能够利用不同模型的优点。

4.3.1 StackingClassifier

StackingClassifier 适用于分类任务，它通过将多个基础分类器的结果传递给一个元分类器来进行最终的分类决策。

示例代码

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import StackingClassifier
from sklearn.metrics import accuracy_score

# 生成合成数据集
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

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

# 定义基础分类器
base_classifiers = [
    ('rf', RandomForestClassifier(n_estimators=100, random_state=42)),
    ('gb', GradientBoostingClassifier(n_estimators=100, random_state=42))
]

# 定义元分类器
meta_classifier = LogisticRegression()

# 创建StackingClassifier实例
stacking_clf = StackingClassifier(estimators=base_classifiers, final_estimator=meta_classifier, cv=5)

# 训练模型
stacking_clf.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred = stacking_clf.predict(X_test)

# 计算并打印准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"Stacking Classifier Accuracy: {accuracy:.4f}")
  • estimators：指定一组基础分类器。
  • final_estimator：指定元分类器，用于学习如何结合基础分类器的输出。
  • cv：指定交叉验证的折数，默认为5折交叉验证。这确保了元模型不会直接看到基础模型的训练数据，从而减少过拟合的风险。
4.3.2 StackingRegressor

StackingRegressor 类似于 StackingClassifier，但适用于回归任务。它通过将多个基础回归器的结果传递给一个元回归器来进行最终的预测。

示例代码

from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import StackingRegressor
from sklearn.metrics import mean_squared_error

# 生成合成数据集
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)

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

# 定义基础回归器
base_regressors = [
    ('rf', RandomForestRegressor(n_estimators=100, random_state=42)),
    ('gb', GradientBoostingRegressor(n_estimators=100, random_state=42))
]

# 定义元回归器
meta_regressor = LinearRegression()

# 创建StackingRegressor实例
stacking_reg = StackingRegressor(estimators=base_regressors, final_estimator=meta_regressor, cv=5)

# 训练模型
stacking_reg.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred = stacking_reg.predict(X_test)

# 计算并打印均方误差
mse = mean_squared_error(y_test, y_pred)
print(f"Stacking Regressor MSE: {mse:.4f}")
  • 参数设置与 StackingClassifier 类似，只是这里的基础模型和元模型都是针对回归任务设计的。

如何理解将多个基础分类器的结果传递给一个元分类器来进行最终的分类决策?

关键点解析：

  • 基础模型（Base Models）：可以是任何类型的机器学习模型，例如决策树、支持向量机、神经网络等。在分类任务中，它们被称为基础分类器；在回归任务中，它们被称为基础回归器。

  • 元模型（Meta Model）：这是一个单独的模型，它接收基础模型对训练数据的预测结果作为输入，并基于这些预测进行最终的预测。对于分类问题，元模型输出的是类别标签；对于回归问题，元模型输出的是连续值。

详细解释

  1. 基础分类器的预测：首先，你有一组不同的基础分类器（比如逻辑回归、随机森林和K近邻）。每个分类器都会对相同的训练集或验证集做出预测。这些预测结果通常是一个概率分布（对于每个样本属于各个类别的概率）或者直接是类别标签。

  2. 生成新的特征集：接下来，利用这些基础分类器对训练集的预测结果来创建一个新的特征集。具体来说，如果有一个包含N个样本的数据集，且有M个基础分类器，则每个样本现在会对应M个预测值（如果是概率形式，则可能是M*K个值，其中K是类别的数量）。这实际上为原始数据集添加了一层新的特征表示。

  3. 元分类器的训练：然后，使用上述步骤生成的新特征集作为输入来训练元分类器。也就是说，元分类器不是直接基于原始特征进行训练，而是基于基础分类器的预测结果进行训练。这样做的目的是让元分类器学会如何最好地整合来自不同基础分类器的信息，从而做出更准确的最终预测。

  4. 最终的分类决策：一旦元分类器训练完成，在测试阶段，首先用所有基础分类器对测试集进行预测，然后将这些预测结果作为输入传递给元分类器，由元分类器根据这些信息做出最终的分类决定。

示例流程

假设我们有三个基础分类器：clf1, clf2, 和 clf3，以及一个元分类器 meta_clf。

  1. 对于训练集中的每个样本，分别得到 clf1, clf2, 和 clf3 的预测结果。
  2. 使用这些预测结果作为新特征来训练 meta_clf。
  3. 在测试阶段，同样获取这三个分类器对测试集的预测结果。
  4. 将这三个分类器的预测结果输入到 meta_clf 中，meta_clf 根据这些输入给出最终的分类结果。

这种机制使得堆叠能够有效地利用多个模型的优势，克服单个模型可能存在的局限性，进而提升整个系统的预测能力。

4.3.3 总结
  • StackingClassifier 和 StackingRegressor 通过构建多个基础模型并将它们的预测结果传递给一个元模型来实现最终的预测。
  • 这种方法允许模型之间进行更复杂的交互，并能够利用不同模型的优点，提高整体模型的性能。
  • 使用交叉验证来生成元模型的训练数据，有助于防止过拟合，使得模型更加稳定和可靠。
  • 在实践中，调整超参数和考虑模型之间的多样性也是优化堆叠模型性能的重要方面。

4.4 Boosting

  • 错题本思想：通过调整错误分类实例的权重，使得后续分类器更加关注这些困难案例。

AdaBoost 和 Gradient Boosting 是两种基于提升（Boosting）策略的集成学习方法，它们通过构建一系列弱学习器并将这些弱学习器组合成一个强学习器来提高预测性能。

4.4.1 AdaBoost

AdaBoost（Adaptive Boosting）是一种迭代算法，它通过对先前分类错误的数据点赋予更高的权重来逐步改进模型。

4.4.1.1 AdaBoostClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# 创建合成数据集
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

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

# 定义AdaBoost分类器
adaboost_clf = AdaBoostClassifier(n_estimators=50, random_state=42)

# 训练模型
adaboost_clf.fit(X_train, y_train)

# 预测
predictions = adaboost_clf.predict(X_test)
4.4.1.2 AdaBoostRegressor

  • 工作原理：类似于 AdaBoostClassifier，但用于回归任务。它通过最小化损失函数来更新样本权重，并结合多个弱回归器的结果以生成最终预测值。

    • 不同之处：主要在于如何计算每个弱学习器的贡献以及如何更新样本权重，具体细节依赖于所使用的损失函数（如线性、平方等）。
from sklearn.ensemble import AdaBoostRegressor
from sklearn.datasets import make_regression

# 创建合成数据集
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)

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

# 定义AdaBoost回归器
adaboost_reg = AdaBoostRegressor(n_estimators=50, random_state=42)

# 训练模型
adaboost_reg.fit(X_train, y_train)

# 预测
predictions = adaboost_reg.predict(X_test)
4.4.2 Gradient Boosting

Gradient Boosting 是一种前向分步算法，它通过添加新的模型来纠正现有模型的误差，从而逐步降低损失函数的值。

4.4.2.1 GradientBoostingClassifier
  • 工作原理：从一个简单的初始模型（通常是常数预测）开始，然后依次添加新的弱学习器（通常是决策树），每个新添加的模型都试图减少整体模型的损失函数。具体来说，每个新的弱学习器都是基于前一轮模型的残差（即预测值与真实值之间的差异）进行训练的。
from sklearn.ensemble import GradientBoostingClassifier

# 定义Gradient Boosting分类器
gb_clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)

# 训练模型
gb_clf.fit(X_train, y_train)

# 预测
predictions = gb_clf.predict(X_test)
4.4.2.2 GradientBoostingRegressor

  • 工作原理：与 GradientBoostingClassifier 类似，但用于回归任务。它的目标是最小化回归任务中的损失函数（如均方误差）。

    • 过程：从初始估计开始，随后每一步都添加一个新的弱学习器，该学习器专注于拟合上一步中模型预测值与实际值之间的残差，以此来逐步改善模型的整体性能。
from sklearn.ensemble import GradientBoostingRegressor

# 定义Gradient Boosting回归器
gb_reg = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)

# 训练模型
gb_reg.fit(X_train, y_train)

# 预测
predictions = gb_reg.predict(X_test)
4.4.3 总结
  • AdaBoost：通过增加难以分类样本的权重来迭代地改进模型，适用于分类和回归任务。
  • Gradient Boosting：通过梯度下降的方式逐步优化模型，专注于减少残差，同样适用于分类和回归任务。
  • 这两种方法都属于提升技术，旨在通过组合弱学习器来构建强大的模型。选择哪种方法取决于具体应用场景及数据特性。

篇幅有点长了，接下一篇《集成学习（二）：从理论到实战(附代码)》

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2297488.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

不小心删除服务[null]后，git bash出现错误

不小心删除服务[null]后，git bash出现错误

不小心删除服务[null]后，git bash出现错误，如何解决？ 错误描述：打开 git bash、msys2都会出现错误「bash: /dev/null: No such device or address」 问题定位： 1.使用搜索引擎搜索「bash: /dev/null: No such device o…
阅读更多...
【云安全】云原生- K8S kubeconfig 文件泄露

【云安全】云原生- K8S kubeconfig 文件泄露

什么是 kubeconfig 文件？ kubeconfig 文件是 Kubernetes 的配置文件，用于存储集群的访问凭证、API Server 的地址和认证信息，允许用户和 kubectl 等工具与 Kubernetes 集群进行交互。它通常包含多个集群的配置，支持通过上下文&am…
阅读更多...
【工业场景】用YOLOv8实现火灾识别

【工业场景】用YOLOv8实现火灾识别

火灾识别任务是工业领域急需关注的重点安全事项，其应用场景和背景意义主要体现在以下几个方面： 应用场景：工业场所：在工厂、仓库等工业场所中，火灾是造成重大财产损失和人员伤亡的主要原因之一。利用火灾识别技术可以及时发现火灾迹象，采取相应的应急措施，保障人员安全和…
阅读更多...
(2025)深度分析DeepSeek-R1开源的6种蒸馏模型之间的逻辑处理和编写代码能力区别以及配置要求，并与ChatGPT进行对比(附本地部署教程)

(2025)深度分析DeepSeek-R1开源的6种蒸馏模型之间的逻辑处理和编写代码能力区别以及配置要求，并与ChatGPT进行对比(附本地部署教程)

(2025)通过Ollama光速部署本地DeepSeek-R1模型(支持Windows10/11)_deepseek猫娘咒语-CSDN博客文章浏览阅读1k次，点赞19次，收藏9次。通过Ollama光速部署本地DeepSeek-R1(支持Windows10/11)_deepseek猫娘咒语https://blog.csdn.net/m0_70478643/article/de…
阅读更多...
【自然语言处理】TextRank 算法提取关键词、短语、句（Python源码实现）

【自然语言处理】TextRank 算法提取关键词、短语、句（Python源码实现）

文章目录 一、TextRank 算法提取关键词 [工具包]二、TextRank 算法提取关键短语[工具包]三、TextRank 算法提取关键句[工具包]四、TextRank 算法提取关键句（Python源码实现） 一、TextRank 算法提取关键词 [工具包] 见链接 【自然语言处理】TextRank 算法…
阅读更多...
记一次Self XSS+CSRF组合利用

记一次Self XSS+CSRF组合利用

视频教程在我主页简介或专栏里 （不懂都可以来问我 专栏找我哦） 目录：　 确认 XSS 漏洞 确认 CSRF 漏洞 这个漏洞是我在应用程序的订阅表单中发现的一个 XSS 漏洞，只能通过 POST 请求进行利用。通常情况下，基于 POST 的…
阅读更多...
JDBC如何连接数据库

JDBC如何连接数据库

首先，我们要去下载JDBC的驱动程序 官网下载地址:https://downloads.mysql.com/archives/c-j/ 选择最新版本就可以 然后回到我们idea点击file - project Structure - Modules， 就行了 参考1：如何解决JDBC连接数据库出现问题且对进行数据库操…
阅读更多...
AI语言模型的技术之争：DeepSeek与ChatGPT的架构与训练揭秘

AI语言模型的技术之争：DeepSeek与ChatGPT的架构与训练揭秘

云边有个稻草人-CSDN博客 目录 第一章：DeepSeek与ChatGPT的基础概述 1.1 DeepSeek简介 1.2 ChatGPT简介 第二章：模型架构对比 2.1 Transformer架构：核心相似性 2.2 模型规模与参数 第三章：训练方法与技术 3.1 预训练与微调…
阅读更多...
网络安全威胁是什么

网络安全威胁是什么

1.网络安全威胁的概念 网络安全威胁指网络中对存在缺陷的潜在利用，这些缺陷可能导致信息泄露、系统资源耗尽、非法访问、资源被盗、系统或数据被破坏等。 2.网络安全威胁的类型 物理威胁系统漏洞威胁身份鉴别威胁线缆连接威胁有害程序危险 （1&#x…
阅读更多...
驱动开发、移植（最后的说法有误，以后会修正）

驱动开发、移植（最后的说法有误，以后会修正）

一、任务明确：把创龙MX8的驱动 按照我们的要求 然后移植到 我们的板子 1.Linux系统启动卡制作， sd卡 先按照 《用户手册—3-2-Linux系统启动卡制作及系统固化》 把创龙的Linux系统刷进去。 2. 把TLIMX8-EVM的板子过一遍 把刚刚烧好系统的sd卡插入 创…
阅读更多...
归并排序（C# C++）

归并排序（C# C++）

目录 1 归并排序的基本概念 2 算法步骤 2-1 分解阶段 2-2 合并阶段 3 代码实现 3-1 C#代码示例（该代码在unity环境下） 3-2 C代码示例 1 归并排序的基本概念 归并排序（Merge Sort）是一种经典的分治算法，由约翰…
阅读更多...
如何使用智能化RFID管控系统，对涉密物品进行安全有效的管理？

如何使用智能化RFID管控系统，对涉密物品进行安全有效的管理？

载体主要包括纸质文件、笔记本电脑、优盘、光盘、移动硬盘、打印机、复印机、录音设备等，载体（特别是涉密载体）是各保密、机要单位保证涉密信息安全、防止涉密信息泄露的重要信息载体。载体管控系统主要采用RFID射频识别及物联网技术&#xf…
阅读更多...
华为云kubernetes基于keda自动伸缩deployment副本（监听redis队列长度）

华为云kubernetes基于keda自动伸缩deployment副本（监听redis队列长度）

1 概述 KEDA（Kubernetes-based Event-Driven Autoscaler，网址是https://keda.sh）是在 Kubernetes 中事件驱动的弹性伸缩器，功能非常强大。不仅支持根据基础的CPU和内存指标进行伸缩，还支持根据各种消息队列中的长度、…
阅读更多...
入选TPAMI2025！傅里叶变换+目标检测新突破！

入选TPAMI2025！傅里叶变换+目标检测新突破！

今天给大家推荐一个目标检测，好发不卷的新思路：与傅里叶变换结合！ 一方面，不仅能提升检测的准确性和可靠性，还能增强模型的通用性和适应性，灵活应对复杂场景。比如TPAMI25的FSD模型，便通过该方…
阅读更多...
物联网智能语音控制灯光系统设计与实现

物联网智能语音控制灯光系统设计与实现

背景 随着物联网技术的蓬勃发展，智能家居逐渐成为现代生活的一部分。在众多智能家居应用中，智能灯光控制系统尤为重要。通过语音控制和自动调节灯光，用户可以更便捷地操作家中的照明设备，提高生活的舒适度与便利性。本文将介绍一…
阅读更多...
等级保护2.0|网络安全服务

等级保护2.0|网络安全服务

等级保护2.0|网络安全服务 定义 对于国家秘密信息、法人和其他组织及公民专有信息以及公开信息的存储、传输、处理这些信息系统分等级实行安全保护，对信息系统中发生的信息安全时间分等级响应、处置。 思想 对信息安全实行等级化保护和等级化管理 目标 突出重…
阅读更多...
安科瑞光伏发电防逆流解决方案——守护电网安全，提升能源效率

安科瑞光伏发电防逆流解决方案——守护电网安全，提升能源效率

安科瑞 华楠 18706163979 在当今大力发展清洁能源的时代背景下，光伏发电作为一种可持续的能源解决方案， 正得到越来越广泛的应用。然而，光伏发电过程中出现的逆流问题，给电网的安全稳定 运行带来了诸多挑战。若不能有效解决&…
阅读更多...
Web第二次作业_补充完小鹅通首页（静态）

Web第二次作业_补充完小鹅通首页（静态）

目录 题目 index css style 解题 技术优势 html css 运营服务 html css 小鹅通 html css 咨询 html css 友情链接、公司信息 html css 效果展示 技术优势 运营服务 小鹅通 咨询 友情链接、公司信息 题目 index <!DOCTYPE html> <html lang…
阅读更多...
碳纤维复合材料制造的六西格玛管理实践：破解高端制造良率困局的实战密码

碳纤维复合材料制造的六西格玛管理实践：破解高端制造良率困局的实战密码

碳纤维复合材料制造的六西格玛管理实践&#xff1a;破解高端制造良率困局的实战密码 在全球碳中和与高端制造升级的双重驱动下&#xff0c;碳纤维复合材料行业正经历前爆发式增长。航空航天、新能源汽车、风电叶片等领域对碳纤维产品的性能稳定性提出近乎苛刻的要求&#xff0…
阅读更多...
在 Mac ARM 架构上使用 nvm 安装 Node.js 版本 16.20.2

在 Mac ARM 架构上使用 nvm 安装 Node.js 版本 16.20.2

文章目录 1. 安装 nvm&#xff08;如果还没有安装的话&#xff09;2. 加载 nvm 配置3. 列出特定系列的 Node.js 版本&#xff08;远程&#xff09;&#xff1a;4. 安装 Node.js 16.20.25. 使用指定版本的 Node.js6. 验证安装 在 Mac ARM 架构上使用 nvm 安装 Node.js 版本 16.…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023