文档章节

贝叶斯网络--TAN树型朴素贝叶斯算法

一贱书生
 一贱书生
发布于 2017/04/16 21:03
字数 3851
阅读 461
收藏 0

前言

在前面的时间里已经学习过了NB朴素贝叶斯算法, 又刚刚初步的学习了贝叶斯网络的一些基本概念和常用的计算方法。于是就有了上篇初识贝叶斯网络的文章,由于本人最近一直在研究学习<<贝叶斯网引论>>,也接触到了许多与贝叶斯网络相关的知识,可以说朴素贝叶斯算法这些只是我们所了解贝叶斯知识的很小的一部分。今天我要总结的学习成果就是基于NB算法的,叫做Tree Augmented Naive Bays,中文意思就是树型朴素贝叶斯算法,简单理解就是树增强型NB算法,那么问题来了,他是如何增强的呢,请继续往下正文的描述。

朴素贝叶斯算法

又得要从朴素贝叶斯算法开始讲起了,因为在前言中已经说了,TAN算法是对NB算法的增强,了解过NB算法的,一定知道NB算法在使用的时候是假设属性事件是相互独立的,而决策属性的分类结果是依赖于各个条件属性的情况的,最后选择分类属性中拥有最大后验概率的值为决策属性。比如下面这个模型可以描述一个简单的模型,

上面账号是否真实的依赖属性条件有3个,好友密度,是否使用真实头像,日志密度,假设这3个属性是相互独立的,但是事实上,在这里的头像是否真实和好友密度其实是有关联的,所以更加真实的情况是下面这张情况;

OK,TAN的出现就解决了条件间的部分属性依赖的问题。在上面的例子中我们是根据自己的主观意识判断出头像和好友密度的关系,但是在真实算法中,我们当然希望机器能够自己根据所给数据集帮我们得出这样的关系,令人高兴的事,TAN帮我们做到了这点。

TAN算法

互信息值

互信息值,在百度百科中的解释如下:

互信息值是信息论中一个有用的信息度量。它可以看出是一个信息量里包含另一个随机变量的信息量。

用图线来表示就是下面这样。

中间的I(x;y)就是互信息值,X,Y代表的2种属性。于是下面这个属性就很好理解了,互信息值越大,就代表2个属性关联性越大。互信息值的标准公式如下:

但是在TAN中会有少许的不一样,会有类变量属性的加入,因为属性之间的关联性的前提是要在某一分类属性确定下进行重新计算,不同的类属性值会有不同的属性关联性。下面是TAN中的I(x;Y)计算公式:

现在看不懂不要紧,后面在给出的程序代码中可自行调试。

算法实现过程

TAN的算法过程其实并不简单,在计算完各个属性对的互信息值之后,要进行贝叶斯网络的构建,这个是TAN中最难的部分,这个部分有下面几个阶段。

1、根据各个属性对的互信息值降序排序,依次取出其中的节点对,遵循不产生环路的原则,构造最大权重跨度树,直到选择完n-1条边为止(因为总共n个属性节点,n-1条边即可确定)。按照互信息值从高到低选择的原因就是要保留关联性更高的关联依赖性的边。

2、上述过程构成的是一个无向图,接下来为整个无向图确定边的方向。选择任意一个属性节点作为根节点,由根节点向外的方向为属性节点之间的方向。

3、为每一个属性节点添加父节点,父节点就是分类属性节点,至此贝叶斯网络结构构造完毕。

为了方便大家理解,我在网上截了几张图,下面这张是在5个属性节点中优先选择了互信息值最大的4条作为无向图:

上述带了箭头是因为,我选择的A作为树的根节点,然后方向就全部确定了,因为A直接连着4个属性节点,然后再此基础上添加父节点,就是下面这个样子了。

OK,这样应该就比较好理解了吧,如果还不理解,请仔细分析我写的程序,从代码中去理解这个过程也可以。

分类结果概率的计算

分类结果概率的计算其实非常简单,只要把查询的条件属性传入分类模型中,然后计算不同类属性下的概率值,拥有最大概率值的分类属性值为最终的分类结果。下面是计算公式,就是联合概率分布公式:

代码实现

测试数据集input.txt:

 

