贝叶斯算法的基本原理和算法实现

Posted taich-flute

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了贝叶斯算法的基本原理和算法实现相关的知识,希望对你有一定的参考价值。

       一. 贝叶斯公式推导

  朴素贝叶斯分类是一种十分简单的分类算法,叫它朴素是因为其思想基础的简单性:就文本分类而言,它认为词袋中的两两词之间的关系是相互独立的,即一个对象 的特征向量中每个维度都是相互独立的。例如,黄色是苹果和梨共有的属性,但苹果 和梨是相互独立的。这是朴素贝叶斯理论的思想基础。现在我们将它扩展到多维的情况:

  朴素贝叶斯分类的正式定义如下:

  1.设 x={a1,a2,…,am}为一个待分类项,而每个 a 为 x 的一个特征属性。
  2.有类别集合 C={y1,y2,…,yn}。
  3.计算 P( y1|x) ,P( y2|x),…, P( yn|x)。
  4.如果 P( yk|x) =max{P( y1|x),P( y2|x),…, P( yn|x)},则 x∈yk。
  那么现在的关键就是如何计算第 3 步中的各个条件概率。我们可以这么做:
    (1) 找到一个已知分类的待分类项集合,也就是训练集。
    (2) 统计得到在各类别下各个特征属性的条件概率估计。即:

          P(a1|y1) , P(a2|y1),…, P(am|y1);
        P(a1|y2) , P(a2|y2),…, P(am|y2);
        P(am|yn) , P(am|yn),…, P(am|yn)。
    (3) 如果各个特征属性是条件独立的(或者我们假设它们之间是相互独立的),则根 据贝叶斯定理有如下推导:

      因为分母对于所有类别为常数,只要将分子最大化皆可。又因为各特征属性是条 件独立的,所以有:

  根据上述分析,朴素贝叶斯分类的流程可以表示如下: 第一阶段:训练数据生成训练样本集:TF-IDF

  第二阶段:对每个类别计算 P(yi)

  第三阶段:对每个特征属性计算所有划分的条件概率 第四阶段:对每个类别计算 Px | yi ) P( yi )

  第五阶段:以 Px | yi ) P( yi ) 的最大项作为 x 的所属类别

  二. 朴素贝叶斯算法实现

   使用简单的英文语料作为数据集:

  

