资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/javascript实现朴素贝叶斯分类与决策树ID3分类

javascript实现朴素贝叶斯分类与决策树ID3分类

ernest.wang / 1782人阅读

摘要：根据这个训练集，运用朴素贝叶斯分类和决策树分类则可以得到一个数据模型，然后通过输入一条测试数据来判断是否回去打网球。一朴素贝叶斯分类大学概率论的贝叶斯定理实现了通过计算概率求出假设推理的结论。

今年毕业时的毕设是有关大数据及机器学习的题目。因为那个时间已经步入前端的行业自然选择使用JavaScript来实现其中具体的算法。虽然JavaScript不是做大数据处理的最佳语言，相比还没有优势，但是这提升了自己对与js的理解以及弥补了一点点关于数据结构的弱点。对机器学习感兴趣的朋友还是去用 python，最终还是在学校的死板论文格式要求之外，记录一下实现的过程和我自己对于算法的理解。
源码在github：https://github.com/abzerolee/...
开始学习机器学习算法是通过 Tom M. Mitchel. Machine Learning[M] 1994 一书。喜欢研究机器学习的朋友入门可以看看这本。接下来叙述的也仅仅是个人对于算法的浅薄理解与实现，只是针对没有接触过机器学习的朋友看个乐呵，自己总结记忆一下。当然能引起大家对机器学习算法的研究热情是最好不过的了。

算法原理

实现过程其实是 对训练集合（已知分类）的数据进行分析解析得到一个分类模型，通过输入一条测试数据（未知分类），分类模型可以推断出该条数据的分类结果。训练数据如下图所示

这个数据集合意思为天气状况决定是否要最终去打网球 一个数组代表一条天气情况与对应结果。前四列代表数据的特征属性（天气，温度，湿度，是否刮风），最后一列代表分类结果。根据这个训练集，运用朴素贝叶斯分类和决策树ID3分类则可以得到一个数据模型，然后通过输入一条测试数据：“sunny cool high TRUE” 来判断是否回去打网球。相似的只要特征属性保持一定且有对应的分类结果，不论训练集为什么样的数据，都可以通过特征属性得到分类结果。所谓分类模型，就是通过一些概率论，统计学的理论基础，用编程语言实现。下面简单介绍一下两种算法原理。

一.朴素贝叶斯分类

大学概率论的贝叶斯定理实现了通过计算概率求出假设推理的结论。贝叶斯定理如下图所示：

E代表训练集合，r表示一个分类结果（即yes或no），P(E)是一个独立于分类结果r的常量，可以发现P(E)越大，P(r|E)受到训练集影响越小。
即可以得到为 P(r) => P(yes)=9/14，或者P(no)=5/14,
再求的条件概率 P(E|r) => P(wind=TRUE|yes)=3/9 P(wind=FALSE|no)=2/5
这样可以得到每个特征属性在分类结果情况下的条件概率。当输入一条测试数据时，通过计算这条数据特质属性值在某种分类假设的钱以下的条件概率，就可以得到对应的分类假设的概率，然后比较出最大值，称为极大似然假设，对应的分类结果就是测试数据的分类结果。
比如测试数据如上：sunny,cool,high,TRUE则对应的计算为：
P(yes)P(sunny|yes)P(high|yes)P(cool|yes)P(TRUE|yes) = P(yes|E)
P(no)P(sunny|no)P(high|no)P(cool|no)P(TRUE|no) = P(no|E)
推断出 no 。
这里推荐介绍贝叶斯文本分类的博客http://www.cnblogs.com/phinec...

二.决策树ID3分类法

决策树分类法更像是我们思考的过程：

测试数据和上文相同，在天气节点判断 则进入sunny分支 温度节点判断 进入high 分支则直接得出no的结果。
决策树在根据测试数据分类时浅显易懂，关键点在通过训练数据构建决策树，那相应的出现两个问题：
1.选择哪个特征属性作为根节点判断？
2.特征属性值对应的分支上的下一个属性节点如何来判断？
这两个问题可以总结为 如何判断最优测试属性？在信息论中，期望信息越小，那么信息增益就越大，从而纯度就越高。其实就是特征属性能够为最终的分类结果带来多少信息，带来的信息越多，该特征属性越重要。对一个属性而言，分类时它是否存在会导致分类信息量发生变化，而前后信息量的差值就是这个特征属性给分类带来的信息量。而信息量就是信息熵。信息熵表示每个离散的消息提供的平均信息量。
如上文中的例子：可以表示为

