python机器学习:朴素贝叶斯(17)

作者 : 慕源网 本文共12959个字,预计阅读时间需要33分钟 发布时间: 2021-10-22 共330人阅读

python机器学习:朴素贝叶斯(17)

本文是Python 机器学习系列的一部分。您可以在此处找到本系列之前所有帖子的链接

介绍

在上一章中,我们学习了决策树。

在本章中,我们将学习朴素贝叶斯。

注意:如果你能将任何事情与你自己或你的生活联系起来,那么理解这个概念的机会就更大。因此,尝试通过将一切与人类联系起来来理解一切。

关键术语

1. 硬币

硬币有两个面,头和尾。如果一个事件由多个硬币组成,则硬币被视为不同的,除非另有说明。

2. 骰子

骰子有六个面,分别标记为 11、2、3、4、5 和 6。如果我们有多个骰子,则所有骰子都被视为不同的,除非另有说明。

3. 扑克牌

一副扑克牌有 52 张牌。有 4 种花色(黑桃、红心、菱形和梅花),每一种都有 13 张牌。有两种颜色,红色(心形和菱形)和黑色(黑桃和梅花),每一种都有 26 张牌。每个花色的 13 张牌中,有 3 张面牌,即国王、王后和杰克,因此总共 12 张面牌。此外,还有16张荣誉牌,每套4张,即王牌、国王、王后和杰克。

实验类型

1. 确定性实验 那些在相同条件下重复产生相同结果或结果的实验​​称为确定性实验,

2. 概率/随机实验 那些在相同条件下重复的实验,每次都不会产生相同的结果,但试验中的结果是称为随机实验的几种可能结果之一。

重要定义

(i) 审判

让一个随机实验,在相同的条件下重复,那么这个实验称为试验。

(ii) 样本空间

实验的所有可能结果的集合称为实验的样本空间,用 S 表示。

(iii) 事件

与随机实验相关的样本空间子集称为事件或案例。

(iv) 样本点

实验的结果称为样本点。

(v) 某些事件

必须发生的事件,无论结果如何,都称为确定或确定事件。

(vi) 不可能的事件

在特定随机实验中不可能发生的事件称为不可能事件。

(vii) 初级活动

一个事件当然只有一个样本点被称为基本事件或不可分解事件。

(viii) 有利事件

令 S 为与随机实验相关的样本空间,令 E ⊂ S。那么,属于 E 的基本事件被称为对 E 的有利事件。

(ix) 复合事件

一个事件肯定不止一个样本点被称为复合事件或可分解事件。

可能性

如果有 n 个与随机实验相关的基本事件,其中 m 个有利于事件 A,则 A 发生或发生的概率,用 P(A) 表示,由 P(A) = m / n 给出= 有利案例数 / 可能案例总数

事件类型

(i) 同样可能的事件

如果给定的事件中没有一个比另一个优先发生,则称给定的事件具有同等可能性。

(ii) 互斥事件

如果一个事件的发生排除了另一个事件的发生,则称一组事件是互斥的。如果 A 和 B 互斥,则 P(A ∩ B) = 0

(iii) 详尽事件

如果实验的执行总是导致至少一个事件的发生,则称一组事件是穷尽的。如果 E1, E2, … , En 是穷举事件,则 El ∪ E2 ∪ … ∪ En = S 即,P(E1 ∪ E2 ∪ E3 ∪ … ∪ En) = 1

(iv) 独立事件

如果 A 发生或不发生的概率不受 B 发生或不发生的影响,则与随机实验相关的两个事件 A 和 B 是独立的。即 P(A ∩ B) = P(A) P (乙)

事件的补充

设 A 是样本空间 S 中的事件~A 的补集是空间中除 A 中的样本点之外的所有样本点的集合,记为 A’ 或 A = {n : n ∈ S, n ∉ A}

(i) P(A ∪ A’) = S

(ii) P(A ∩ A’) = φ

(iii) P(A’)’ = A

样本空间的划分

如果事件 A1, A2,…., An 表示样本空间 S 的一个分区,如果它们是成对不相交的、穷举的并且具有非零概率。IE,

