决策树(ID3)

最新推荐文章于 2024-04-30 13:31:06 发布
最新推荐文章于 2024-04-30 13:31:06 发布
阅读量1k 收藏 3
点赞数
文章标签： 决策树 算法 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zhang_ing/article/details/131983880
版权

目录

算法介绍

决策树算法是一种常见的机器学习算法，用于分类和回归问题。它基于一系列的规则和条件，构建一棵树状结构来进行预测或决策。

训练过程

  1. 特征选择：从训练数据中选择一个最佳的特征作为根节点，将数据集分为不同的子集。
  2. 分支节点：对每个子集，重复进行特征选择的过程，选择一个最佳的特征作为当前子集的分支节点，继续划分数据集。
  3. 叶节点：重复上述过程，直到满足停止条件，例如达到最大深度、样本数量小于阈值等。此时，生成叶节点，用于分类或回归的预测。

特征选择方式

  1. 信息增益（Information Gain）：信息增益是基于信息论的概念，用于衡量特征对数据集划分后整体熵减少的程度。计算信息增益时，首先计算划分前的熵，然后计算每个特征划分后的加权平均熵，最后用划分前熵减去加权平均熵得到信息增益。信息增益越大，表示特征对于分类的贡献越大。
  2. 基尼不纯度（Gini Impurity）：基尼不纯度是用于衡量特征对数据集划分后类别不纯度减少的程度。计算基尼不纯度时，首先计算划分前的基尼系数，然后计算每个特征划分后的加权平均基尼系数，最后用划分前基尼系数减去加权平均基尼系数得到基尼指数。基尼指数越小，表示特征对于分类的贡献越大。
  3. 增益率（Gain Ratio）：增益率是在信息增益的基础上加入了对特征取值数目多少的惩罚，以防止特征取值过多对信息增益的影响。计算增益率时，除了计算信息增益，还要除以划分前特征的熵，最后用信息增益除以划分前特征的熵得到增益率。
  4. 卡方检验（Chi-square test）：卡方检验是用于衡量特征与类别之间的相关性。它基于统计学的卡方检验方法，通过计算特征与类别之间的卡方统计量和显著性水平，来判断特征是否与类别相关。

算法优点

  1. 直观易解释，可以生成可视化的决策过程。
  2. 能够处理离散特征和连续特征。
  3. 可以处理多类别问题。
  4. 在一定条件下，对缺失值和异常值具有较好的容忍性。

算法缺点

  1. 对噪声和过拟合敏感，容易产生复杂的树结构。
  2. 对于包含大量特征和类别的数据集，决策树可能过于复杂，导致计算和存储开销增加。
  3. 决策树是一种贪心算法，可能无法找到全局最优解。

代码设计

构造方法

	/**
	 ********************
	 * The constructor.
	 * 
	 * @param paraFilename
	 *            The given file.
	 ********************
	 */
	public ID3(String paraFilename) {
		dataset = null;
		try {
			FileReader fileReader = new FileReader(paraFilename);
			dataset = new Instances(fileReader);
			fileReader.close();
		} catch (Exception ee) {
			System.out.println("Cannot read the file: " + paraFilename + "\r\n" + ee);
			System.exit(0);
		} // Of try
 
		dataset.setClassIndex(dataset.numAttributes() - 1);
		numClasses = dataset.classAttribute().numValues();
 
		availableInstances = new int[dataset.numInstances()];
		for (int i = 0; i < availableInstances.length; i++) {
			availableInstances[i] = i;
		} // Of for i
		availableAttributes = new int[dataset.numAttributes() - 1];
		for (int i = 0; i < availableAttributes.length; i++) {
			availableAttributes[i] = i;
		} // Of for i
 
		// Initialize.
		children = null;
		// Determine the label by simple voting.
		label = getMajorityClass(availableInstances);
		// Determine whether or not it is pure.
		pure = pureJudge(availableInstances);
	}// Of the first constructor

先读取数据，再为主要属性赋值

