贝叶斯分类器

最新推荐文章于 2023-11-20 18:04:54 发布

刘彦佐

最新推荐文章于 2023-11-20 18:04:54 发布

阅读量291

点赞数 1

分类专栏：数据挖掘文章标签：贝叶斯分类器

本文链接：https://blog.csdn.net/u012562931/article/details/54802194

版权

数据挖掘专栏收录该内容

1 篇文章 0 订阅

订阅专栏

贝叶斯

贝叶斯公式：

$P(A|C)=\displaystyle\frac{P(C|A)P(A)}{P(C)}$
事件A在事件C发生的概率为事件C在A发生下的概率乘以事件A发生的概率，最后除上事件C发生的概率

经典场景

射击问题

A,B两人射击，A有50%的概率命中，B有60%概率命中，已知目标被命中，求分别为A、B的概率。

令目标被命中事件为C，则有：
由求贝叶斯公式可得：
$P(C)=0.5*0.6+0.5*0.6+0.5*0.4=0.8$

$P(A|C)=\displaystyle\frac{P(C|A)P(A)}{P(C)}=\displaystyle\frac{5}{8}$

同理可得 $P(B|C)=\displaystyle\frac{3}{4}$

医疗检测

已知条件如下：
1. 人口统计先验有：
得癌症的概率： $P(\omega_1)=0.008$
不得癌症概率： $P(\omega_2)=0.992$
2. 医疗检测中：
阳性：
$P(+|\omega_1)=0.98$
$P(+|\omega_2)=0.02$
阴性：
$P(-|\omega_2)=0.97$
$P(-|\omega_1)=0.03$
那么当一次检测为阳性时，得癌症的概率有多大？
$P(+)=P(\omega_1)*P(+|\omega_1)+P(\omega_2)*P(+|\omega_2)=0.1948$
$P(\omega_1|+)=\displaystyle\frac{P(+|\omega_1)P(\omega_1)}{P(+)}=0.28$
当第二次检测为阳性时，得癌症的概率为多少？
这里的计算过程不变，但是先验概率 $P(\omega_1)$ 改变了，为0.28，所以要重新计算 $P(+)$

用贝叶斯做分类

推导过程

1.开始公式

