semi-Naive Bayesian（半朴素贝叶斯）

于 2024-10-21 20:43:39 发布
阅读量1.1k 收藏 20
点赞数 8
分类专栏： 机器学习 文章标签： 半朴素贝叶斯 机器学习 朴素贝叶斯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_52049033/article/details/143131720
版权

semi-Naive Bayesian（半朴素贝叶斯）

引言

朴素贝叶斯算法是基于特征是相互独立这个假设开展的（为了降低贝叶斯公式: P ( c ∣ x ) = P ( c ) P ( x ∣ c ) P ( x ) P(c|x) = \frac {P(c)P(x|c)}{P(x)} P(c∣x)=P(x)P(c)P(x∣c)​中后验概率 P ( c ∣ x ) P(c|x) P(c∣x)的困难），但在现实中这个假设往往很难成立。对条件独立假设进行适当的放宽，便引申出了“半朴素贝叶斯”。半朴素的意思就是，在朴素和非朴素之间寻找平衡，并不完全遵从条件独立，也不完全符合现实情况。

原理

在朴素贝叶斯中，对一个样本进行预测就是要找最大概率对应的类别，即
a r g m a x c k p ( c k ) ∏ i = 1 d P ( x i ∣ c l ) argmax_{c_k}p(c_k)\prod_{i=1}^d P(x_i|c_l) argmaxck​​p(ck​)i=1∏d​P(xi​∣cl​)
半朴素贝叶斯分类器的基本想法是适当考虑一部分属性间的相互依赖信息，从而既不需进行完全联合概率计算，又不至于彻底忽略了比较强的属性依赖关系。“独依赖估计”（One-Dependent Estimator，简称ODE）是半朴素贝叶斯分类器最常用的一种策略。“独依赖”就是假设每个属性在类别之外最多仅依赖于一个其他属性，即:
p ( c ∣ x ) ∝ p ( c k ) ∏ i = 1 d p ( x i ∣ c k , p a i ) p(c|x) \propto p(c_k)\prod_{i=1}^d p(x_i|c_k,pa_i) p(c∣x)∝p(ck​)i=1∏d​p(xi​∣ck​,pai​)
其中 p a i pa_i pai​为属性 x i x_i xi​所依赖的属性，称为 x i x_i xi​的父属性。此时，对每个属性 x i x_i xi​，若其父属性 p a i pa_i pai​已知，则可采用类似
p ^ ( x i ∣ c ) = ∣ D c , x i ∣ + 1 ∣ D c ∣ + N i \hat p(x_i|c) = \frac{|D_{c,x_i}|+1}{|D_c|+N_i} p^​(xi​∣c)=∣Dc​∣+Ni​∣Dc,xi​​∣+1​
的方法来估计概率值 p ( x i ∣ c , p a i ) p(x_i|c,pa_i) p(xi​∣c,pai​)。于是，问题就转化为如何确定每个属性的父属性，不同的做法产生不同的独依赖分类器。

根据不同确定父属性可以有不同的半朴素贝叶斯分类器：

  1. 选择贝叶斯分类器(SBC:Selective Bayesian Classifier)
  2. 超父独依赖估计分类器(SPODE:Super Parent ODE)
  3. 树增广朴素贝叶斯网络分类器(TAN:Tree Augmented NaiveBayes)
  4. 平均独依赖估测器(AODE:Averaged ODE)
  5. 加权平均独依赖估测器(WAODE:Weightily Averaged ODE)

