数据挖掘 -- CART决策树算法

最新推荐文章于 2023-03-04 17:06:36 发布
最新推荐文章于 2023-03-04 17:06:36 发布
阅读量702 收藏 3
点赞数 2
分类专栏： 数据挖掘 文章标签： cart 数据挖掘 决策树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l1832876815/article/details/89963055
版权
1. 算法原理

CART算法: 为二叉决策树， 能够同时处理离散属性和连续属性，计算所有属性的Gini值，根据最大Gini值进行分裂生成决策树。(离散属性可以用二进制枚举分成两部分， 连续值根据值进行排序后遍历的时候同时更新类别判断值的状态，复杂度降到o(n))

2. 代码实现

Node.java

package com.clxk1997.model;

/**
 * @Description 决策树节点
 * @Author Clxk
 * @Date 2019/5/5 15:53
 * @Version 1.0
 */
public class Node {

    private String field;
    private String value;

   	constructor...
   	getters ans setters....
}

Field.java

package com.clxk1997.model;

/**
 * @Description 属性标签
 * @Author Clxk
 * @Date 2019/5/5 14:45
 * @Version 1.0
 */
public class Field {

    private String fieldName;
    private int fieldClass;
	
	constructor...
   	getters ans setters....
}

DecisionTree.java

package com.clxk1997.model;

import com.clxk1997.utils.Fields;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description 决策树
 * @Author Clxk
 * @Date 2019/5/5 15:59
 * @Version 1.0
 */
public class DecisionTree {

    private Node node;
    private DecisionTree lTree, rTree;

    constructor...
   	getters ans setters....

    public static DecisionTree initTree() {
        DecisionTree root = new DecisionTree();
        root.setNode(new Node("root","root"));
        root.setlTree(null);
        root.setrTree(null);
        return root;
    }

    public static void print(DecisionTree root) {
        if(root == null) return;
        System.out.println("属性: " + root.node.getField() + "  " + "判断: " + root.getNode().getValue());
        print(root.lTree);
        print(root.rTree);
    }

    public static String search(DecisionTree tree, ArrayList<String> list, List<Field> fields_copy) {
        if(tree.getNode().getField().equals("leaf")) return tree.getNode().getValue();
        if(tree.getlTree().getNode().getField().equals("leaf")) return tree.getlTree().getNode().getValue();
        DecisionTree lTree = tree.getlTree();
        DecisionTree rTree = tree.getrTree();
        String lfield = lTree.getNode().getField();
        String lvalue = lTree.getNode().getValue();
        int idx = 0;
        boolean isContinous = true;
        for(int i = 0; i < fields_copy.size(); i++) {
           if(fields_copy.get(i).getFieldName().equals(lfield)) {
               if(fields_copy.get(i).getFieldClass() == Fields.CONTINOUS) {
                   isContinous = true;
               } else {
                   isContinous = false;
               }
               idx = i;
               break;
           }
        }
        if(isContinous) {
            double value = Double.valueOf(lvalue.substring(2));
            if(Double.valueOf(list.get(idx)) <= value) {
                return search(lTree, list, fields_copy);
            } else {
                return search(rTree, list, fields_copy);
            }
        } else {
            String value = "|" + list.get(idx) + "|";
            if(lvalue.indexOf(value) > -1) {
                return search(lTree, list, fields_copy);
            } else {
                return search(rTree, list, fields_copy);
            }
        }
    }
}

Fields.java

package com.clxk1997.utils;

/**
 * @Description 属性标签
 * @Author Clxk
 * @Date 2019/5/5 14:47
 * @Version 1.0
 */
public final class Fields {

    public static final int ID = 1;
    public static final int CONTINOUS = 2;
    public static final int DISCRETE = 3;
    public static final int CLASS = 4;
}

Cart.java

package com.clxk1997.cart;

import com.clxk1997.model.DecisionTree;
import com.clxk1997.model.Field;
import com.clxk1997.model.Node;
import com.clxk1997.utils.Fields;

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

/**
 * @Description Cart算法实现
 * @Author Clxk
 * @Date 2019/5/5 14:42
 * @Version 1.0
 */
public class Cart {