[java] view plain copy

 print?

  1. OutLook Temperature Humidity Wind PlayTennis  
  2. Sunny Hot High Weak No  
  3. Sunny Hot High Strong No  
  4. Overcast Hot High Weak Yes  
  5. Rainy Mild High Weak Yes  
  6. Rainy Cool Normal Weak Yes  
  7. Rainy Cool Normal Strong No  
  8. Overcast Cool Normal Strong Yes  
  9. Sunny Mild High Weak No  
  10. Sunny Cool Normal Weak Yes  
  11. Rainy Mild Normal Weak Yes  
  12. Sunny Mild Normal Strong Yes  
  13. Overcast Mild High Strong Yes  
  14. Overcast Hot Normal Weak Yes  
  15. Rainy Mild High Strong No  

节点类Node.java:

 

 

[java] view plain copy

 print?

  1. package DataMining_TAN;  
  2.   
  3. import java.util.ArrayList;  
  4.   
  5. /** 
  6.  * 贝叶斯网络节点类 
  7.  *  
  8.  * @author lyq 
  9.  *  
  10.  */  
  11. public class Node {  
  12.     //节点唯一id,方便后面节点连接方向的确定  
  13.     int id;  
  14.     // 节点的属性名称  
  15.     String name;  
  16.     // 该节点所连续的节点  
  17.     ArrayList<Node> connectedNodes;  
  18.   
  19.     public Node(int id, String name) {  
  20.         this.id = id;  
  21.         this.name = name;  
  22.   
  23.         // 初始化变量  
  24.         this.connectedNodes = new ArrayList<>();  
  25.     }  
  26.   
  27.     /** 
  28.      * 将自身节点连接到目标给定的节点 
  29.      *  
  30.      * @param node 
  31.      *            下游节点 
  32.      */  
  33.     public void connectNode(Node node) {  
  34.         //避免连接自身  
  35.         if(this.id == node.id){  
  36.             return;  
  37.         }  
  38.           
  39.         // 将节点加入自身节点的节点列表中  
  40.         this.connectedNodes.add(node);  
  41.         // 将自身节点加入到目标节点的列表中  
  42.         node.connectedNodes.add(this);  
  43.     }  
  44.   
  45.     /** 
  46.      * 判断与目标节点是否相同,主要比较名称是否相同即可 
  47.      *  
  48.      * @param node 
  49.      *            目标结点 
  50.      * @return 
  51.      */  
  52.     public boolean isEqual(Node node) {  
  53.         boolean isEqual;  
  54.   
  55.         isEqual = false;  
  56.         // 节点名称相同则视为相等  
  57.         if (this.id == node.id) {  
  58.             isEqual = true;  
  59.         }  
  60.   
  61.         return isEqual;  
  62.     }  
  63. }  

 

互信息值类.Java:

 

[java] view plain copy

 print?

  1. package DataMining_TAN;  
  2.   
  3. /** 
  4.  * 属性之间的互信息值,表示属性之间的关联性大小 
  5.  * @author lyq 
  6.  * 
  7.  */  
  8. public class AttrMutualInfo implements Comparable<AttrMutualInfo>{  
  9.     //互信息值  
  10.     Double value;  
  11.     //关联属性值对  
  12.     Node[] nodeArray;  
  13.       
  14.     public AttrMutualInfo(double value, Node node1, Node node2){  
  15.         this.value = value;  
  16.           
  17.         this.nodeArray = new Node[2];  
  18.         this.nodeArray[0] = node1;  
  19.         this.nodeArray[1] = node2;  
  20.     }  
  21.   
  22.     @Override  
  23.     public int compareTo(AttrMutualInfo o) {  
  24.         // TODO Auto-generated method stub  
  25.         return o.value.compareTo(this.value);  
  26.     }  
  27.       
  28. }  


 

 

算法主程序类TANTool.java:

 