在这里插入图片描述

  • SPODE

    确定父属性最直接的做法是假设所有属性都依赖于同一个属性，称为“超父”（super-parent），然后通过交叉验证等模型选择方法来确定超父属性，由此形成了SPODE（Super-Parent ODE）方法。

  • AODE

    将每个属性都作为超父来构建SPODE，然后将具有足够训练数据支撑的SPODE集成起来作为最终结果，由此形成了AODE算法（Averaged ODE），AODE是一种基于集成学习机制、更为强大的独依赖分类器。表达式：
    ∑ i = 1 d p ( c , x i ) ∏ j = 1 d p ( x j ∣ c , x i ) ， ∣ D x i ∣ ≥ m ′ \sum_{i=1}^d p(c,x_i)\prod{j=1}^dp(x_j|c,x_i)，|D_{x_i}|\geq m' i=1∑d​p(c,xi​)∏j=1dp(xj​∣c,xi​)，∣Dxi​​∣≥m′

    ∣ D x i ∣ |D_{x_i}| ∣Dxi​​∣ 是在第i个属性上取值为 x i x_i xi​的样本的集合，m’是阈值常数。
    p ( c , x i ) = ∣ D c , x i ∣ + 1 ∣ D ∣ + N c ∗ N i p(c,x_i) = \frac{|D_{c,x_i}|+1}{|D|+N_c*N_i} p(c,xi​)=∣D∣+Nc​∗Ni​∣Dc,xi​​∣+1​
    p ( x j ∣ c , x i ) = ∣ D c , x i , x j ∣ + 1 ∣ D c , x i ∣ + N j p(x_j|c,x_i) = \frac {|D_{c,x_i,x_j}|+1}{|D_{c,x_i}|+N_j} p(xj​∣c,xi​)=∣Dc,xi​​∣+Nj​∣Dc,xi​,xj​​∣+1​其中， N c N_c Nc​表示分类类别数， N i N_i Ni​表示第i个属性可能的取值数， N j N_j Nj​表示第j个属性可能的取值数， ∣ D c , x I ∣ |D_{c,x_I}| ∣Dc,xI​​∣表示分类为c，第i个属性取值为 x i x_i xi​的样本集合， ∣ D c , x i , x j ∣ |D_{c,x_i,x_j}| ∣Dc,xi​,xj​​∣表示分类为c，第i个属性取值为 x i x_i xi​，第j个属性取值为 x j x_j xj​的样本集合。

  • TAN

    TAN（Tree Augmented naive Bayes）是在最大带权生成树（maximum weighted spanning tree）算法的基础上，通过以下步骤将属性间依赖关系约简为如上图©所示的树形结构：

    1. 计算任意两个属性之间的条件互信息:
      I ( x i , x j ∣ y ) = ∑ x i , x j ; c ∈ y P ( x i , x j ∣ c ) l o g P ( x i , x j ∣ c ) P ( x i ∣ c ) P ( x j ∣ c ) I(x_i,x_j|y) = \sum_{x_i,x_j;c\in y}P(x_i,x_j|c)log\frac{P(x_i,x_j|c)}{P(x_i|c)P(x_j|c)} I(xi​,xj​∣y)=xi​,xj​;c∈y∑​P(xi​,xj​∣c)logP(xi​∣c)P(xj​∣c)P(xi​,xj​∣c)​
    2. 以属性为结点，构建完全图，任意两个结点之间边的权重设为 I ( x i , x j ∣ y ) I(x_i,x_j|y) I(xi​,xj​∣y)。
    3. 构建此完全图的最大带权生成树，挑选根变量，将边置为有向。
    4. 加入类别节点y，增加从y到每个属性的有向边。

代码

import numpy as np
import pandas as pd