(i) Ai∩Aj = φ;i≠j;i,j= 1,2, …. ,n

(ii) A1 ∪ A2 ∪ … ∪ An = S

(iii) P(Ai) > 0, ∀ i = 1,2, …. ,n

概率的重要结果

(i) 如果一组事件 A1, A2,…., An 是互斥的,那么

A1 ∩ A2 ∩ A3 ∩ …∩ An = φ

P(A1 ∪ A2 ∪ A3 ∪… ∪ An) = P(A1) + (A2) + … + P(An) 和 A1 ∩ A2 ∩ A3 ∩ …∩ An = 0

(ii) 如果一组事件 A1, A2,…., An 是穷举的,那么 P(A1 ∪ A2 ∪ … ∪ An) = 1
(iii) 不可能事件的概率为 O。即,如果 A 是不可能事件,则 P(A) = 0。,
(iv) 样本空间中任何事件的概率为 1。即 P(A) = 1
(v) A 的赔率 = P(A) / P(A)

(vi) 反对 A 的赔率 = P(A) / P(A)

(vii) 概率加法定理

(a) 对于两个事件 A 和 B

P(A ∪ B) = P(A) + P(B) – P(A ∩ B)

(b) 对于三个事件 A、B 和 C

P(A ∪ B ∪ C) = P(A) + P(B) + P(C) -P(A ∩ B) – P(B ∩ C) – P(A ∩ C) + P(A ∩ B) ∩ C)

(c) 对于 n 个事件 A1, A2,…, An

(viii) 如果 A 和 B 是两个事件,则 P(A ∩ B) ≤ P(A) ≤ P(A ∪ B) ≤ P(A) + P(B)

(ix) 如果 A 和 B 是与随机实验相关的两个事件,则

(a) P(A ∩ B) = P(B) – P(A ∩ B)

(b) P(A ∩ B) = P(A) – P(A ∩ B)

(c)P [(A ∩ B) ∪ (A ∩ B)] = P(A) + P(B) – 2P(A ∩ B)

(d) P(A ∩ B) = 1- P(A ∪ B)

(e) P(A ∪ B) = 1- P(A ∩ B)

(f) P(A) = P(A ∩ B) + P(A ∩ B)。

(g) P(B) = P(A ∩ B) + P(B ∩ A)

(X)

(a) P(恰好是 A、B 之一)= P(A) + P(B) – 2P(A ∩ B) = P(A ∪ B) – P(A ∩ B)

(b) P(既不是 A 也不是 B) = P(A’ ∩ B’) = 1 – P(A ∪ B)

(xi) 如果 A、B 和 C 是三个事件,则

(a) P(恰好 A、B、C 之一出现)= P(A) + P(B) + P(C) – 2P(A ∩ B) – 2P(B ∩ C) – 2P(A ∩ C) ) + 3P(A ∩ B ∩ C)

(b) P(A、B、C中至少出现两个)= P(A ∩ B) + P(B ∩ C) + P(C ∩ A) – 2P(A ∩ B ∩ C)

(c) P(恰好两个 A、B、C 出现)。= P(A ∩ B) + P(B ∩ C) + P(A ∩ C) – 3P(A ∩ B ∩ C)

(十二)

(a) P(A ∪ B) = P(A) + P(B),如果 A 和 B 是互斥事件。

(b) P(A ∪ B ∪ C) = P(A) + P(B) + P(C),如果 A 和波段 C 是互斥事件。

(xiii) P(A) = 1- P(A)

(xiv) P(A ∪ B) = P(S) = 1, P(φ) = 0

(xv) P(A ∩ B) = P(A) x P(B),如果 A 和 B 是独立事件。

(xvi) 如果 A1, A2,…., An 是与随机实验相关的独立事件,则至少有一个事件发生的概率

= P(A1 ∪ A2 ∪…. ∪ An)

= 1 – P(A1 ∪ A2 ∪…. ∪ An)

= 1 – P(A1)P(A2)…P(An)

(xvii) 如果 B ⊆ A,则 P(A ∩ B) = P(A) – P(B)

条件概率