投票选择最多标签

	/**
	 ********************************** 
	 * Compute the majority class of the given block for voting.
	 * 
	 * @param paraBlock
	 *            The block.
	 * @return The majority class.
	 ********************************** 
	 */
	public int getMajorityClass(int[] paraBlock) {
		int[] tempClassCounts = new int[dataset.numClasses()];
		for (int i = 0; i < paraBlock.length; i++) {
			tempClassCounts[(int) dataset.instance(paraBlock[i]).classValue()]++;
		} // Of for i
 
		int resultMajorityClass = -1;
		int tempMaxCount = -1;
		for (int i = 0; i < tempClassCounts.length; i++) {
			if (tempMaxCount < tempClassCounts[i]) {
				resultMajorityClass = i;
				tempMaxCount = tempClassCounts[i];
			} // Of if
		} // Of for i
 
		return resultMajorityClass;
	}// Of getMajorityClass

这个方法可以投票选择最多的标签

判纯

	/**
	 ********************************** 
	 * Is the given block pure?
	 * 
	 * @param paraBlock
	 *            The block.
	 * @return True if pure.
	 ********************************** 
	 */
	public boolean pureJudge(int[] paraBlock) {
		pure = true;
 
		for (int i = 1; i < paraBlock.length; i++) {
			if (dataset.instance(paraBlock[i]).classValue() != dataset.instance(paraBlock[0])
					.classValue()) {
				pure = false;
				break;
			} // Of if
		} // Of for i
 
		return pure;
	}// Of pureJudge

判断该数组的标签是否为纯的

选择熵最低的标签

	/**
	 ********************************** 
	 * Select the best attribute.
	 * 
	 * @return The best attribute index.
	 ********************************** 
	 */
	public int selectBestAttribute() {
		splitAttribute = -1;
		double tempMinimalEntropy = 10000;
		double tempEntropy;
		for (int i = 0; i < availableAttributes.length; i++) {
			tempEntropy = conditionalEntropy(availableAttributes[i]);
			if (tempMinimalEntropy > tempEntropy) {
				tempMinimalEntropy = tempEntropy;
				splitAttribute = availableAttributes[i];
			} // Of if
		} // Of for i
		return splitAttribute;
	}// Of selectBestAttribute

计算单个熵

    /**
	 ********************************** 
	 * Compute the conditional entropy of an attribute.
	 * 
	 * @param paraAttribute
	 *            The given attribute.
	 * 
	 * @return The entropy.
	 ********************************** 
	 */
	public double conditionalEntropy(int paraAttribute) {
		// Step 1. Statistics.
		int tempNumClasses = dataset.numClasses();
		int tempNumValues = dataset.attribute(paraAttribute).numValues();
		int tempNumInstances = availableInstances.length;
		double[] tempValueCounts = new double[tempNumValues];
		double[][] tempCountMatrix = new double[tempNumValues][tempNumClasses];
 
		int tempClass, tempValue;
		for (int i = 0; i < tempNumInstances; i++) {
			tempClass = (int) dataset.instance(availableInstances[i]).classValue();
			tempValue = (int) dataset.instance(availableInstances[i]).value(paraAttribute);
			tempValueCounts[tempValue]++;
			tempCountMatrix[tempValue][tempClass]++;
		} // Of for i
 
		// Step 2.
		double resultEntropy = 0;
		double tempEntropy, tempFraction;
		for (int i = 0; i < tempNumValues; i++) {
			if (tempValueCounts[i] == 0) {
				continue;
			} // Of if
			tempEntropy = 0;
			for (int j = 0; j < tempNumClasses; j++) {
				tempFraction = tempCountMatrix[i][j] / tempValueCounts[i];
				if (tempFraction == 0) {
					continue;
				} // Of if
				tempEntropy += -tempFraction * Math.log(tempFraction);
			} // Of for j
			resultEntropy += tempValueCounts[i] / tempNumInstances * tempEntropy;
		} // Of for i
 
		return resultEntropy;
	}// Of conditionalEntropy

