机器学习--朴素贝叶斯的分析与实现

最新推荐文章于 2024-08-06 11:08:19 发布
最新推荐文章于 2024-08-06 11:08:19 发布
阅读量2k 收藏
点赞数 2
分类专栏： c# 编程 Machine Learning
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lan_liang/article/details/51577964
版权

贝叶斯定理：
p(a|b) = p(b|a)*p(a)/p(b)
假设：时间a，b相互独立。


由于朴素贝叶斯基于贝叶斯定理，因此，在应用贝叶斯分类器时，所选的特征也应当是不相关的。


例：
训练数据： 四维向量数组，共15个元素。
 
inputs ={
    new int[] { 0, 1, 1, 0 }, //  c=0 
    new int[] { 0, 1, 0, 0 }, //  c=0
    new int[] { 0, 0, 1, 0 }, //  c=0
    new int[] { 0, 1, 1, 0 }, //  c=0
    new int[] { 0, 1, 0, 0 }, //  c=0
    new int[] { 1, 0, 0, 0 }, //  c=1
    new int[] { 1, 0, 0, 0 }, //  c=1
    new int[] { 1, 0, 0, 1 }, //  c=1
    new int[] { 0, 0, 0, 1 }, //  c=1
    new int[] { 0, 0, 0, 1 }, //  c=1
    new int[] { 1, 1, 1, 1 }, //  c=2
    new int[] { 1, 0, 1, 1 }, //  c=2
    new int[] { 1, 1, 0, 1 }, //  c=2
    new int[] { 0, 1, 1, 1 }, //  c=2
    new int[] { 1, 1, 1, 1 }, //  c=2
};



前5个分类为0，中间五个分类为1，后五个分类为2。


现在需要预测向量v{0,1,1,0}的分类。
即分别求: 
p(c=0, inputs[0]=0, inputs[1]=1, inputs[2]=1, inputs[3]=0)的概率
p(c=1, inputs[0]=0, inputs[1]=1, inputs[2]=1, inputs[3]=0)的概率
p(c=2, inputs[0]=0, inputs[1]=1, inputs[2]=1, inputs[3]=0)的概率


，然后选出最大值。


根据贝叶斯定理，并假设4个维度的特征不相关： 
p(c=0,v={0,1,1,0}) = p(input[0]=0,c=0)*p(input[1]=1,c=0)*p(input[2]=1,c=0)*p(input[3]=0,c=0)*p(c=0)/p(input[0]=0)*p(input[1]=1)*p(input[2]=1)*p(input[3]=0)
p(c=1,v={0,1,1,0}) = p(input[0]=0,c=1)*p(input[1]=1,c=1)*p(input[2]=1,c=1)*p(input[3]=0,c=1)*p(c=1)/p(input[0]=0)*p(input[1]=1)*p(input[2]=1)*p(input[3]=0)
p(c=2,v={0,1,1,0}) = p(input[0]=0,c=2)*p(input[1]=1,c=2)*p(input[2]=1,c=2)*p(input[3]=0,c=2)*p(c=2)/p(input[0]=0)*p(input[1]=1)*p(input[2]=1)*p(input[3]=0)


，对于本例，p(c=0) == p(c=1) == p(c=2)，因此可将p(c={0|1|2})/p(input[0]=0)*p(input[1]=1)*p(input[2]=1)*p(input[3]=0)视为常数。


设，

C = {p(c=0)/p(input[0]=0)*p(input[1]=1)*p(input[2]=1)*p(input[3]=0)}



 
p(c=0,v={0,1,1,0}) = p(input[0]=0,c=0)*p(input[1]=1,c=0)*p(input[2]=1,c=0)*p(input[3]=0,c=0)*C
p(c=1,v={0,1,1,0}) = p(input[0]=0,c=1)*p(input[1]=1,c=1)*p(input[2]=1,c=1)*p(input[3]=0,c=1)*C
p(c=2,v={0,1,1,0}) = p(input[0]=0,c=2)*p(input[1]=1,c=2)*p(input[2]=1,c=2)*p(input[3]=0,c=2)*C



求出以上3个概率后，取最大值即得到了分类。


本例实现代码： 


