初学分类算法-NB

最新推荐文章于 2024-01-23 22:48:47 发布
最新推荐文章于 2024-01-23 22:48:47 发布
阅读量718 收藏
点赞数
分类专栏： 机器学习 文章标签： 分类 数据挖掘 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51294669/article/details/123215374
版权

说道分类算法-NB，我要从两个方面入手，第一什么是分类问题？第二什么是NB算法？

分类问题：

1.1 二值问题：就是 0，1是与否的问题和回归（概率，分数值）问题。前者我们很好理解，我们用淘宝举个例子，买东西我们要搜索对吧，那么这个商品能不能推荐给你是不是只有两种可能，推荐或者不推荐嘛。可如果符合你胃口的商品有很多件，实际情况也是这样，那么要把最适合你的这类商品推荐给你，就存在一个拟合度，涉及到回归问题和概率的问题了。回归问题这里比如有一个域值：0.8，我们对商品进行预测只有大于0.8说明这商品多半是你想要的，我就推荐给你放在上面，如果小于0.8我就不推荐出来或者放在后面。应该懂了吧。

1.2 多值问题：前面的Knn中花的种类就是多值问题。还有比如一部电影的种类：爱情，治愈，励志，科幻，动漫等类别，现在有一部新的电影要判断它属于哪一个类别，就要从它的性质来分出它的类别。

有监督问题和无监督问题就在于是否含有数据的标签，不多介绍了，进入正题。

分类算法——NB (朴素贝叶斯)

贝叶斯分类算法是统计学的一种概率分类方法，朴素贝叶斯分类是贝叶斯分类中最简单的一种。其分类原理就是利用贝叶斯公式根据某特征的先验概率计算出其后验概率，然后选择具有具有最大后验概率的类作为该特征所属的类。之所以称为朴素是因为贝叶斯只做最原始、最简单的假设：所有特征之间是统计独立的。

假设某样本 X 有 a1,a2,...,an 个属性，那么有 P(X) = P(a1,a2,a3,...,an) = P(a1)* P(a2)*...* P(an).满足这样的公式就说明特征统计独立。

1.条件概率公式

条件概率(conditional probability),就是指在事件B发生的情况下，事件A发生的概率，用P(A|B)来表示。

根据文氏图可知：在事件B发生的情况下事件A发生的概率就是P(A∩B)除以P(B).

P(A|B) = \frac{P(A\cap B)}{P(B)} => P(A\cap B) = P(A|B)P(B)

接着我们来看全概率公式，如果事件 A1,A2,...,An 构成一个完备事件且都有正概率，那么对于任意一个事件B都有：

                          P(B) = P(BA1) + P(BA2) + ... + P(BAn)

                                  = P(B|A1)P(A1) + P(B|A2)P(A2) + ... + P(B|An)P(An)

                                  =    \sum_{i = 1}^{n} P(A_{i})P(B|A_{i})

2.贝叶斯公式推断

根据条件概率公式和全概率公式，可以得到贝叶斯公式如下：

P(A|B) = P(A)\frac{P(A|B)}{P(B)}

P(A_{i}|B) = P(A_{i})\frac{P(B|A_{i})}{\sum_{i=1}^{n}P(B|A_{i})}

P(A)其实就是先验概率，在事件B发生之前我们对事件A做一个简单的判断。左边的P(A|B)其实就是我们要求的后验概率，意思是在事件B发生之后我们对事件A发生的概率重新评估。而 P(A|B)/P(B)就是调正因子，它的作用便是使预估概率更接近我们的真实概率，调整因子又叫做可能性函数。这样我们可以理解为 后验概率 = 先验概率 * 调整因子。

这里我们需要注意的是：

  • 调整因子如果它大于1，也就是说先验概率被放大了，那么事件A发生的概率就增大了。
  • 调整因子如果 = 1，说明 B 事件无助于判断事件A的可能性。
  • 调整因子如果 < 1，说明先验概率变小了，事件A的可能性变小了。

