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

一、引言

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

二、机器学习 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.rhkb.cn/news/16478.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Linux之kernel(1)系统基础理论(2)

Linux之kernel(1)系统基础理论(2)

Linux之Kernel(1)系统基础理论(2) Author: Once Day Date: 2025年2月10日 一位热衷于Linux学习和开发的菜鸟，试图谱写一场冒险之旅，也许终点只是一场白日梦… 漫漫长路，有人对你微笑过嘛… 全系列文章可参考专栏: Linux内核知识_Once-Day的…
阅读更多...
git本地建的分支,删除后内容还能找回

git本地建的分支,删除后内容还能找回

前提&#xff1a; 需要有commit 动作 1、git reflog 命令查看所有分支操作记录&#xff1b; 2、git checkout -b 命令创建一个新的分支&#xff0c;将其指向被删除分支的最后一个提交记录‌&#xff1b; git checkout -b <branch-name> <commit-hash>旨在分享~…
阅读更多...
【每日一题 | 2025】2.3 ~ 2.9

【每日一题 | 2025】2.3 ~ 2.9

个人主页&#xff1a;GUIQU. 归属专栏&#xff1a;每日一题 文章目录 1. 【2.3】P8784 [蓝桥杯 2022 省 B] 积木画2. 【2.4】P8656 [蓝桥杯 2017 国 B] 对局匹配3. 【2.5】[ABC365D] AtCoder Janken 34. 【2.6】P8703 [蓝桥杯 2019 国 B] 最优包含5. 【2.7】P8624 [蓝桥杯 2015…
阅读更多...
Unity URP后处理在Game窗口不显示

Unity URP后处理在Game窗口不显示

摄像机勾选这个就可以了&#xff1a; 参考&#xff1a;UNITY3D URP与后处理,在game窗口不显示问题_unity urp 半透明材质game看不到-CSDN博客
阅读更多...
Java进阶14 TCP日志枚举

Java进阶14 TCP日志枚举

Java进阶14 TCP&日志&枚举 一、网络编程TCP Java对基于TCP协议得网络提供了良好的封装&#xff0c;使用Socket对象来代表两端的通信端口&#xff0c;并通过Socket产生IO流来进行网络通信。 1、TCP协议发数据 1.1 构造方法 方法 说明 Socket(InetAddress address…
阅读更多...
C#02项目——Checked用法

C#02项目——Checked用法

知识点 本项目用到的知识点包括&#xff1a; checked。主要用来处理溢出错误 Try.Prarse。将数字的字符串表示形式转换为其等效的 32 位有符号整数。 返回值指示转换是否成功 public static bool TryParse (string? s, out int result);Try…Catch。用于捕捉异常&#xff0c…
阅读更多...
WPF 设置宽度为 父容器 宽度的一半

WPF 设置宽度为 父容器 宽度的一半

方法1&#xff1a;使用 绑定和转换器 实现 创建类文件 HalfWidthConverter public class HalfWidthConverter : IValueConverter{public object Convert(object value, Type targetType, object parameter, CultureInfo culture){if (value is double width){return width / 4…
阅读更多...
Windows 系统 GDAL库 配置到 Qt 上

Windows 系统 GDAL库 配置到 Qt 上

在地理信息开发中广泛使用的开源库&#xff0c;GDAL(Geospatial Data Abstraction Library&#xff09;)库提供了读取和处理各种地理空间数据格式的能力。 准备阶段 下载 GDAL 库&#xff1a;前往 GDAL 的官方网站&#xff08;https://www.gisinternals.com/&#xff09;下载…
阅读更多...
自己动手实现一个简单的Linux AI Agent

自己动手实现一个简单的Linux AI Agent

大模型带我们来到了自然语言人机交互的时代 1、安装本地大模型进行推理 下载地址&#xff1a; https://ollama.com/download 部署本地deepseek和嵌入模型 ollama run deepseek-r1:7b2、制定Linux操作接口指令规范 3、编写大模型对话工具 #!/usr/bin/python3 #coding: utf-8…
阅读更多...
豆包MarsCode “一键Apply”功能测评：编程效率革新利器

豆包MarsCode “一键Apply”功能测评：编程效率革新利器

本文 前言功能亮点1. 告别重复操作2. 精准问题解决3. 助力新项目开发4.代码快速切换5.注释快速生成&#xff0c;一键Apply直接粘贴 使用体验总结 本文正在参加豆包MarsCode上新Apply体验活动 前言 在当今快节奏的编程开发领域&#xff0c;效率无疑是开发者们追求的核心目标之一…
阅读更多...
SpringBoot中的Javaconfig

SpringBoot中的Javaconfig