[java] view plain copy

 print?

  1. package DataMining_TAN;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.File;  
  5. import java.io.FileReader;  
  6. import java.io.IOException;  
  7. import java.util.ArrayList;  
  8. import java.util.Collections;  
  9. import java.util.HashMap;  
  10.   
  11. /** 
  12.  * TAN树型朴素贝叶斯算法工具类 
  13.  *  
  14.  * @author lyq 
  15.  *  
  16.  */  
  17. public class TANTool {  
  18.     // 测试数据集地址  
  19.     private String filePath;  
  20.     // 数据集属性总数,其中一个个分类属性  
  21.     private int attrNum;  
  22.     // 分类属性名  
  23.     private String classAttrName;  
  24.     // 属性列名称行  
  25.     private String[] attrNames;  
  26.     // 贝叶斯网络边的方向,数组内的数值为节点id,从i->j  
  27.     private int[][] edges;  
  28.     // 属性名到列下标的映射  
  29.     private HashMap<String, Integer> attr2Column;  
  30.     // 属性,属性对取值集合映射对  
  31.     private HashMap<String, ArrayList<String>> attr2Values;  
  32.     // 贝叶斯网络总节点列表  
  33.     private ArrayList<Node> totalNodes;  
  34.     // 总的测试数据  
  35.     private ArrayList<String[]> totalDatas;  
  36.   
  37.     public TANTool(String filePath) {  
  38.         this.filePath = filePath;  
  39.   
  40.         readDataFile();  
  41.     }  
  42.   
  43.     /** 
  44.      * 从文件中读取数据 
  45.      */  
  46.     private void readDataFile() {  
  47.         File file = new File(filePath);  
  48.         ArrayList<String[]> dataArray = new ArrayList<String[]>();  
  49.   
  50.         try {  
  51.             BufferedReader in = new BufferedReader(new FileReader(file));  
  52.             String str;  
  53.             String[] array;  
  54.   
  55.             while ((str = in.readLine()) != null) {  
  56.                 array = str.split(" ");  
  57.                 dataArray.add(array);  
  58.             }  
  59.             in.close();  
  60.         } catch (IOException e) {  
  61.             e.getStackTrace();  
  62.         }  
  63.   
  64.         this.totalDatas = dataArray;  
  65.         this.attrNames = this.totalDatas.get(0);  
  66.         this.attrNum = this.attrNames.length;  
  67.         this.classAttrName = this.attrNames[attrNum - 1];  
  68.   
  69.         Node node;  
  70.         this.edges = new int[attrNum][attrNum];  
  71.         this.totalNodes = new ArrayList<>();  
  72.         this.attr2Column = new HashMap<>();  
  73.         this.attr2Values = new HashMap<>();  
  74.   
  75.         // 分类属性节点id最小设为0  
  76.         node = new Node(0, attrNames[attrNum - 1]);  
  77.         this.totalNodes.add(node);  
  78.         for (int i = 0; i < attrNames.length; i++) {  
  79.             if (i < attrNum - 1) {  
  80.                 // 创建贝叶斯网络节点,每个属性一个节点  
  81.                 node = new Node(i + 1, attrNames[i]);  
  82.                 this.totalNodes.add(node);  
  83.             }  
  84.   
  85.             // 添加属性到列下标的映射  
  86.             this.attr2Column.put(attrNames[i], i);  
  87.         }  
  88.   
  89.         String[] temp;  
  90.         ArrayList<String> values;  
  91.         // 进行属性名,属性值对的映射匹配  
  92.         for (int i = 1; i < this.totalDatas.size(); i++) {  
  93.             temp = this.totalDatas.get(i);  
  94.   
  95.             for (int j = 0; j < temp.length; j++) {  
  96.                 // 判断map中是否包含此属性名  
  97.                 if (this.attr2Values.containsKey(attrNames[j])) {  
  98.                     values = this.attr2Values.get(attrNames[j]);  
  99.                 } else {  
  100.                     values = new ArrayList<>();  
  101.                 }  
  102.   
  103.                 if (!values.contains(temp[j])) {  
  104.                     // 加入新的属性值  
  105.                     values.add(temp[j]);  
  106.                 }  
  107.   
  108.                 this.attr2Values.put(attrNames[j], values);  
  109.             }  
  110.         }  
  111.     }  
  112.   
  113.     /** 
  114.      * 根据条件互信息度对构建最大权重跨度树,返回第一个节点为根节点 
  115.      *  
  116.      * @param iArray 
  117.      */  
  118.     private Node constructWeightTree(ArrayList<Node[]> iArray) {  
  119.         Node node1;  
  120.         Node node2;  
  121.         Node root;  
  122.         ArrayList<Node> existNodes;  
  123.   
  124.         existNodes = new ArrayList<>();  
  125.   
  126.         for (Node[] i : iArray) {  
  127.             node1 = i[0];  
  128.             node2 = i[1];  
  129.   
  130.             // 将2个节点进行连接  
  131.             node1.connectNode(node2);  
  132.             // 避免出现环路现象  
  133.             addIfNotExist(node1, existNodes);  
  134.             addIfNotExist(node2, existNodes);  
  135.   
  136.             if (existNodes.size() == attrNum - 1) {  
  137.                 break;  
  138.             }  
  139.         }  
  140.   
  141.         // 返回第一个作为根节点  
  142.         root = existNodes.get(0);  
  143.         return root;  
  144.     }  
  145.   
  146.     /** 
  147.      * 为树型结构确定边的方向,方向为属性根节点方向指向其他属性节点方向 
  148.      *  
  149.      * @param root 
  150.      *            当前遍历到的节点 
  151.      */  
  152.     private void confirmGraphDirection(Node currentNode) {  
  153.         int i;  
  154.         int j;  
  155.         ArrayList<Node> connectedNodes;  
  156.   
  157.         connectedNodes = currentNode.connectedNodes;  
  158.   
  159.         i = currentNode.id;  
  160.         for (Node n : connectedNodes) {  
  161.             j = n.id;  
  162.   
  163.             // 判断连接此2节点的方向是否被确定  
  164.             if (edges[i][j] == 0 && edges[j][i] == 0) {  
  165.                 // 如果没有确定,则制定方向为i->j  
  166.                 edges[i][j] = 1;  
  167.   
  168.                 // 递归继续搜索  
  169.                 confirmGraphDirection(n);  
  170.             }  
  171.         }  
  172.     }  
  173.   
  174.     /** 
  175.      * 为属性节点添加分类属性节点为父节点 
  176.      *  
  177.      * @param parentNode 
  178.      *            父节点 
  179.      * @param nodeList 
  180.      *            子节点列表 
  181.      */  
  182.     private void addParentNode() {  
  183.         // 分类属性节点  
  184.         Node parentNode;  
  185.   
  186.         parentNode = null;  
  187.         for (Node n : this.totalNodes) {  
  188.             if (n.id == 0) {  
  189.                 parentNode = n;  
  190.                 break;  
  191.             }  
  192.         }  
  193.   
  194.         for (Node child : this.totalNodes) {  
  195.             parentNode.connectNode(child);  
  196.   
  197.             if (child.id != 0) {  
  198.                 // 确定连接方向  
  199.                 this.edges[0][child.id] = 1;  
  200.             }  
  201.         }  
  202.     }  
  203.   
  204.     /** 
  205.      * 在节点集合中添加节点 
  206.      *  
  207.      * @param node 
  208.      *            待添加节点 
  209.      * @param existNodes 
  210.      *            已存在的节点列表 
  211.      * @return 
  212.      */  
  213.     public boolean addIfNotExist(Node node, ArrayList<Node> existNodes) {  
  214.         boolean canAdd;  
  215.   
  216.         canAdd = true;  
  217.         for (Node n : existNodes) {  
  218.             // 如果节点列表中已经含有节点,则算添加失败  
  219.             if (n.isEqual(node)) {  
  220.                 canAdd = false;  
  221.                 break;  
  222.             }  
  223.         }  
  224.   
  225.         if (canAdd) {  
  226.             existNodes.add(node);  
  227.         }  
  228.   
  229.         return canAdd;  
  230.     }  
  231.   
  232.     /** 
  233.      * 计算节点条件概率 
  234.      *  
  235.      * @param node 
  236.      *            关于node的后验概率 
  237.      * @param queryParam 
  238.      *            查询的属性参数 
  239.      * @return 
  240.      */  
  241.     private double calConditionPro(Node node, HashMap<String, String> queryParam) {  
  242.         int id;  
  243.         double pro;  
  244.         String value;  
  245.         String[] attrValue;  
  246.   
  247.         ArrayList<String[]> priorAttrInfos;  
  248.         ArrayList<String[]> backAttrInfos;  
  249.         ArrayList<Node> parentNodes;  
  250.   
  251.         pro = 1;  
  252.         id = node.id;  
  253.         parentNodes = new ArrayList<>();  
  254.         priorAttrInfos = new ArrayList<>();  
  255.         backAttrInfos = new ArrayList<>();  
  256.   
  257.         for (int i = 0; i < this.edges.length; i++) {  
  258.             // 寻找父节点id  
  259.             if (this.edges[i][id] == 1) {  
  260.                 for (Node temp : this.totalNodes) {  
  261.                     // 寻找目标节点id  
  262.                     if (temp.id == i) {  
  263.                         parentNodes.add(temp);  
  264.                         break;  
  265.                     }  
  266.                 }  
  267.             }  
  268.         }  
  269.   
  270.         // 获取先验属性的属性值,首先添加先验属性  
  271.         value = queryParam.get(node.name);  
  272.         attrValue = new String[2];  
  273.         attrValue[0] = node.name;  
  274.         attrValue[1] = value;  
  275.         priorAttrInfos.add(attrValue);  
  276.   
  277.         // 逐一添加后验属性  
  278.         for (Node p : parentNodes) {  
  279.             value = queryParam.get(p.name);  
  280.             attrValue = new String[2];  
  281.             attrValue[0] = p.name;  
  282.             attrValue[1] = value;  
  283.   
  284.             backAttrInfos.add(attrValue);  
  285.         }  
  286.   
  287.         pro = queryConditionPro(priorAttrInfos, backAttrInfos);  
  288.   
  289.         return pro;  
  290.     }  
  291.   
  292.     /** 
  293.      * 查询条件概率 
  294.      *  
  295.      * @param attrValues 
  296.      *            条件属性值 
  297.      * @return 
  298.      */  
  299.     private double queryConditionPro(ArrayList<String[]> priorValues,  
  300.             ArrayList<String[]> backValues) {  
  301.         // 判断是否满足先验属性值条件  
  302.         boolean hasPrior;  
  303.         // 判断是否满足后验属性值条件  
  304.         boolean hasBack;  
  305.         int attrIndex;  
  306.         double backPro;  
  307.         double totalPro;  
  308.         double pro;  
  309.         String[] tempData;  
  310.   
  311.         pro = 0;  
  312.         totalPro = 0;  
  313.         backPro = 0;  
  314.   
  315.         // 跳过第一行的属性名称行  
  316.         for (int i = 1; i < this.totalDatas.size(); i++) {  
  317.             tempData = this.totalDatas.get(i);  
  318.   
  319.             hasPrior = true;  
  320.             hasBack = true;  
  321.   
  322.             // 判断是否满足先验条件  
  323.             for (String[] array : priorValues) {  
  324.                 attrIndex = this.attr2Column.get(array[0]);  
  325.   
  326.                 // 判断值是否满足条件  
  327.                 if (!tempData[attrIndex].equals(array[1])) {  
  328.                     hasPrior = false;  
  329.                     break;  
  330.                 }  
  331.             }  
  332.   
  333.             // 判断是否满足后验条件  
  334.             for (String[] array : backValues) {  
  335.                 attrIndex = this.attr2Column.get(array[0]);  
  336.   
  337.                 // 判断值是否满足条件  
  338.                 if (!tempData[attrIndex].equals(array[1])) {  
  339.                     hasBack = false;  
  340.                     break;  
  341.                 }  
  342.             }  
  343.   
  344.             // 进行计数统计,分别计算满足后验属性的值和同时满足条件的个数  
  345.             if (hasBack) {  
  346.                 backPro++;  
  347.                 if (hasPrior) {  
  348.                     totalPro++;  
  349.                 }  
  350.             } else if (hasPrior && backValues.size() == 0) {  
  351.                 // 如果只有先验概率则为纯概率的计算  
  352.                 totalPro++;  
  353.                 backPro = 1.0;  
  354.             }  
  355.         }  
  356.   
  357.         if (backPro == 0) {  
  358.             pro = 0;  
  359.         } else {  
  360.             // 计算总的概率=都发生概率/只发生后验条件的时间概率  
  361.             pro = totalPro / backPro;  
  362.         }  
  363.   
  364.         return pro;  
  365.     }  
  366.   
  367.     /** 
  368.      * 输入查询条件参数,计算发生概率 
  369.      *  
  370.      * @param queryParam 
  371.      *            条件参数 
  372.      * @return 
  373.      */  
  374.     public double calHappenedPro(String queryParam) {  
  375.         double result;  
  376.         double temp;  
  377.         // 分类属性值  
  378.         String classAttrValue;  
  379.         String[] array;  
  380.         String[] array2;  
  381.         HashMap<String, String> params;  
  382.   
  383.         result = 1;  
  384.         params = new HashMap<>();  
  385.   
  386.         // 进行查询字符的参数分解  
  387.         array = queryParam.split(",");  
  388.         for (String s : array) {  
  389.             array2 = s.split("=");  
  390.             params.put(array2[0], array2[1]);  
  391.         }  
  392.   
  393.         classAttrValue = params.get(classAttrName);  
  394.         // 构建贝叶斯网络结构  
  395.         constructBayesNetWork(classAttrValue);  
  396.   
  397.         for (Node n : this.totalNodes) {  
  398.             temp = calConditionPro(n, params);  
  399.   
  400.             // 为了避免出现条件概率为0的现象,进行轻微矫正  
  401.             if (temp == 0) {  
  402.                 temp = 0.001;  
  403.             }  
  404.   
  405.             // 按照联合概率公式,进行乘积运算  
  406.             result *= temp;  
  407.         }  
  408.   
  409.         return result;  
  410.     }  
  411.   
  412.     /** 
  413.      * 构建树型贝叶斯网络结构 
  414.      *  
  415.      * @param value 
  416.      *            类别量值 
  417.      */  
  418.     private void constructBayesNetWork(String value) {  
  419.         Node rootNode;  
  420.         ArrayList<AttrMutualInfo> mInfoArray;  
  421.         // 互信息度对  
  422.         ArrayList<Node[]> iArray;  
  423.   
  424.         iArray = null;  
  425.         rootNode = null;  
  426.   
  427.         // 在每次重新构建贝叶斯网络结构的时候,清空原有的连接结构  
  428.         for (Node n : this.totalNodes) {  
  429.             n.connectedNodes.clear();  
  430.         }  
  431.         this.edges = new int[attrNum][attrNum];  
  432.   
  433.         // 从互信息对象中取出属性值对  
  434.         iArray = new ArrayList<>();  
  435.         mInfoArray = calAttrMutualInfoArray(value);  
  436.         for (AttrMutualInfo v : mInfoArray) {  
  437.             iArray.add(v.nodeArray);  
  438.         }  
  439.   
  440.         // 构建最大权重跨度树  
  441.         rootNode = constructWeightTree(iArray);  
  442.         // 为无向图确定边的方向  
  443.         confirmGraphDirection(rootNode);  
  444.         // 为每个属性节点添加分类属性父节点  
  445.         addParentNode();  
  446.     }  
  447.   
  448.     /** 
  449.      * 给定分类变量值,计算属性之间的互信息值 
  450.      *  
  451.      * @param value 
  452.      *            分类变量值 
  453.      * @return 
  454.      */  
  455.     private ArrayList<AttrMutualInfo> calAttrMutualInfoArray(String value) {  
  456.         double iValue;  
  457.         Node node1;  
  458.         Node node2;  
  459.         AttrMutualInfo mInfo;  
  460.         ArrayList<AttrMutualInfo> mInfoArray;  
  461.   
  462.         mInfoArray = new ArrayList<>();  
  463.   
  464.         for (int i = 0; i < this.totalNodes.size() - 1; i++) {  
  465.             node1 = this.totalNodes.get(i);  
  466.             // 跳过分类属性节点  
  467.             if (node1.id == 0) {  
  468.                 continue;  
  469.             }  
  470.   
  471.             for (int j = i + 1; j < this.totalNodes.size(); j++) {  
  472.                 node2 = this.totalNodes.get(j);  
  473.                 // 跳过分类属性节点  
  474.                 if (node2.id == 0) {  
  475.                     continue;  
  476.                 }  
  477.   
  478.                 // 计算2个属性节点之间的互信息值  
  479.                 iValue = calMutualInfoValue(node1, node2, value);  
  480.                 mInfo = new AttrMutualInfo(iValue, node1, node2);  
  481.                 mInfoArray.add(mInfo);  
  482.             }  
  483.         }  
  484.   
  485.         // 将结果进行降序排列,让互信息值高的优先用于构建树  
  486.         Collections.sort(mInfoArray);  
  487.   
  488.         return mInfoArray;  
  489.     }  
  490.   
  491.     /** 
  492.      * 计算2个属性节点的互信息值 
  493.      *  
  494.      * @param node1 
  495.      *            节点1 
  496.      * @param node2 
  497.      *            节点2 
  498.      * @param vlaue 
  499.      *            分类变量值 
  500.      */  
  501.     private double calMutualInfoValue(Node node1, Node node2, String value) {  
  502.         double iValue;  
  503.         double temp;  
  504.         // 三种不同条件的后验概率  
  505.         double pXiXj;  
  506.         double pXi;  
  507.         double pXj;  
  508.         String[] array1;  
  509.         String[] array2;  
  510.         ArrayList<String> attrValues1;  
  511.         ArrayList<String> attrValues2;  
  512.         ArrayList<String[]> priorValues;  
  513.         // 后验概率,在这里就是类变量值  
  514.         ArrayList<String[]> backValues;  
  515.   
  516.         array1 = new String[2];  
  517.         array2 = new String[2];  
  518.         priorValues = new ArrayList<>();  
  519.         backValues = new ArrayList<>();  
  520.   
  521.         iValue = 0;  
  522.         array1[0] = classAttrName;  
  523.         array1[1] = value;  
  524.         // 后验属性都是类属性  
  525.         backValues.add(array1);  
  526.   
  527.         // 获取节点属性的属性值集合  
  528.         attrValues1 = this.attr2Values.get(node1.name);  
  529.         attrValues2 = this.attr2Values.get(node2.name);  
  530.   
  531.         for (String v1 : attrValues1) {  
  532.             for (String v2 : attrValues2) {  
  533.                 priorValues.clear();  
  534.   
  535.                 array1 = new String[2];  
  536.                 array1[0] = node1.name;  
  537.                 array1[1] = v1;  
  538.                 priorValues.add(array1);  
  539.   
  540.                 array2 = new String[2];  
  541.                 array2[0] = node2.name;  
  542.                 array2[1] = v2;  
  543.                 priorValues.add(array2);  
  544.   
  545.                 // 计算3种条件下的概率  
  546.                 pXiXj = queryConditionPro(priorValues, backValues);  
  547.   
  548.                 priorValues.clear();  
  549.                 priorValues.add(array1);  
  550.                 pXi = queryConditionPro(priorValues, backValues);  
  551.   
  552.                 priorValues.clear();  
  553.                 priorValues.add(array2);  
  554.                 pXj = queryConditionPro(priorValues, backValues);  
  555.   
  556.                 // 如果出现其中一个计数概率为0,则直接赋值为0处理  
  557.                 if (pXiXj == 0 || pXi == 0 || pXj == 0) {  
  558.                     temp = 0;  
  559.                 } else {  
  560.                     // 利用公式计算针对此属性值对组合的概率  
  561.                     temp = pXiXj * Math.log(pXiXj / (pXi * pXj)) / Math.log(2);  
  562.                 }  
  563.   
  564.                 // 进行和属性值对组合的累加即为整个属性的互信息值  
  565.                 iValue += temp;  
  566.             }  
  567.         }  
  568.   
  569.         return iValue;  
  570.     }  
  571. }  