3.朴素贝叶斯种类

3.1GaussianNB

GaussianNB就是先验为高斯分布（正态分布）的朴素贝叶斯，假设每个标签的数据服从简单的正态分布。

 其中Ck为Y的第k类别，\mu _{k} 和 \sigma _{k}^{2} 为需要从训练集估计的值。

3.2MultinomialNB

MultinomialNB就是先验为多项式分布的朴素贝叶斯。它假设特征是由一个简单多项式分布生成的。多项分布可以描述各种类型样本出现次数的概率，因此多项式朴素贝叶斯非常适用于描述出现次数或者出现次数比例的特征。该模型常用于文本分类，特征表示的是次数，例如某个单词出现的次数。多项式分布公式如下：

其中，P(Xj= x_{jl}|Y =Ck)是第k个类别的第j维特征的第I个取值条件概率。m_{k}是训练集中输出为第k类的样本数。入为一个大于0的常数，常常取为1，即拉普拉斯平滑。也可以取其他值。

 3.BernoulliNB

BernoulliNB就是先验为伯努利分布的朴素贝叶斯。假设特征的先验概率为二元伯努利分布，即如下式：

P(X_{j} = x_{jl}|Y = C_{k})x_{jl} + (1-P(j|Y = C_{k}))(1-x_{jl})

 此时l只有两种取值，x_{jl}只能取0或1。

在伯努利模型中，每个取值都是布尔型的，即 ture 和 false。在文本中，就是一个特征有没有在文档中出现。

小结

  • 样本特征的分布大部分是连续值，使用GaussianNB会比较好。
  • 样本分布大部分是多元离散，使用MultinomialNB比较合适
  • 样本特征是二元离散值或者很稀疏的多元离散值，应该使用BernoulliNB。

这里附上代码，里面是细致的注释，方便我们更深入的学习。

package machinelearning.bayes;

import java.io.FileReader;
import java.util.Arrays;

import weka.core.*;

public class NaiveBayes {
	/**
	 ************************* 
	 * 用于存储参数的内部类。
	 ************************* 
	 */
	private class GaussianParamters {
		double mu;
		double sigma;
		
		// 内部类的构造方法，给mu sigma 赋值
		public GaussianParamters(double paraMu, double paraSigma) {
			mu = paraMu;
			sigma = paraSigma;
		}// Of the constructor

		public String toString() {
			return "(" + mu + ", " + sigma + ")";
		}// Of toString
	}// Of GaussianParamters

	/**
	 * 数据
	 */
	Instances dataset;

	/**
	 * 类的数量. 对于二元分类器它是2，鸢尾花就是 3 种花，天气就是 P N
	 */
	int numClasses;

	/**
	 * 事例的数量
	 */
	int numInstances;

	/**
	 * 条件属性的数量。
	 */
	int numConditions;

	/**
	 * 预测，包括查询标签和预测标签。
	 */
	int[] predicts;

	/**
	 * 类分布
	 */
	double[] classDistribution;

	/**
	 * 拉普拉斯光滑的类分布.
	 */
	double[] classDistributionLaplacian;

	/**
	 * 计算所有值上所有属性上所有类的条件概率。
	 * 
	 */
	double[][][] conditionalCounts;

	/**
	 * 拉普拉斯光滑的条件概率。
	 */
	double[][][] conditionalProbabilitiesLaplacian;

	/**
	 * 高斯参数
	 */
	GaussianParamters[][] gaussianParameters;

	/**
	 * 数据类型
	 */
	int dataType;

	/**
	 * nominal（0,1）
	 */
	public static final int NOMINAL = 0;

	/**
	 * 数值的
	 */
	public static final int NUMERICAL = 1;

	/**
	 ********************
	 * 传递数据
	 * 
	 * @param paraFilename
	 *            The given file.
	 ********************
	 */
	public NaiveBayes(String paraFilename) {
		dataset = null;
		try {
			FileReader fileReader = new FileReader(paraFilename);
			dataset = new Instances(fileReader);
			fileReader.close();
		} catch (Exception ee) {
			System.out.println("Cannot read the file: " + paraFilename + "\r\n" + ee);
			System.exit(0);
		} // Of try

		dataset.setClassIndex(dataset.numAttributes() - 1);
		// 去除了花名，留下了花的特征,五个特征，就只有四个
		numConditions = dataset.numAttributes() - 1;
		// 花的总数
		numInstances = dataset.numInstances();
		// 获得最后一个决策属性个数，P 和 N,数组0开始，numcondition便是最后一个属性
		numClasses = dataset.attribute(numConditions).numValues();
	}// Of the constructor

	/**
	 ********************
	 * 设置数据类型。
	 ********************
	 */
	public void setDataType(int paraDataType) {
		dataType = paraDataType;
	}// Of setDataType

	/**
	 ********************
	 * 用拉普拉斯平滑法计算类分布。
	 ********************
	 */
	public void calculateClassDistribution() {
		// 累的分布，一维数组，它的空间是numclasses，决策的种类
		classDistribution = new double[numClasses];
		// 拉普拉斯分布。
		classDistributionLaplacian = new double[numClasses];

		// 生成一个double 型数组，它的长度是数据的数目
		double[] tempCounts = new double[numClasses];
		// 这里给了一个循环，统计0,1决策的总数。
		for (int i = 0; i < numInstances; i++) {
			// tempClassValue 用来存储第 i 个决策属性
			int tempClassValue = (int) dataset.instance(i).classValue();
			tempCounts[tempClassValue]++;
		} // Of for i

		for (int i = 0; i < numClasses; i++) {
			classDistribution[i] = tempCounts[i] / numInstances;
			classDistributionLaplacian[i] = (tempCounts[i] + 1) / (numInstances + numClasses);
		} // Of for i

		System.out.println("Class distribution: " + Arrays.toString(classDistribution));
		System.out.println(
				"Class distribution Laplacian: " + Arrays.toString(classDistributionLaplacian));
	}// Of calculateClassDistribution

	/**
	 ********************
	 * 用拉普拉斯计算条件概率。 只遍历一遍数据集就可以了
	 *  这里有一个更简单的, 我删除它是因为时间复杂度更高。
	 ********************
	 */
	public void calculateConditionalProbabilities() {
		conditionalCounts = new double[numClasses][numConditions][];
		conditionalProbabilitiesLaplacian = new double[numClasses][numConditions][];

		// 分配空间 a[决策数目][属性值]
		for (int i = 0; i < numClasses; i++) {
			for (int j = 0; j < numConditions; j++) {
				int tempNumValues = (int) dataset.attribute(j).numValues();
				conditionalCounts[i][j] = new double[tempNumValues];
				conditionalProbabilitiesLaplacian[i][j] = new double[tempNumValues];
			} // Of for j
		} // Of for i

		// 计算成员占决策的数目，比如yes 50 人，no 20人。
		int[] tempClassCounts = new int[numClasses];
		// 求每一个条件下yes,no的数目
		for (int i = 0; i < numInstances; i++) {
			int tempClass = (int) dataset.instance(i).classValue();
			tempClassCounts[tempClass]++;
			for (int j = 0; j < numConditions; j++) {
				int tempValue = (int) dataset.instance(i).value(j);
				conditionalCounts[tempClass][j][tempValue]++;
			} // Of for j
		} // Of for i

		// 现在来看看拉普拉斯的真实概率
		for (int i = 0; i < numClasses; i++) {
			for (int j = 0; j < numConditions; j++) {
				int tempNumValues = (int) dataset.attribute(j).numValues();
				for (int k = 0; k < tempNumValues; k++) {
					conditionalProbabilitiesLaplacian[i][j][k] = (conditionalCounts[i][j][k] + 1)
							/ (tempClassCounts[i] + tempNumValues);
				} // Of for k
			} // Of for j
		} // Of for i

		System.out.println("Conditional probabilities: " + Arrays.deepToString(conditionalCounts));
	}// Of calculateConditionalProbabilities

	/**
	 ********************
	 * Calculate the conditional probabilities with Laplacian smooth.
	 ********************
	 */
	public void calculateGausssianParameters() {
		// gaussianParameters [决策数目][决策属性]
		gaussianParameters = new GaussianParamters[numClasses][numConditions];

		// 这个数组，空间是数据的数目
		double[] tempValuesArray = new double[numInstances];
		int tempNumValues = 0;
		double tempSum = 0;

		// 外层是yes,no,内层是决策属性 天气温度等
		for (int i = 0; i < numClasses; i++) {
			for (int j = 0; j < numConditions; j++) {
				tempSum = 0;

				// 从这个类获取值
				tempNumValues = 0;
				for (int k = 0; k < numInstances; k++) {
					// 1 代表 yes , 0 代表 no，第一次循环就是收集 no
					if ((int) dataset.instance(k).classValue() != i) {
						continue;
					} // Of if
					
					// tempValuesArray[tempValues] 索引 0 处存放 第 i 行 第 j 个属性值
					tempValuesArray[tempNumValues] = dataset.instance(k).value(j);
					// 再把这个属性值加起来乘以数组长度
					tempSum += tempValuesArray[tempNumValues];
					// 这个是索引，继续加
					tempNumValues++;
				} // Of for k

				// Obtain parameters.
				double tempMu = tempSum / tempNumValues;

				double tempSigma = 0;
				for (int k = 0; k < tempNumValues; k++) {
					tempSigma += (tempValuesArray[k] - tempMu) * (tempValuesArray[k] - tempMu);
				} // Of for k
				tempSigma /= tempNumValues;
				tempSigma = Math.sqrt(tempSigma);

				gaussianParameters[i][j] = new GaussianParamters(tempMu, tempSigma);
			} // Of for j
		} // Of for i

		System.out.println(Arrays.deepToString(gaussianParameters));
	}// Of calculateGausssianParameters

	/**
	 ********************
	 * 对所有数据分类，结果储存在 predicts[].
	 ********************
	 */
	public void classify() {
		predicts = new int[numInstances];
		for (int i = 0; i < numInstances; i++) {
			predicts[i] = classify(dataset.instance(i));
		} // Of for i
	}// Of classify

	/**
	 ********************
	 * 对事例进行分类
	 ********************
	 */
	public int classify(Instance paraInstance) {
		if (dataType == NOMINAL) {
			return classifyNominal(paraInstance);
		} else if (dataType == NUMERICAL) {
			return classifyNumerical(paraInstance);
		} // Of if

		return -1;
	}// Of classify

	/**
	 ********************
	 * 使用符号数据对实例进行分类。
	 ********************
	 */
	public int classifyNominal(Instance paraInstance) {
		// 找到一个最大的
		double tempBiggest = -10000;
		int resultBestIndex = 0;
		for (int i = 0; i < numClasses; i++) {
			// 公式的技巧性处理
			double tempClassProbabilityLaplacian = Math.log(classDistributionLaplacian[i]);
			// 申明tempPseudoProbability它的值是tempClassProbabilityLaplacian
			double tempPseudoProbability = tempClassProbabilityLaplacian;
			for (int j = 0; j < numConditions; j++) {
				int tempAttributeValue = (int) paraInstance.value(j);

				// 拉普拉斯平滑，这里也有技巧处理，注意，每一项和整体
				tempPseudoProbability += Math.log(conditionalCounts[i][j][tempAttributeValue])
				- tempClassProbabilityLaplacian;
			} // Of for j

			if (tempBiggest < tempPseudoProbability) {
				tempBiggest = tempPseudoProbability;
				resultBestIndex = i;
			} // Of if
		} // Of for i

		return resultBestIndex;
	}// Of classifyNominal

