[机器学习算法]决策树

1. 理解决策树的基本概念

决策树是一种监督学习算法，可以用于分类和回归任务。决策树通过一系列规则将数据划分为不同的类别或值。树的每个节点表示一个特征，节点之间的分支表示特征的可能取值，叶节点表示分类或回归结果。
在这里插入图片描述

2. 决策树的构建过程

2.1. 特征选择

特征选择是构建决策树的第一步，通常使用信息增益、基尼指数或增益率等指标。

  1. 信息增益（Information Gain）

信息增益表示通过某个特征将数据集划分后的纯度增加量，公式如下：
在这里插入图片描述
其中：

D 是数据集。
A 是特征。
V(A) 是特征 A 的所有可能取值。
Dv 是数据集中特征 A 取值为 v 的子集。
∣Dv​∣ 是 Dv​ 中样本的数量。
∣D∣ 是数据集 D 中样本的总数量。
Entropy(D) 是数据集 D 的熵，表示数据集本身的纯度。

选择信息增益最大的特征作为当前节点的划分特征。

熵的计算公式为：
在这里插入图片描述
其中：

c 是类别的数量。
pi 是数据集中属于第 i 类的样本所占的比例。

以下代码展示了如何计算熵、信息增益，并选择最优特征。

import numpy as np
from collections import Counter
from sklearn.datasets import load_irisdef entropy(y):hist = np.bincount(y)ps = hist / len(y)return -np.sum([p * np.log2(p) for p in ps if p > 0])def information_gain(X, y, feature):# Entropy before splitentropy_before = entropy(y)# Values and countsvalues, counts = np.unique(X[:, feature], return_counts=True)# Weighted entropy after splitentropy_after = 0for v, count in zip(values, counts):entropy_after += (count / len(y)) * entropy(y[X[:, feature] == v])return entropy_before - entropy_afterdef best_feature_by_information_gain(X, y):features = X.shape[1]gains = [information_gain(X, y, feature) for feature in range(features)]return np.argmax(gains), max(gains)# Load dataset
iris = load_iris()
X = iris.data
y = iris.target# Find best feature
best_feature, best_gain = best_feature_by_information_gain(X, y)
print(f'Best feature: {iris.feature_names[best_feature]}, Information Gain: {best_gain}')
  1. 基尼指数（Gini Index）
    也称为基尼不纯度（Gini Impurity），是一种衡量数据集纯度的指标。基尼指数越小，数据集的纯度越高。

基尼指数的计算公式：
对于一个包含 k 个类别的分类问题，基尼指数 G(D) 定义如下：
在这里插入图片描述
其中：

D 是数据集。
k 是类别的数量。
pi 是数据集中属于第 i 类的样本所占的比例。

条件基尼指数：
在某个特征 A 的条件下，数据集 D 的条件基尼指数 G(D∣A) 定义如下：
在这里插入图片描述
其中：

values(A) 是特征 A 的所有可能取值。
Dv​ 是数据集中特征 A 取值为 v 的子集。
∣Dv∣ 是 Dv​ 中样本的数量。
∣D∣ 是数据集 D 中样本的总数量。
G(Dv) 是子集 Dv​ 的基尼指数。

基尼增益（Gini Gain）：
基尼增益 GG(D,A) 是通过特征 A 划分数据集 D 后基尼指数的减少量。计算公式如下：
在这里插入图片描述
参数解释

D：整个数据集，包含了所有的样本。
A：某个特征，用于划分数据集。
G(D)：数据集 D 的基尼指数，表示数据集本身的纯度。
G(D∣A)：在特征 A 的条件下，数据集 D 的条件基尼指数，表示在特征 A 的条件下数据集的纯度。

选择基尼增益最大的特征及其分割点作为当前节点的划分特征。

以下代码展示如何使用上述步骤来选择基尼增益最大的特征：