属性集分割

	/**
	 ********************************** 
	 * Split the data according to the given attribute.
	 * 
	 * @return The blocks.
	 ********************************** 
	 */
	public int[][] splitData(int paraAttribute) {
		int tempNumValues = dataset.attribute(paraAttribute).numValues();
		// System.out.println("Dataset " + dataset + "\r\n");
		// System.out.println("Attribute " + paraAttribute + " has " +
		// tempNumValues + " values.\r\n");
		int[][] resultBlocks = new int[tempNumValues][];
		int[] tempSizes = new int[tempNumValues];
 
		// First scan to count the size of each block.
		int tempValue;
		for (int i = 0; i < availableInstances.length; i++) {
			tempValue = (int) dataset.instance(availableInstances[i]).value(paraAttribute);
			tempSizes[tempValue]++;
		} // Of for i
 
		// Allocate space.
		for (int i = 0; i < tempNumValues; i++) {
			resultBlocks[i] = new int[tempSizes[i]];
		} // Of for i
 
		// Second scan to fill.
		Arrays.fill(tempSizes, 0);
		for (int i = 0; i < availableInstances.length; i++) {
			tempValue = (int) dataset.instance(availableInstances[i]).value(paraAttribute);
			// Copy data.
			resultBlocks[tempValue][tempSizes[tempValue]] = availableInstances[i];
			tempSizes[tempValue]++;
		} // Of for i
 
		return resultBlocks;
	}// Of splitData

树的创建

	/**
	 ********************************** 
	 * Build the tree recursively.
	 ********************************** 
	 */
	public void buildTree() {
		if (pureJudge(availableInstances)) {
			return;
		} // Of if
		if (availableInstances.length <= smallBlockThreshold) {
			return;
		} // Of if
 
		selectBestAttribute();
		int[][] tempSubBlocks = splitData(splitAttribute);
		children = new ID3[tempSubBlocks.length];
 
		// Construct the remaining attribute set.
		int[] tempRemainingAttributes = new int[availableAttributes.length - 1];
		for (int i = 0; i < availableAttributes.length; i++) {
			if (availableAttributes[i] < splitAttribute) {
				tempRemainingAttributes[i] = availableAttributes[i];
			} else if (availableAttributes[i] > splitAttribute) {
				tempRemainingAttributes[i - 1] = availableAttributes[i];
			} // Of if
		} // Of for i
 
		// Construct children.
		for (int i = 0; i < children.length; i++) {
			if ((tempSubBlocks[i] == null) || (tempSubBlocks[i].length == 0)) {
				children[i] = null;
				continue;
			} else {
				// System.out.println("Building children #" + i + " with
				// instances " + Arrays.toString(tempSubBlocks[i]));
				children[i] = new ID3(dataset, tempSubBlocks[i], tempRemainingAttributes);
 
				// Important code: do this recursively
				children[i].buildTree();
			} // Of if
		} // Of for i
	}// Of buildTree
 
	/**
	 ********************
	 * The constructor.
	 * 
	 * @param paraDataset
	 *            The given dataset.
	 ********************
	 */
	public ID3(Instances paraDataset, int[] paraAvailableInstances, int[] paraAvailableAttributes) {
		// Copy its reference instead of clone the availableInstances.
		dataset = paraDataset;
		availableInstances = paraAvailableInstances;
		availableAttributes = paraAvailableAttributes;
 
		// Initialize.
		children = null;
		// Determine the label by simple voting.
		label = getMajorityClass(availableInstances);
		// Determine whether or not it is pure.
		pure = pureJudge(availableInstances);
	}// Of the second constructor

测试

	/**
	 ********************************** 
	 * Classify an instance.
	 * 
	 * @param paraInstance
	 *            The given instance.
	 * @return The prediction.
	 ********************************** 
	 */
	public int classify(Instance paraInstance) {
		if (children == null) {
			return label;
		} // Of if
 
		ID3 tempChild = children[(int) paraInstance.value(splitAttribute)];
		if (tempChild == null) {
			return label;
		} // Of if
 
		return tempChild.classify(paraInstance);
	}// Of classify
 
	/**
	 ********************************** 
	 * Test on a testing set.
	 * 
	 * @param paraDataset
	 *            The given testing data.
	 * @return The accuracy.
	 ********************************** 
	 */
	public double test(Instances paraDataset) {
		double tempCorrect = 0;
		for (int i = 0; i < paraDataset.numInstances(); i++) {
			if (classify(paraDataset.instance(i)) == (int) paraDataset.instance(i).classValue()) {
				tempCorrect++;
			} // Of i
		} // Of for i
 
		return tempCorrect / paraDataset.numInstances();
	}// Of test
