【转】决策树C4.5算法

 
Java代码
  1. 数据挖掘中决策树C4.5预测算法实现(半成品，还要写规则后煎支及对非离散数据信息增益计算)，下一篇博客讲原理  

Java代码
  1. package org.struct.decisiontree;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.Arrays;   
  5. import java.util.List;   
  6. import java.util.TreeSet;   
  7.   
  8. /**  
  9.  * @author Leon.Chen  
  10.  */  
  11. public class DecisionTreeBaseC4p5 {   
  12.        
  13.     /**  
  14.      * root node  
  15.      */  
  16.     private DecisionTreeNode root;   
  17.   
  18.     /**  
  19.      * visableArray  
  20.      */  
  21.     private boolean[] visable;   
  22.   
  23.     private static final int NOT_FOUND = -1;   
  24.   
  25.     private static final int DATA_START_LINE = 1;   
  26.   
  27.     private Object[] trainingArray;   
  28.   
  29.     private String[] columnHeaderArray;   
  30.   
  31.     /**  
  32.      * forecast node index  
  33.      */  
  34.     private int nodeIndex;   
  35.   
  36.     /**  
  37.      * @param args  
  38.      */  
  39.     @SuppressWarnings("boxing")   
  40.     public static void main(String[] args) {   
  41.         Object[] array = new Object[] {   
  42.                 new String[] { "age",          "income",   "student", "credit_rating", "buys_computer" },   
  43.                 new String[] { "youth",        "high",     "no",      "fair",          "no"  },   
  44.                 new String[] { "youth",        "high",     "no",      "excellent",     "no"  },   
  45.                 new String[] { "middle_aged",  "high",     "no",      "fair",          "yes" },   
  46.                 new String[] { "senior",       "medium",   "no",      "fair",          "yes" },   
  47.                 new String[] { "senior",       "low",      "yes",     "fair",          "yes" },   
  48.                 new String[] { "senior",       "low",      "yes",     "excellent",     "no"  },   
  49.                 new String[] { "middle_aged",  "low",      "yes",     "excellent",     "yes" },   
  50.                 new String[] { "youth",        "medium",   "no",      "fair",          "no"  },   
  51.                 new String[] { "youth",        "low",      "yes",     "fair",          "yes" },   
  52.                 new String[] { "senior",       "medium",   "yes",     "fair",          "yes" },   
  53.                 new String[] { "youth",        "medium",   "yes",     "excellent",     "yes" },   
  54.                 new String[] { "middle_aged",  "medium",   "no",      "excellent",     "yes" },   
  55.                 new String[] { "middle_aged",  "high",     "yes",     "fair",          "yes" },   
  56.                 new String[] { "senior",       "medium",   "no",      "excellent",     "no"  },   
  57.         };   
  58.   
  59.         DecisionTreeBaseC4p5 tree = new DecisionTreeBaseC4p5();   
  60.         tree.create(array, 4);   
  61.         System.out.println("===============END PRINT TREE===============");   
  62.         System.out.println("===============DECISION RESULT===============");   
  63.         //tree.forecast(printData, tree.root);   
  64.     }   
  65.   
  66.     /**  
  67.      * @param printData  
  68.      * @param node  
  69.      */  
  70.     public void forecast(String[] printData, DecisionTreeNode node) {   
  71.         int index = getColumnHeaderIndexByName(node.nodeName);   
  72.         if (index == NOT_FOUND) {   
  73.             System.out.println(node.nodeName);   
  74.         }   
  75.         DecisionTreeNode[] childs = node.childNodesArray;   
  76.         for (int i = 0; i < childs.length; i++) {   
  77.             if (childs[i] != null) {   
  78.                 if (childs[i].parentArrtibute.equals(printData[index])) {   
  79.                     forecast(printData, childs[i]);   
  80.                 }   
  81.             }   
  82.         }   
  83.     }   
  84.   
  85.     /**  
  86.      * @param array  
  87.      * @param index  
  88.      */  
  89.     public void create(Object[] array, int index) {   
  90.         this.trainingArray = Arrays.copyOfRange(array, DATA_START_LINE,   
  91.                 array.length);   
  92.         init(array, index);   
  93.         createDecisionTree(this.trainingArray);   
  94.         printDecisionTree(root);   
  95.     }   
  96.   
  97.     /**  
  98.      * @param array  
  99.      * @return Object[]  
  100.      */  
  101.     @SuppressWarnings("boxing")   
  102.     public Object[] getMaxGain(Object[] array) {   
  103.         Object[] result = new Object[2];   
  104.         double gain = 0;   
  105.         int index = -1;   
  106.   
  107.         for (int i = 0; i < visable.length; i++) {   
  108.             if (!visable[i]) {   
  109.                 //TODO ID3 change to C4.5   
  110.                 double value = gainRatio(array, i, this.nodeIndex);   
  111.                 System.out.println(value);   
  112.                 if (gain < value) {   
  113.                     gain = value;   
  114.                     index = i;   
  115.                 }   
  116.             }   
  117.         }   
  118.         result[0] = gain;   
  119.         result[1] = index;   
  120.         // TODO throws can't forecast this model exception   
  121.         if (index != -1) {   
  122.             visable[index] = true;   
  123.         }   
  124.         return result;   
  125.     }   
  126.   
  127.     /**  
  128.      * @param array  
  129.      */  
  130.     public void createDecisionTree(Object[] array) {   
  131.         Object[] maxgain = getMaxGain(array);   
  132.         if (root == null) {   
  133.             root = new DecisionTreeNode();   
  134.             root.parentNode = null;   
  135.             root.parentArrtibute = null;   
  136.             root.arrtibutesArray = getArrtibutesArray(((Integer) maxgain[1])   
  137.                     .intValue());   
  138.             root.nodeName = getColumnHeaderNameByIndex(((Integer) maxgain[1])   
  139.                     .intValue());   
  140.             root.childNodesArray = new DecisionTreeNode[root.arrtibutesArray.length];   
  141.             insertDecisionTree(array, root);   
  142.         }   
  143.     }   
  144.   
  145.     /**  
  146.      * @param array  
  147.      * @param parentNode  
  148.      */  
  149.     public void insertDecisionTree(Object[] array, DecisionTreeNode parentNode) {   
  150.         String[] arrtibutes = parentNode.arrtibutesArray;   
  151.         for (int i = 0; i < arrtibutes.length; i++) {   
  152.             Object[] pickArray = pickUpAndCreateSubArray(array, arrtibutes[i],   
  153.                     getColumnHeaderIndexByName(parentNode.nodeName));   
  154.             Object[] info = getMaxGain(pickArray);   
  155.             double gain = ((Double) info[0]).doubleValue();   
  156.             if (gain != 0) {   
  157.                 int index = ((Integer) info[1]).intValue();   
  158.                 DecisionTreeNode currentNode = new DecisionTreeNode();   
  159.                 currentNode.parentNode = parentNode;   
  160.                 currentNode.parentArrtibute = arrtibutes[i];   
  161.                 currentNode.arrtibutesArray = getArrtibutesArray(index);   
  162.                 currentNode.nodeName = getColumnHeaderNameByIndex(index);   
  163.                 currentNode.childNodesArray = new DecisionTreeNode[currentNode.arrtibutesArray.length];   
  164.                 parentNode.childNodesArray[i] = currentNode;   
  165.                 insertDecisionTree(pickArray, currentNode);   
  166.             } else {   
  167.                 DecisionTreeNode leafNode = new DecisionTreeNode();   
  168.                 leafNode.parentNode = parentNode;   
  169.                 leafNode.parentArrtibute = arrtibutes[i];   
  170.                 leafNode.arrtibutesArray = new String[0];   
  171.                 leafNode.nodeName = getLeafNodeName(pickArray,this.nodeIndex);   
  172.                 leafNode.childNodesArray = new DecisionTreeNode[0];   
  173.                 parentNode.childNodesArray[i] = leafNode;   
  174.             }   
  175.         }   
  176.     }   
  177.   
  178.     /**  
  179.      * @param node  
  180.      */  
  181.     public void printDecisionTree(DecisionTreeNode node) {   
  182.         System.out.println(node.nodeName);   
  183.         DecisionTreeNode[] childs = node.childNodesArray;   
  184.         for (int i = 0; i < childs.length; i++) {   
  185.             if (childs[i] != null) {   
  186.                 System.out.println(childs[i].parentArrtibute);   
  187.                 printDecisionTree(childs[i]);   
  188.             }   
  189.         }   
  190.     }   
  191.   
  192.     /**  
  193.      * init data  
  194.      *   
  195.      * @param dataArray  
  196.      * @param index  
  197.      */  
  198.     public void init(Object[] dataArray, int index) {   
  199.         this.nodeIndex = index;   
  200.         // init data   
  201.         this.columnHeaderArray = (String[]) dataArray[0];   
  202.         visable = new boolean[((String[]) dataArray[0]).length];   
  203.         for (int i = 0; i < visable.length; i++) {   
  204.             if (i == index) {   
  205.                 visable[i] = true;   
  206.             } else {   
  207.                 visable[i] = false;   
  208.             }   
  209.         }   
  210.     }   
  211.   
  212.     /**  
  213.      * @param array  
  214.      * @param arrtibute  
  215.      * @param index  
  216.      * @return Object[]  
  217.      */  
  218.     public Object[] pickUpAndCreateSubArray(Object[] array, String arrtibute,   
  219.             int index) {   
  220.         List<String[]> list = new ArrayList<String[]>();   
  221.         for (int i = 0; i < array.length; i++) {   
  222.             String[] strs = (String[]) array[i];   
  223.             if (strs[index].equals(arrtibute)) {   
  224.                 list.add(strs);   
  225.             }   
  226.         }   
  227.         return list.toArray();   
  228.     }   
  229.   
  230.     /**  
  231.      * gain(A)  
  232.      *   
  233.      * @param array  
  234.      * @param index  
  235.      * @return double  
  236.      */  
  237.     public double gain(Object[] array, int index, int nodeIndex) {   
  238.         int[] counts = separateToSameValueArrays(array, nodeIndex);   
  239.         String[] arrtibutes = getArrtibutesArray(index);   
  240.         double infoD = infoD(array, counts);   
  241.         double infoaD = infoaD(array, index, nodeIndex, arrtibutes);   
  242.         return infoD - infoaD;   
  243.     }   
  244.   
  245.     /**  
  246.      * @param array  
  247.      * @param nodeIndex  
  248.      * @return  
  249.      */  
  250.     public int[] separateToSameValueArrays(Object[] array, int nodeIndex) {   
  251.         String[] arrti = getArrtibutesArray(nodeIndex);   
  252.         int[] counts = new int[arrti.length];   
  253.         for (int i = 0; i < counts.length; i++) {   
  254.             counts[i] = 0;   
  255.         }   
  256.         for (int i = 0; i < array.length; i++) {   
  257.             String[] strs = (String[]) array[i];   
  258.             for (int j = 0; j < arrti.length; j++) {   
  259.                 if (strs[nodeIndex].equals(arrti[j])) {   
  260.                     counts[j]++;   
  261.                 }   
  262.             }   
  263.         }   
  264.         return counts;   
  265.     }   
  266.        
  267.     /**  
  268.      * gainRatio = gain(A)/splitInfo(A)  
  269.      *   
  270.      * @param array  
  271.      * @param index  
  272.      * @param nodeIndex  
  273.      * @return  
  274.      */  
  275.     public double gainRatio(Object[] array,int index,int nodeIndex){   
  276.         double gain = gain(array,index,nodeIndex);   
  277.         int[] counts = separateToSameValueArrays(array, index);   
  278.         double splitInfo = splitInfoaD(array,counts);   
  279.         if(splitInfo != 0){   
  280.             return gain/splitInfo;   
  281.         }   
  282.         return 0;   
  283.     }   
  284.   
  285.     /**  
  286.      * infoD = -E(pi*log2 pi)  
  287.      *   
  288.      * @param array  
  289.      * @param counts  
  290.      * @return  
  291.      */  
  292.     public double infoD(Object[] array, int[] counts) {   
  293.         double infoD = 0;   
  294.         for (int i = 0; i < counts.length; i++) {   
  295.             infoD += DecisionTreeUtil.info(counts[i], array.length);   
  296.         }   
  297.         return infoD;   
  298.     }   
  299.   
  300.     /**  
  301.      * splitInfoaD = -E|Dj|/|D|*log2(|Dj|/|D|)  
  302.      *   
  303.      * @param array  
  304.      * @param counts  
  305.      * @return  
  306.      */  
  307.     public double splitInfoaD(Object[] array, int[] counts) {   
  308.         return infoD(array, counts);   
  309.     }   
  310.   
  311.     /**  
  312.      * infoaD = E(|Dj| / |D|) * info(Dj)  
  313.      *   
  314.      * @param array  
  315.      * @param index  
  316.      * @param arrtibutes  
  317.      * @return  
  318.      */  
  319.     public double infoaD(Object[] array, int index, int nodeIndex,   
  320.             String[] arrtibutes) {   
  321.         double sv_total = 0;   
  322.         for (int i = 0; i < arrtibutes.length; i++) {   
  323.             sv_total += infoDj(array, index, nodeIndex, arrtibutes[i],   
  324.                     array.length);   
  325.         }   
  326.         return sv_total;   
  327.     }   
  328.   
  329.     /**  
  330.      * ((|Dj| / |D|) * Info(Dj))  
  331.      *   
  332.      * @param array  
  333.      * @param index  
  334.      * @param arrtibute  
  335.      * @param allTotal  
  336.      * @return double  
  337.      */  
  338.     public double infoDj(Object[] array, int index, int nodeIndex,   
  339.             String arrtibute, int allTotal) {   
  340.         String[] arrtibutes = getArrtibutesArray(nodeIndex);   
  341.         int[] counts = new int[arrtibutes.length];   
  342.         for (int i = 0; i < counts.length; i++) {   
  343.             counts[i] = 0;   
  344.         }   
  345.   
  346.         for (int i = 0; i < array.length; i++) {   
  347.             String[] strs = (String[]) array[i];   
  348.             if (strs[index].equals(arrtibute)) {   
  349.                 for (int k = 0; k < arrtibutes.length; k++) {   
  350.                     if (strs[nodeIndex].equals(arrtibutes[k])) {   
  351.                         counts[k]++;   
  352.                     }   
  353.                 }   
  354.             }   
  355.         }   
  356.   
  357.         int total = 0;   
  358.         double infoDj = 0;   
  359.         for (int i = 0; i < counts.length; i++) {   
  360.             total += counts[i];   
  361.         }   
  362.         for (int i = 0; i < counts.length; i++) {   
  363.             infoDj += DecisionTreeUtil.info(counts[i], total);   
  364.         }   
  365.         return DecisionTreeUtil.getPi(total, allTotal) * infoDj;   
  366.     }   
  367.   
  368.     /**  
  369.      * @param index  
  370.      * @return String[]  
  371.      */  
  372.     @SuppressWarnings("unchecked")   
  373.     public String[] getArrtibutesArray(int index) {   
  374.         TreeSet<String> set = new TreeSet<String>(new SequenceComparator());   
  375.         for (int i = 0; i < trainingArray.length; i++) {   
  376.             String[] strs = (String[]) trainingArray[i];   
  377.             set.add(strs[index]);   
  378.         }   
  379.         String[] result = new String[set.size()];   
  380.         return set.toArray(result);   
  381.     }   
  382.   
  383.     /**  
  384.      * @param index  
  385.      * @return String  
  386.      */  
  387.     public String getColumnHeaderNameByIndex(int index) {   
  388.         for (int i = 0; i < columnHeaderArray.length; i++) {   
  389.             if (i == index) {   
  390.                 return columnHeaderArray[i];   
  391.             }   
  392.         }   
  393.         return null;   
  394.     }   
  395.   
  396.     /**  
  397.      * @param array  
  398.      * @return String  
  399.      */  
  400.     public String getLeafNodeName(Object[] array,int nodeIndex) {   
  401.         if (array != null && array.length > 0) {   
  402.             String[] strs = (String[]) array[0];   
  403.             return strs[nodeIndex];   
  404.         }   
  405.         return null;   
  406.     }   
  407.   
  408.     /**  
  409.      * @param name  
  410.      * @return int  
  411.      */  
  412.     public int getColumnHeaderIndexByName(String name) {   
  413.         for (int i = 0; i < columnHeaderArray.length; i++) {   
  414.             if (name.equals(columnHeaderArray[i])) {   
  415.                 return i;   
  416.             }   
  417.         }   
  418.         return NOT_FOUND;   
  419.     }   
  420. }  