void Main()
{
	
//p(a|b) = p(b|a)*p(a)/p(b)


//to calculate : p(c={0,1,2}, input = [0,1,1,0]):
//p(c=0,input={0,1,1,0}) = p(input[0]=0,c=0)*p(input[1]=1,c=0)*p(input[2]=1,c=0)*p(input[3]=0,c=0)*p(c=0)/p(input[0]=0)*p(input[1]=1)*p(input[2]=1)*p(input[3]=0)
//p(c=1,input={0,1,1,0}) = p(input[0]=0,c=1)*p(input[1]=1,c=1)*p(input[2]=1,c=1)*p(input[3]=0,c=1)*p(c=1)/p(input[0]=0)*p(input[1]=1)*p(input[2]=1)*p(input[3]=0)
//p(c=2,input={0,1,1,0}) = p(input[0]=0,c=2)*p(input[1]=1,c=2)*p(input[2]=1,c=2)*p(input[3]=0,c=2)*p(c=2)/p(input[0]=0)*p(input[1]=1)*p(input[2]=1)*p(input[3]=0)


//since p(c=0) == p(c=1) == p(c=2), set C = {p(c=0)/p(input[0]=0)*p(input[1]=1)*p(input[2]=1)*p(input[3]=0)}


//p(c=0,input={0,1,1,0}) = p(input[0]=0,c=0)*p(input[1]=1,c=0)*p(input[2]=1,c=0)*p(input[3]=0,c=0)*C
//p(c=1,input={0,1,1,0}) = p(input[0]=0,c=1)*p(input[1]=1,c=1)*p(input[2]=1,c=1)*p(input[3]=0,c=1)*C
//p(c=2,input={0,1,1,0}) = p(input[0]=0,c=2)*p(input[1]=1,c=2)*p(input[2]=1,c=2)*p(input[3]=0,c=2)*C


	var f0=0;
	var f1=1;
	var f2=1;
	var f3=0;
	
	var p_input_equals_0_1_2_3 = 8*8*7*7/15*15*15*15.0;
	var p_c_0_1_2 = 1/3;
	var C = p_c_0_1_2 / p_input_equals_0_1_2_3;
	
	var p_c_0 = P_c_0(Feature(inputs,0), f0) * P_c_0(Feature(inputs,1),f1)* P_c_0(Feature(inputs,2),f2)* P_c_0(Feature(inputs,3),f3) * C;
	//Console.WriteLine(p0);
	var p_c_1 = P_c_1(Feature(inputs,0), f0) * P_c_1(Feature(inputs,1),f1)* P_c_1(Feature(inputs,2),f2)* P_c_1(Feature(inputs,3),f3) * C;
	var p_c_2 = P_c_2(Feature(inputs,0), f0) * P_c_2(Feature(inputs,1),f1)* P_c_2(Feature(inputs,2),f2)* P_c_2(Feature(inputs,3),f3) * C;


	var max = Math.Max(Math.Max(p_c_0,p_c_1),p_c_2);
	if(max == p_c_0){
		Console.WriteLine("category is 0");
	}
	else if(max == p_c_1){
		Console.WriteLine("category is 1");
	}
	else{
		Console.WriteLine("category is 2");
	}
}


static int[][] inputs ={
    new int[] { 0, 1, 1, 0 }, //  c=0 
    new int[] { 0, 1, 0, 0 }, //  c=0
    new int[] { 0, 0, 1, 0 }, //  c=0
    new int[] { 0, 1, 1, 0 }, //  c=0
    new int[] { 0, 1, 0, 0 }, //  c=0
    new int[] { 1, 0, 0, 0 }, //  c=1
    new int[] { 1, 0, 0, 0 }, //  c=1
    new int[] { 1, 0, 0, 1 }, //  c=1
    new int[] { 0, 0, 0, 1 }, //  c=1
    new int[] { 0, 0, 0, 1 }, //  c=1
    new int[] { 1, 1, 1, 1 }, //  c=2
    new int[] { 1, 0, 1, 1 }, //  c=2
    new int[] { 1, 1, 0, 1 }, //  c=2
    new int[] { 0, 1, 1, 1 }, //  c=2
    new int[] { 1, 1, 1, 1 }, //  c=2
};


public static double P_c_0(int[] feature,int v){
	var r = feature.Take(5).Count(x=>x == v)/5.0 /*from 1-5 , category is 0*/;
	//Console.WriteLine(r);
	return r;
}
public static double P_c_1(int[] feature,int v){
	var r = feature.Skip(5).Take(5).Count(x=>x == v)/5.0 /*from 6-10 , category is 1*/;
	//Console.WriteLine(r);
	return r;
}
public static double P_c_2(int[] feature,int v){
	var r = feature.Skip(10).Take(5).Count(x=>x == v)/5.0 /*from 11-15 , category is 2*/;
	//Console.WriteLine(r);
	return r;
}




public static int[] Feature(int[][] inputs, int c){
	var result = new int[inputs.Length];
	for(var i =0 ;i < inputs.Length; i++){
		result[i] = inputs[i][c];
	}
	return result;
}
// Define other methods and classes here






注，以上代码只用于对本例的朴素贝叶斯分类过程的分析，很多条件是hardcode的。




以下是使用accord-framework实现的贝叶斯分类： 


public class BayesianDemo
    {
        public static void Execute()
        {
            int[][] inputs =
            {
                //input                     output
                new int[] { 0, 1, 1, 0 }, //  0 
                new int[] { 0, 1, 0, 0 }, //  0
                new int[] { 0, 0, 1, 0 }, //  0
                new int[] { 0, 1, 1, 0 }, //  0
                new int[] { 0, 1, 0, 0 }, //  0
                new int[] { 1, 0, 0, 0 }, //  1
                new int[] { 1, 0, 0, 0 }, //  1
                new int[] { 1, 0, 0, 1 }, //  1
                new int[] { 0, 0, 0, 1 }, //  1
                new int[] { 0, 0, 0, 1 }, //  1
                new int[] { 1, 1, 1, 1 }, //  2
                new int[] { 1, 0, 1, 1 }, //  2
                new int[] { 1, 1, 0, 1 }, //  2
                new int[] { 0, 1, 1, 1 }, //  2
                new int[] { 1, 1, 1, 1 }, //  2
            };


            int[] outputs = // those are the class labels
            {
                0, 0, 0, 0, 0,
                1, 1, 1, 1, 1,
                2, 2, 2, 2, 2,
            };
             
            // Create a discrete naive Bayes model for 3 classes and 4 binary inputs
            var bayes = new NaiveBayes(classes: 3, symbols: new int[] { 2, 2, 2, 2 });


            // Teach the model. The error should be zero:
            double error = bayes.Estimate(inputs, outputs);


            int answer = bayes.Compute(new int[] { 0, 1, 1, 0 });


            Console.WriteLine("category is : {0}",answer);
        }
    }


class Program
    {
        static void Main(string[] args)
        {
            BayesianDemo.Execute();
            Console.ReadLine();
        }
    }


_iorilan
关注
专栏目录
Naive Bayes 朴素贝叶斯代码实现-Python
hua_453的博客
10-28 648
Naive Bayes 朴素贝叶斯代码实现-Python
机器学习-分类-朴素贝叶斯算法
weixin_44020827的博客
12-17 840
三、朴素贝叶斯算法 朴素贝叶斯算法是基于贝叶斯定理与特征条件独立性假设的分类方法 1.原理 （1）贝叶斯定理 （2）特征条件独立性假设 给定一个数据集(x,y)，每个样本x包含n维特征，类标签集合y包含N个类别。 现给定一个新样本x，需要判断它属于哪一类。在这里，我们取概率最大的类别作为其类标签，即问题转化为：找到最大值对应的类标签。即 ...
机器学习——朴素贝叶斯算法（转载自知乎）
小唐要努力的博客
11-21 948
本文仅用于学习交流，原文链接https://zhuanlan.zhihu.com/p/26262151 如有侵权请联系删除~ 贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。而朴素朴素贝叶斯分类是贝叶斯分类中最简单，也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到的朴素贝叶斯分类算法，希望有利于他人理解。 分类问题综述 对于分类问题，其实谁都不会陌生，日常生活中我们每天都进行着分类过程。例如，当你看到一个人，你的脑子下意识判断...
Python大数据分析——朴素贝叶斯模型
最新发布
Eric005的博客
08-06 1198
请问在给定的信息下，对于高收入的公务员，并且其学历为硕士的男生来说，女孩是否愿意参与他的相亲？被预测为不经过上面的计算可知，当客户的年龄为24岁，并且收入为8500时，放贷的概率是4.8079x10-8，放贷的概率为2.1479x10-6，所以根据argmax P(Ci)P(X I Ci)的原则，最终该金融公司决定给客户放贷。结果所示，当用户的评论中只含有“还行”一词时，计算该评论为正面情绪的概率约为0.015，评论为负面情绪的概率约为0.00073，故根据贝叶斯后验概率最大原则将该评论预判为正面情绪。
机器学习算法及实战——朴素贝叶斯代码实现
weixin_30790841的博客
07-26 398
朴素贝叶斯是经典的机器学习算法之一，也是为数不多的基于概率论的分类算法。朴素贝叶斯原理简单，也很容易实现，多用于文本分类，比如垃圾邮件过滤。 1.算法思想——基于概率的预测 逻辑回归通过拟合曲线（或者学习超平面）实现分类，决策树通过寻找最佳划分特征进而学习样本路径实现分类，支持向量机通过寻找分类超平面进而最大化类别间隔实现分类。相比之下，朴素...
【朴素贝叶斯】实战朴素贝叶斯_代码实现_训练算法
云计算?
09-07 185
说一下Train函数的实现。 在上文中，我提到过，朴素贝叶斯也有两种模型：贝努力模型和多项式模型。小弟第一次实现朴素贝叶斯，就老老实实按照基本原理做了一个贝努力模型；多项式模型也不难，变通一下就行。不废话了，直接上代码了，有点长，不过很容易看懂： bool NaiveBayes::Train (const char * sFileSample, int iClassNum, int...
朴素贝叶斯算法原理解析及代码实现
weixin_34347651的博客
05-24 295
为什么80%的码农都做不了架构师？>>> ...
人工智能-项目实践-朴素贝叶斯分类器-朴素贝叶斯文本分类器
03-25
人工智能_项目实践_朴素贝叶斯分类器_朴素贝叶斯文本分类器 **数据：**搜狗文本分类语料库 **分类器：**朴素贝叶斯分类器 NBC(Naive Bayesian Classifier) **编程语言：**Python+jieba分词库+nltk+sklearn
机器学习-Python-朴素贝叶斯-垃圾邮件
09-28
本资源包聚焦于一个具体的机器学习应用——垃圾邮件检测，通过使用朴素贝叶斯算法。 朴素贝叶斯是一种基于概率的分类方法，其基本思想是假设特征之间相互独立，并且每个特征对类别有相同的影响力。在垃圾邮件过滤中...
机器学习文本分类基于TF-IDF+朴素贝叶斯文本数据的分类与分析源码（高分大作业）.zip
04-18
机器学习文本分类基于TF-IDF+朴素贝叶斯文本数据的分类与分析源码（高分大作业）.zip本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的能够...
朴素贝叶斯算法matlab代码实现
03-16
关于朴素贝叶斯算法matlab代码实现，简单易懂，有关键注解
机器学习——朴素贝叶斯代码实现
blinnnnk的博客
11-30 420
代码：链接：https://pan.baidu.com/s/17Cm6Yq99WCT3XB0D19fqGA?pwd=3kfh提取码：3kfh运行结果：判断是正常邮件还是垃圾邮件的概率：判断的结果：反思。
朴素贝叶斯代码实现
kaka19880812的专栏
09-18 986
本文讨论了不同类型的朴素贝叶斯模型，并用代码实现了Multinomial Native Bayes
朴素贝叶斯分析及实验
m0_74739796的博客
05-13 934
贝叶斯定理是概率论中的一个基本定理，它描述了在已知某些条件下，一个事件发生的概率如何被更新。数学上，贝叶斯定理可以表示为： (P(A|B) = \frac{P(B|A) \cdot P(A)}{P(B)}) 其中，(P(A|B)) 是在给定B的条件下A发生的概率，(P(B|A)) 是在给定A的条件下B发生的概率，(P(A)) 和 (P(B)) 分别是A和B发生的概率。
朴素贝叶斯原理及实现
褪色的博客
03-10 1203
贝叶斯 朴素贝叶斯 分类问题 数据挖掘 机器学习
[MLReview] Naive Bayes 朴素贝叶斯代码实现
gdtop的个人笔记
06-05 1283
朴素贝叶斯
机器学习——朴素贝叶斯（手动代码实现）
weixin_50348308的博客
06-19 2502
从小菜鸡的试错思考中逐步清晰！ python纯手动实现朴素贝叶斯的算法，对比 sklearn实现的算法，两者结果有差异，但差异不算太大。
朴素贝叶斯算法代码实现（垃圾邮件检测）
qq_52053775的博客
09-23 2688
（1）分词首先需要对文本进行分词操作，转换为list,同时词语全部小写，并去除字母数量小于等于2的单词(2)创建语料表对于每一封邮件，我们需要得到每一封邮件出现的词语，即语料表（3）得到词向量首先初始化一个向量，只要对应词在邮件中出现，相应位置置1，于是我们得到了词向量串联起来：首先读取邮件，得到每个邮件的语料表，然后划分训练集和测试集，得到训练集每个邮件的词向量以及类别（垃圾邮件/非垃圾邮件）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值