	/**
	 ********************
	 * 使用数字数据对实例进行分类。
	 ********************
	 */
	public int classifyNumerical(Instance paraInstance) {
		// Find the biggest one
		double tempBiggest = -10000;
		int resultBestIndex = 0;

		for (int i = 0; i < numClasses; i++) {
			double tempClassProbabilityLaplacian = Math.log(classDistributionLaplacian[i]);
			double tempPseudoProbability = tempClassProbabilityLaplacian;
			for (int j = 0; j < numConditions; j++) {
				double tempAttributeValue = paraInstance.value(j);
				double tempSigma = gaussianParameters[i][j].sigma;
				double tempMu = gaussianParameters[i][j].mu;

				// 这里也要技巧处理
				tempPseudoProbability += -Math.log(tempSigma) - (tempAttributeValue - tempMu)
						* (tempAttributeValue - tempMu) / (2 * tempSigma * tempSigma);
			} // Of for j

			if (tempBiggest < tempPseudoProbability) {
				tempBiggest = tempPseudoProbability;
				resultBestIndex = i;
			} // Of if
		} // Of for i

		return resultBestIndex;
	}// Of classifyNumerical

	/**
	 ********************
	 * Compute accuracy.
	 ********************
	 */
	public double computeAccuracy() {
		double tempCorrect = 0;
		for (int i = 0; i < numInstances; i++) {
			if (predicts[i] == (int) dataset.instance(i).classValue()) {
				tempCorrect++;
			} // Of if
		} // Of for i

		double resultAccuracy = tempCorrect / numInstances;
		return resultAccuracy;
	}// Of computeAccuracy

	/**
	 ************************* 
	 * Test nominal data.
	 ************************* 
	 */
	public static void testNominal() {
		System.out.println("Hello, Naive Bayes. I only want to test the nominal data.");
		String tempFilename = "D:/data/mushroom.arff";

		NaiveBayes tempLearner = new NaiveBayes(tempFilename);
		tempLearner.setDataType(NOMINAL);
		tempLearner.calculateClassDistribution();
		tempLearner.calculateConditionalProbabilities();
		tempLearner.classify();

		System.out.println("The accuracy is: " + tempLearner.computeAccuracy());
	}// Of testNominal

	/**
	 ************************* 
	 * Test numerical data.
	 ************************* 
	 */
	public static void testNumerical() {
		System.out.println(
				"Hello, Naive Bayes. I only want to test the numerical data with Gaussian assumption.");
		// String tempFilename = "D:/data/iris.arff";
		String tempFilename = "D:/data/iris-imbalance.arff";

		NaiveBayes tempLearner = new NaiveBayes(tempFilename);
		tempLearner.setDataType(NUMERICAL);
		tempLearner.calculateClassDistribution();
		tempLearner.calculateGausssianParameters();
		tempLearner.classify();

		System.out.println("The accuracy is: " + tempLearner.computeAccuracy());
	}// Of testNominal

	/**
	 ************************* 
	 * Test this class.
	 * 
	 * @param args
	 *            Not used now.
	 ************************* 
	 */
	public static void main(String[] args) {
		testNominal();
		testNumerical();
	}// Of main
}// Of class NaiveBayes