######一、朴素贝叶斯分类器
class NBayes(object):
    #设置属性
    def __init__(self):
        self.Y = 0          #训练集标签
        self.X = 0          #训练集数据
        self.PyArr = {}     #先验概率总容器
        self.PxyArr = {}    #条件概率总容器

    #连续变量处理，返回均值和标准差
    def Gaussian(self, xArr):
        miu = np.mean(xArr)            #变量平均数
        sigma = np.std(xArr)           #变量标准差
        return miu, sigma

    #离散变量直接计算概率
    def classify(self, x, xArr, countSetX):
        countX = len(xArr)              #计算变量X的数量
        countXi = sum(xArr == x)   #计算变量X某个属性的数量
        Pxy = (countXi+1)/(countX+countSetX)    #加入拉普拉斯修正的概率
        return Pxy

    #计算P(y)，加入了拉普拉斯修正
    def calPy(self,Y):
        Py = {}
        countY = len(Y)
        for i in set(Y.flatten()):
            countI = sum(Y[:,0] == i)
            Py[i] = (countI + 1) / (countY + len(set(Y.flatten())))
        self.PyArr = Py
        return

    #计算P(x|y)，加入了拉普拉斯修正
    def calPxy(self, X, Y):
        m, n = np.shape(X)
        Pxy = {}
        for yi in set(Y.flatten()):
            countYi = sum(Y[:,0] == yi)
            Pxy[yi] = {}                        #第一层是标签Y的分类
            for xIdx in range(n):
                Pxy[yi][xIdx] = {}              #第二层是不同的变量X
                setX = set(X[:,xIdx])
                tempX = X[np.nonzero(Y[:,0] == yi)[0],xIdx]
                for xi in setX:
                    countSetX = len(setX)
                    if countSetX <= 10:
                        Pxy[yi][xIdx][xi] = self.classify(xi, tempX, countSetX)     #第三层是变量Xi的分类概率，离散变量
                    else:
                        Pxy[yi][xIdx]['miu'], Pxy[yi][xIdx]['sigma'] = self.Gaussian(tempX)
        self.PxyArr = Pxy
        return

    #训练
    def train(self, X, Y):
        self.calPy(Y)
        print('P(y)训练完毕')
        self.calPxy(X, Y)
        print('P(x|y)训练完毕')
        self.X = X
        self.Y = Y
        return

    #连续变量求概率密度
    def calContinous(self, x, miu, sigma):
        Pxy = np.exp(-(x-miu)**2/(2*sigma**2))/(np.power(2*np.pi,0.5)*sigma)   #计算概率密度
        return Pxy

    #预测
    def predict(self, testX):
        preP = {}
        m, n = testX.shape
        for yi, Py in self.PyArr.items():
            Ptest = Py
            print(yi,Ptest)
            for xIdx in range(n):
                xi = testX[0,xIdx]
                if len(set(self.X[:,xIdx])) <= 10:
                    Ptest *= self.PxyArr[yi][xIdx][xi]
                else:
                    pxy = self.calContinous(xi, self.PxyArr[yi][xIdx]['miu'], self.PxyArr[yi][xIdx]['sigma'])
                    Ptest *= pxy
                print(yi,Ptest)
            preP[yi] = Ptest
        return preP

    #防止数值下溢，预测时用log
    def predictlog(self, testX):
        preP = {}
        m, n = testX.shape
        for yi, Py in self.PyArr.items():
            Ptest = 0
            for xIdx in range(n):
                xi = testX[0,xIdx]
                if len(set(self.X[:,xIdx])) <= 10:
                    Ptest += np.log(self.PxyArr[yi][xIdx][xi])
                else:
                    pxy = self.calContinous(xi, self.PxyArr[yi][xIdx]['miu'], self.PxyArr[yi][xIdx]['sigma'])
                    Ptest += np.log(pxy)
                print(yi,Ptest)
            preP[yi] = Py*Ptest
        return preP