设 A 和 B 为与随机实验相关的两个事件,则在 B 已经发生且 P(B) ≠ 0 的条件下,事件 A 发生的概率称为条件概率。

即,P(A/B) = P(A ∩ B) / P(B)

如果 A 已经发生并且 P (A) ≠ 0,则

P(B/A) = P(A ∩ B) / P(A)

另外,P(A/B)+P(A/B)=1

概率乘法定理

(i) 如果 A 和 B 是与随机实验相关的两个事件,则

P(A∩B)=P(A)P(B/A),如果P(A)≠0

或者

P(A ∩ B) = P(B)P(A /B), 如果 P(B) ≠ 0

(ii) 如果 A1, A2,…., An 是与随机实验相关的 n 个事件,则

P(A1 ∩ A2 ∩….∩ An) = P(A1) P(A2 / A1) P(A3 / (A1 ∩ A2)) …P(An / (A1 ∩ A2 ∩ A3 ∩…∩A n – 1 ))

总概率

设 S 为样本空间,E1, E2,…., En 为与随机实验相关的 n 个互斥且详尽的事件。如果 A 是随 E1 或 E2 或 … 或 En 发生的任何事件,则

P(A) = P(E1)P(A / E1) + P(E2)P(A / E2) + … + P(En) P(A / En)

贝叶定理

设 S 为样本空间,设 E1、E2、…、En 为与随机实验相关的 n 个互斥且详尽的事件。如果 A 是随 E1 或 E2 或 … 或 En 发生的任何事件,则当 A 发生时 Ei 的发生概率,

在哪里,

  1. P (Ei), i = 1,2, n 被称为先验概率
  2. P (A / Ei), i= 1,2, , n 称为似然概率
  3. P (Ei / A), i = 1, 2, … ,n 称为后验概率

python机器学习:朴素贝叶斯(17)

或者

python机器学习:朴素贝叶斯(17)

其中 A 和 B 是事件且 P ( B ) ≠ 0。

  1. P ( A ∣ B ) 是条件概率:给定 B 为真,事件 A 发生的可能性。
  2. P ( B ∣ A ) 也是一个条件概率:假设 A 为真,事件 B 发生的可能性。
  3. P ( A ) 和 P ( B ) 是观察 A 和 Bindependently 彼此的概率;这被称为边际概率。

随机变量

让 U 或 S 是与给定随机实验相关的样本空间。在 U 或 S 上定义的实值函数 X,即,

X: U → R 称为随机变量。

有两种类型的随机变量。

(i) 离散随机变量

如果实函数 X: U → R 的范围是实数的有限集或无限集,则称为离散随机变量。

(ii) 连续随机变量

如果 X 的范围是 R 的区间 (a, b),则称 X 为连续随机变量。例如,掷两枚硬币 S = {HH, HT, TH, TT},设 X 表示掷两枚硬币正面朝上的次数,则 X(HH) = 2, X(TH) = 1, X( TT) = 0

概率分布

如果随机变量 X 取值 X1, X2,…., Xn 具有各自的概率 P1, P2,…., Pn 那么被称为 X 的概率分布,或者概率分布给出随机变量的值以及相应的概率。

数学期望/平均值

如果 X 是一个离散随机变量,假设值 X1, X2,…., Xn 具有各自的概率 P1, P2,…., Pn 那么 X 的均值 x 定义为

E(X) = X = P1X1 + P2X2 + … + PnXn = Σni = 1 PiXi

重要结果

(i) 方差 V(X) = σ2x = E(X2) – (E(X))2

其中,E(X2) = Σni = 1 x2iP(xi)

(ii) 标准偏差 √V(X) = σx = √E(X2) – (E(X))2

(iii) 如果 Y = a X + b,则

(a) E(Y) = E(aX + b) = aE(X) + b

(b) σ2y = a2V(Y) = a2σ2x

(c) σy = √V(Y) = |a|σx

(iv) 如果 Z = aX2 + bX + c,则

E(Z) = E(aX2 + bX + c) = aE(X2) + bE(X) + c

贝叶定理举例说明

让我们试着通过一个例子来理解上面的公式:

说到C-SharpCorner,如果一个人访问C-SharpCorner,他/她重访的几率是60%,一个人喜欢某篇文章的几率是75%。一个人喜欢这篇文章并回来的几率是 75%。因此,我们需要找出一个人在不喜欢这篇文章的情况下重新访问该网站的概率。

解决方案

A:一个人再次访问该网站

B:一个人喜欢一篇文章

所以,P(A) = 0.6,P(A’) = 0.4

P(B) = 0.75 , P(B’) =0.25

P(A|B) = 0.75, P(A’|B) = 0.25

P(B|A’) = P((A’|B)*P(B))/ P(A’)

            = (0.25*0.75)/0.4

= 0.46875

所以,从上面的计算,很明显,如果一个人不喜欢某篇文章,他/她会重新访问约 47% 的时间

什么时候使用朴素贝叶斯分类器?

1.实时预测

朴素贝叶斯算法速度快,随时可以学习,因此最适合实时预测。

2. 多类预测

可以使用朴素贝叶斯算法预测任何目标变量的多类概率。

3.推荐系统

朴素贝叶斯分类器在协同过滤的帮助下构建了一个推荐系统。该系统使用数据挖掘和机器学习技术来过滤以前从未见过的信息,然后预测用户是否会欣赏给定的资源。

4. 文本分类/情感分析/垃圾邮件过滤

由于朴素贝叶斯算法在处理多类问题时的性能更好,并且具有独立性规则,因此在文本分类中表现更好或成功率更高,因此被用于情感分析和垃圾邮件过滤。

贝叶斯和朴素贝叶斯算法的区别