当选取了某个特征属性attr后的信息熵可以表示为

对应该属性的信息增益可以表示为

选择最适合树节点的特征属性，就是信息增益最大的属性。应该可以得到Gain(天气)=0.246
接下来是对该属性值分支的节点选取的判断，从训练集中找出满足该属性值的子集再次进行对于子集的每个属性的信息增益，比较。重复上述步骤，直到子集为空返回最普遍的分类结果。

上图为《Machine Learning》一书中对于ID3算法的介绍，下图为程序流程图

三.分类模型评估
分类模型的评估指标通过混淆矩阵来进行计算

P为样本数据中yes的数量，N为样本数据中no的数量，TP为正确预测yes的数量，FP为把yes预测为no的数量，FN为把yes预测为no的数量，TN为正确预测yes的数目。评估量度为
1.命中率：正确诊断确实患病的的概率 TP/P
2.虚警率：没有患病却诊断为患病概率。FP/N
分类模型的评估方法为交叉验证法与.632的平均抽样法，比如100条原始数据，对训练集有放回的随机抽样100次，并在每次抽样时标注抽取的次数 将大于63.2的数据作为训练集，小于的数据作为测试集，但是实际程序实现中可以样本偏离的太厉害我选择了44次作为标准。
这样将测试集的每一条数据输入，通过训练集得到的分类模型，得出测试数据的分类结果与真实分类进行比较。就可以得到混淆矩阵，最后根据混淆矩阵可以得到决策树与贝叶斯分类的命中率与虚警率。重复评估40次 则可以得到[命中率，虚警率]，以命中率为纵坐标，虚警率为横坐标描点可以得到ROC曲线，描出的点越靠近左上角代表分类模型越正确，直观的表现出来两种分类模型差异。我得到的描点图如下所示

从图中明显可以发现对于小样本的数据，决策树分类模型更为准确。

核心代码

朴素贝叶斯分类法

</>复制代码 
  1. const HashMap = require("./HashMap");
  2. function Bayes($data){
  3.   this._DATA = $data;
  4. }
  5. Bayes.prototype = {
  6.   /**
  7.    * 将训练数据单条数据按类别分类
  8.    * @return HashMap<类别，对用类别的训练数据>
  9.    */
  10.   dataOfClass: function() {
  11.     var map = new HashMap();
  12.     var t = [], c = "";
  13.     var datas = this._DATA;
  14.     if(!(datas instanceof Array)) return;
  15.     for(var i = 0; i < datas.length; i++){
  16.       t = datas[i];
  17.       c = t[t.length - 1];
  18.       if(map.hasKey(c)){
  19.         var ot = map.get(c);
  20.         ot.push(t);
  21.         map.put(c, ot);
  22.       }else{
  23.         var nt = [];
  24.         nt.push(t);
  25.         map.put(c, nt);
  26.       }
  27.     }
  28.     return map;
  29.   },
  30.   /**
  31.    * 预测测试数据的类别
  32.    * @param Array testT 测试数据
  33.    * @return String 测试数据对应类别
  34.    */
  35.   predictClass: function(testT){
  36.     var doc = this.dataOfClass();
  37.     var maxP = 0, maxPIndex = -1;
  38.     var classes = doc.keys();
  39.     for(var i = 0; i < classes.length; i++){
  40.       var c = classes[i]
  41.       var d = doc.get(c);
  42.       var pOfC = d.length / this._DATA.length;
  43.       for(var j = 0; j < testT.length; j++){
  44.         var pv = this.pOfV(d, testT[j], j);
  45.         pOfC = pOfC * pv;
  46.       }
  47.       if(pOfC > maxP){
  48.         maxP = pOfC;
  49.         maxPIndex = i;
  50.       }
  51.     }
  52.     if(maxPIndex === -1 || maxPIndex > doc.length){
  53.       return "无法分类";
  54.     }
  55.     return classes[maxPIndex];
  56.   },
  57.   /**
  58.    * 计算指定属性在训练数据中指定值出现的条件概率
  59.    * @param d     属于某一类的训练元组
  60.    * @param value 指定属性
  61.    * @param index 指定属性所在列
  62.    * @return 特征属性在某类别下的条件概率
  63.    */
  64.   pOfV: function(d, value, index){
  65.     var p = 0, count = 0, total = d.length, t = [];
  66.     for(var i = 0; i < total; i++){
  67.       if(d[i][index] === value)
  68.         count++;
  69.     }
  70.     p = count / total;
  71.     return p;
  72.   } 
  73. }
  74. module.exports = Bayes;

