贝叶斯算法
朴素贝叶斯是一种基于贝叶斯定理和特征条件独立假设的分类算法。它假设给定类别的特征之间相互独立,并利用特征的条件概率来进行分类。朴素贝叶斯算法在文本分类、垃圾邮件过滤、情感分析等领域有广泛应用。贝叶斯定理是概率论中的一个重要定理,用于计算条件概率。在朴素贝叶斯算法中,我们通常使用多维正态分布来描述特征的概率分布。对于一个待分类的样本,该算法会计算其在每个类别下的条件概率,然后选择条件概率最高的类别作为最终的分类结果。虽然在一些情况中,可能由于数据集的假设特征均为相互独立,朴素贝叶斯算法对于他们可能会表现不佳,但在实际应用中,朴素贝叶斯算法在许多领域仍具有较好的分类性能。
贝叶斯算法的公式为:P(A|B) = P(B|A) * P(A) / P(B)
其中,P(A|B) 表示在已知事件 B 发生的情况下,事件 A 发生的概率;P(B|A) 表示在已知事件 A 发生的情况下,事件 B 发生的概率;P(A) 和 P(B) 分别表示事件 A 和事件 B 发生的概率。
垃圾分类
基于贝叶斯算法我们时间一个垃圾邮件分类的例子,其中大体思路如下:
(1)收集数据:提供文本文件。
(2)准备数据:将文本文件解析成词条向量。
(3)分析数据:检查词条确保解析的正确性。
(4)训练算法:计算不同的独立特征的条件概率。
(5)测试算法:计算错误率。
(6)使用算法:构建一个完整的程序对一组文档进行分类。
代码如下:
import os
import re
import string
import math
DATA_DIR = 'enron'
target_names = ['ham', 'spam']
def get_data(DATA_DIR):
subfolders = ['enron%d' % i for i in range(1, 7)]
data = []
target = [] #目录
for subfolder in subfolders:
# spam
spam_files = os.listdir(os.path.join(DATA_DIR, subfolder, 'spam'))
for spam_file in spam_files:
with open(os.path.join(DATA_DIR, subfolder, 'spam', spam_file), encoding="latin-1") as f:
data.append(f.read())
target.append(1) #list.append()函数数组增加元素
# ham
ham_files = os.listdir(os.path.join(DATA_DIR, subfolder, 'ham'))
for ham_file in ham_files:
with open(os.path.join(DATA_DIR, subfolder, 'ham', ham_file), encoding="latin-1") as f:
data.append(f.read()) #读入数据
target.append(0)
return data, target
X, y = get_data(DATA_DIR)
class SpamDetector_1(object):
"""Implementation of Naive Bayes for binary classification"""
# 清除空格
def clean(self, s):
translator = str.maketrans("", "", string.punctuation)
return s.translate(translator)
# 分开每个单词
def tokenize(self, text):
text = self.clean(text).lower()
return re.split("\W+", text)
# 计算某个单词出现的次数
def get_word_counts(self, words):
word_counts = {}
for word in words:
word_counts[word] = word_counts.get(word, 0.0) + 1.0
return word_counts
class SpamDetector_2(SpamDetector_1):
# X:data,Y:target标签(垃圾邮件或正常邮件)
def fit(self, X, Y):
self.num_messages = {}
self.log_class_priors = {}
self.word_counts = {}
# 建立一个集合存储所有出现的单词
self.vocab = set()
# 统计spam和ham邮件的个数
self.num_messages['spam'] = sum(1 for label in Y if label == 1)
self.num_messages['ham'] = sum(1 for label in Y if label == 0)
# 计算先验概率,即所有的邮件中,垃圾邮件和正常邮件所占的比例
self.log_class_priors['spam'] = math.log(
self.num_messages['spam'] / (self.num_messages['spam'] + self.num_messages['ham']))
self.log_class_priors['ham'] = math.log(
self.num_messages['ham'] / (self.num_messages['spam'] + self.num_messages['ham']))
self.word_counts['spam'] = {}
self.word_counts['ham'] = {}
for x, y in zip(X, Y):
c = 'spam' if y == 1 else 'ham'
# 构建一个字典存储单封邮件中的单词以及其个数
counts = self.get_word_counts(self.tokenize(x))
for word, count in counts.items():
if word not in self.vocab:
self.vocab.add(word) # 确保self.vocab中含有所有邮件中的单词
# 下面语句是为了计算垃圾邮件和非垃圾邮件的词频,即给定词在垃圾邮件和非垃圾邮件中出现的次数。
# c是0或1,垃圾邮件的标签
if word not in self.word_counts[c]:
self.word_counts[c][word] = 0.0
self.word_counts[c][word] += count
MNB = SpamDetector_2()
MNB.fit(X[100:], y[100:])
class SpamDetector(SpamDetector_2):
def predict(self, X):
result = []
flag_1 = 0
# 遍历所有的测试集
for x in X:
counts = self.get_word_counts(self.tokenize(x)) # 生成可以记录单词以及该单词出现的次数的字典
spam_score = 0
ham_score = 0
flag_2 = 0
for word, _ in counts.items():
if word not in self.vocab:
continue
# 下面计算P(内容|垃圾邮件)和P(内容|正常邮件),所有的单词都要进行拉普拉斯平滑
else:
# 该单词存在于正常邮件的训练集和垃圾邮件的训练集当中
if word in self.word_counts['spam'].keys() and word in self.word_counts['ham'].keys():
log_w_given_spam = math.log(
(self.word_counts['spam'][word] + 1) / (
sum(self.word_counts['spam'].values()) + len(self.vocab)))
log_w_given_ham = math.log(
(self.word_counts['ham'][word] + 1) / (sum(self.word_counts['ham'].values()) + len(
self.vocab)))
# 该单词存在于垃圾邮件的训练集当中,但不存在于正常邮件的训练集当中
if word in self.word_counts['spam'].keys() and word not in self.word_counts['ham'].keys():
log_w_given_spam = math.log(
(self.word_counts['spam'][word] + 1) / (
sum(self.word_counts['spam'].values()) + len(self.vocab)))
log_w_given_ham = math.log(1 / (sum(self.word_counts['ham'].values()) + len(
self.vocab)))
# 该单词存在于正常邮件的训练集当中,但不存在于垃圾邮件的训练集当中
if word not in self.word_counts['spam'].keys() and word in self.word_counts['ham'].keys():
log_w_given_spam = math.log(1 / (sum(self.word_counts['spam'].values()) + len(self.vocab)))
log_w_given_ham = math.log(
(self.word_counts['ham'][word] + 1) / (sum(self.word_counts['ham'].values()) + len(
self.vocab)))
# 把计算到的P(内容|垃圾邮件)和P(内容|正常邮件)加起来
spam_score += log_w_given_spam
ham_score += log_w_given_ham
flag_2 += 1
# 最后,还要把先验加上去,即P(垃圾邮件)和P(正常邮件)
spam_score += self.log_class_priors['spam']
ham_score += self.log_class_priors['ham']
# 最后进行预测,如果spam_score > ham_score则标志为1,即垃圾邮件
if spam_score > ham_score:
result.append(1)
else:
result.append(0)
flag_1 += 1
return result
MNB = SpamDetector()
MNB.fit(X[100:], y[100:])
pred = MNB.predict(X[:100])
true = y[:100]
accuracy = 0
for i in range(100):
if pred[i] == true[i]:
accuracy += 1
print(accuracy)
运行结果如下:
总结
贝叶斯算法是一种基于概率论和统计学的机器学习方法,以其在处理不确定性和分类问题方面的能力而著名。它的优点有:
1. 处理不确定性:贝叶斯方法能够处理不确定性和概率推断问题,适用于各种领域,如自然语言处理、模式识别、图像识别等。
2. 灵活性:贝叶斯算法可以根据不同的应用场景和问题进行调整,如朴素贝叶斯、高斯朴素贝叶斯、多项式分布下的朴素贝叶斯等。
4. 易于理解和实现:贝叶斯算法的原理相对简单,易于理解和实现。
5. 对缺失数据不敏感:贝叶斯算法对缺失数据的处理相对较好,可以通过概率推断来估计缺失值。
缺点:
1. 计算复杂度高:贝叶斯算法中涉及到的概率计算和积分运算可能导致计算复杂度高,尤其是在处理大规模数据时。
2. 需要大量的训练数据:贝叶斯算法对于小规模数据的表现可能不佳,因为它们需要足够的数据来估计概率分布。
3. 模型选择和参数调优:贝叶斯算法中涉及到的模型选择(如朴素贝叶斯中的多项式分布、高斯分布等)和参数调优可能导致算法性能的波动。
4. 过拟合问题:贝叶斯算法也可能出现过拟合问题,尤其是在处理高维数据时。
5. 增量式训练限制:与其他机器学习算法相比,贝叶斯算法的增量式训练性能较差。
总之,贝叶斯算法具有扎实的理论基础和较强的处理不确定性的能力,但在计算复杂度、数据规模要求、模型选择和训练性能方面存在一定的局限性。在实际应用中,需要根据具体问题和场景来评估贝叶斯算法的适用性。