场景测试类client.java:

 

 

[java] view plain copy

 print?

  1. package DataMining_TAN;  
  2.   
  3. /** 
  4.  * TAN树型朴素贝叶斯算法 
  5.  *  
  6.  * @author lyq 
  7.  *  
  8.  */  
  9. public class Client {  
  10.     public static void main(String[] args) {  
  11.         String filePath = "C:\\Users\\lyq\\Desktop\\icon\\input.txt";  
  12.         // 条件查询语句  
  13.         String queryStr;  
  14.         // 分类结果概率1  
  15.         double classResult1;  
  16.         // 分类结果概率2  
  17.         double classResult2;  
  18.   
  19.         TANTool tool = new TANTool(filePath);  
  20.         queryStr = "OutLook=Sunny,Temperature=Hot,Humidity=High,Wind=Weak,PlayTennis=No";  
  21.         classResult1 = tool.calHappenedPro(queryStr);  
  22.   
  23.         queryStr = "OutLook=Sunny,Temperature=Hot,Humidity=High,Wind=Weak,PlayTennis=Yes";  
  24.         classResult2 = tool.calHappenedPro(queryStr);  
  25.   
  26.         System.out.println(String.format("类别为%s所求得的概率为%s", "PlayTennis=No",  
  27.                 classResult1));  
  28.         System.out.println(String.format("类别为%s所求得的概率为%s", "PlayTennis=Yes",  
  29.                 classResult2));  
  30.         if (classResult1 > classResult2) {  
  31.             System.out.println("分类类别为PlayTennis=No");  
  32.         } else {  
  33.             System.out.println("分类类别为PlayTennis=Yes");  
  34.         }  
  35.     }  
  36. }  