四川兔兔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分类算法之NB
hzh36的博客
06-26 593
以文本分类为例，通过文本分类的过程，学习NB算法的流程及实现方法。 极大似然估计下的NB 贝叶斯估计下的NB 用极大似然估计可能出现所要估计的概率值为0的情况（测试集中的词在样本集中没出现过）。这时会影响到后验概率的计算结果，使分类产生偏差。解决这一问题的方法是采用贝叶斯估计。 贝叶斯估计下的的条件概率 贝叶斯估计下的的先验概率 两种NB的模型封装 极大似然估计下的NB模型封装 贝叶斯估计下的NB模型封装 ...
朴素贝叶斯算法对文本的分类
cccccccaaaaaaaaa的博客
04-26 296
1.案例 2.为了防止像tokyo这种为零的情况，因此引入拉普拉斯平滑系数 8是在C中所有词个数，6是在所有特征词个数，一个类别只算一次 API
机器学习之概率学习朴素贝叶斯（NB）
学习中
01-23 1428
机器学习之概率学习朴素贝叶斯（NB）
Naive Bayes算法（朴素贝叶斯算法）
Panonsense
04-19 1628
NaiveBayes（朴素贝叶斯）是ML中的一个非常基础和简单的算法
分类算法-NB（NaiveBeyesian Classification）分类器及AUC效果评估
Jameslvt的博客
07-31 6029
  在整个机器学习领域，有很多算法，除了与业务相关的推荐算法，还有分类，回归，聚类算法。其实，回归算法中也有类似分类算法，回归算法在机器学习中就是为了解决分类问题。 至于这个分类模型有什么用，我们在机器学习过程中： 定义一个对象X，将其划分到定义的某个类别Y中，输出是某个类别，例如新闻类，军事类 这里分类我们说一下，分类中有二分类（邮件垃圾邮件）、多分类（网页分类），那么分类算法解决的流程...