def loadDataSet():
  postingList=[[\'my\', \'dog\', \'has\', \'flea\', \'problems\', \'help\', \'please\'],
  [\'maybe\', \'not\', \'take\', \'him\', \'to\', \'dog\', \'park\', \'stupid\'],
  [\'my\', \'dalmation\', \'is\', \'so\', \'cute\', \'I\', \'love\', \'him\',\'my\'], [\'stop\', \'posting\', \'stupid\', \'worthless\', \'garbage\'],
  [\'mr\', \'licks\', \'ate\', \'my\', \'steak\', \'how\', \'to\', \'stop\', \'him\'],
  [\'quit\', \'buying\', \'worthless\', \'dog\', \'food\', \'stupid\']] classVec = [0,1,0,1,0,1]    #1 is abusive, 0 not
  return postingList,classVec

  postList 是训练集文本,classVec 是每个文本对应的分类。

  根据上节的步骤,逐步实现贝叶斯算法的全过程:

  1.编写一个贝叶斯算法类,并创建默认的构造方法:

class NBayes(object): def __init__(self):
    self.vocabulary= [] # 词典
    self.idf=0    #  词典的 idf 权值向量
    self.tf=0    # 训练集的权值矩阵
    self.tdm=0    # P(x|yi)
    self.Pcates = {}    # P(yi)--是个类别字典
    self.labels=[]    #  对应每个文本的分类,是个外部导入的列表
    self.doclength = 0    #  训练集文本数
    self.vocablen = 0    # 词典词长
    self.testset = 0    # 测试集

  2.导入和训练数据集,生成算法必须的参数和数据结构:

def train_set(self,trainset,classVec):
    self.cate_prob(classVec)    # 计算每个分类在数据集中的概率:P(yi)                     
   self.doclength = len(trainset)
tempset = set()   [tempset.add(word) for doc in trainset for word in doc ] # Th成词典   self.vocabulary= list(tempset)   self.vocablen = len(self.vocabulary)   self.calc_wordfreq(trainset) # 计算词频数据集 self.build_tdm() # 按分类累计向量空间的每维值:P(x|yi)

  3.cate_prob 函数:计算在数据集中每个分类的概率:P(yi)

def cate_prob(self,classVec): 
    self.labels = classVec
    labeltemps = set(self.labels) # 获取全部分类
    for labeltemp in labeltemps:
      #  统计列表中重复的分类:self.labels.count(labeltemp)
    self.Pcates[labeltemp] = float(self.labels.count(labeltemp))/float(len(self.labels))
    

  4.calc_wordfreq 函数:生成普通的词频向量

# Th成普通的词频向量
def calc_wordfreq(self,trainset):
  self.idf = np.zeros([1,self.vocablen]) # 1*词典数
  self.tf = np.zeros([self.doclength,self.vocablen]) # 训练集文件数*词典数
  for indx in xrange(self.doclength):    # 遍历所有的文本
    for word in trainset[indx]:    # 遍历文本中的每个词
      self.tf[indx,self.vocabulary.index(word)]  +=1   #  找到文本的词在字典中的位置+1
    for signleword in set(trainset[indx]):
      self.idf[0,self.vocabulary.index(signleword)] +=1

  5.build_tdm 函数:按分类累计计算向量空间的每维值:P(x|yi)

#按分类累计向量空间的每维值:P(x|yi)
def build_tdm(self):
  self.tdm = np.zeros([len(self.Pcates),self.vocablen]) # 类别行*词典列 sumlist = np.zeros([len(self.Pcates),1])   # 统计每个分类的总值
  for indx in xrange(self.doclength):
    self.tdm[self.labels[indx]] += self.tf[indx]    # 将同一类别的词向量空间值加总
    # 统计每个分类的总值--是个标量
  sumlist[self.labels[indx]]= np.sum(self.tdm[self.labels[indx]]) self.tdm = self.tdm/sumlist    #  Th成 P(x|yi)


   6.map2vocab 函数:将测试集映射到当前词典

def map2vocab(self,testdata):
  self.testset = np.zeros([1,self.vocablen]) for word in testdata:
  self.testset[0,self.vocabulary.index(word)] +=1

  7.predict 函数:预测分类结果,输出预测的分类类别

def predict(self,testset):
  if np.shape(testset)[1] != self.vocablen: # 如果测试集长度与词典不相等,退出程序
    print "输入错误" 
    exit(0)   predvalue
= 0 # 初始化类别概率   predclass = "" # 初始化类别名称   for tdm_vect,keyclass in zip(self.tdm,self.Pcates):     # P(x|yi) P(yi)     temp = np.sum(testset*tdm_vect*self.Pcates[keyclass]) # 变量 tdm,计算最大分类值     if temp > predvalue:
      predvalue = temp predclass = keyclass   return predclass

  三. 算法改进

  为普通的词频向量使用 TF-IDF 策略,使之有能力修正多种偏差。

  4.calc_tfidf 函数:以 tf-idf 方式Th成向量空间:

#  Th成 tf-idf
def calc_tfidf(self,trainset):
  self.idf = np.zeros([1,self.vocablen])
  self.tf = np.zeros([self.doclength,self.vocablen]) 
  for indx in xrange(self.doclength):     for word in trainset[indx]:       self.tf[indx,self.vocabulary.index(word)] +=1       # 消除不同句长导致的偏差       self.tf[indx] = self.tf[indx]/float(len(trainset[indx]))
        for signleword in set(trainset[indx]):           self.idf[0,self.vocabulary.index(signleword)] +=1   self.idf = np.log(float(self.doclength)/self.idf)   self.tf = np.multiply(self.tf,self.idf) # 矩阵与向量的点乘 tf x idf

  四. 评估分类结果

# -*- coding: utf-8 -*-

import sys import os
from numpy import * import numpyas np
from Nbayes_lib import *

dataSet,listClasses = loadDataSet()    # 导入外部数据集
# dataset: 句子的词向量,
# listClass 是句子所属的类别 [0,1,0,1,0,1]
nb = NBayes()    # 实例化
nb.train_set(dataSet,listClasses)    # 训练数据集
nb.map2vocab(dataSet[0])    # 随机选择一个测试句
print nb.predict(nb.testset)    # 输出分类结果

  分类结果

 1

 

执行我们创建的朴素贝叶斯类,获取执行结果

 

以上是关于贝叶斯算法的基本原理和算法实现的主要内容,如果未能解决你的问题,请参考以下文章

机器学习--朴素贝叶斯算法原理方法及代码实现

第五篇:朴素贝叶斯分类算法原理分析与代码实现

朴素贝叶斯分类算法的sklearn实现

朴素贝叶斯分类器原理

算法朴素贝叶斯分类算法原理与实践

朴素贝叶斯分类和预测算法的原理及实现