import numpy as np
from sklearn.datasets import load_irisdef gini(y):hist = np.bincount(y)ps = hist / len(y)return 1 - np.sum([p**2 for p in ps if p > 0])def gini_gain(X, y, feature):# Gini index before splitgini_before = gini(y)# Values and countsvalues, counts = np.unique(X[:, feature], return_counts=True)# Weighted gini after splitgini_after = 0for v, count in zip(values, counts):gini_after += (count / len(y)) * gini(y[X[:, feature] == v])return gini_before - gini_afterdef best_feature_by_gini_gain(X, y):features = X.shape[1]gains = [gini_gain(X, y, feature) for feature in range(features)]return np.argmax(gains), max(gains)# Load dataset
iris = load_iris()
X = iris.data
y = iris.target# Find best feature
best_feature, best_gain = best_feature_by_gini_gain(X, y)
print(f'Best feature: {iris.feature_names[best_feature]}, Gini Gain: {best_gain}')
  1. 增益率（Gain Ratio）
    决策树中的增益率（Gain Ratio）用于选择最优的划分属性，以便构建决策树。增益率是基于信息增益（Information Gain）的一个修正版本，用于克服信息增益在处理属性取值多样性时可能出现的偏向问题。

信息增益是指选择某一属性划分数据集后，信息熵的减少量。信息增益公式为：

在这里插入图片描述
其中：

IG(T,A)：属性 A 对数据集 T 的信息增益。
H(T)：数据集 T 的熵。
H(T∣A)：在给定属性 A 的条件下数据集 T 的条件熵。

增益率通过将信息增益除以属性的固有值（Intrinsic Value）来计算。固有值是衡量属性取值多样性的一种指标。增益率公式为：
在这里插入图片描述
其中：

GR(T,A)：属性 A 对数据集 T 的增益率。
IG(T,A)：属性 A 对数据集 T 的信息增益。
IV(A)：属性 A 的固有值。

固有值（Intrinsic Value）

固有值反映了属性的取值多样性，计算公式为：

在这里插入图片描述
其中：

Ti​：属性 A 的第 i 个取值所对应的样本子集。
∣Ti∣：属性 A 的第 i 个取值所对应的样本子集的样本数量。
∣T∣：数据集 T 的总样本数量。
n：属性 A 取值的个数。

通过计算每个属性的增益率，选择增益率最高的属性作为决策树节点的划分属性，从而构建最优的决策树。

2.2. 划分节点

根据选定的特征和阈值，数据集被划分成多个子集。

2.3. 递归构建

递归地对每个子集进行特征选择和划分，直到满足停止条件（如当前数据子集中的所有实例都属于同一个类别，或达到预设的最大树深度）。
特征选择以增益率为例，在决策树构建过程中，选择每个节点的分裂特征是基于当前数据集的增益率计算结果的。对于每个分裂点，我们都会重新计算剩余特征的增益率，并选择其中最高的作为下一个分裂特征。

import numpy as np
import pandas as pd# 计算熵
def entropy(y):unique_labels, counts = np.unique(y, return_counts=True)probabilities = counts / counts.sum()return -np.sum(probabilities * np.log2(probabilities))# 计算信息增益
def information_gain(data, split_attribute, target_attribute):total_entropy = entropy(data[target_attribute])values, counts = np.unique(data[split_attribute], return_counts=True)weighted_entropy = np.sum([(counts[i] / np.sum(counts)) * entropy(data[data[split_attribute] == values[i]][target_attribute])for i in range(len(values))])info_gain = total_entropy - weighted_entropyreturn info_gain# 计算固有值
def intrinsic_value(data, split_attribute):values, counts = np.unique(data[split_attribute], return_counts=True)probabilities = counts / counts.sum()return -np.sum(probabilities * np.log2(probabilities))# 计算增益率
def gain_ratio(data, split_attribute, target_attribute):info_gain = information_gain(data, split_attribute, target_attribute)iv = intrinsic_value(data, split_attribute)return info_gain / iv if iv != 0 else 0# 递归构建决策树
def build_decision_tree(data, original_data, features, target_attribute, parent_node_class=None):# 条件1: 所有数据点属于同一类别if len(np.unique(data[target_attribute])) <= 1:return np.unique(data[target_attribute])[0]# 条件2: 数据子集为空elif len(data) == 0:return np.unique(original_data[target_attribute])[np.argmax(np.unique(original_data[target_attribute], return_counts=True)[1])]# 条件3: 没有更多的特征可以分裂elif len(features) == 0:return parent_node_classelse:parent_node_class = np.unique(data[target_attribute])[np.argmax(np.unique(data[target_attribute], return_counts=True)[1])]gain_ratios = {feature: gain_ratio(data, feature, target_attribute) for feature in features}best_feature = max(gain_ratios, key=gain_ratios.get)tree = {best_feature: {}}features = [i for i in features if i != best_feature]for value in np.unique(data[best_feature]):sub_data = data[data[best_feature] == value]subtree = build_decision_tree(sub_data, original_data, features, target_attribute, parent_node_class)tree[best_feature][value] = subtreereturn tree# 可视化决策树
def visualize_tree(tree, depth=0):if isinstance(tree, dict):for attribute, subtree in tree.items():if isinstance(subtree, dict):for value, subsubtree in subtree.items():print(f"{'|   ' * depth}|--- {attribute} = {value}")visualize_tree(subsubtree, depth + 1)else:print(f"{'|   ' * depth}|--- {attribute} = {value}: {subtree}")else:print(f"{'|   ' * depth}|--- {tree}")# 示例数据
data = pd.DataFrame({'Outlook': ['Sunny', 'Sunny', 'Overcast', 'Rain', 'Rain', 'Rain', 'Overcast', 'Sunny', 'Sunny', 'Rain', 'Sunny', 'Overcast', 'Overcast', 'Rain'],'Temperature': ['Hot', 'Hot', 'Hot', 'Mild', 'Cool', 'Cool', 'Cool', 'Mild', 'Cool', 'Mild', 'Mild', 'Mild', 'Hot', 'Mild'],'Humidity': ['High', 'High', 'High', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'High'],'Wind': ['Weak', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Strong'],'PlayTennis': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No']
})# 构建决策树
features = ['Outlook', 'Temperature', 'Humidity', 'Wind']
target_attribute = 'PlayTennis'
tree = build_decision_tree(data, data, features, target_attribute)# 可视化决策树
print("Decision Tree:")
visualize_tree(tree)

通过运行代码，可以看到每个节点选择的分裂特征以及决策树的结构：

Decision Tree:
|--- Temperature = Cool
|   |--- PlayTennis = Yes
|--- Temperature = Hot
|   |--- PlayTennis = No
|--- Temperature = Mild
|   |--- Outlook = Sunny
|   |   |--- Humidity = High
|   |   |   |--- PlayTennis = No
|   |   |--- Humidity = Normal
|   |   |   |--- PlayTennis = Yes
|   |--- Outlook = Rain
|   |   |--- Wind = Weak
|   |   |   |--- PlayTennis = Yes
|   |   |--- Wind = Strong
|   |   |   |--- PlayTennis = No
|   |--- Outlook = Overcast
|   |   |--- PlayTennis = Yes

解释决策树的结构：

根节点是 Temperature，这是第一个选择的分裂特征。
Temperature 的每个取值（Cool, Hot, Mild）对应一个子节点。
如果 Temperature 是 Cool，则 PlayTennis 是 Yes。
如果 Temperature 是 Hot，则 PlayTennis 是 No。
如果 Temperature 是 Mild，则继续分裂 Outlook 属性：Outlook 是 Sunny 时，进一步分裂 Humidity 属性：Humidity 是 High 时，PlayTennis 是 No。Humidity 是 Normal 时，PlayTennis 是 Yes。Outlook 是 Rain 时，进一步分裂 Wind 属性：Wind 是 Weak 时，PlayTennis 是 Yes。Wind 是 Strong 时，PlayTennis 是 No。Outlook 是 Overcast 时，PlayTennis 是 Yes。

通过这种方式，决策树会根据每个节点选择最佳的分裂特征，直到所有数据点都被正确分类或没有更多的特征可供分裂。

2.4. 防止过拟合

防止决策树过拟合的方法主要包括剪枝、设置深度限制和样本数量限制。以下是一些常用的方法及其实现：

  1. 预剪枝 (Pre-pruning)

预剪枝是在构建决策树时限制树的增长。常用的方法包括：

设置最大深度：限制树的深度，防止树过深导致过拟合。
设置最小样本分裂数：如果节点中的样本数小于某个阈值，则不再分裂该节点。
设置最小信息增益：如果信息增益小于某个阈值，则不再分裂该节点。
  1. 后剪枝 (Post-pruning)

后剪枝是在决策树完全生长后，剪去一些不重要的分支。常用的方法包括：