2.决策树ID3分类法

</>复制代码 
  1. const HashMap = require("./HashMap");
  2. const $data = require("./data");
  3. const TreeNode = require("./TreeNode");
  4. const InfoGain = require("./InfoGain");
  5. function Iterator(arr){
  6.   if(!(arr instanceof Array)){
  7.     throw new Error("iterator needs a arguments that type is Array!");
  8.   }
  9.   this.arr = arr;
  10.   this.length = arr.length;
  11.   this.index = 0;
  12. }
  13. Iterator.prototype.current = function() {
  14.   return this.arr[this.index-1];
  15. }
  16. Iterator.prototype.next = function(){
  17.   this.index += 1;
  18.   if(this.index > this.length || this.arr[this.index-1] === null)
  19.     return false;
  20.   return true;
  21. }
  22. function DecisionTree(data, attribute) {
  23.   if(!(data instanceof Array) || !(attribute instanceof Array)){
  24.     throw new Error("argument needs Array!");
  25.   }
  26.   this._data = data;
  27.   this._attr = attribute;
  28.   this._node = this.createDT(this._data,this._attr);
  29. }
  30. DecisionTree.prototype.createDT = function(data, attrList) {
  31.   var node = new TreeNode();
  32.   var resultMap = this.isPure(this.getTarget(data));
  33.   
  34.   if(resultMap.size() === 1){
  35.     node.setType("result");
  36.     node.setName(resultMap.keys()[0]);
  37.     node.setVals(resultMap.keys()[0]);
  38.     // console.log("单节点树：" + node.getVals());
  39.     return node;
  40.   }
  41.   if(attrList.length === 0){
  42.     var max = this.getMaxVal(resultMap);
  43.     node.setType("result");
  44.     node.setName(max)
  45.     node.setVals(max);
  46.     // console.log("最普遍性结果："+ max);
  47.     return node;
  48.   }
  49.   var maxGain = this.getMaxGain(data, attrList).maxGain;
  50.   var attrIndex = this.getMaxGain(data, attrList).attrIndex
  51.   // console.log("选出的最大增益率属性为："+ attrList[attrIndex]);
  52.   // console.log("创建节点："+attrList[attrIndex])
  53.   node.setName(attrList[attrIndex]);
  54.   node.setType("attribute");
  55.   var remainAttr = new Array();
  56.   remainAttr = attrList;
  57.   // remainAttr.splice(attrIndex, 1);
  58.   var self = this;
  59.   var gain = new InfoGain(data, attrList)
  60.   var attrValueMap = gain.getAttrValue(attrIndex); //最好分类的属性的值MAP
  61.   var possibleValues = attrValueMap.keys();
  62.   
  63.   node_vals = possibleValues.map(function(v) {
  64.     // console.log("创建分支："+v);
  65.     var newData = data.filter(function(x) {
  66.       return x[attrIndex] === v;
  67.     });
  68.     // newData = newData.map(function(v) {
  69.     //   return v.slice(1);
  70.     // })
  71.     var child_node = new TreeNode(v, "feature_values");
  72.     var leafNode = self.createDT(newData, remainAttr);
  73.     child_node.setVals(leafNode);
  74.     return child_node;
  75.   })
  76.   node.setVals(node_vals);
  77.   this._node = node;
  78.   return node;
  79. }
  80. /**
  81.  * 判断训练数据纯度分类是否为一种分类或没有分类
  82.  */
  83. DecisionTree.prototype.getTarget = function(data){
  84.   var list = new Array();
  85.   var iter = new Iterator(data);
  86.   while(iter.next()){
  87.     var index = iter.current().length - 1;
  88.     var value = iter.current()[index];
  89.     list.push(value);
  90.   }
  91.   return list;
  92. },
  93. /**
  94.  * 获取分类结果数组，判断纯度
  95.  */
  96. DecisionTree.prototype.isPure = function(list) {
  97.   var map = new HashMap(), count = 1;
  98.   list.forEach(function(item) {
  99.     if(map.get(item)){
  100.       count++;
  101.     }
  102.     map.put(item, count);
  103.   });
  104.   return map;
  105. }
  106. /**
  107.  * 获取最大增益量属性
  108.  */
  109. DecisionTree.prototype.getMaxGain = function(data, attrList) {
  110.   var gain = new InfoGain(data, attrList);
  111.   var maxGain = 0;
  112.   var attrIndex = -1;
  113.   for(var i = 0; i < attrList.length; i++){
  114.     var temp = gain.getGainRaito(i);
  115.     if(maxGain < temp){
  116.       maxGain = temp;
  117.       attrIndex = i;
  118.     }
  119.   }
  120.   return {attrIndex: attrIndex, maxGain: maxGain};
  121. }
  122. /**
  123.  * 获取resultMap中值最大的key
  124.  */
  125. DecisionTree.prototype.getMaxVal = function(map){
  126.   var obj = map.obj, temp = 0, okey = "";
  127.   for(var key in obj){
  128.     if(temp < obj[key] && typeof obj[key] === "number"){
  129.       temp = obj[key];
  130.       okey = key;
  131.     };
  132.   }
  133.   return okey;
  134. }
  135. /**
  136.  * 预测属性
  137.  */
  138. DecisionTree.prototype.predictClass = function(sample){
  139.   var root = this._node;
  140.   var map = new HashMap();
  141.   var attrList = this._attr;
  142.   for(var i = 0; i < attrList.length; i++){
  143.     map.put(attrList[i], sample[i]);
  144.   }
  145.   while(root.type !== "result"){
  146.     if(root.name === undefined){
  147.       return root = "无法分类";
  148.     }
  149.     var attr = root.name;
  150.     var sample = map.get(attr);
  151.     var childNode = root.vals.filter(function(node) {
  152.       return node.name === sample;
  153.     });
  154.     if(childNode.length === 0){
  155.       return root = "无法分类";
  156.     }
  157.     root = childNode[0].vals; // 只遍历attribute节点
  158.   }
  159.   return root.vals;
  160. }
  161. module.exports = DecisionTree;