$\omega_{map}=\underset{\displaystyle\omega_i\in\omega}{argmax}P(\omega_i|a_1,a_2,a_3..a_n)$
其中， $a_i$ 为其中的属性。整个公式的解释是：这条数据的最终类别是 $\omega_i$ 在条件 ${a_$ 的概率最大的那个分类

2.用贝叶斯公式

$\omega_{map}=\underset{\displaystyle\omega_i\in\omega}{argmax}\displaystyle\frac{P(a_1,a_2...a_n|\omega_i)P(\omega_i)}{P(a_1,a_2...a_n)}$

3.化简

去掉 $P(a_1,a_2...a_n)$ ，因为每个都一样
其中 $P(\omega_i)$ 是可以从训练集中统计出来的先验概率

4.引入独立条件

$P(a_1,a_2...a_n|\omega_i)=P(a_1|\omega_i)P(a_2|\omega_i)...P(a_n|\omega_i)$

5.最终可得到公式

$\omega_{map}=\underset{\displaystyle\omega_i\in\omega}{argmax}P(\omega_i)\underset{j}{\prod}P(a_j|\omega_i)$
输入数据就是 $a_j$ ，也就是各个属性的值
在数据集中可以获得的数据有：
1. $P(\omega_i)=\displaystyle\frac{每个分类数量}{总数}$
2. $P(a_j|\omega_i)=\displaystyle\frac{\omega_i中a_j的数量}{\omega_i总数}$

决策树

ID3

熵

定义：
$Entropy(S)=\displaystyle-\sum_{i=1}^cp_ilog(p_i)$
解释：
1. S是最后的标签属性，取值范围为c
2. $p_i=\displaystyle\frac{标签为i的数据数}{总数据数}$

信息增益

在上节中，只是计算了当前集合的总体熵，信息增益=总体熵-(用标签外的属性X来划分之后的熵)
$Gain(S,X)=Entropy(S)-Entropy(S|X)$
$Entropy(S|X)=\displaystyle\sum_{v\in X}\frac{|S_v|}{|S|}Entropy(S_v)$
$Entropy(S_v)=\displaystyle-\sum_{i=1}^cp_ilog(p_i)$ 这个样本公式的 $S_v$ 代表属性 $X=v$ 的所有属性局
例子：

id	是否抽烟	头发长度	鞋码	性别（男\|女）
1	false	100	mid	女
2	true	100	small	女
3	true	10	big	男
4	false	20	mid	男
5	true	30	mid	女
6	true	70	big	男
7	false	100	small	女
8	false	50	small	女

1. 总体熵:
$p(男)=3/8$
$p(女)=5/8$
$Entropy(性别)=-p(男)*log_2p(男)-p(女)*log_2p(女)=0.96$
2. 计算 $Entropy(性别|抽烟=true)$ :
$p(性别=男|抽烟=true)=0.5$
$p(性别=女|抽烟=true)=0.5$
$Entropy(性别|抽烟=true)=1.0$
3. 计算 $Entropy(性别|抽烟=false)$
$p(性别=男|抽烟=false)=1/4$
$p(性别=女|抽烟=false)=3/4$
$Entropy(性别|抽烟=false)=-\displaystyle\frac{1}{4}*log_2\frac{1}{4}-\frac{3}{4}*log_2\frac{3}{4}=0.81$
4. 计算 $Entropy(性别|抽烟)$
$p(抽烟=true)=0.5$
$p(抽烟=false)=0.5$
$Entropy(性别|抽烟)=0.5*1.0+0.5*0.81=0.905$
5. 信息增益
$Gain(性别,抽烟)=0.96-0.905=0.095$

利用信息熵

分别计算各个属性的信息增益，去最大的那个属性作为节点label

过拟合

两个分类器A、B，A在训练集中的效果比B好，但是在测试集中比B差，我们说A过拟合。

限制决策树高度

剪枝

将两个叶子节点，合并后，按照少数服从多数得出label
需要增设一个校验集，用于剪枝过程中的误差比较。
当剪枝进行到在校验集上误差由减小到增大的拐点时，停止剪枝

处理连续性数据

采用信息增益衡量按照进行对阈值切分点后的数据集的纯度，采用信息增益比较大的。

贝叶斯分类器实现

package com.liuyanzuo.datamining.classification;

import java.util.*;

/**
 * 朴素贝叶斯分类器实现
 * Created by tempuser on 2017/1/19.
 */
public class NaiveBayesClassification {
    //定义常量
    public static final String NOT_DEFINE_ATTR="not build the attributeList";
    public static final String SUCCESS="success";


    //定义存储类别信息的结构
    private Map<String,Map<String,Map<String,Integer>>> statisticsMsg;
    //定义属性名称集合
    private List<String> attributeList;
    //每个label的数量统计
    private Map<String,Integer> labelCountMap;
    //每个属性可取值的范围
    private Map<String,List<String>> attrValue;
    //每个label的每个属性的百分比统计
    private Map<String,Map<String,Map<String,Double>>> labelAttrPercentMap;
    //label在属性的下标
    private int labelIndex;
    //数据的总数量
    private int totalCount;

    /**
     * 构造分类器
     * @param data
     * @param labelIndex
     */
    public String build(List<List<String>> data,int labelIndex){
        if(null==attributeList || "".equals(attributeList)){
            return NOT_DEFINE_ATTR;
        }
        this.labelIndex=labelIndex;
        //初始化各个属性
        statisticsMsg=new HashMap<>();
        labelCountMap=new HashMap<>();
        attrValue=new HashMap<>();


        for(List<String> attributeLabelList : data){
            //这行数据的标签
            String label=attributeLabelList.get(labelIndex);
            //统计这行数据的label
            Integer labelPercentValue=labelCountMap.get(label);
            if(labelPercentValue==null){
                labelPercentValue=0;
            }
            labelPercentValue++;
            labelCountMap.put(label,labelPercentValue);
            totalCount++;

            Map<String,Map<String,Integer>> labelMap= statisticsMsg.get(label);
            if(null == labelMap){
                labelMap=new HashMap<>();
                statisticsMsg.put(label,labelMap);
            }

            for(int i=0;i<attributeLabelList.size();i++){
                if(i != labelIndex){
                    //现在所在下标的属性名称
                    String attributeName=attributeList.get(i);
                    //现在所在下标的属性值
                    String attributeValue=attributeLabelList.get(i);
                    //统计属性的取值范围
                    List<String> attrValueList=attrValue.get(attributeName);
                    if(attrValueList==null){
                        attrValueList=new ArrayList<>();
                    }
                    if(!attrValueList.contains(attributeValue)){
                        attrValueList.add(attributeValue);
                    }
                    attrValue.put(attributeName,attrValueList);

                    Map<String,Integer> attributeMap=labelMap.get(attributeName);
                    if( null == attributeMap){
                        attributeMap=new HashMap<>();
                        labelMap.put(attributeList.get(i),attributeMap);
                    }
                    Integer attributeCountValue=attributeMap.get(attributeValue);
                    if(null==attributeCountValue){
                        attributeCountValue=0;
                    }
                    attributeCountValue++;
                    attributeMap.put(attributeValue,attributeCountValue);
                }
            }
        }
        labelAttrPercentMap=new HashMap<>();
        //统计label百分比
        Set<String> labelSet=statisticsMsg.keySet();
        for(String label:labelSet){
            //这个label的总长度
            int labelCount=labelCountMap.get(label);
            Map<String,Map<String,Integer>> statisticsLabelAttrMap=statisticsMsg.get(label);
            //统计每个label下的各个属性的各个取值的数量
            Map<String,Map<String,Double>> percentValue=new HashMap<>();
            Set<String> attrSet=statisticsLabelAttrMap.keySet();
            for(String attribute:attrSet){
                Map<String,Integer> attributeValueMap=statisticsLabelAttrMap.get(attribute);
                Set<String> attributeValueSet=attributeValueMap.keySet();
                Map<String,Double> percentAttributeValueMap=new HashMap<>();
                for(String attributeValue:attributeValueSet){
                    //最终属性取值的百分比
                    percentAttributeValueMap.put(attributeValue,attributeValueMap.get(attributeValue)/(labelCount*1.0));
                }
                percentValue.put(attribute,percentAttributeValueMap);
            }
            labelAttrPercentMap.put(label,percentValue);
        }
        return SUCCESS;
    }

    /**
     * 对传入数据进行分类
     * @param needClassify
     */
    public Map<String,Double> classify(List<String> needClassify){
        Map<String,Double> result=new HashMap<>();
        if(null == statisticsMsg || statisticsMsg.size()==0){
            return result;
        }
        for(String label:labelCountMap.keySet()){
            double prediction=1.0;
            for(int i=0;i<attributeList.size();i++){
                //当前属性名称
                String attrName=attributeList.get(i);

                if(i != labelIndex){
                    //要做一个laplace平滑
                    Integer labelAttrPercentValue=statisticsMsg.get(label).get(attributeList.get(i)).get(needClassify.get(i));
                    if(labelAttrPercentValue==null){
                        labelAttrPercentValue=0;
                    }
                    prediction*=(labelAttrPercentValue+1.0)/(attrValue.get(attrName).size()*1.0+labelCountMap.get(label)*1.0);
                }
            }
            result.put(label,prediction);
        }
        return result;
    }
    public Map<String, Map<String, Map<String, Integer>>> getStatisticsMsg() {
        return statisticsMsg;
    }

    public void setStatisticsMsg(Map<String, Map<String, Map<String, Integer>>> statisticsMsg) {
        this.statisticsMsg = statisticsMsg;
    }
    public List<String> getAttributeList() {
        return attributeList;
    }

    public void setAttributeList(List<String> attributeList) {
        this.attributeList = attributeList;
    }

    public Map<String, Integer> getLabelCountMap() {
        return labelCountMap;
    }

    public Map<String, Map<String, Map<String, Double>>> getLabelAttrPercentMap() {
        return labelAttrPercentMap;
    }

    public void setLabelAttrPercentMap(Map<String, Map<String, Map<String, Double>>> labelAttrPercentMap) {
        this.labelAttrPercentMap = labelAttrPercentMap;
    }
}

刘彦佐

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
贝叶斯分类器

贝叶斯贝叶斯公式：P(A|C)=P(C|A)P(A)P(C)P(A|C)=\displaystyle\frac{P(C|A)P(A)}{P(C)} 事件A在事件C发生的概率为事件C在A发生下的概率乘以事件A发生的概率，最后除上事件C发生的概率经典场景射击问题A,B两人射击，A有50%的概率命中，B有60%概率命中，已知目标被命中，求分别为A、B的概率。令目标被命中事件为C，则有：由求
复制链接

扫一扫

专栏目录