代价复杂度剪枝 (Cost Complexity Pruning)：基于一个代价复杂度参数 α，剪去那些对降低训练误差贡献较小但增加了模型复杂度的分支。

代价复杂度剪枝 (CCP) 是一种后剪枝技术，用于简化已经完全生长的决策树。CCP 通过引入一个复杂度惩罚参数 α 来权衡决策树的复杂度与其在训练集上的误差。通过调整 α，我们可以控制模型的复杂度，防止过拟合。
原理

CCP 的基本思想是通过最小化以下代价复杂度函数来选择最佳的子树：
在这里插入图片描述
其中：

Rα(T) 是带有复杂度惩罚项的代价复杂度。
R(T)是子树 T 的误差。
α 是复杂度惩罚项，控制模型复杂度与误差之间的权衡。
∣T∣ 是子树 T 的叶节点数量。

较小的 α 值允许更多的节点，使树更加复杂；较大的 α 值会剪去更多的节点，使树更加简单。
代价复杂度剪枝步骤：

构建完全生长的决策树：首先，生成一棵完全生长的决策树，使其充分拟合训练数据。
计算每个子树的误差：对子树中的所有节点计算其误差 R(T)。
计算代价复杂度：对于每个子树，计算其代价复杂度 Rα(T)。
选择合适的 α：通过关系图或交叉验证结果选择最佳的 α 值。
剪枝：根据选定的 α 值，剪去那些对降低误差贡献不大但增加了复杂度的节点。

import numpy as np
import pandas as pd
from sklearn.tree import DecisionTreeClassifier, export_text
import matplotlib.pyplot as plt# 示例数据
data = pd.DataFrame({'Outlook': ['Sunny', 'Sunny', 'Overcast', 'Rain', 'Rain', 'Rain', 'Overcast', 'Sunny', 'Sunny', 'Rain', 'Sunny', 'Overcast', 'Overcast', 'Rain'],'Temperature': ['Hot', 'Hot', 'Hot', 'Mild', 'Cool', 'Cool', 'Cool', 'Mild', 'Cool', 'Mild', 'Mild', 'Mild', 'Hot', 'Mild'],'Humidity': ['High', 'High', 'High', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'High'],'Wind': ['Weak', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Strong'],'PlayTennis': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No']
})# 将特征和目标变量转换为数值编码
data_encoded = pd.get_dummies(data[['Outlook', 'Temperature', 'Humidity', 'Wind']])
target = data['PlayTennis'].apply(lambda x: 1 if x == 'Yes' else 0)# 拆分数据集
X = data_encoded
y = target# 构建完全生长的决策树
clf = DecisionTreeClassifier(random_state=0)
clf.fit(X, y)# 导出决策树规则
tree_rules = export_text(clf, feature_names=list(data_encoded.columns))
print("Original Decision Tree Rules:")
print(tree_rules)# 计算代价复杂度剪枝路径
path = clf.cost_complexity_pruning_path(X, y)
ccp_alphas, impurities = path.ccp_alphas, path.impurities# 训练不同复杂度惩罚项的决策树
clfs = []
for ccp_alpha in ccp_alphas:clf = DecisionTreeClassifier(random_state=0, ccp_alpha=ccp_alpha)clf.fit(X, y)clfs.append(clf)# 绘制复杂度惩罚项与树结构的关系图
node_counts = [clf.tree_.node_count for clf in clfs]
depth = [clf.tree_.max_depth for clf in clfs]fig, ax = plt.subplots(3, 1, figsize=(10, 10))
ax[0].plot(ccp_alphas, node_counts, marker='o', drawstyle="steps-post")
ax[0].set_xlabel("alpha")
ax[0].set_ylabel("number of nodes")
ax[0].set_title("Number of nodes vs alpha")ax[1].plot(ccp_alphas, depth, marker='o', drawstyle="steps-post")
ax[1].set_xlabel("alpha")
ax[1].set_ylabel("depth")
ax[1].set_title("Depth vs alpha")ax[2].plot(ccp_alphas, impurities, marker='o', drawstyle="steps-post")
ax[2].set_xlabel("alpha")
ax[2].set_ylabel("impurity")
ax[2].set_title("Impurity vs alpha")plt.tight_layout()
plt.show()# 选择合适的 alpha 进行剪枝并可视化决策树，例如选择 impurity 最小对应的 alpha
# Impurity 反映了决策树在分裂节点时的纯度，纯度越高（impurity 越低），节点中样本越一致，分类效果越好。
optimal_alpha = ccp_alphas[np.argmin(impurities)]
pruned_tree = DecisionTreeClassifier(random_state=0, ccp_alpha=optimal_alpha)
pruned_tree.fit(X, y)# 导出剪枝后的决策树规则
pruned_tree_rules = export_text(pruned_tree, feature_names=list(data_encoded.columns))print("Pruned Decision Tree Rules:")
print(pruned_tree_rules)