机器学习-分类之朴素贝叶斯(NB)原理及实战
周先森爱吃素的博客
12-01 1272
朴素贝叶斯（NB） 简介 一个简单的概率分类器。 朴素贝叶斯分类器（Naive Bayes Classifier，NBC）发源于古典数学理论，有着坚实的数学基础，以及稳定的分类效率。 同时NBC模型所需要估计的参数很少，对缺失数据不太敏感，算法比较简单。之所以称为“朴素”是因为整个形式化过程只做最简单、最原始的假设。 朴素贝叶斯在数据较少的情况下仍然有效，可以处理多分类问题。 ...
项目实战-朴素贝叶斯算法实现新闻分类源码及数据集.zip
04-17
1、内容概要：本资源主要基朴素贝叶斯算法实现新闻分类，适用于初学者学习文本分类使用。 2、新闻分类源码实现过程：将数据集划分为训练集和测试集；使用jieba模块进行分词，词频统计，停用词过滤，文本特征提取，将...
通过信息增益处理NSL-KDD与UNSW-NB
10-11
在处理NSL-KDD和UNSW-NB数据集时，计算各特征的信息增益可以帮助我们找出对分类最有影响的特征，从而减少冗余特征，提高模型效率。 在处理这两个数据集时，通常会进行以下步骤： 1. **数据加载**：读取CSV或ARFF...
项目实战-朴素贝叶斯算法实现垃圾邮件过滤源码及数据集.zip
04-17
1、内容概要：本资源主要基朴素贝叶斯算法实现垃圾邮件过滤分类，适用于初学者学习文本分类使用。 2、主要内容：邮件数据集email，email文件夹下有两个文件夹ham和spam，其中ham文件夹下的txt文件为正常邮件，spam...
KNN、NB、SVM实现鸢尾花分类-代码+结果表格/图表
最新发布
05-06
在这个项目中，我们将深入探讨三种不同的分类算法：K近邻（K-Nearest Neighbors, KNN）、朴素贝叶斯（Naive Bayes, NB）以及支持向量机（Support Vector Machine, SVM），并将它们应用于鸢尾花的分类任务。...
AMR-NB算法
03-21
3GPP AMR-NB C++算法，分享给需要的朋友
ＮＢ朴素贝叶斯算法在UCI数据集上的的java实现
12-23
java实现的NB算法，在UCI的三个个数据集上进行了测试，包含测试结果和实验报告，还有UCI测试数据 人工智能大作业实验
NB 算法
weixin_46007132的博客
05-09 500
基础理论： 1.条件概率 P(AB)=P(A)P(B∣A) P(A) 表示事件 A 发生的概率; P(AB)表示事件 A 和 B 同时发生的概率; P(B|A) 表示在事件 A发生的情况下, 事件 B 也发生的概率。 2.Laplacian 平滑 零概率问题：在计算事件的概率时，如果某个事件在训练集中没有出现，那么会导致该事件的概率结果为0. Laplacian 平滑是为了解决零概率的问题。举例：假设有三个仅包含字母的文本分类w1、w2、w3,在指定的训练样本中查找字母k。查找到的次数分别为0..
信息检索——NB算法的训练及分类过程实现
clown0004的博客
06-24 1039
信息检索——NB算法的训练及分类过程实现
朴素贝叶斯算法（NB)
业精于勤，荒于嬉；行成于思，毁于随。
12-06 2214
算法分析：贝叶斯分类器的分类原理是通过某对象的先验概率，利用贝叶斯公式计算出其后验概率，即该对象属于某一类的概率，选择具有最大后验概率的类作为该对象所属的类。目前研究较多的贝叶斯分类器主要有四种，分别是：Naive Bayes、TAN、BAN和GBN。这次使用NB算法来实现。        实现步骤：     1、找到一个已知分类的待分类项集合，这个集合叫做训练样本集。       2、统计
ML之NB：朴素贝叶斯Naive Bayesian算法的简介、应用、经典案例之详细攻略
热门推荐
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
08-24 1万+
​ ML之NB：朴素贝叶斯Naive Bayesian算法的简介、应用、经典案例之详细攻略 目录 NB算法的简介 NB算法的应用：案例理解 NB算法的经典案例 NB算法的简介 朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。朴素贝叶斯分类器基于一个简单的假定：给定目标值时属性之间相互条件独立。 通过以上定理和“朴素”的假定，我们知道： P(Category | Document) = P(Document | Categ
深入理解贝叶斯分类与朴素贝叶斯模型（Naive Bayes, NB）：从基础到实战
weixin_54703767的博客
12-02 781
一种通常的做法是忽略文本中的词序关系，假设各个特征词的位置都是可以互换的，即词袋模型（Bag Of Word，BOW）。基于以上条件的贝叶斯模型，称为。计算机，t2 = 排球，t3 = 运动会，t4 = 高校，t5 = 大学，y = 1表示教育类，y = 0表示体育类，可以得到如下参数估计结果。在朴素贝叶斯分类器中，特征之间的独立性假设是一个简化，但在实际应用中，该方法在垃圾邮件过滤等任务上表现良好。从参数估计的结果例可以看出，在多项式分布假设下，频率正是概率的最大似然估计值，例如，类别概率。
朴素贝叶斯法（Naive Bayes，NB）（结合例子推公式，通俗易懂）
weixin_46838605的博客
02-16 3908
朴素贝叶斯是一种概率模型，同时也是参数化模型，经常用于监督学习的分类应用中，例如垃圾邮件分类。对于训练集，首先学习输入输出的联合概率分布模型，然后基于此模型，对给出的输入x，利用贝叶斯定理求出后验概率最大的输出y。 先来看看最终的公式： y=argmaxP(Y=ck)∏jP(X(j)=x(j)∣Y=ck) y = argmaxP(Y=c_k)\prod_{j}P(X^{(j)}=x^{(j)}|Y=c_k) y=argmaxP(Y=ck​)j∏...
机器学习——NB算法（包括符号型与数值型两种）
weixin_43763325的博客
07-24 656
4.符号型NB算法使用的是mushroom.arff数据集，数值型NB算法使用的是iris.arff数据集。3.为防止0概率冲突事件需要对数据进行平滑处理。NB算法(包括符号型与数值型,结合Java程序分析)中学习代码的基础公式。......

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值