    //属性
    private static List<Field> fields = new ArrayList<>();
    private static List<Field> fields_copy = new ArrayList<>();
    //训练集
    private static List<ArrayList<String>> trains = new ArrayList<>();
    //测试集
    private static List<ArrayList<String>> tests = new ArrayList<>();
    //决策树
    private static DecisionTree tree = DecisionTree.initTree();


    public static void main(String[] args) {

        try {
            inputModel();

            training();

            inputTest();

            OutputResult();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 输入训练集
     */
    public static void inputModel() throws FileNotFoundException {

        inputFields();

        inputTrains();
    }

    /**
     * 输入训练集
     */
    public static void inputTrains() throws FileNotFoundException {
        System.out.println("请输入训练集:(\"exit\"结束)");
        Scanner scan = new Scanner(new FileInputStream("D:\\CART\\src\\input_trains.txt"));
        String strLine;
        while(true) {
            strLine = scan.nextLine();
            if(strLine.equals("exit"))break;
            String[] split = strLine.split("\\s");
            ArrayList<String> train = new ArrayList<>();
            for(String s: split) {
                train.add(s);
            }
            trains.add(train);
        }
    }

    /**
     * 输入属性
     */
    public static void inputFields() throws FileNotFoundException {
        System.out.println("请输入属性数量:");
        Scanner scan = new Scanner(new FileInputStream("D:\\CART\\src\\input_fields.txt"));
        int fieldCnt = scan.nextInt();

        scan.nextLine();
        for(int i = 0; i < fieldCnt; i++) {
            System.out.println("请输入第" + (i+1) + "个属性及属性类型(ID-1 | CONTINOUS-2 | DISCRETE-3 | CLASS-4)");
            String strLine = scan.nextLine();
            String[] fieldStr = strLine.split("\\s");
            int fieldClass = Integer.valueOf(fieldStr[1]);
            Field field = new Field(fieldStr[0], fieldClass);
            fields.add(field);
            fields_copy.add(field);
        }
    }

    /**
     * 训练
     */
    public static void training() {

        train(fields, trains, tree);

        System.out.println("===================训练完成====================");
    }

    public static void train(List<Field> fields, List<ArrayList<String>> trains, DecisionTree tree) {
        if(trains.size() == 0) return;
        if(isPure(trains)) {
            tree.setlTree(new DecisionTree(new Node("leaf", trains.get(0).get(trains.get(0).size()-1)), null, null));
            tree.setrTree(new DecisionTree(new Node("leaf", trains.get(0).get(trains.get(0).size()-1)), null, null));
            return;
        }
        String conflictAns = isConflict(trains);
        if(conflictAns != "") {
            tree.setlTree(new DecisionTree(new Node("leaf", conflictAns), null, null));
            tree.setrTree(new DecisionTree(new Node("leaf", conflictAns), null, null));
            return;
        }

        double classGini = getClassGini(trains);
        System.out.println("类属性的Gini值为: " + classGini);
        int maxIndex = 0;
        double maxGini = -100000;
        double ansResult = 0;
        boolean isContinous = true;
        String[] keys = null;
        Object[] result = new Object[3];
        for (int i = 1; i < fields.size() - 1; i++) {
            if(fields.get(i).getFieldClass() == Fields.ID) continue;
            if(fields.get(i).getFieldClass() == Fields.CLASS) continue;
            if(fields.get(i).getFieldClass() == Fields.CONTINOUS) {
                result = getContinousGini(trains, i, classGini);
                System.out.println("Gini值计算:     " + "属性: " + fields.get(i).getFieldName() + "  Gini值: " + (double)result[0]);
                if((double)result[0] > maxGini) {
                    maxGini = (double)result[0];
                    ansResult = (double)result[1];
                    isContinous = true;
                    maxIndex = i;
                }
            } else {
                result = getDiscreteGini(trains, i, classGini);
                System.out.println("Gini值计算:     " + "属性: " + fields.get(i).getFieldName() + "  Gini值: " + (double)result[0]);
                if((double)result[0] > maxGini) {
                    maxGini = (double)result[0];
                    ansResult = (double)result[1];
                    keys = (String[]) result[2];
                    isContinous = false;
                    maxIndex = i;
                }
            }
        }
        //如果Gini值最大的节点是连续节点
        if(fields.size() > 2 && isContinous) {
            System.out.println("最大Gini值:     " + "属性: " + fields.get(maxIndex).getFieldName() + "  分隔条件: " + "<= " + String.valueOf(ansResult) + " and " + "> " + String.valueOf(ansResult));
            Node lnode = new Node(fields.get(maxIndex).getFieldName(), "<=" + String.valueOf(ansResult));
            Node rnode = new Node(fields.get(maxIndex).getFieldName(), ">" + String.valueOf(ansResult));
            DecisionTree lTree = new DecisionTree(lnode, null, null);
            DecisionTree rTree = new DecisionTree(rnode, null, null);
            tree.setrTree(rTree);
            tree.setlTree(lTree);
            ArrayList<ArrayList<String>> llist = new ArrayList<>();
            ArrayList<ArrayList<String>> rlist = new ArrayList<>();
            ArrayList<Field> fields_copy1 = new ArrayList<>();
            ArrayList<Field> fields_copy2 = new ArrayList<>();
            for(Field field : fields) {
                fields_copy1.add(field);
                fields_copy2.add(field);
            }
            fields_copy1.remove(maxIndex);
            fields_copy2.remove(maxIndex);
            for(ArrayList<String> list : trains) {
                if(Double.valueOf(list.get(maxIndex)) <= ansResult) {
                    list.remove(maxIndex);
                    llist.add(list);
                } else {
                    list.remove(maxIndex);
                    rlist.add(list);
                }
            }
            train(fields_copy1, llist, lTree);
            train(fields_copy2, rlist, rTree);
        } else if(fields.size() > 2) { //Gini值最大的节点是离散节点
            String lfield = "";
            String rfield = "";
            for(int i = 0; i < keys.length; i++) {
                if(((int)ansResult & (1 << i)) != 0) {
                    rfield += "|" + keys[i] + "|";
                } else {
                    lfield += "|" + keys[i] + "|";
                }
            }
            System.out.println("最大Gini值:     " + "属性: " + fields.get(maxIndex).getFieldName() + "  分隔条件: " + lfield + " and " + rfield);
            Node lnode = new Node(fields.get(maxIndex).getFieldName(), lfield);
            Node rnode = new Node(fields.get(maxIndex).getFieldName(), rfield);
            DecisionTree lTree = new DecisionTree(lnode, null, null);
            DecisionTree rTree = new DecisionTree(rnode, null, null);
            tree.setlTree(lTree);
            tree.setrTree(rTree);
            ArrayList<ArrayList<String>> llist = new ArrayList<>();
            ArrayList<ArrayList<String>> rlist = new ArrayList<>();
            ArrayList<Field> fields_copy1 = new ArrayList<>();
            ArrayList<Field> fields_copy2 = new ArrayList<>();
            for(Field field : fields) {
                fields_copy1.add(field);
                fields_copy2.add(field);
            }
            fields_copy1.remove(maxIndex);
            fields_copy2.remove(maxIndex);
            for(ArrayList<String> list : trains) {
                if(lfield.indexOf("|" + list.get(maxIndex) + "|") > -1) {
                    list.remove(maxIndex);
                    llist.add(list);
                } else {
                    list.remove(maxIndex);
                    rlist.add(list);
                }
            }
            train(fields_copy1, llist, lTree);
            train(fields_copy2, rlist, rTree);
        }
    }

    /**
     * 混乱节点(普通属性相同类属性不相同)
     * @param trains
     * @return
     */
    public static String isConflict(List<ArrayList<String>> trains) {
        int len = trains.get(0).size();
        for(int i = 1; i < len-1; i++) {
            Set<String> set = new HashSet<>();
            for(ArrayList<String> train : trains) {
                set.add(train.get(i));
                if(set.size() > 1) return "";
            }
        }
        int lcnt = 0, rcnt = 0;
        String lcur = trains.get(0).get(trains.get(0).size()-1);
        String rcur = "";
        for(ArrayList<String> train : trains) {
            if(train.get(train.size()-1).equals(lcur)) lcnt++;
            else {
                rcnt++;
                rcur = train.get(train.size()-1);
            }
        }
        if(lcnt >= rcnt) return lcur;
        else return rcur;
    }

    /**
     * 判断当前节点是不是纯节点
     * @param trains
     * @return
     */
    public static boolean isPure(List<ArrayList<String>> trains) {
        Set<String> set = new HashSet<>();
        for(ArrayList<String> list : trains) {
            set.add(list.get(list.size()-1));
            if(set.size() > 1) return false;
        }
        return true;
    }

    /**
     * 计算连续值Gini系数
     * @param trains
     * @param idx
     * @param classGini
     * @return
     */
    public static Object[] getContinousGini(List<ArrayList<String>> trains, int idx, double classGini) {

        String classValue = trains.get(0).get(trains.get(0).size()-1);
        trains.sort(new Comparator<ArrayList<String>>() {
            @Override
            public int compare(ArrayList<String> o1, ArrayList<String> o2) {
                double a = Double.valueOf(o1.get(idx));
                double b = Double.valueOf(o2.get(idx));
                if(a > b) return 1;
                else if(a == b) return 0;
                else return -1;
            }
        });
        int lcnt0 = 0, lcnt1 = 0, rcnt0 = 0, rcnt1 = 0;
        double maxgini = 0;
        double ansValue = 0;
        String curStr = trains.get(0).get(trains.get(0).size()-1);
        //初始化lcnt, rcnt
        for(ArrayList<String> train : trains) {
            if(train.get(train.size()-1).equals(curStr)) {
                rcnt0++;
            }
            rcnt1++;
        }
        for(int i = 0; i < trains.size()-1; i++) {
            double curt = (Double.valueOf(trains.get(i).get(idx)) + Double.valueOf(trains.get(i+1).get(idx))) / 2.0;
            lcnt1++;
            rcnt1--;
            if(trains.get(i).get(trains.get(i).size()-1).equals(curStr)) {
                rcnt0--;
                lcnt0++;
            }
            /*for (int j = 0; j < trains.size(); j++) {
                if(Double.valueOf(trains.get(j).get(idx)) > curt) break;
                lcnt1++;
                if(trains.get(j).get(trains.get(j).size()-1).equals(classValue)) {
                    lcnt0++;
                }
            }
            for (int j = trains.size()-1; j >= 0; j--) {
                if(Double.valueOf(trains.get(j).get(idx)) <= curt) break;
                rcnt1++;
                if(trains.get(j).get(trains.get(j).size()-1).equals(classValue)) {
                    rcnt0++;
                }
            }*/
            double cur = calculDeta(trains.size(), classGini, lcnt0, lcnt1, rcnt0, rcnt1);
            if(cur > maxgini) {
                maxgini = cur;
                ansValue = curt;
            }
        }
        Object[] ans = new Object[2];
        ans[0] = maxgini;
        ans[1] = ansValue;
        return ans;
    }

    /**
     * 计算离散值Gini系数
     * @param trains
     * @param idx
     * @param classGini
     * @return
     */
    public static Object[] getDiscreteGini(List<ArrayList<String>> trains, int idx, double classGini) {

        String classValue = trains.get(0).get(trains.get(0).size()-1);
        Map<String, Integer> fieldmp = new HashMap<>();
        Map<String, Map<String, Integer>> classmp = new HashMap<>();
        for(int i = 0; i < trains.size(); i++) {
            ArrayList<String> cur = trains.get(i);
            String key = cur.get(idx);
            String classKey = cur.get(cur.size()-1);
            if(fieldmp.containsKey(key)) {
                fieldmp.put(key, fieldmp.get(key)+1);
                if(classmp.get(key).containsKey(classKey)) {
                    classmp.get(key).put(classKey, classmp.get(key).get(classKey) + 1);
                } else {
                    classmp.get(key).put(classKey, 1);
                }
            } else {
                fieldmp.put(key, 1);
                Map<String, Integer> cd = new HashMap<>();
                cd.put(classKey, 1);
                classmp.put(key, cd);
            }
        }
        String[] keys = new String[classmp.size()];
        classmp.keySet().toArray(keys);
        int lcnt0 = 0, lcnt1 = 0, rcnt0 = 0, rcnt1 = 0;
        double maxgini = 0;
        double ansValue = 0;
        if(fieldmp.size() != 1) {
            for(int i = 1; i < (1 << fieldmp.size())-1; i++) {
                lcnt0 = lcnt1 = rcnt1 = rcnt0 = 0;
                for (int j = 0; j < fieldmp.size(); j++) {
                    if((i&(1 << j)) != 0) {
                        if(classmp.get(keys[j]).containsKey(classValue))
                            lcnt0 += classmp.get(keys[j]).get(classValue);
                        lcnt1 += fieldmp.get(keys[j]);
                    } else {
                        if(classmp.get(keys[j]).containsKey(classValue))
                            rcnt0 += classmp.get(keys[j]).get(classValue);
                        rcnt1 += fieldmp.get(keys[j]);
                    }
                }
                double cur = calculDeta(trains.size(), classGini, lcnt0, lcnt1, rcnt0, rcnt1);
                if(cur > maxgini) {
                    maxgini = cur;
                    ansValue = i;
                }
            }
        }
        Object[] ans = new Object[3];
        ans[0] = maxgini;
        ans[1] = ansValue;
        ans[2] = keys;
        return ans;
    }

    /**
     * 计算deta值
     * @param size
     * @param classGini
     * @param lcnt0
     * @param lcnt1
     * @param rcnt0
     * @param rcnt1
     * @return
     */
    public static double calculDeta(int size, double classGini, int lcnt0, int lcnt1, int rcnt0, int rcnt1) {
        return classGini - ((double)lcnt1 / (double)size) * calculGini(lcnt0, lcnt1) - ((double)rcnt1 / (double)size) * calculGini(rcnt0, rcnt1);
    }

    /**
     * 计算左右节点Gini值
     * @param lcnt0
     * @param lcnt1
     * @return
     */
    public static double calculGini(int lcnt0, int lcnt1) {
        double a = (double)lcnt0 / (double)lcnt1;
        double b = (double)(lcnt1-lcnt0) / (double)lcnt1;
        return 1d - a * a - b * b;
    }

    public static double getClassGini(List<ArrayList<String>> trains) {
        double ans = 1;
        Map<String, Integer> mp = new HashMap<>();
        for(int i = 0; i < trains.size(); i++) {
            String key = trains.get(i).get(trains.get(i).size()-1);
            if(mp.containsKey(key)) mp.put(key, mp.get(key)+1);
            else mp.put(key, 1);
        }
        for(Map.Entry<String,Integer> entry : mp.entrySet()) {
            ans -= ((double)entry.getValue() / (double)trains.size()) * ((double)entry.getValue() / (double)trains.size());
        }
        return ans;
    }

    /**
     * 输入测试集
     */
    public static void inputTest() throws FileNotFoundException {

        System.out.println("请输入测试集:(\"exit\"结束)");
        Scanner scan = new Scanner(new FileInputStream("D:\\CART\\src\\input_test.txt"));
        String strLine;
        while(true) {
            strLine = scan.nextLine();
            if(strLine.equals("exit"))break;
            String[] split = strLine.split("\\s");
            ArrayList<String> test = new ArrayList<>();
            for(String s: split) {
                test.add(s);
            }
            tests.add(test);
        }
        System.out.println("===================开始预测====================");

    }

    /**
     * 输出测试结果
     */
    public static void OutputResult() throws Exception {
        int tr = 0;
        DecisionTree.print(tree);
        String s = "";
        FileWriter writer = new FileWriter("D:\\CART\\src\\output_ans.txt",true);
        BufferedWriter bufferedWriter = new BufferedWriter(writer);
        for(ArrayList<String> list : tests) {
            String ans = DecisionTree.search(tree, list, fields_copy);
            bufferedWriter.write(ans + "\n");
        }
        bufferedWriter.close();
        writer.close();
        System.out.println("===================预测完成====================");
    }

}
Chook_lxk
关注
专栏目录
数据挖掘领域十大经典算法之—CART算法（超详细附代码）
fuqiuai的博客
03-07 2万+
相关文章： 数据挖掘领域十大经典算法之—C4.5算法（超详细附代码） 数据挖掘领域十大经典算法之—K-Means算法（超详细附代码） 数据挖掘领域十大经典算法之—SVM算法（超详细附代码） 数据挖掘领域十大经典算法之—Apriori算法 数据挖掘领域十大经典算法之—EM算法 数据挖掘领域十大经典算法之—PageRank算法 数据挖掘领域十大经典算法之—...
CART决策树分类算法VC++
02-23
CART决策树分类算法VC++ CART决策树分类算法VC++ CART决策树分类算法VC++ CART决策树分类算法VC++
数据挖掘—决策树ID3分类算法的C++实现
Coding for Dreams
03-05 1229
数据挖掘课上面老师介绍了下决策树ID3算法，我抽空余时间把这个算法用C++实现了一遍。 决策树算法是非常常用的分类算法，是逼近离散目标函数的方法，学习得到的函数以决策树的形式表示。其基本思路是不断选取产生信息增益最大的属性来划分样例集和，构造决策树。信息增益定义为结点与其子结点的信息熵之差。信息熵是香农提出的，用于描述信息不纯度(不稳定性)，其计算公式是 Pi为子集合中不同性(而二元分类即...
机器学习决策树学习算法(C++实现）
热门推荐
PiggyGaGa的博客
12-02 2万+
C++ 实现决策树学习算法 史上最简单写在前面当看到自己的程序能够将简单的例子成功运行，证明自己程序的逻辑性没有问题，真的是非常高兴，虽然需要做 的事情还有很多很多，总之还是有一些喜悦的啦，所以将我的这段工作以这篇博客记录下来，如果有人看到能和我 相互交流那再好不过了。刚刚还在知乎上面搜索了一个词是什么意思，可能大家都听过这个词：造轮子，我这次做的工作算是造轮子吧， 大牛说：放到编程中，就是说
机器学习C++源码解析-决策树cart算法-源码+数据
08-05
机器学习C++源码解析-决策树cart算法-源码+数据
论文研究-数据挖掘中决策树算法的最新进展.pdf
07-22
论文《论文研究-数据挖掘中决策树算法的最新进展》总结了决策树算法在数据挖掘中的基础原理和优势，同时指出了其在大数据环境下的局限性，并从五个主要方面综述了决策树算法的最新进展，最后探讨了该领域所面临的...
生物数据挖掘-决策树实验报告.pdf
06-14
实验报告中的内容详细介绍了如何使用决策树算法，特别是ID3算法，来进行数据分析。 ID3算法基于**信息熵**和**信息增益**的概念。信息熵是度量数据纯度的一个指标，表示的是数据集合的不确定性。信息增益则是通过...
基于CART决策树数据挖掘算法的应用研究
06-02
分类与回归树CART算法是数据挖掘技术中重要的算法。依据CART算法理论,采用类型变量求解决策树,并引入优化的分裂函数,然后利用基于类型变量的论域划分创建二叉树,抽取和筛选预测准则,从而为职能部门决策提供科学而...
数据挖掘实战-基于决策树算法构建北京市空气质量预测模型.rar
最新发布
05-13
在本项目中，我们将深入探讨如何利用数据挖掘技术，特别是决策树算法，来构建一个预测北京市空气质量的模型。首先，我们需要理解数据挖掘的基本概念，它是一种从大量数据中发现有价值信息的过程，通常包括预处理、...
决策树算法小结(三) CART原理及代码实现
weixin_30786617的博客
08-30 2141
前面总结了决策树ID3算法(ID3原理及代码实现)和改进版C4.5算法(C4.5原理及代码实现)，它们存在一些不如，如只能处理分类不能处理回归存在过拟合等问题。因此，有必要介绍一个新的叫做CART（Classification And Regression Trees，分类回归树）的树构建算法。该算法既可以用于分类还可以用于回归，它使用二元切分来处理连续型变量。 决策树算法三要素：特征选...
用c++从头开始实现决策树
deephub
05-24 5171
Python已经成为数据科学的语言之王。大多数新的数据科学家和程序员继续学习Python作为他们的第一门语言。这是有充分理由的;Python具有较浅的学习曲线、强大的社区和丰富的数据科学库生态系统。 我用Python开始了我的数据科学之旅，它仍然是我解决数据科学问题最常用的工具。我很想更好地理解Python从您那里抽象出了什么，以及用性能更高的语言编写更快代码的成本与好处。 为了有代表性地介绍c++，我需要一个代表性的应用程序，c++将是一个合适的选择。从头实现一个分类决策树分类器似乎是一个适当的挑战。这已
决策树---ID3算法、C4.5算法、CART算法
xiaoming1999的博客
11-04 1069
决策树是一种树形结构，它每一个内部节点都表示一个属性的判断，每一个分支表示的是一种结果的输出，最后的叶子节点是代表一种分类的结果。 决策树比较适合分析离散数据，如果是连续数据要先转成离散数据然后再进行分析。下面以一个例题来分析： RID age income student credit_rating Class:buys_computer 1 youth high no fair no 2 youth high no
cart算法实例matlab,matlab 决策树cart算法源代码
weixin_34394265的博客
04-14 1146
matlab源码 决策树 c4.5 cartfunction D = CART(train_features, train_targets, params, region)% Classify using classification and regression trees% Inputs:% features - Train features% targets - Train targ...
决策树ID3 C4.5 CART代码
雨化于画
01-18 283
ID3 # encoding: gbk import pandas as pd import numpy as np class DecisionTree: def __init__(self): self.model = None # 计算熵 def calEntropy(self, y): valRate = y.value_counts().apply(lambda x: x / y.size) # 频次汇总 得到各个特征对应的概率
万字详解决策树之ID3、CART、C4.5【原理+实例+代码实现】
雷恩Layne
07-27 2571
文章目录决策树的含义(信息熵+信息增益)&ID3(纯度+基尼系数)&CART信息增益率&C4.5各种决策树比较与总结决策树编程实战调用sklearn库实现回归决策树手动实现ID3决策树使用sklearn库回归决策树预测boston房价使用sklearn库分类决策树对iris分类 决策树的含义 首先我们先来了解下什么是决策树。 上图就是一颗带有决策的树，其中天气、温度等称为特征，后面问号的位置称为阈值，如温度=35°，则阈值为35。 决策树是一种基本的分类与回归方法。这里主要讨论决
决策树(ID3 C4.5 CART)原理+推导+代码
Braylon的博客
03-04 1280
文章目录简介初识决策树特征选择信息增益信息增益比ID3C4.5决策树剪枝CART 分类与回归树简述：回归树的生成分类树的生成CART剪枝优缺点决策树ID3、C4.5算法CART分类与回归树适用场景代码 简介 决策树模型，自己总结了很久，也认为比较全面了。现在分享一下自己总结的东西。 这里面我只捡精炼的说，基本上都是干货，然后能用人话说的，我也不会疯狂排列数学公式。 初识决策树 决策树其实是用于分...
6. 决策树算法原理以及cart代码实现
weixin_43796012的博客
03-04 774
这篇博客介绍了CART决策树的原理以及如何使用Python编写代码来构建一个CART决策树模型，以诊断乳腺癌为例。文章首先介绍了决策树的基本概念和构建流程，然后详细讲解了CART决策树的原理，包括基尼系数、切分点选择、剪枝等内容。接着，文章以乳腺癌数据为例，自己编写了一个CART决策树分类器，并在该数据集上训练和测试，并使用后剪枝的方法提高模型的泛化能力。完整的实验代码在我的github上👉QYHcrossover/ML-numpy: 机器学习算法numpy实现 (github.com)欢迎star⭐。
Decision Tree决策树 ID3,C4.5,CART方法原理及伪代码
zhongzhh8的博客
04-02 8617
1.算法原理 决策树：决策树是一个通过训练的数据来搭建起的树结构模型，根节点中存储着所有数据集和特征集，当前节点的每个分支是该节点在相应的特征值上的表现，而叶子节点存放的结果则是决策结果。通过这个模型，我们可以高效的对于未知的数据进行归纳分类。每次使用决策树时，是将测试样本从根节点开始，选择特征分支一直向下直至到达叶子节点，然后得到叶子节点的决策结果。 其中决策树算法的关键在于如何选出一个特...
理解数据挖掘：经典决策树算法详解
决策树算法是数据挖掘中的一个重要组成部分，它是一种基于树形结构进行决策的模型。每个内部节点代表一个特征或属性，每个分支代表该特征的一个可能值，而叶节点则表示一个决策结果。决策树通过不断地分裂数据集，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Chook_lxk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值