3.增益率计算

</>复制代码 
  1. function InfoGain(data, attr) {
  2.   if(!(data instanceof Array) || !(attr instanceof Array)){
  3.     throw new Error("arguments needs Array!");
  4.   }
  5.   this._data = data;
  6.   this._attr = attr;
  7. }
  8. InfoGain.prototype = {
  9.   /**
  10.    * 获取训练数据分类个数
  11.    * @return hashMap<类别, 该类别数量>
  12.    */
  13.   getTargetValue: function() {
  14.     var map = new HashMap();
  15.     var iter = new Iterator(this._data);
  16.     while(iter.next()){
  17.       var t = iter.current();
  18.       var key = t[t.length-1];
  19.       var value = map.get(key);
  20.       map.put(key, value !== undefined ? ++value : 1);
  21.     }
  22.     return map;
  23.   },
  24.   /**
  25.    * 获取训练数据信息熵
  26.    * @return 训练数据信息熵
  27.    */
  28.   getEntroy: function(){
  29.     var targetValueMap = this.getTargetValue();
  30.     var targetKey = targetValueMap.keys(), entroy = 0;
  31.     var self = this;
  32.     var iter = new Iterator(targetKey);
  33.     while(iter.next()){
  34.       var p = targetValueMap.get(iter.current()) / self._data.length;
  35.       entroy += (-1) * p * (Math.log(p) / Math.LN2);
  36.     }
  37.     return entroy;
  38.   },
  39.   /**
  40.    * 获取属性值在训练数据集中的数量
  41.    * @param number index 属性名数组索引
  42.    */
  43.   getAttrValue: function(index){
  44.     var map = new HashMap();
  45.     var iter = new Iterator(this._data);
  46.     while(iter.next()){
  47.       var t = iter.current();
  48.       var key = t[index];
  49.       var value = map.get(key);
  50.       map.put(key, value !== undefined ? ++value : 1);
  51.     }
  52.     return map;
  53.   },
  54.   /**
  55.    * 得到属性值在决策空间的比例
  56.    * @param string name 属性值
  57.    * @param number index 属性所在第几列
  58.    */
  59.   getAttrValueTargetValue: function(name, index){
  60.     var map = new HashMap();
  61.     var iter = new Iterator(this._data);
  62.     while(iter.next()){
  63.       var t = iter.current();
  64.       if(name === t[index]){
  65.         var size = t.length;
  66.         var key = t[t.length-1];
  67.         var value = map.get(key);
  68.         map.put(key, value !== undefined ? ++value : 1);
  69.       }
  70.     }
  71.     return map;
  72.   },
  73.   /**
  74.    * 获取特征属性作用于训练数据集后分类出的数据集的熵
  75.    * @param number index 属性名数组索引
  76.    */
  77.   getInfoAttr: function(index){
  78.     var attrValueMap = this.getAttrValue(index);
  79.     var infoA = 0;
  80.     var c = attrValueMap.keys();
  81.     for(var i = 0; i < attrValueMap.size(); i++){
  82.       var size = this._data.length;
  83.       var attrP = attrValueMap.get(c[i]) / size;
  84.       var targetValueMap = this.getAttrValueTargetValue(c[i], index);
  85.       var totalCount = 0 ,valueSum = 0;
  86.       for(var j = 0; j < targetValueMap.size(); j++){
  87.         totalCount += targetValueMap.get(targetValueMap.keys()[j]);
  88.       }
  89.       for(var k = 0; k < targetValueMap.size(); k++){
  90.         var p = targetValueMap.get(targetValueMap.keys()[k]) / totalCount;
  91.         valueSum += (Math.log(p) / Math.LN2) * p;
  92.       }
  93.       infoA += (-1) * attrP * valueSum;
  94.     }
  95.     return infoA;
  96.   },
  97.   /**
  98.    * 获得信息增益量
  99.    */
  100.   getGain: function(index) {
  101.     return this.getEntroy() - this.getInfoAttr(index);
  102.   },
  103.   getSplitInfo: function(index){
  104.     var map = this.getAttrValue(index);
  105.     var splitA = 0;
  106.     for(var i = 0; i < map.size(); i++){
  107.       var size = this._data.length;
  108.       var attrP = map.get(map.keys()[i]) / size;
  109.       splitA += (-1) * attrP * (Math.log(attrP) / Math.LN2);
  110.     }
  111.     return splitA;
  112.   },
  113.   /**
  114.    * 获得增益率
  115.    */
  116.   getGainRaito: function(index){
  117.     return this.getGain(index) / this.getSplitInfo(index);
  118.   },
  119.   getData4Value: function(attrValue, attrIndex){
  120.     var resultData = new Array();
  121.     var iter = new Iterator(this._data);
  122.     while(iter.next()){
  123.       var temp = iter.current();
  124.       if(temp[attrIndex] === attrValue){
  125.         resultData.push(temp);
  126.       }
  127.     }
  128.     return resultData;
  129.   }
  130. }