3. 使用集成方法

  • 随机森林：通过构建多棵决策树并结合它们的预测结果，可以减少单棵树的过拟合。

使用随机森林（Random Forest）是一种有效的方法来防止单个决策树模型的过拟合问题。随机森林通过构建多棵决策树并集成它们的预测结果，从而提高模型的泛化能力。
随机森林防止过拟合的机制：

1. 集成学习：随机森林是一种集成学习方法，通过构建多棵决策树，并将它们的预测结果进行投票或平均，从而得到最终的预测结果。这种方式可以有效地减少单棵决策树的高方差，提高模型的稳定性和泛化能力。2. 随机特征选择：在每棵决策树的节点分裂时，随机森林不会考虑所有特征，而是从所有特征中随机选择一个子集来进行分裂。这样可以减少树之间的相关性，提高集成效果。3. Bootstrap 重采样：每棵决策树都是通过对原始训练数据进行 bootstrap 重采样（有放回抽样）得到的不同样本集进行训练。这样每棵树都有不同的训练数据，进一步减少了树之间的相关性。
  • 梯度提升树：通过逐步构建一系列决策树，每棵树修正前一棵树的错误，可以提高模型的泛化能力。

梯度提升树（Gradient Boosting Trees, GBT）是一种集成学习方法，通过逐步构建一系列决策树来提高模型的预测性能。每棵新树的构建是为了修正之前所有树的误差。
梯度提升树防止过拟合的机制：

1. 分阶段训练：梯度提升树采用逐步训练的方法。每次构建新树时，模型会根据之前所有树的预测误差来调整新树的结构。这种逐步优化的方法可以有效减少过拟合。2. 学习率：学习率（learning rate）控制每棵树对最终模型的贡献。较小的学习率使得每棵树的影响较小，从而需要更多的树来拟合训练数据。尽管这会增加计算成本，但可以显著降低过拟合的风险。3. 树的深度：限制每棵树的最大深度可以防止单棵树过于复杂，从而避免过拟合。浅层树（通常 3-5 层）虽然不能完全拟合数据，但可以捕捉到数据的主要结构，从而与其他树一起构成一个强大的集成模型。4. 子样本采样：在构建每棵树时，梯度提升树可以对训练数据进行子样本采样（subsampling）。这种方法通过引入训练数据的随机性，减少了模型的方差，从而防止过拟合。5. 正则化：梯度提升树可以引入正则化参数，如 L1 和 L2 正则化，来进一步防止模型的过拟合。

4. 实际应用中的决策树

决策树可以用于多个实际应用，如客户分类、疾病诊断、风险评估等。在实际应用中，需要根据具体问题调整决策树的参数（如树的最大深度、最小样本分裂数等），以达到最佳效果。

使用 TensorFlow 和 NumPy 实现一个简单的决策树分类器

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

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

相关文章

Python基础-引用参数、斐波那契数列、无极分类

Python基础-引用参数、斐波那契数列、无极分类

1.引用参数的问题 &#xff08;1&#xff09;列表&#xff08;list&#xff09; 引用参数&#xff0c;传地址的参数&#xff0c;即list1会因list2修改而改变。 list1 [1,2,3,4] list2 list1 print(list1) list2[2] 1 print(list2) print(list1)非引用参数&#xff0c;不传…
阅读更多...
Jenkins+K8s实现持续集成（一）

Jenkins+K8s实现持续集成（一）

镜像仓库的搭建 docker run -d \--restartalways \--name registry \-p 5000:5000 \-v /root/devops/registry/data:/var/lib/registry \registry安装完之后&#xff0c;执行下面命令可以看到镜像仓库已经安装成功 docker ps 然后在浏览器上输入下面地址进行访问 http://ip:…
阅读更多...
关于app爬虫的环境准备