outragee
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ID3决策树
onlynima的博客
04-12 1548
一、基本概要 决策树(Decision Tree）是在已知各种情况发生概率的基础上，通过构成决策树来求取净现值的期望值大于等于零的概率，评价项目风险，判断其可行性的决策分析方法，是直观运用概率分析的一种图解法。由于这种决策分支画成图形很像一棵树的枝干，故称决策树。在机器学习中，决策树是一个预测模型，他代表的是对象属性与对象值之间的一种映射关系。Entropy = 系统的凌乱程度，使用算法ID3, ...
决策树之ID3算法
热门推荐
ACdreamer
03-27 8万+
今天，我来讲解的是决策树。对于决策树来说，主要有两种算法：ID3算法和C4.5算法。C4.5算法是 对ID3算法的改进。今天主要先讲ID3算法，之后会讲C4.5算法和随机森林等。   Contents        1. 决策树的基本认识      2. ID3算法介绍      3. 信息熵与信息增益      4. ID3算法的C++实现     1. 决策树的基本认识
决策树-ID3
个人学习笔记库，一篇一篇记录成长的足迹
10-07 1734
决策树 基本概念 决策树是一个树状结构，它包含一个根节点，若干内部节点和若干叶子节点。根节点包含样本全集，叶子节点对应决策结果，内部节点对应一个特征和属性或属性测试。从根节点到每个叶子节点的路径对应了一个判定测试序列，决策树学习的目的是为了产生一颗泛化能力强，即处理未见示例能力强的决策树，器基本流程遵循简单而直观的分而治之策略，决策树的生成是一个递归过程。 构造决策树的核心问题在于每一步如何选择适当的特征对样本做拆分，其主要算法有CART, ID3, C4.5 ； CART使用Gini指数作为选择特征
机器学习决策树ID3
caechen的博客
02-27 2146
在机器学习中，决策树是一种预测模型，代表的是一种对象属性与对象值之间的一种映射关系...
机器学习ID3构造决策树
最新发布
wsndddhh的博客
04-30 479
决策树是一种。
决策树ID3算法matlab源代码
11-11
决策树ID3算法matlab源代码片段 function [Tree RulesMatrix]=DecisionTree(DataSet,AttributName) %输入为训练集，为离散后的数字，如记录1：1 1 3 2 1； %前面为属性列，最后一列为类标 if nargin<1 error('请...
ID3_决策树ID3_
10-02
ID3（Iterative Dichotomiser 3）算法是一种经典的决策树学习方法，由Ross Quinlan于1986年提出。它主要用于分类任务，通过构建一棵决策树来实现对离散特征数据的预测。ID3算法的核心思想是信息熵和信息增益，这两个...
决策树ID3\ID4算法实例源码
04-16
ID3（Iterative Dichotomiser 3）是决策树算法的早期版本，由Ross Quinlan于1986年提出，主要用于分类问题。ID4是ID3的后续改进，增加了对连续属性的支持，但在实际应用中不如C4.5和CART算法普及。 ID3算法基于信息...
决策树id3实现
11-08
ID3（Iterative Dichotomiser 3）是决策树算法的一种早期实现，由Ross Quinlan在1986年提出。ID3算法主要基于信息熵和信息增益来选择最优特征，构建决策树模型。 首先，我们需要理解决策树的基本原理。决策树通过一...
决策树ID3算法的实现
10-26
ID3（Iterative Dichotomiser 3）是决策树算法的一种早期版本，由Ross Quinlan于1986年提出。它基于信息熵和信息增益的概念来选择最优特征，构建决策树模型。 **ID3算法的基本概念** 1. **信息熵（Entropy）**：...
id3 决策树
09-02
id3 决策树 matlab 用于画出决策树
ID3决策树（含预测函数）
09-20
使用Java实现的ID3决策树，内含数据文件及ID3类的源代码。实现了决策树分类，结果存储为XML文件，以及基于模型进行的分类预测。
决策树——ID3算法
m0_72668380的博客
07-03 3524
所谓决策树，顾名思义，是一种树，一种依托于策略抉择而建立起来的树。机器学习中，决策树是一个预测模型；它代表的是对象属性与对象值之间的一种映射关系。树中每个节点表示某个对象，而每个分叉路径则代表的是某个可能的属性值，而每个叶子节点则对应根节点到该叶子节点所经历的路径所表示的对象的值。决策树仅有单一输出，若欲有复数输出，可以建立独立的决策树以处理不同的输出。从数据产生决策树的机器学习技术叫做决策树学习，通俗点就是决策树，是一种依托于分类、训练上的预测树，根据已知预测、归类未来。
id3决策树_实用数学| ID3决策树
weixin_39936310的博客
12-01 575
01简介 ID3算法是一种贪心算法，最早由罗斯昆(J. Ross Quinlan)于1975年在悉尼大学提出，算法的核心是“信息熵”。ID3算法通过计算每个属性的信息增益，认为信息增益高的是好属性，每次划分选取信息增益最高的属性为划分标准，重复这个过程，直至生成一个能完美分类训练样例的决策树。02贪心算法贪心算法是一种对某些求最优解问题的更简单、更迅速的设计技术。贪心算法的特...
决策树ID3
ziding的博客
08-23 427
ID3算法： ID3算法是决策树的一种，它是基于奥卡姆剃刀原理的，即用尽量用较少的东西做更多的事。ID3算法，即Iterative Dichotomiser 3，迭代二叉树3代，是Ross Quinlan发明的一种决策树算法，这个算法的基础就是上面提到的奥卡姆剃刀原理，越是小型的决策树越优于大的决策树，尽管如此，也不总是生成最小的树型结构，而是一个启发式算法。 在信息论中，期望信息越小，那么信
决策树 ID3
Claroja
10-27 190
1.被用作分裂点的特征叫做分裂特征 ID3 算法（Iterative Dichotomiser 3）：以信息增益为度量，选择分裂后信息增益最大的特征进行分裂。 信息熵(information entropy) 样本集合中第k类样本所占的比例为pk(k=1,2,...,n)p_k(k=1,2,...,n)pk​(k=1,2,...,n)，n为样本分类的个数，则D的信息熵为 Ent(D)=−∑k=1npklog2(pk)Ent(D)=-\sum_{k=1}^np_klog_2(p_k)Ent(D)=−∑k=1n
《机器学习实战》第三章——决策树（ID3)
weixin_44275584的博客
11-16 258
理论 寻找最具影响力的特征先进行判别，像一棵树一样的判断分支再判断分支，知道最后判别出属于哪个类别 优点 计算复杂度不高 输出结果易于理解，可以看出内在含义 对缺失值不敏感 可以处理不相关特征数据 缺点 易产生过拟合问题 适用于 离散型数据 连续型数据需要离散化 总结： 划分数据集-按照信息增益 信息增益最高的特征就是最好的选择 信息增益：划分数据集之前和之后发生的信息变化 度量信息的单位称为熵（entropy），即信息的期望值 信息熵公式： H=−∑i=1np(xi)log⁡2p(xi)
ID3决策树（R实现）
xiaohukun的博客
09-21 2554
说明 1.参考文章：R语言实现决策树ID3算法 2.补充了分类预测的函数部分 3.采用数据框模拟xml文件的方式存储决策树 代码 训练集（train_data） outlook temperature humidity windy play sunny hot high FALSE no sunny hot high ...
决策树ID3算法实例解析
"这篇资源主要介绍了18种经过审核的机器学习和数据挖掘候选算法，包括分类、统计学习和关联分析等领域的经典方法，并重点解析了决策树ID3算法。文章出自嘉兴学院数学与信息工程学院的杜卫锋，内容涵盖了嘉兴地区的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值