朴素贝叶斯分类器是贝叶斯分类器的近似,其中我们假设特征在给定类的情况下是条件独立的,而不是在给定类的情况下对其完整的条件分布进行建模。贝叶斯分类器最好解释为决策规则。假设我们试图估计(“分类”)一个观察的类别,给定一个特征向量。表示 C 类和特征向量 (F1, F2,…, Fk)。给定数据背后的概率模型(即给定 (C, F1, F2,…, Fk) 的联合分布,贝叶斯分类函数通过最大化给定观察到的特征的类的概率来选择一个类: argmaxc P( C=c∣F1=f1,…,Fk=fk)

朴素贝叶斯算法的假设

  1. 所有功能都是独立的,即任何功能之间都没有依赖关系。
  2. 每个特征都被赋予相同或相同的重要性或相同的权重

充分利用朴素贝叶斯算法的注意事项

  1. 分类输入朴素贝叶斯假定标签属性如二元、分类或名义。
  2. 高斯输入如果输入变量是实值,则假定为高斯分布。在这种情况下,如果您的数据的单变量分布是高斯分布或接近高斯分布,则算法的性能会更好。这可能需要去除异常值(例如,与平均值相差超过 3 或 4 个标准差的值)。
  3. 分类问题朴素贝叶斯最适用于二元和多类分类。
  4. 对数概率计算不同类别值的可能性涉及将许多小数相乘。我们应该使用概率的对数变换来避免数值精度下溢。
  5. 核函数不是假设数值输入值是高斯分布,而是可以使用更复杂的分布,例如各种核密度函数。
  6. 更新概率当新数据可用时,您可以简单地更新模型的概率。如果数据频繁更改,这会很有帮助。

朴素贝叶斯算法的类型

1. 多项式朴素贝叶斯

这主要用于文档分类问题,即文档是否属于体育、政治、技术等类别。分类器使用的特征/预测器是文档中出现的单词的频率。

2. 伯努利朴素贝叶斯

这类似于多项式朴素贝叶斯,但预测变量是布尔变量。我们用于预测变量类别的参数仅取值 yes 或 no,例如,文本中是否出现一个单词。

3. 高斯朴素贝叶斯

当预测变量采用连续值而不是离散值时,我们假设这些值是从高斯分布中采样的。

4. 半监督参数估计

放弃从标记数据训练朴素贝叶斯分类器,可以构建半监督训练算法,该算法可以通过在循环中运行监督学习算法来从标记数据和未标记数据的组合中学习

什么是朴素贝叶斯?

Type Long Not Long Sweet Not Sweet Yellow Not Yellow Total
Banana 400 100 350 150 450 50 500
Orange 0 300 150 150 300 0 300
Other 100 100 150 50 50 150 200
Total 500 500 650 350 800 200 1000

因此,分类器的目标是在仅知道 3 个特征(long, sweet, 和 yellow)时预测给定的水果是“香蕉”还是“橙色”或“其他”。

因此,为了预测这一点,我们需要找到 3 个概率。开始吧

1. 我们首先计算每一类水果的“Prior”概率
P[Y=Banana] = 500/1000 = 0.5
P[Y=Orange] = 300/1000 = 0.3
P[Y=Other] = 200/1000 = 0.2

2. 然后我们计算进入分母的证据概率

P[x1=Long] =  500/100 = 0.5
P[x2=Sweet] = 650/100 = 0.65
P[x3=Yellow] = 800/100 = 0.8

3. 现在我们计算进入分子的证据的似然概率

P[x1=Long | Y=Banana] = 400/500 = 0.8
P[x2=Sweet | Y=Banana] = 350/500 = 0.7
P[x3=Yellow | Y=Banana] = 450/500 = 0.9

4. 最后我们替换朴素贝叶斯公式中的所有值,

a. P(Banana | Long, Sweet and Yellow)
= ((P(Long | Banana) * P(Sweet | Banana) * P(Yellow | Banana))*P(Banana))/ (P(Long) * P(Sweet) * P(Yellow))
= ((0.8 * 0.7 * 0.9) * 0.5)/(0.5 * 0.65 * 0.8)
=  0.97
b. P(Orange | Long, Sweet and Yellow)
=  ((P(Long | Orange) * P(Sweet | Orange) * P(Yellow | Orange))*P(Orange))/ (P(Long) * P(Sweet) * P(Yellow))
= 0
c. P(Others | Long, Sweet and Yellow)
= ((P(Long | Others) * P(Sweet | Others) * P(Yellow | Others))*P(Others))/ (P(Long) * P(Sweet) * P(Yellow))
= 0.07

因此,根据朴素贝叶斯分类器,我们预测水果是Banana。

决策树的Python实现

以IRIS数据集为例,可以直接从sklearn数据集仓库中导入。随意使用任何数据集,kaggle 和 Google Colab 上有一些非常好的数据集。

1. 使用功能

from csv import reader  
from math import sqrt  
from math import exp  
from math import pi  
   
# Load a CSV file  
def load_csv(filename):  
    dataset = list()  
    with open(filename, 'r') as file:  
        csv_reader = reader(file)  
        for row in csv_reader:  
            if not row:  
                continue  
            dataset.append(row)  
    return dataset  
   
# Convert string column to float  
def str_column_to_float(dataset, column):  
    for row in dataset:  
        row[column] = float(row[column].strip())  
   
# Convert string column to integer  
def str_column_to_int(dataset, column):  
    class_values = [row[column] for row in dataset]  
    unique = set(class_values)  
    lookup = dict()  
    for i, value in enumerate(unique):  
        lookup[value] = i  
        print('[%s] => %d' % (value, i))  
    for row in dataset:  
        row[column] = lookup[row[column]]  
    return lookup  
   
# Split the dataset by class values, returns a dictionary  
def separate_by_class(dataset):  
    separated = dict()  
    for i in range(len(dataset)):  
        vector = dataset[i] 
        class_value = vector[-1]  
        if (class_value not in separated):  
            separated[class_value] = list()  
        separated[class_value].append(vector)  
    return separated  
   
# Calculate the mean of a list of numbers  
def mean(numbers):  
    return sum(numbers)/float(len(numbers))  
   
# Calculate the standard deviation of a list of numbers  
def stdev(numbers):  
    avg = mean(numbers)  
    variance = sum([(x-avg)**2 for x in numbers]) / float(len(numbers)-1)  
    return sqrt(variance)  
   
# Calculate the mean, stdev and count for each column in a dataset  
def summarize_dataset(dataset):  
    summaries = [(mean(column), stdev(column), len(column)) for column in zip(*dataset)]  
    del(summaries[-1])  
    return summaries  
   
# Split dataset by class then calculate statistics for each row  
def summarize_by_class(dataset):  
    separated = separate_by_class(dataset)  
    summaries = dict()  
    for class_value, rows in separated.items():  
        summaries[class_value] = summarize_dataset(rows)  
    return summaries  
   
# Calculate the Gaussian probability distribution function for x  
def calculate_probability(x, mean, stdev):  
    exponent = exp(-((x-mean)**2 / (2 * stdev**2 )))  
    return (1 / (sqrt(2 * pi) * stdev)) * exponent  
   
# Calculate the probabilities of predicting each class for a given row  
def calculate_class_probabilities(summaries, row):  
    total_rows = sum([summaries[label][0][2] for label in summaries])  
    probabilities = dict()  
    for class_value, class_summaries in summaries.items():  
        probabilities[class_value] = summaries[class_value][0][2]/float(total_rows)  
        for i in range(len(class_summaries)):  
            mean, stdev, _ = class_summaries[i]  
            probabilities[class_value] *= calculate_probability(row[i], mean, stdev)  
    return probabilities  
   
# Predict the class for a given row  
def predict(summaries, row):  
    probabilities = calculate_class_probabilities(summaries, row)  
    best_label, best_prob = None, -1  
    for class_value, probability in probabilities.items():  
        if best_label is None or probability > best_prob:  
            best_prob = probability  
            best_label = class_value  
    return best_label  
   
# Make a prediction with Naive Bayes on Iris Dataset  
filename = 'iris.csv'  
dataset = load_csv(filename)  
for i in range(len(dataset[0])-1):  
    str_column_to_float(dataset, i)  
# convert class column to integers  
str_column_to_int(dataset, len(dataset[0])-1)  
# fit model  
model = summarize_by_class(dataset)  
# define a new record  
row = [5.7,2.9,4.2,1.3]  
# predict the label  
label = predict(model, row)  
print('Data=%s, Predicted: %s' % (row, label)) 

我得到的输出是

[Iris-versicolor] => 0
[Iris-setosa] => 1
[Iris-virginica] => 2
Data=[5.7, 2.9, 4.2, 1.3], Predicted: 0

2. 使用 Sklearn

from sklearn import datasets  
  
#Load dataset  
wine = datasets.load_wine()  
# print the names of the 13 features  
print ("Features: ", wine.feature_names)  
 
# print the label type of wine(class_0, class_1, class_2)  
print ("Labels: ", wine.target_names)  
  
# Import train_test_split function  
from sklearn.model_selection import train_test_split  
  
# Split the dataset into the training set and test set  
X_train, X_test, y_train, y_test = train_test_split(wine.data, wine.target, test_size=0.3,random_state=109)  
  
#Import Gaussian Naive Bayes model  
from sklearn.naive_bayes import GaussianNB  
  
#Create a Gaussian Classifier  
gnb = GaussianNB()  
 
#Train the model using the training sets  
gnb.fit(X_train, y_train)  
  
#Predict the response for test dataset  
y_pred = gnb.predict(X_test)  
  
print("y_pred: ",y_pred)  
  
#Import scikit-learn metrics module for accuracy calculation  
from sklearn import metrics  
  
# Model Accuracy, how often is the classifier correct?  
print("Accuracy:",metrics.accuracy_score(y_test, y_pred)) 

我得到的输出是

Features: [‘alcohol’, ‘malic_acid’, ‘ash’, ‘alcalinity_of_ash’, ‘magnesium’, ‘total_phenols’, ‘flavanoids’, ‘nonflavanoid_phenols’, ‘proanthocyanins’, ‘color_intensity’, ‘hue’, ‘od280/od315_of_diluted_wines’, ‘proline’]
Labels: [‘class_0’ ‘class_1’ ‘class_2’]
y_pred: [0 0 1 2 0 1 0 0 1 0 2 2 2 2 0 1 1 0 0 1 2 1 0 2 0 0 1 2 0 1 2 1 1 0 1 1 0 2 2 0 2 1 0 0 0 2 2 0 1 1 2 0 0 2]
Accuracy(准确度): 0.9074074074074074

3. 使用 TensorFlow

from IPython import embed  
from matplotlib import colors  
from matplotlib import pyplot as plt  
from sklearn import datasets  
import numpy as np  
import tensorflow as tf  
from sklearn.utils.fixes import logsumexp  
import numpy as np  
  
 
class TFNaiveBayesClassifier:  
    dist = None  
  
    def fit(self, X, y):  
        # Separate training points by class (nb_classes * nb_samples * nb_features)  
        unique_y = np.unique(y)  
        points_by_class = np.array([  
            [x for x, t in zip(X, y) if t == c]  
            for c in unique_y])  
  
        # Estimate mean and variance for each class / feature  
        # shape: nb_classes * nb_features  
        mean, var = tf.nn.moments(tf.constant(points_by_class), axes=[1])  
  
        # Create a 3x2 univariate normal distribution with the   
        # known mean and variance  
        self.dist = tf.distributions.Normal(loc=mean, scale=tf.sqrt(var))  
  
    def predict(self, X):  
        assert self.dist is not None  
        nb_classes, nb_features = map(int, self.dist.scale.shape)  
  
        # Conditional probabilities log P(x|c) with shape  
        # (nb_samples, nb_classes)  
        cond_probs = tf.reduce_sum(  
            self.dist.log_prob(  
                tf.reshape(  
                    tf.tile(X, [1, nb_classes]), [-1, nb_classes, nb_features])),  
            axis=2)  
  
        # uniform priors  
        priors = np.log(np.array([1. / nb_classes] * nb_classes))  
  
        # posterior log probability, log P(c) + log P(x|c)  
        joint_likelihood = tf.add(priors, cond_probs)  
  
        # normalize to get (log)-probabilities  
        norm_factor = tf.reduce_logsumexp(  
            joint_likelihood, axis=1, keep_dims=True)  
        log_prob = joint_likelihood - norm_factor  
        # exp to get the actual probabilities  
        return tf.exp(log_prob)  
  
  
if __name__ == '__main__':  
    iris = datasets.load_iris()  
    # Only take the first two features  
    X = iris.data[:, :2]  
    y = iris.target  
  
    tf_nb = TFNaiveBayesClassifier()  
    tf_nb.fit(X, y)  
      
    # Create a regular grid and classify each point  
    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5  
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5  
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 30),  
                         np.linspace(y_min, y_max, 30))  
    s = tf.Session()  
    Z = s.run(tf_nb.predict(np.c_[xx.ravel(), yy.ravel()]))  
    # Extract probabilities of class 2 and 3  
    Z1 = Z[:, 1].reshape(xx.shape)  
    Z2 = Z[:, 2].reshape(xx.shape)  
  
    # Plot  
    fig = plt.figure(figsize=(5, 3.75))  
    ax = fig.add_subplot(111)  
  
    ax.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1,  
                edgecolor='k')  
    # Swap signs to make the contour dashed (MPL default)  
    ax.contour(xx, yy, -Z1, [-0.5], colors='k')  
    ax.contour(xx, yy, -Z2, [-0.5], colors='k')  
  
    ax.set_xlabel('Sepal length')  
    ax.set_ylabel('Sepal width')  
    ax.set_title('TensorFlow decision boundary')  
    ax.set_xlim(x_min, x_max)  
    ax.set_ylim(y_min, y_max)  
    ax.set_xticks(())  
    ax.set_yticks(())  
  
    plt.tight_layout()  
    fig.savefig('tf_iris.png', bbox_inches='tight') 

我得到的输出是:

python机器学习:朴素贝叶斯(17)

结论

在本文中,我们研究了朴素贝叶斯。

在下一章中,我们将研究 k-means 聚类。


慕源网 » python机器学习:朴素贝叶斯(17)

常见问题FAQ

程序仅供学习研究,请勿用于非法用途,不得违反国家法律,否则后果自负,一切法律责任与本站无关。
请仔细阅读以上条款再购买,拍下即代表同意条款并遵守约定,谢谢大家支持理解!

发表评论

开通VIP 享更多特权,建议使用QQ登录