#数据集准备
from sklearn.preprocessing import OrdinalEncoder
dataSet = [
        ['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.697, 0.460, '好瓜'],
        ['乌黑', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', 0.774, 0.376, '好瓜'],
        ['乌黑', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.634, 0.264, '好瓜'],
        ['青绿', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', 0.608, 0.318, '好瓜'],
        ['浅白', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.556, 0.215, '好瓜'],
        ['青绿', '稍蜷', '浊响', '清晰', '稍凹', '软粘', 0.403, 0.237, '好瓜'],
        ['乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘', 0.481, 0.149, '好瓜'],
        ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '硬滑', 0.437, 0.211, '好瓜'],
        ['乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑', 0.666, 0.091, '坏瓜'],
        ['青绿', '硬挺', '清脆', '清晰', '平坦', '软粘', 0.243, 0.267, '坏瓜'],
        ['浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑', 0.245, 0.057, '坏瓜'],
        ['浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘', 0.343, 0.099, '坏瓜'],
        ['青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑', 0.639, 0.161, '坏瓜'],
        ['浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑', 0.657, 0.198, '坏瓜'],
        ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘', 0.360, 0.370, '坏瓜'],
        ['浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑', 0.593, 0.042, '坏瓜'],
        ['青绿', '蜷缩', '沉闷', '稍糊', '稍凹', '硬滑', 0.719, 0.103, '坏瓜']
    ]
#特征值列表
labels = ['色泽', '根蒂', '敲击', '纹理', '脐部', '触感', '密度', '含糖率']
dataX = np.array(dataSet)[:,:6]
oriencode = OrdinalEncoder(categories='auto')
oriencode.fit(dataX)
X1=oriencode.transform(dataX)           #编码后的数据
X2=np.array(dataSet)[:,6:8].astype(float)
X = np.hstack((X1,X2))
Y = np.array(dataSet)[:,8]
Y[Y=="好瓜"]=1
Y[Y=="坏瓜"]=0
Y=Y.astype(float)
Y = Y.reshape(-1,1)

#训练
NB = NBayes()
NB.train(X, Y)
Pdict = NB.predict(X[0,:].reshape(1,-1))
logPdict = NB.predictlog(X[0,:].reshape(1,-1))


######二、半朴素贝叶斯分类器(Averaged One-Dependent Estimator)
class HalfNBayes(object):
    #设置属性
    def __init__(self):
        self.Y = 0          #训练集标签
        self.X = 0          #训练集数据
        self.PyArr = {}     #先验概率总容器
        self.PxyArr = {}    #条件概率总容器

    #连续变量处理，返回均值和标准差
    def Gaussian(self, xArr):
        miu = np.mean(xArr)            #变量平均数
        sigma = np.std(xArr)           #变量标准差
        return miu, sigma

    #离散变量直接计算概率
    def classify(self, x, xArr, countSetX):
        countX = len(xArr)              #计算变量X的数量
        countXi = sum(xArr == x)   #计算变量X某个属性的数量
        Pxy = (countXi+1)/(countX+countSetX)    #加入拉普拉斯修正的概率
        return Pxy

    #计算P(xi,y)，加入了拉普拉斯修正
    def calPy(self, X, Y):
        m, n = np.shape(X)
        Py = {}
        countY = len(Y)
        for i in set(Y.flatten()):
            Py[i] = {}                          #第一层是标签Y的分类
            for j in range(n):
                setX = set(X[:,j])
                countSetX = len(setX)
                if countSetX <= 10:
                    Py[i][j] = {}               #第二层是不同的变量X
                    for xi in setX:
                        countI = sum((Y[:,0] == i) & (X[:,j] == xi))
                        Py[i][j][xi] = (countI + 1) / (countY + countSetX*len(set(Y.flatten())))       #第二层是分类变量xi的不同值
        self.PyArr = Py
        return

    #计算P(x|y,xi)，加入了拉普拉斯修正
    def calPxy(self, X, Y):
        m, n = np.shape(X)
        Pxy = {}
        for yi in set(Y.flatten()):
            countYi = sum(Y[:,0] == yi)
            Pxy[yi] = {}                        #第一层是标签Y的分类
            for superX in range(n):
                setSuperX = set(X[:,superX])
                countSuperX = len(setSuperX)
                if countSuperX <= 10:
                    Pxy[yi][superX] = {}        #第二层是超父变量X，只有离散变量
                    for superXi in setSuperX:
                        Pxy[yi][superX][superXi] = {}               #第三层是超父变量的属性值superXi
                        for xIdx in range(n):
                            if xIdx == superX:
                                continue
                            Pxy[yi][superX][superXi][xIdx] = {}     #第四层是不同的变量X
                            setX = set(X[:,xIdx])
                            tempX = X[np.nonzero((Y[:,0] == yi)&(X[:,superX] == superXi))[0],xIdx]
                            for xi in setX:
                                countSetX = len(setX)
                                if countSetX <= 10:
                                    Pxy[yi][superX][superXi][xIdx][xi] = self.classify(xi, tempX, countSetX)     #第五层是变量Xi的分类概率，离散变量
                                else:
                                    Pxy[yi][superX][superXi][xIdx]['miu'], Pxy[yi][superX][superXi][xIdx]['sigma'] = self.Gaussian(tempX)
        self.PxyArr = Pxy
        return

    #训练
    def train(self, X, Y):
        self.calPy(X, Y)
        print('P(y)训练完毕')
        self.calPxy(X, Y)
        print('P(x|y)训练完毕')
        self.X = X
        self.Y = Y
        return

    #连续变量求概率密度
    def calContinous(self, x, miu, sigma):
        Pxy = np.exp(-(x-miu)**2/(2*sigma**2+1.0e-6))/(np.power(2*np.pi,0.5)*sigma+1.0e-6)   #计算概率密度
        return Pxy

    #预测
    def predict(self, testX):
        preP = {}
        m, n = testX.shape
        for yi, Py in self.PyArr.items():
            Ptest = Py
            print(yi,Ptest)
            for xIdx in range(n):
                xi = testX[0,xIdx]
                if len(set(self.X[:,xIdx])) <= 10:
                    Ptest *= self.PxyArr[yi][xIdx][xi]
                else:
                    pxy = self.calContinous(xi, self.PxyArr[yi][xIdx]['miu'], self.PxyArr[yi][xIdx]['sigma'])
                    Ptest *= pxy
                print(yi,Ptest)
            preP[yi] = Ptest
        return preP

    #防止数值下溢，预测时用log
    def predictlog(self, testX):
        preP = {}
        m, n = testX.shape
        for yi, superXdict in self.PyArr.items():
            print('yi是{}================'.format(yi))
            Ptest = 0
            for superX, superXidict in superXdict.items():
                superXi = testX[0,superX]
                Py = superXidict[superXi]
                print('超父属性是{}，Py概率是{}'.format(superX, Py))
                print('----------------')
                Pxi = 0
                for xIdx in range(n):
                    if xIdx == superX:
                        continue
                    xi = testX[0,xIdx]
                    print('第{}个变量，值是{}'.format(xIdx, xi))
                    if len(set(self.X[:,xIdx])) <= 10:
                        Pxi += np.log(self.PxyArr[yi][superX][superXi][xIdx][xi])
                        print('概率是：',np.log(self.PxyArr[yi][superX][superXi][xIdx][xi]))
                    else:
                        pxy = self.calContinous(xi, self.PxyArr[yi][superX][superXi][xIdx]['miu'], self.PxyArr[yi][superX][superXi][xIdx]['sigma'])
                        print('概率是：',pxy)
                        Pxi += np.log(pxy)
                Ptest += Py*Pxi
            preP[yi] = Ptest
        return preP

#训练
HNB = HalfNBayes()
HNB.train(X, Y)
logPdict = HNB.predictlog(X[15,:].reshape(1,-1))

参考

机器学习基础

知乎

知乎

代码

机器学习强基计划4-5：详解半朴素贝叶斯分类TAN原理(附Python实现)
FRIGIDWINTER的博客
10-13 2421
TAN算法通过条件互信息分析属性内部结构，保留了强依赖属性间的联系，本文解析了TAN算法内部的几个技术点，并给出了Python实现与可视化
【ML小结7】贝叶斯分类器：朴素、半朴素贝叶斯
樛木
11-20 667
贝叶斯分类器在预先给定代价的情况下平均风险最小的分类器。 分类原理：通过某对象的先验概率，利用贝叶斯公式计算出其后验概率。 贝叶斯分类器的基础 贝叶斯公式 P(H∣X)=P(X∣H)P(H)P(X)P(H|X)=\frac{P(X|H)P(H)}{P(X)}P(H∣X)=P(X)P(X∣H)P(H)​其中,X表示n个属性的测量描述； H为某种假设，比如假设某观察值X属于某个特定的类别C； P(X)...
机器学习-半朴素贝叶斯
lyn5284767的专栏
09-06 1019
一，介绍 朴素贝叶斯采用了属性独立的假设条件，这在现实生活中是难以成立的，因而人们尝试对属性条件进行了一定程度放松，假设每个属性最多依赖另一个属性，产生了一类称为半朴素贝叶斯的学习方法：                                                                  半朴素贝叶斯的基本思路是适当考虑一部分依赖性强的属性。最常用的策略是“独依赖...
半朴素贝叶斯算法
qq_32172681的博客
09-21 2674
前置知识： 贝叶斯公式：https://blog.youkuaiyun.com/qq_32172681/article/details/98032205 朴素贝叶斯算法：https://blog.youkuaiyun.com/qq_32172681/article/details/101112211 1.、半朴素贝叶斯的“半” 前面说到，朴素贝叶斯(NB)的‘朴素’就体现在它假设各属性之间没有相互依赖，可以...
贝叶斯分类器-2：半朴素贝叶斯分类器
super
02-02 4628
朴素贝叶斯存在两个问题需要考虑：1、特征独立性假设；2、在训练样本不足的前提下先验概率的估计方法。半朴素贝叶斯改进了这两个问题。
生成模型之半朴素贝叶斯
kylin_learn的博客
08-29 226
【机器学习-西瓜书】第7章 贝叶斯分类器
wayaya112的博客
04-01 3346
7.1 贝叶斯决策论 (Bayesian Decision Theory) 在所有相关概率都已知的情况下，贝叶斯决策论考虑的是：如何基于这些概率和误判损失来选择最优的类别标记。 以多分类任务为例解释BDT的基本原理 表示 将真实标记 cj 的样本误分类为 ci 所产生的损失。基于后验概率可得到 将样本 x 分类为 ci 所产生的期望损失： 我们的目标是：寻找一个判定准则以最小化总体风险： 贝叶斯判定准则：为最小化总体风险，只需 在每个样本上选择那个能使条件风险 R( c|x...
半朴素贝叶斯
最新发布
03-09
半朴素贝叶斯(Semi-Naive Bayesian, SNB)是一种改进型的贝叶斯分类方法，在传统朴素贝叶斯的基础上放松了属性独立性的假设。具体而言，SNB允许某些特定类型的依赖关系存在于变量之间，从而提高了模型的表现力和准确...
机器学习之贝叶斯分类器
weixin_44153121的博客
02-20 4626
贝叶斯决策论(Bayesian decision theory)是概率框架下实施决策的基本方法。对分类任务来说，在所有相关概率都己知的理想情形下，贝叶斯决策论考虑如何基于这些概率和误判损失来选择最优的类别标记。GaussianNB 实现了运用于分类的高斯朴素贝叶斯算法。MultinomialNB 实现了服从多项分布数据的朴素贝叶斯算法。ComplementNB实现了补充朴素贝叶斯(CNB)算法。
理解贝叶斯分类器原理及关系
ID-Explorer的博客
01-03 1097
作者：vicky 致谢：小龙快跑jly, 巧儿、克力,Esther_or so,雨佳小和尚 本文是对贝叶斯分类器的初步理解，通过案例解释贝叶斯并对贝叶斯分类器的关系进一步分析和理解。本文只是在学习后进行了总结并加入了自己的理解，如有不妥之处，还望海涵，也希望大家多多指教，一起学习！ 一、 贝叶斯三连问 贝叶斯分类器是什么？有什么用？怎么用？ 为了更好地理解这个问题，我们先看一个案例： 案...
机器学习实验数据深度解析：HMM、LDA与朴素贝叶斯
该文件可能涉及到机器学习中的多种算法和数据集，包括隐马尔可夫模型（HMM）、潜在狄利克雷分配（LDA）和朴素贝叶斯分类器（Naive Bayesian）。每一种算法都有其特定的应用场景和特点，例如HMM适用于序列数据的处理...
【贝叶斯分类3】半朴素贝叶斯分类器
NoBug
06-22 3404
  我们根据贝叶斯决策论，或者说是贝叶斯分类原理，首先得到的是一个期望损失【R(ci∣x)=∑j=1NλijP(cj∣x)R(c_i|x)=\sum_{j=1}^N\lambda_{ij}P(c_j|x)R(ci​∣x)=∑j=1N​λij​P(cj​∣x)】。贝叶斯判定准则就是要让总体风险最小，从而可推到要求部分风险最小【h∗(x)=arg minc∈YR(c∣x)h^*(x)=arg\ min_{c\in Y}R(c|x)h∗(x)=arg minc∈Y​R(c∣x)】。   可以把ccc 看作“类别”
机器学习算法——贝叶斯分类器4（半朴素贝叶斯分类器）
Vicky_xiduoduo的博客
04-29 2453
为了降低贝叶斯公式中估计后验概率的困难，朴素贝叶斯分类器采用了属性条件独立性假设，但在现实任务中这个假设往往很难成立。于是，人们尝试对属性条件独立性假设进行一定程度的放松，由此产生了一类称为“半朴素贝叶斯分类器”的学习方法。 半朴素分类器的基本思想是适当考虑一部分属性间的相互依赖信息，从而既不需进行完全联合概率计算，又不至于彻底忽略了比较强的属性依赖关系。“独依赖估计”（One-Dependent Estimator,ODE）是半朴素贝叶斯分类器常用的一种策略。即假设每个属性在类别之外最多仅依赖于一个其它
朴素贝叶斯 半朴素贝叶斯_从零开始实施朴素贝叶斯
weixin_26735933的博客
09-11 849
朴素贝叶斯 半朴素贝叶斯I have a little knowledge of LaTeX and I just found out how to show them in a Medium Post. Hence I am going to use my truly “useful” LaTex knowledge to start a new series on something that...
朴素和半朴素贝叶斯
bravery_again的博客
07-22 1428
引入 贝叶斯决策论是概率框架下实施决策的基本方法，它基于概率和误判误差的最小化来进行判别，是一种分类问题的解法。 原理 首先，将数据及其属性记为x，对于多分类任务，其可能的取值有N种，设为{c1,c2,c3.....cNc1,c2,c3.....cNc_1,c_2,c_3.....c_N}，统称为c。数据x的正确分类记为cxcxc_x。于是将算法的正确率记为： ​ ...
（《机器学习》完整版系列）第7章 贝叶斯分类器——7.4 朴素贝叶斯分类器与半朴素贝叶斯分类器（样本独立？属性独立？类条件属性独立？）
qiy_icbc的博客
02-26 460
基于样本独立，用于极大似然法；基于属性独立，用于朴素贝叶斯。 朴素贝叶斯分类器的独立性假设，是针对所有属性而言，这个要求太强了，难以达到。弱化为：假定在类条件下所有属性相互独立，则得到半朴素贝叶斯分类器。
【机器学习】贝叶斯分类器 | 分类器基本原理，朴素贝叶斯，半朴素贝叶斯，贝叶斯网
专注于人工智能的算法与应用
03-12 1822
在学习贝叶斯分类器的过程中​ 我们的学习本质上是对于众多的属性，x1,x2,x3 到一个结果分类y，线性分类器什么的是训练集拟合一个函数从众多属性x到y，SVM是学习一个分界线划分不同的y对应的x，而贝叶斯分类器本质上是对数据集观测做统计结果从而对未知的属性进行预测​ 传统机器学习果然就是手工提取特征，就是比如属性之间的依赖关系也得靠我们人工设计，甚至会有很多的假设。
机器学习基础（六）：贝叶斯分类（贝叶斯决策论、朴素/半朴素贝叶斯分类器、贝叶斯网、EM算法）
zero_ling
09-27 3868
6、贝叶斯分类 6.1贝叶斯决策论Bayesian decision theory 概率框架下实施决策的基本方法。 对分类任务来说，在所有相关概率都已知的理想情形下，贝叶斯决策论考虑如何基于这些概率和误判损失来选择最优的类别标记。 贝叶斯判定准则Bayes decision rule：为最小化总体风险，只需在每个样本上选择那个能使条件风险最小的类别标记，即，h* 称为贝叶斯最优分类器Bayes optimal classifier，与之对应的总体风险R(h*)称为贝叶斯风险Bayes risk，1-R(h
【机器学习】贝叶斯分类（通过通俗的例子轻松理解朴素贝叶斯与半朴素贝叶斯）
qq_43703185的博客
06-10 839
原文链接：https://blog.youkuaiyun.com/lyl771857509/article/details/78993493 贝叶斯分类 贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。而朴素朴素贝叶斯分类是贝叶斯分类中最简单，也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到的朴素贝叶斯分类算法，希望有利于他人理解。
使用cl-naive-bayes库在Lisp中实现朴素贝叶斯分类
资源摘要信息:"Cl-Naive-Bayes是Common Lisp编程语言的一个库，用于实现朴素贝叶斯分类器，这是一种基于概率的简单但有效的机器学习算法。朴素贝叶斯分类器基于贝叶斯定理，并且假设每个特征都是独立的，即不考虑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

czijin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值