关于app爬虫的环境准备

摘要 有些数据需要在手机应用中才能查看&#xff0c;没有网页版&#xff0c;所以学习移动端的爬虫是有必要的。 手机系统分为安卓和苹果两大系统&#xff0c;本次讲解主要以安卓手机为例 有安卓手机的可以使用手机&#xff0c;没有的可以使用模拟器&#xff0c;本次以夜神模…
阅读更多...
.net 奇葩问题调试经历之1——在红外相机获取温度时异常

.net 奇葩问题调试经历之1——在红外相机获取温度时异常

📢欢迎点赞 ：👍 收藏 ⭐留言 📝 如有错误敬请指正，赐人玫瑰，手留余香！📢本文作者：由webmote 原创📢作者格言：新的征程，我们面对的不仅仅是技术还有人心，人心不可测，海水不可量，唯有技术，才是深沉黑夜中的一座闪烁的灯塔序言 我们在研发中，经常除了造产品…
阅读更多...
springMVC的bug

springMVC的bug

写SpringMVC时&#xff0c;配置视图解析器路径中少写了个“/”导致url拼接错误&#xff0c;无法返回视图
阅读更多...
[JS]变量

[JS]变量

变量是什么 变量就是计算机储存数据的"容器" 变量的使用 //1.声明变量 let age//2.变量赋值: age 20//3.变量初始化: 声明变量并赋值 let age 20//4.更新变量: 重新给变量赋值 let age 20 age 22//5.声明多个变量 //不推荐, 虽然代码更短, 但可读性较差 let na…
阅读更多...
springboot应用cpu飙升的原因排除

springboot应用cpu飙升的原因排除

1、通过top或者jps命令查到是那个java进程&#xff0c; top可以看全局那个进程耗cpu&#xff0c;而jps则默认是java最耗cpu的&#xff0c;比如找到进程是196 1.1 top (推荐)或者jps命令均可 2、根据第一步获取的进程号&#xff0c;查询进程里那个线程最占用cpu&#xff0c;发…
阅读更多...
windows系统中开发的GO程序生成docker镜像并部署到阿里云服务（linux系统）的操作说明

windows系统中开发的GO程序生成docker镜像并部署到阿里云服务（linux系统）的操作说明

本文简述将go程序生成docker镜像的操作方法&#xff0c;以及如何部署到阿里云服务。其中go程序在windows系统中开发&#xff0c;阿里云服务的操作系统为linux&#xff08;centos7.9&#xff09;&#xff0c;以下为流程示意图&#xff1a; 一、window系统中开发go程序 程序实现…
阅读更多...
Python学习打卡：day10

Python学习打卡：day10

day10 笔记来源于&#xff1a;黑马程序员python教程&#xff0c;8天python从入门到精通&#xff0c;学python看这套就够了 目录 day1073、文件的读取操作文件的操作步骤open()打开函数mode常用的三种基础访问模式读操作相关方法read()方法readlines()方法readline()方法for循…
阅读更多...
数据结构：小白专场：树的同构2程序框架、建树及同构判别

数据结构：小白专场：树的同构2程序框架、建树及同构判别

T1T2是之前提到的结构数组&#xff0c;是全局变量&#xff0c;作为参数传进去 调用Ismorphic这个函数判断R1R2是不是同构的 首先考虑如何构建BuidTree函数 输入数据的结构如左图 知道n之后&#xff0c;n不为0&#xff0c;循环&#xff0c;循环一次读入一行数据 为了处理方便…
阅读更多...
计算机组成原理---Cache的基本工作原理习题

计算机组成原理---Cache的基本工作原理习题

对应知识点&#xff1a; Cache的基本原理 1.某存储系统中&#xff0c;主存容量是Cache容量的4096倍&#xff0c;Cache 被分为 64 个块&#xff0c;当主存地址和Cache地址采用直接映射方式时&#xff0c;地址映射表的大小应为&#xff08;&#xff09;(假设不考虑一致维护和替…
阅读更多...
课程设计---哈夫曼树的编码与解码（Java详解）

课程设计---哈夫曼树的编码与解码（Java详解）