为什么要使用Javaconfig&#xff1f; 如果要声明的bean对象&#xff0c;来自于第三方jar包&#xff08;不是自定义的&#xff09;&#xff0c;无法使用Component 及衍生注解来声明bean&#xff0c;因为第三方的jar一般不可写&#xff0c;需要使用注解Configuration和Bean注解来…
阅读更多...
ThinkPHP8视图赋值与渲染

ThinkPHP8视图赋值与渲染

【图书介绍】《ThinkPHP 8高效构建Web应用》-CSDN博客 《2025新书 ThinkPHP 8高效构建Web应用 编程与应用开发丛书 夏磊 清华大学出版社教材书籍 9787302678236 ThinkPHP 8高效构建Web应用》【摘要 书评 试读】- 京东图书 在控制器操作中&#xff0c;使用view函数可以传入视图…
阅读更多...
笔记4——列表list

笔记4——列表list

列表list list&#xff1a;一种有序的集合&#xff1b;可以随时添加和删除列表元素&#xff1b;可以包含不同数据类型 使用 【】 定义列表&#xff1b;元素之间用 , 分开 my_list [1,love,0.123,[1,2,3]] print(my_list)len() &#xff1a;获取元素个数&#xff1b;空列表…
阅读更多...
大数据系列 | 白话讲解大数据技术生态中Hadoop、Hive、Spark的关系介绍

大数据系列 | 白话讲解大数据技术生态中Hadoop、Hive、Spark的关系介绍

大数据属于数据管理系统的范畴&#xff0c;数据管理系统无非就两个问题&#xff1a;数据怎么存、数据怎么算    现在的信息爆炸时代&#xff0c;一台服务器数据存不下&#xff0c;可以找10台服务器存储&#xff0c;10台存储不下&#xff0c;可以再找100台服务器存储。但是这1…
阅读更多...
分布式 IO 模块：港口控制主柜的智能 “助手”

分布式 IO 模块：港口控制主柜的智能 “助手”

在繁忙的港口&#xff0c;每一个集装箱的装卸、每一艘货轮的停靠与离港&#xff0c;都离不开高效精准的控制系统。港口控制主柜作为整个港口作业的核心枢纽之一&#xff0c;其稳定运行至关重要。而明达技术自主研发推出的MR30分布式 IO 模块可作为从站&#xff0c;与 PLC&#…
阅读更多...
Golang GORM系列：GORM 高级查询教程

Golang GORM系列：GORM 高级查询教程

有效的数据检索是任何程序功能的基础。健壮的Go对象关系映射包&#xff08;称为GORM&#xff09;除了标准的CRUD操作之外&#xff0c;还提供了复杂的查询功能。这是学习如何使用GORM进行高级查询的综合资源。我们将涵盖WHERE条件、连接、关联、预加载相关数据&#xff0c;甚至涉…
阅读更多...
常见的数据仓库有哪些?

常见的数据仓库有哪些?

数据仓库（Data Warehouse，简称数仓）是企业用于存储、管理和分析大量数据的重要工具，其核心目标是通过整合和处理数据，为决策提供高质量、一致性和可信度的数据支持。在构建和使用数仓时，选择合适的工具和技术至关重要。以下是常见的数仓工具及其特点的详细介绍： 1. Hiv…
阅读更多...
搜维尔科技在动作捕捉与动画制作、汽车制造与安全测试、机器人与自动化领域的一些案例

搜维尔科技在动作捕捉与动画制作、汽车制造与安全测试、机器人与自动化领域的一些案例

动作捕捉与动画制作领域 1.逼真的手部和面部动画制作&#xff1a;动画师施先生利用搜维尔科技代理的Xsens套装、Manus VR手套和Faceware的面部动作捕捉系统&#xff0c;捕捉短片中人物的手部和面部动作&#xff0c;再将数据重新定位到角色骨架上并调整&#xff0c;最终在虚幻引…
阅读更多...
HTTP3原理解析和实战应用

HTTP3原理解析和实战应用

http协议原理解析 HTTP1.1改动 keeplive 在http1.0版本中http连接会在每次请求都会发起连接, 并且每次连接在保证安全性都需要建立三次握手, 每次请求后就立即断开连接, 下次请求就还需要重新建立连接.这样就提升了请求的复杂度. keeplive就使得每次建立连接后可以多次请求…
阅读更多...
【分布式理论9】分布式协同：分布式系统进程互斥与互斥算法

【分布式理论9】分布式协同：分布式系统进程互斥与互斥算法

文章目录 一、互斥问题及分布式系统的特性二、分布式互斥算法1. 集中互斥算法调用流程优缺点 2. 基于许可的互斥算法&#xff08;Lamport 算法&#xff09;调用流程优缺点 3. 令牌环互斥算法调用流程优缺点 三、三种算法对比 在分布式系统中&#xff0c;多个应用服务可能会同时…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023