c4.5决策树算法例题
matlab实现的C45分类决策树算法
function D = C4_5(train_features, train_targets, inc_node, region)%Classify using Quinlan's C4.5 algorithm%Inputs:%features - Train features%targets- Train targets%inc_node- Percentage of incorrectly assigned samples at a node%region- Decision region vector: [-x x -yy number_of_points]%% Outputs% D- Decision sufrace%NOTE: In this implementation it is assumed that a feature vector with fewer than 10 unique values (the parameter Nu)%is discrete, and will be treated as such. Other vectors will be treated as continuous[Ni, M]= size(train_features);inc_node= inc_node*M/100;Nu= 10;%For the decision regionN= region(5);mx= ones(N,1) * linspace(region(1),region(2),N);my= linspace (region(3),region(4),N)' * ones(1,N);flatxy= [mx(:), my(:)]';%Preprocessing%[f, t, UW, m]= PCA(train_features,train_targets, Ni, region);%train_features = UW * (train_features -m*ones(1,M));;%flatxy= UW * (flatxy - m*ones(1,N^2));;%Find which of the input features are discrete,and discretisize the corresponding%dimension on the decision regiondiscrete_dim = zeros(1,Ni);for i = 1:Ni,Nb = length(unique(train_features(i,:)));if (Nb <= Nu),%This is a discrete featurediscrete_dim(i)= Nb;[H, flatxy(i,:)] =high_histogram(flatxy(i,:), Nb);endend%Build the tree recursivelydisp( 'Building tree')tree= make_tree(train_features,train_targets, inc_node, discrete_dim,max(discrete_dim), 0);%Make the decision region according to the treedisp( 'Building decision surface using the tree') targets = use_tree(flatxy, 1:N^2, tree,discrete_dim, unique(train_targets));D= reshape(targets,N,N);%ENDfunction targets = use_tree(features, indices,tree, discrete_dim, Uc)%Classify recursively using a treetargets = zeros(1, size(features,2));if (tree.dim == 0)%Reached the end of the treetargets(indices) = tree.child;breakend%This is not the last level of the tree,so: %First, find the dimension we are to work on dim = tree.dim;dims= 1:size(features,1);%And classify according to itif (discrete_dim(dim) == 0),%Continuous featurein= indices(find(features(dim, indices) <= tree.split_loc));targets= targets +use_tree(features(dims, :), in, tree.child(1), discrete_dim(dims), Uc);in= indices(find(features(dim, indices) > tree.split_loc));targets= targets +use_tree(features(dims, :), in, tree.child(2), discrete_dim(dims), Uc);else%Discrete featureUf= unique(features(dim,:));for i = 1:length(Uf),in= indices(find(features(dim, indices) == Uf(i)));targets= targets +use_tree(features(dims, :), in, tree.child(i), discrete_dim(dims), Uc);endend%END use_treefunction tree = make_tree(features, targets, inc_node, discrete_dim, maxNbin, base)%Build a tree recursively[Ni, L]= size(features);Uc= unique(targets);tree.dim= 0;%tree.child(1:maxNbin) = zeros(1,maxNbin);tree.split_loc= inf;if isempty(features),breakend%When to stop: If the dimension is one or the number of examples is smallif ((inc_node> L) | (L == 1) | (length(Uc)== 1)), H= hist(targets, length(Uc));[m, largest]= max(H);tree.child= Uc(largest);breakend%Compute the node's Ifor i = 1:length(Uc),Pnode(i)= length(find(targets== Uc(i)))/L; endInode = -sum(Pnode.*log(Pnode)/log(2));%For each dimension,compute the gain ratio impurity%This is done separately for discrete and continuous featuresdelta_Ib= zeros(1, Ni);split_loc= ones(1, Ni)*inf;for i = 1:Ni,data = features(i,:);Nbins = length(unique(data));if (discrete_dim(i)),%This is a discrete featureP= zeros(length(Uc), Nbins);for j = 1:length(Uc),for k = 1:Nbins,indices = find((targets == Uc(j)) &(features(i,:) == k));P(j,k) = length(indices);endendPk= sum(P);P= P/L;Pk= Pk/sum(Pk);info= sum(-P.*log(eps+P)/log(2));delta_Ib(i) =(Inode-sum(Pk.*info))/-sum(Pk.*log(eps+Pk)/log(2));else%This is a continuous featureP = zeros(length(Uc), 2);%Sort the features[sorted_data, indices] = sort(data);sorted_targets = targets(indices);%Calculate the information for each possiblesplitI = zeros(1, L-1);for j = 1:L-1,for k =1:length(Uc),P(k,1)= length(find(sorted_targets(1:j) ==Uc(k)));P(k,2) =length(find(sorted_targets(j+1:end) == Uc(k)));endPs = sum(P)/L;P= P/L;info= sum(-P.*log(eps+P)/log(2));I(j) = Inode - sum(info.*Ps);end[delta_Ib(i), s] = max(I);split_loc(i) = sorted_data(s);endend%Find the dimension minimizing delta_Ib [m, dim] = max(delta_Ib);dims= 1:Ni;tree.dim = dim;%Split along the 'dim' dimensionNf= unique(features(dim,:));Nbins= length(Nf);if (discrete_dim(dim)),%Discrete featurefor i = 1:Nbins,indices= find(features(dim, :) ==Nf(i));tree.child(i) = make_tree(features(dims, indices), targets(indices), inc_node,discrete_dim(dims), maxNbin, base);endelse%Continuous featuretree.split_loc= split_loc(dim);indices1= find(features(dim,:) <=split_loc(dim));indices2= find(features(dim,:) >split_loc(dim));tree.child(1)= make_tree(features(dims, indices1), targets(indices1), inc_node, discrete_dim(dims), maxNbin);tree.child(2)= make_tree(features(dims, indices2), targets(indices2), inc_node, discrete_dim(dims), maxNbin);end。
C4.5算法
ID3算法与C4.5算法ID3算法ID3算法是J. Ross Quinlan在1975提出的分类预测算法，当时还没有数据挖掘吧，哈哈哈。
该算法的核心是“信息熵”,属于数学问题，我也是从这里起发现数据挖掘最底层最根本的不再是编程了，而是数学，编程只是一种实现方式而已，数学才是基础，如：朴素贝叶斯分类，小波聚类，尤其是我正在搞的支持向量机，它就是高等代数，空间解析几何，概率统计的综合应用。
记得读本科时，朱琛学姐说过,数学学得再好也不为过。
我现在深刻体会到了。
信息熵就是一组数据包含的信息，概率的度量。
一组数据越有序信息熵也就越低，极端时如果一组数据中只有一个非0，其它都是0，那么熵等于0，因为只有可能是这个非0的情况发生，它给人们的信息已经确定了，或者说不含有任何信息了，因为信息熵含量为0。
一组数据越无序信息熵也就越高，极端时如果一组数据均匀分布，那么它的熵最大，因为我们不知道那种情况发生的概率大些。
假如一组数据由{d1,d2,...,dn}构成，其和是sum,那么求信息熵的公式是。
分类预测算法属于有指导学习，方法是通过训练数据，按照参考属性对目标属性的依赖程度对参考属性分级别处理，这种分级别处理体现在创建决策树，目的是通过生成的判别树，产生规则，用来判断以后的数据。
以如下数据为例：共14条记录，目标属性是，是否买电脑，共有两个情况，yes或者no。
参考属性有4种情况，分别是，age,income,student,credit_rating。
属性age有3种取值情况，分别是,youth,middle_aged,senior,属性income有3种取值情况，分别是,high,medium,low,属性student有2种取值情况，分别是，no,yes,属性credit_rating有2种取值情况，分别是fair,excellent。
我们先求参考属性的信息熵：，式中的5表示5个no,9表示9个yes,14是总的记录数。
C4.5决策树法在高校贫困生认定中的应用
０ 引 言
高 校贫 困生认定 是 一项 每年 必须 重复 的烦 琐 而又 重要 的工 作 ， 准 确 性直 接 影 响 到 高校 贫 困 生 资助 的 其
摘 要 ： 确 认 定 贫 困 生 资格 ， 高校 公 平 、 正 、 理 分 配 国 家 资助 资 源 的 先 决 条 件 ． 数 据 挖 掘 的 决 策 树 方 法 准 是 公 合 将 引入 高校 贫 困 生 资 格认 证 分 析 中 ， 用 ｃ ． 利 ４ ５算法 创 建 决 策 树 ， 掘 学 生 信 息和 贫 困种 类 关 系的 历 史 数 据 ， 立 学 挖 建 生 信 息一 贫 困 种 类 智 能 评 价 模 型 ． 过 实验 仿 真 发 现 ，４ ５决 策 树 算 法取 得 了较 为理 想 的 分 类 预 测 效 果 ． 通 ｃ． 关 键 词 ： ４ ５算 法 ； 策 树 ； 困 生认 定 Ｃ． 决 贫
则 —— 贫 困种 类智 能评 价模 型．
我们 对计 算机 系 ２ ０ ０ ９级 ４ ５名学 生 ２ ｌ— ２ １ 学年 的信 息建立 数据 表 ， 行分 析 和处理 ， 中包括 学 生 Ｏ０ ０１ 进 其
基本 信息 、 生父母 的基本情 况 、 学 学生 父母 经济 情况 、 学生 家 庭 的债 务情 况 及贫 困种类 ． 过数 据 清 洗 、 据 通 数
并进 行 比较 ， 选取 信 息增益 值 最大 的 Ａ 作 为该 连续属 性 的断点 ， 属性值 设 置为 ［ ， Ａ ］和 ［ ＭＡ ． 把 Ⅳ， Ａ ， Ｘ］
ｃ． ４ ５算法 是 一个 循环 、 递归 的过 程 ， 心 部分 的描述 如 下 核 ． Ｄ ｃｓｏ Ｔｅ ４ （ Ｃ， ） ．参 数 ： ｅ ｉ ｎ ｒｅＣ ５ Ｒ， Ｓ ／： ｉ ｃ Ｒ表 示判 定对 象属性 ， ｃ表 示 目标属 性 ， 示训 练集 ／ Ｓ表
机器学习总结（八）决策树ID3，C4.5算法，CART算法
机器学习总结（⼋）决策树ID3，C4.5算法，CART算法本⽂主要总结决策树中的ID3,C4.5和CART算法，各种算法的特点，并对⽐了各种算法的不同点。
决策树：是⼀种基本的分类和回归⽅法。
在分类问题中，是基于特征对实例进⾏分类。
既可以认为是if-then规则的集合，也可以认为是定义在特征空间和类空间上的条件概率分布。
决策树模型：决策树由结点和有向边组成。
结点⼀般有两种类型，⼀种是内部结点，⼀种是叶节点。
内部结点⼀般表⽰⼀个特征，⽽叶节点表⽰⼀个类。
当⽤决策树进⾏分类时，先从根节点开始，对实例的某⼀特征进⾏测试，根据测试结果，将实例分配到⼦结点。
⽽⼦结点这时就对应着该特征的⼀个取值。
如此递归对实例进⾏测试分配，直⾄达到叶结点，则该实例属于该叶节点的类。
决策树分类的主要算法有ID3，C4.5。
回归算法为CART算法，该算法既可以分类也可以进⾏回归。
（⼀）特征选择与信息增益准则特征选择在于选取对训练数据具有分类能⼒的特征，⽽且是分类能⼒越强越好，这样⼦就可以提⾼决策树的效率。
如果利⽤⼀个特征进⾏分类，分类的结果与随机分类的结果没有差异，那么这个特征是没有分类能⼒的。
那么⽤什么来判别⼀个特征的分类能⼒呢？那就是信息增益准则。
何为信息增益？⾸先，介绍信息论中熵的概念。
熵度量了随机变量的不确定性，越不确定的事物，它的熵就越⼤。
具体的，随机变量X的熵定义如下：条件熵H(Y|X)表⽰在已知随机变量X的条件下随机变量Y的不确定性，随机变量X给定的条件下随机变量Y的条件熵为H(Y|X)，定义为X给定条件下Y的条件概率分布的熵对X的数学期望：信息增益表⽰在已知特征X的情况下，⽽使得Y的信息的不确定性减少的程度。
信息增益的定义式如下：g(D,A)表⽰特征A对训练集D的信息增益，其为集合D的经验熵H(D)与在特征A给定条件下D的经验条件熵H(D|A)之差。
⼀般熵与条件熵之差，称为互信息。
在决策树中，信息增益就等价于训练数据集中的类与特征的互信息。
决策树分类ID3和C4.5原理Java实现
决策树分类ID3和C4.5原理Java实现决策树（decision tree）是一个树结构（可以是二叉树或非二叉树）。
其每个非叶节点表示一个特征属性上的测试，每个分支代表这个特征属性在某个值域上的输出，而每个叶节点存放一个类别。
使用决策树进行决策的过程就是从根节点开始，测试待分类项中相应的特征属性，并按照其值选择输出分支，直到到达叶子节点，将叶子节点存放的类别作为决策结果。
•决策树的构造:•决策树的构造就是通过属性选择来确定拓扑结构。
•构造决策树的关键步骤是分裂属性。
所谓分裂属性就是在某个节点处按照某一特征属性的不同划分构造不同的分支，其目标是让各个分裂子集尽可能地“纯”。
尽可能“纯”就是尽量让一个分裂子集中待分类项属于同一类别。
分裂属性分为三种不同的情况：•1、属性是离散值且不要求生成二叉决策树。
此时用属性的每一个划分作为一个分支。
•2、属性是离散值且要求生成二叉决策树。
此时使用属性划分的一个子集进行测试，按照“属于此子集”和“不属于此子集”分成两个分支。
•3、属性是连续值。
此时确定一个值作为分裂点split_point，按照>split_point和<=split_point生成两个分支。
ID3ID3算法使用信息增益(IG)或者熵(Entropy)值来确定使用哪个属性进行判定，作为最佳属性。
计算熵的公式为：信息增益的公式如下：缺点：1：ID3算法在选择根节点和内部节点中的分支属性时，采用信息增益作为评价标准。
信息增益的缺点是倾向于选择取值较多的属性，在有些情况下这类属性可能不会提供太多有价值的信息。
例如ID字段等。
2：ID3算法只能对描述属性为离散型属性的数据集构造决策树C4.5C4.5算法采用信息增益率作为选择分支属性的标准，并克服了ID3算法中信息增益选择属性时偏向选择取值多的属性的不足，并能够完成对连续属性离散化是处理；还能够对不完整数据进行处理。
C4.5算法属于基于信息论Information Theory的方法，以信息论为基础，以信息熵和信息增益度为衡量标准，从而实现对数据的归纳和分类。
C4.5算法学习
C4.5算法学习C4.5属于决策树算法的分类树决策树更是常见的机器学习⽅法，可以帮助我们解决分类与回归两类问题。
以决策树作为起点的原因很简单，因为它⾮常符合我们⼈类处理问题的⽅法，⽽且逻辑清晰，可解释性好。
从婴⼉到长者，我们每天都使⽤⽆数次！决策树的总体流程；总体流程分⽽治之（devide and conquer）⾃根结点的递归过程从每⼀个中间结点寻找⼀个划分（split and test）的属性三种停⽌条件：当前结点包含的样本属于同⼀类别，⽆需划分当前属性集为空，或是所有样本在所有属性值上取值相同，⽆法划分当前结点包含的样本集合为空，不能划分核⼼数学概念：熵信息熵（entropy）是度量样本集合“纯度”最常⽤的⼀种指标C4.5算法流程C4.5算法优缺点分析优点：（1）通过信息增益率选择分裂属性，克服了ID3算法中通过信息增益倾向于选择拥有多个属性值的属性作为分裂属性的不⾜；（2）能够处理离散型和连续型的属性类型，即将连续型的属性进⾏离散化处理；（3）构造决策树之后进⾏剪枝操作；（4）能够处理具有缺失属性值的训练数据。
缺点：（1）算法的计算效率较低，特别是针对含有连续属性值的训练样本时表现的尤为突出。
（2）算法在选择分裂属性时没有考虑到条件属性间的相关性，只计算数据集中每⼀个条件属性与决策属性之间的期望信息，有可能影响到属性选择的正确性。
算法详解：算法程序while（当前节点不纯）1.计算当前节点的类别熵Info（D）(以类别取值计算)2.计算当前节点的属性熵info(Ai)(按照当前属性取值下的类别取值计算)3.计算各个属性的信息增益Gain(Ai) = Info(D)-info(Ai)4.计算各个属性的分类信息度量H（Ai）(按照属性取值计算)5.计算各个属性的信息增益率 IGR = Gain(Ai)/H(Ai)and while当前节点设置为叶⼦节点。
C4.5决策树
C4.5决策树C4.5决策树在ID3决策树的基础之上稍作改进，请先阅读。
C4.5克服了ID3的2个缺点：1.⽤信息增益选择属性时偏向于选择分枝⽐较多的属性值，即取值多的属性2.不能处理连贯属性Outlook Temperature Humidity Windy PlayGolf?sunny8585FALSE nosunny8090TRUE noovercast8386FALSE yesrainy7096FALSE yesrainy6880FALSE yesrainy6570TRUE noovercast6465TRUE yessunny7295FALSE nosunny6970FALSE yesrainy7580FALSE yessunny7570TRUE yesovercast7290TRUE yesovercast8175FALSE yesrainy7191TRUE noOutlook和Windy取离散值，Temperature和Humidity则取连续值。
对于离散属性V，ID3中计算的是“信息增益”，C4.5中则计算“信息增益率”:$IG\_ratio=\frac{IG(V)}{H(V)}$$H(V)=-\sum_j{p(v_j)logp(v_j)}$v j表⽰属性V的各种取值，在ID3中⽤信息增益选择属性时偏向于选择分枝⽐较多的属性值，即取值多的属性，在C4.5中由于除以了H(V)，可以削弱这种作⽤。
C4.5是如何处理连续属性的呢？实际上它先把连续属性转换为离散属性再进⾏处理。
虽然本质上属性的取值是连续的，但对于有限的采样数据它是离散的，如果有N条样本，那么我们有N-1种离散化的⽅法：<=v j的分到左⼦树，>v j的分到右⼦树。
计算这N-1种情况下最⼤的信息增益率。
在离散属性上只需要计算1次信息增益率，⽽在连续属性上却需要计算N-1次，计算量是相当⼤的。
有办法可以减少计算量。
《决策树例题》课件(2024)
基于信息增益的决策树
通过计算每个特征的信息增益来选择 最佳划分特征，构建决策树。例如， 在二分类问题中，可以使用ID3算法 来构建决策树。
基于基尼指数的决策树
通过计算每个特征的基尼指数来选择 最佳划分特征，构建决策树。例如， 在二分类问题中，可以使用CART算 法来构建决策树。
剪枝策略
针对决策树过拟合问题，可以采用预 剪枝或后剪枝策略来优化决策树性能 。
输入 欠标采题样
从多数类样本中随机选择一部分样本，减少其样本数 量，使得正负样本数量平衡。例如Random UnderSampler算法。
过采样
代价敏感学 习
通过集成多个基分类器的结果来提高整体性能。例如 Bagging和Boosting方法。
集成学习方 法
为不同类别的样本设置不同的误分类代价，使得模型 在训练过程中更加关注少数类样本。例如AdaCost算 法。
剪枝策略
通过预剪枝或后剪枝策略，可以优化决策 树的性能，减少过拟合。
19
过拟合问题解决方案讨论
增加训练数据
更多的训练数据可以让模型学习 到更多的模式，减少过拟合。
使用集成学习方法
去除不相关或冗余的特征，可以 减少模型的复杂度，降低过拟合
风险。
2024/1/30
特征选择
通过添加正则化项，可以惩罚模 型的复杂度，防止过拟合。
模型构建：选择合适的 模型优化：针对不平衡
决策树算法（如ID3、 数据集问题，可以采用
C4.5、CART等）构建分 过采样、欠采样或代价
类模型，并采用交叉验 敏感学习等方法优化模
证等方法评估模型性能 型性能。同时，也可以
。
通过调整决策树参数（
如最大深度、最小样本
决策树分类算法matlab,matlab实现的C45分类决策树算法
决策树分类算法matlab,matlab实现的C45分类决策树算法《matlab实现的C45分类决策树算法》由会员分享，可在线阅读，更多相关《matlab实现的C45分类决策树算法(6页珍藏版)》请在⼈⼈⽂库⽹上搜索。
1、functionD = C4_5(train_features, train_targets,inc_node, region) % Classify using Quinlans C4.5 algorithm% Inputs:% features - Train features% targets - Train targets% inc_node - Percentage of incorrectly assigned samples at a node%region - Decision region vector: -x x -y y number_of_points% Output。
2、s% D- Decision sufrace %NOTE: In this implementation it is assumed that a feature vector with fewer than 10 unique values (the parameter Nu)%is discrete, and will be treated as such. Other vectors will be treated as continuous Ni, M =size(train_features); inc_node = inc_node*M/100; Nu = 10;%For the。
3、 decision regionN= region(5);mx= ones(N,1) * linspace(region(1),region(2),N);my= linspace (region(3),region(4),N)*ones(1,N);flatxy = mx(:), my(:);%Preprocessing%f, t, UW, m = PCA(train_features, train_targets, Ni, region);%train_features = UW * (train_features - m*ones(1,M);%flatxy=UW * (flatxy - m。
C4.5算法的实现
C4.5算法的实现一.C4.5算法介绍C4.5算法是机器学习算法中的一种分类决策树算法,其核心算法是ID3算法.C4.5算法继承了ID3算法的优点，并在以下几方面对ID3算法进行了改进：1) 用信息增益率来选择属性，克服了用信息增益选择属性时偏向选择取值多的属性的不足；2) 在树构造过程中进行剪枝；3) 能够完成对连续属性的离散化处理；4) 能够对不完整数据进行处理。
C4.5算法有如下优点：产生的分类规则易于理解，准确率较高。
其缺点是：在构造树的过程中，需要对数据集进行多次的顺序扫描和排序，因而导致算法的低效。
二. 算法实现// C4.5_test.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <stdio.h>#include <math.h>#include "malloc.h"#include <stdlib.h>const int MAX = 10;int** iInput;int i = 0;//列数int j = 0;//行数void build_tree(FILE *fp, int* iSamples, int* iAttribute,int ilevel);//输出规则int choose_attribute(int* iSamples, int* iAttribute);//通过计算信息增益率选出test_attribute double info(double dTrue,double dFalse);//计算期望信息double entropy(double dTrue, double dFalse, double dAll);//求熵double splitinfo(int* list,double dAll);int check_samples(int *iSamples);//检查samples是否都在同一个类里int check_ordinary(int *iSamples);//检查最普通的类int check_attribute_null(int *iAttribute);//检查attribute是否为空void get_attributes(int *iSamples,int*iAttributeValue,int iAttribute);int _tmain(int argc, _TCHAR* argv[]){FILE *fp;FILE *fp1;char iGet;int a = 0;int b = 0;//a,b是循环变量int* iSamples;int* iAttribute;fp = fopen("c:\\input.txt","r");if (NULL == fp){printf("error\n");return 0;}iGet = getc(fp);while (('\n' != iGet)&&(EOF != iGet)) {if (',' == iGet){i++; }iGet = getc(fp); }i++;iAttribute = (int *)malloc(sizeof(int)*i); for (int k = 0; k<i; k++){iAttribute[k] = (int)malloc(sizeof(int)); iAttribute[k] = 1; }while (EOF != iGet){ if ('\n' == iGet){j++; }iGet = getc(fp); }j++;iInput = (int **)malloc(sizeof(int*)*j);iSamples = (int *)malloc(sizeof(int)*j);for (a = 0;a < j;a++){ iInput[a] = (int *)malloc(sizeof(int)*i); iSamples[a] = (int)malloc(sizeof(int));iSamples[a] = a; }a = 0;fclose(fp);fp=fopen("c:\\input.txt","r");iGet = getc(fp);while(EOF != iGet){ if ((',' != iGet)&&('\n' != iGet)){ iInput[a][b] = iGet - 48;b++; }if (b == i){ a++;b = 0;}iGet = getc(fp); }fp1 = fopen("d:\\output.txt","w");build_tree(fp1,iSamples,iAttribute,0);fclose(fp);return 0;}void build_tree(FILE * fp, int* iSamples, int* iAttribute,int level)//{ int iTest_Attribute = 0;int iAttributeValue[MAX];int k = 0;int l = 0;int m = 0;int *iSamples1;for (k = 0; k<MAX; k++){ iAttributeValue[k] = -1; }if (0 == check_samples(iSamples)){fprintf(fp,"result: %d\n",iInput[iSamples[0]][i-1];return; }if (1 == check_attribute_null(iAttribute)) {fprintf(fp,"result: %d\n",check_ordinary(iSamples));return; }iTest_Attribute = choose_attribute(iSamples,iAttribute);iAttribute[iTest_Attribute] = -1;get_attributes(iSamples,iAttributeValue,iTest_Attribute);k = 0;while ((-1 != iAttributeValue[k])&&(k < MAX)){ l = 0;m = 0;while ((-1 != iSamples[l])&&(l < j)){if(iInput[iSamples[l]][iTest_Attribute]==iAttributeValue[k]){ m++; }l++; }iSamples1 = (int *)malloc(sizeof(int)*(m+1));l = 0;m = 0;while ((-1 != iSamples[l])&&(l < j)){if(iInput[iSamples[l]][iTest_Attribute]==iAttributeValue[k]){ iSamples1[m] = iSamples[l];m++; }l++; }iSamples1[m] = -1;if (-1 == iSamples1[0]){fprintf(fp,"result: %d\n",check_ordinary(iSamples));return; }fprintf(fp,"level%d: %d = %d\n",level,iTest_Attribute,iAttributeValue[k]);build_tree(fp,iSamples1,iAttribute,level+1);k++; }}int choose_attribute(int* iSamples, int* iAttribute){ int iTestAttribute = -1;int k = 0;int l = 0;int m = 0;int n = 0;int iTrue = 0;int iFalse = 0;int iTrue1 = 0;int iFalse1 = 0;int iDepart[MAX];int iRecord[MAX];double dEntropy = 0.0;double dGainratio = 0.0;double test = 0.0;for (k = 0;k<MAX;k++){ iDepart[k] = -1;iRecord[k] = 0; }k = 0;while ((l!=2)&&(k<(i - 1))){ if (iAttribute[k] == -1){ l++; }k++; }if (l == 1){ for (k = 0;k<(k-1);k++){ if (iAttribute[k] == -1){ return iAttribute[k]; } } }for (k = 0;k < (i-1);k++){ l = 0;iTrue = 0;iFalse = 0;if (iAttribute[k] != -1){ while ((-1 != iSamples[l])&&(l < j)){ if (0 == iInput[iSamples[l]][i-1]){ iFalse++; }if (1 == iInput[iSamples[l]][i-1]){ iTrue++; }l++; }for (n = 0;n<l;n++)//计算该属性有多少不同的值并记录 { m = 0;while((iDepart[m]!=-1)&&(m!=MAX)){ if (iInput[iSamples[n]][iAttribute[k]] == iDepart[m]) {break; }m++; }if (-1 == iDepart[m]){ iDepart[m] = iInput[iSamples[n]][iAttribute[k]]; } } while ((iDepart[m] != -1)&&(m!=MAX)){ for (n = 0;n<l;n++){if (iInput[iSamples[n]][iAttribute[k]] == iDepart[m]) {if (1 == iInput[iSamples[n]][i-1]){ iTrue1++; }if (0 == iInput[iSamples[n]][i-1]){ iFalse1++; }iRecord[m]++; } }dEntropy += entropy((double)iTrue1,(double)iFalse1,(double)l);iTrue1 = 0;iFalse1 = 0;m++; }double dSplitinfo = splitinfo(iRecord,(double)l);if (-1 == iTestAttribute){iTestAttribute = k;dGainratio=(info((double)iTrue,(double)iFalse)-dEntropy)/dSplitinfo;} else{test=(info((double)iTrue,(double)iFalse)-dEntro py)/dSplitinfo;if (dGainratio < test){ iTestAttribute = k;dGainratio = test; }}} }return iTestAttribute;}double info(double dTrue,double dFalse){ double dInfo = 0.0;dInfo = ((dTrue/(dTrue+dFalse))*(log(dTrue/(dTrue+dFalse))/log(2 .0))+(dFalse/(dTrue+dFalse))*(log(dFalse/(dTrue+dFalse)) /log(2.0)))*(-1);return dInfo;}double entropy(double dTrue, double dFalse, double dAll) { double dEntropy = 0.0;dEntropy = (dTrue + dFalse)*info(dTrue,dFalse)/dAll;return dEntropy;}double splitinfo(int* list,double dAll){ int k = 0;double dSplitinfo = 0.0;while (0!=list[k]){dSplitinfo-=((double)list[k]/(double)dAll)*(log((double)li st[k]/(double)dAll));k++; }return dSplitinfo;}int check_samples(int *iSamples){ int k = 0;int b = 0;while ((-1 != iSamples[k])&&(k < j-1)){ if (iInput[k][i-1] != iInput[k+1][i-1]){b = 1;break; }k++; }return b;}11int check_ordinary(int *iSamples){ int k = 0;int iTrue = 0;int iFalse = 0;while ((-1 != iSamples[k])&&(k < i)){ if (0 == iInput[iSamples[k]][i-1]){iFalse++; }else{ iTrue++; }k++;}if (iTrue >= iFalse){ return 1;}else{ return 0; }}int check_attribute_null(int *iAttribute){ int k = 0;while (k < (i-1)){if (-1 != iAttribute[k]){ return 0;}k++; }return 1;}void get_attributes(int *iSamples,int12*iAttributeValue,int iAttribute){int k = 0;int l = 0;while ((-1 != iSamples[k])&&(k < j)){l = 0;while (-1 != iAttributeValue[l]){if (iInput[iSamples[k]][iAttribute] == iAttributeValue[l]) { break; }l++; }if (-1 == iAttributeValue[l]){iAttributeValue[l] = iInput[iSamples[k]][iAttribute];}k++;}}13。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
c4.5决策树算法例题
例题：预测鸢尾花分类
题目描述：
给定鸢尾花的三种类型：山鸢尾（setosa）、杂色鸢尾（versicolor）和维吉尼亚鸢尾（virginica），以及鸢尾花的四个特征：花萼长度、花萼宽度、花瓣长度和花瓣宽度。
使用这些特征来预测鸢尾花的类型。
数据集：
以下是一个鸢尾花数据集的样例，每一行表示一个样本，每个特征用一个数字表示。
最后一列是鸢尾花的类型。
1.4 3.5 5.1 1.7 setosa
5.0 3.6 5.5 2.6 versicolor
4.9 3.0
5.1 1.8 virginica
解题思路：
使用C4.5决策树算法对鸢尾花数据集进行分类。
首先，我们需要将数据集分成训练集和测试集，然后使用训练集训练决策树模型。
在训练过程中，我们需要计算每个特征的信息增益率，选择信息增益率最大的特征作为划分标准。
在每个节点处，我们需要计算划分后的数据集的纯度，选择最优的划分标准。
最后，我们使用测试集对决策树模型进行评估，计算分类准确率。
C4.5决策树算法的具体步骤如下：
1. 将数据集分成训练集和测试集。
2. 初始化根节点，选择一个特征作为划分标准，计算划分后的数据集的纯度。
3. 如果数据集的纯度已经达到要求，则将该节点标记为叶子节点，并将该节点的类标签作为最终分类结果。
4. 如果数据集的纯度未达到要求，则选择信息增益率最大的特征作为划分标准，将数据集划分为子数据集。
5. 对每个子数据集重复步骤2-4，直到满足停止条件。
6. 构建决策树，将每个节点的最优划分标准记录下来。
7. 使用测试集对决策树模型进行评估，计算分类准确率。