结果输出:

 

 

[java] view plain copy

 print?

  1. 类别为PlayTennis=No所求得的概率为0.09523809523809525  
  2. 类别为PlayTennis=Yes所求得的概率为3.571428571428571E-5  
  3. 分类类别为PlayTennis=No  

本文转载自:http://blog.csdn.net/Androidlushangderen/article/details/46763427

一贱书生
粉丝 19
博文 724
码字总数 600123
作品 0
私信 提问
Python · 朴素贝叶斯(三)· GaussianNB

(这里是本章会用到的 GitHub 地址) (话说居然一个月没写了啊……)(然而你一个月没写之后写的东西还这么水对得起观众老爷吗) (刚发现算法叙述居然在这篇文章中说过了…… ( σ'ω')σ)...

射命丸咲
2017/04/20
0
0
统计学习方法第四章:朴素贝叶斯法(naive Bayes),贝叶斯估计及python实现

统计学习方法第二章:感知机(perceptron)算法及python实现 统计学习方法第三章:k近邻法(k-NN),kd树及python实现 统计学习方法第四章:朴素贝叶斯法(naive Bayes),贝叶斯估计及python实现 ...

无限大的饿
02/17
0
0
机器学习 西瓜书 Day07 贝叶斯分类器(上)

p147- p156 今天来看第七章。同时,今天心情不错:) 2018.5.16 凌晨0:51 不行了不行了,这一章感觉比SVM还烧脑,困了困了:( 所以这一章分两天看吧。 明天补上今天少看的6页 第七章 贝叶斯分...

皇家马德里主教练齐达内
2018/05/16
0
0
统计学习方法 | 朴素贝叶斯法

01 分类方法 之前我们学习了一种分类方法——K近邻法(KNN),今天我们再学习一种更常用的分类方法 朴素贝叶斯法 这里,我们先区分一下“分类”和“聚类” 分类的目的是学会一个分类函数或分类...

邓莎
2018/05/23
0
0
【人工智能】贝叶斯网络之MATLAB实验

1、贝叶斯网络基础 首先复习一下贝页斯公式 例题:分别有 A、B 两个容器,在容器 A 里分别有 7 个红球和 3 个白球,在容器 B 里有 1 个红球和 9 个白球,现已知从这两个容器里任意抽出了一个...

realsa
2014/11/12
0
5

没有更多内容

加载失败,请刷新页面

加载更多

GatewayWorker 报错:stream_socket_server(): unable to connect to tcp://0.0.0.0:1238

GatewayWorker 报错:stream_socket_server(): unable to connect to tcp://0.0.0.0:1238 (Address already in use) 官方文档虽然有相同的问题,但是对我的问题没起作用…… 后面发现自己手贱...

wenzhizhong
昨天
2
0
REST接口

文章来源 https://zhuanlan.zhihu.com/p/28674721?group_id=886181549958119424 http://www.ruanyifeng.com/blog/2014/05/restful_api.html REST 对请求的约定 REST 用来规范应用如何在 HTTP......

Airship
昨天
4
0
Spring Cloud Config 统一配置中心

Spring Cloud Config 统一配置中心 一、统一配置中心 统一管理配置 通常,我们会使用配置文件来管理应用的配置。如一个 Spring Boot 的应用,可以将配置信息放在 application.yml 文件中,如...

非摩尔根
昨天
3
0
android ------ AAPT2 error: check logs for details解决方法

AAPT 是全称是 Android Asset Packaging Tool,它是构建 App,甚至是构建 Android 系统都必不可少的一个工具。它的作用是将所有资源文件压缩打包到Android APK 当中。我们在 Android SDK 目录...

切切歆语
昨天
3
0
今天的学习

今天学到了<select></select>标签: <label for="unittype">Select unit type: </label><select id="unittype" name="unittype" autofocus > <option value="1"> Miner </option> ......

墨冥
昨天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部