目录 一.设计任务&&要求&#xff1a; 二.方案设计报告&#xff1a; 2.1 哈夫曼树编码&译码的设计原理&#xff1a; 2.3设计目的&#xff1a; 2.3设计的主要过程&#xff1a; 2.4程序方法清单&#xff1a; 三.整体实现源码&#xff1a; 四.运行结果展示&…
阅读更多...
pytorch库 02 Anaconda、Jupyter常用命令及操作

pytorch库 02 Anaconda、Jupyter常用命令及操作

文章目录 一、Anaconda Prompt1、conda常用命令2、pip常用命令 二、Jupyter1、Jupyter常用命令及基本操作2、Jupyter代码补全插件安装 一、Anaconda Prompt 1、conda常用命令 下列命令可以在Anaconda Prompt中输入。 清屏&#xff1a; cls 查看帮助&#xff1a; conda -h 查…
阅读更多...
【MySQL统计函数count详解】

【MySQL统计函数count详解】

MySQL统计函数count详解 1. count()概述2. count(1)和count(*)和count(列名)的区别3. count(*)的实现方式 1. count()概述 count() 是一个聚合函数&#xff0c;返回指定匹配条件的行数。开发中常用来统计表中数据&#xff0c;全部数据&#xff0c;不为null数据&#xff0c;或…
阅读更多...
【尝鲜】SpringCloudAlibaba AI 配置使用教程

【尝鲜】SpringCloudAlibaba AI 配置使用教程

1、环境配置 maven依赖pom.xml 注意配置远程仓库&#xff0c;原因见&#xff1a;Unresolved dependency: ‘org.springframework.ai:spring-ai-core:jar:0.8.1’ <dependencies><!--Base--><dependency><groupId>org.springframework.boot</group…
阅读更多...
【Python机器学习实战】 | Lasso回归和弹性网回归详细分析研究

【Python机器学习实战】 | Lasso回归和弹性网回归详细分析研究

&#x1f3a9; 欢迎来到技术探索的奇幻世界&#x1f468;‍&#x1f4bb; &#x1f4dc; 个人主页&#xff1a;一伦明悦-CSDN博客 ✍&#x1f3fb; 作者简介&#xff1a; C软件开发、Python机器学习爱好者 &#x1f5e3;️ 互动与支持&#xff1a;&#x1f4ac;评论 &…
阅读更多...
自然语言处理概述

自然语言处理概述

目录 1.概述 2.背景 3.作用 4.优缺点 4.1.优点 4.2.缺点 5.应用场景 5.1.十个应用场景 5.2.文本分类 5.2.1.一般流程 5.2.2.示例 6.使用示例 7.总结 1.概述 自然语言处理&#xff08;NLP&#xff09;是计算机科学、人工智能和语言学的交叉领域&#xff0c;旨在实…
阅读更多...
Charles代理https接口到本地

Charles代理https接口到本地

一、操作手册 1、安装工具 1.1、安装代理软件Charles 软件下载地址&#xff1a;Download a Free Trial of Charles • Charles Web Debugging Proxy 1.2、安装https代理插件&#xff1a;&#xff08;有问题自行百度解决&#xff09; 2、配置策略 以下以https接口为例&…
阅读更多...
JAVAEE之网络原理（2）_传输控制协议(TCP)的连接管理机制，三次握手、四次挥手，及常见面试题

JAVAEE之网络原理（2）_传输控制协议(TCP)的连接管理机制，三次握手、四次挥手，及常见面试题

前言 在上一节中&#xff0c;我们简单介绍了 TCP 协议的相关概念和格式&#xff0c;而且还介绍了TCP 协议原理中的 确认应答机制、超时重传机制&#xff0c;在本节中我们将会继续介绍 TCP协议原理中的其他机制。 连接管理机制&#xff08;安全机制&#xff09; 在正常情况下&…
阅读更多...
QT基础 - QMainWindow主窗口

QT基础 - QMainWindow主窗口

目录 零. 简介 一. 菜单栏 二. 工具栏 三. 状态栏 四. 可停靠区域 五. 总结 零. 简介 QMainWindow 是 Qt 中用于构建主窗口的类。 它通常包含以下几个主要部分&#xff1a; 菜单栏&#xff1a;用于提供各种操作选项。工具栏&#xff1a;放置常用的操作按钮。中心区域&…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023