具体的程序实现我会再继续介绍的，待续。。。。
第一次在segmentfault发文章 有点紧张 各位有什么意见或者想法可以及时指正我。

GPU云服务器 云服务器 贝叶斯分类 朴素贝叶斯 朴素贝叶斯算法 php高斯朴素贝叶斯

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/84402.html

相关文章

  • 机器学习算法基础（使用Python代码）

    摘要：机器学习算法类型从广义上讲，有种类型的机器学习算法。强化学习的例子马尔可夫决策过程常用机器学习算法列表以下是常用机器学习算法的列表。我提供了对各种机器学习算法的高级理解以及运行它们的代码。决策树是一种监督学习算法，主要用于分类问题。 showImg(https://segmentfault.com/img/remote/1460000019086462); 介绍 谷歌的自动驾驶汽车和机...

    BenCHou 评论0 收藏0

  • 基于概率论的分类方法：朴素贝叶斯

    摘要：基于概率论的分类方法朴素贝叶斯概述贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。另外一种有效计算条件概率的方法称为贝叶斯准则。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。 基于概率论的分类方法：朴素贝叶斯 1. 概述 贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。本章首先介绍贝叶斯分类算法的基础—...

    LeviDing 评论0 收藏0

发表评论

登陆后可评论

0条评论

ernest.wang

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<