Java代码
  1. package org.struct.decisiontree;   
  2.   
  3. /**  
  4.  * @author Leon.Chen  
  5.  */  
  6. public class DecisionTreeNode {   
  7.   
  8.     DecisionTreeNode parentNode;   
  9.   
  10.     String parentArrtibute;   
  11.   
  12.     String nodeName;   
  13.   
  14.     String[] arrtibutesArray;   
  15.   
  16.     DecisionTreeNode[] childNodesArray;   
  17.   
  18. }  

Java代码
  1. package org.struct.decisiontree;   
  2.   
  3. /**  
  4.  * @author Leon.Chen  
  5.  */  
  6. public class DecisionTreeUtil {   
  7.   
  8.     /**  
  9.      * entropy:Info(T)=(i=1...k)pi*log（2）pi  
  10.      *   
  11.      * @param x  
  12.      * @param total  
  13.      * @return double  
  14.      */  
  15.     public static double info(int x, int total) {   
  16.         if (x == 0) {   
  17.             return 0;   
  18.         }   
  19.         double x_pi = getPi(x, total);   
  20.         return -(x_pi * logYBase2(x_pi));   
  21.     }   
  22.   
  23.     /**  
  24.      * log2y  
  25.      *   
  26.      * @param y  
  27.      * @return double  
  28.      */  
  29.     public static double logYBase2(double y) {   
  30.         return Math.log(y) / Math.log(2);   
  31.     }   
  32.   
  33.     /**  
  34.      * pi=|C(i,d)|/|D|  
  35.      *   
  36.      * @param x  
  37.      * @param total  
  38.      * @return double  
  39.      */  
  40.     public static double getPi(int x, int total) {   
  41.         return x / (double) total;   
  42.     }   
  43.   
  44. }  

Java代码
  1. package org.struct.decisiontree;   
  2.   
  3. import java.util.Comparator;   
  4.   
  5. /**  
  6.  * @author Leon.Chen  
  7.  *   
  8.  */  
  9. @SuppressWarnings("unchecked")   
  10. public class SequenceComparator implements Comparator {   
  11.   
  12.     public int compare(Object o1, Object o2) throws ClassCastException {   
  13.         String str1 = (String) o1;   
  14.         String str2 = (String) o2;   
  15.         return str1.compareTo(str2);   
  16.     }   
  17. }  

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode