基于朴素贝叶斯算法的垃圾邮件处理问题

最新推荐文章于 2023-03-27 15:24:28 发布

clpython

最新推荐文章于 2023-03-27 15:24:28 发布

阅读量495

点赞数 1

文章标签：算法

本文链接：https://blog.csdn.net/clpython/article/details/128014625

版权

问题背景：我们每天都会收到很多的邮件，想象一下，如果再某一天内，我们收到了几百封邮件，但是这几百封邮件中，自己需要处理的邮件只有寥寥的数十封。所以我们需要一个“筛选器”在众多邮件中，将垃圾邮件和正常邮件筛选出来，以便我们进行正常邮件的处理。

朴素贝叶斯算法对于垃圾邮件的分类具有较高的准确度。

贝叶斯公式简介和应用：http://t.csdn.cn/fAm15

主要思路：首先我们假设所有词语彼此之间是不相关的（严格说这个假设不成立；实际上各词语之间不可能完全没有相关性，但可以忽略）。然后要明确我们要计算的内容是：在某几个关键词下，该邮件是正常邮件的概率：P(正常邮件|关键词)和在某几个关键词下，该邮件是垃圾邮件的概率：P(垃圾邮件|关键词)。

基于贝叶斯公式和条件概率公式，我们可以把P(正常邮件|关键词)转化为：

将 P(垃圾邮件|关键词)转化为：

可以看到，二者的分母是一样的，但是分子不同，所以我们只要计算分子的大小即可。

存在的问题：例如当P1(中奖|正常）很小，P2(免费|正常）也很小，并且在正常条件下，其他的关键词的概率Pn(关键词|正常）的概率也很小的时候，就会导致P1*P2*...*Pn无限小，我们对上式的分子取以e为底的对数ln。经过处理之后，分子就变成了：

取对数存在的问题：经过这样的处理之后，仍存在一个问题就是例如“中奖”，没有在邮件中出现的时候，就会导致上述公式中的P(中奖|正常）和P(中奖|垃圾邮件）的结果为零，这是我们不想要的，因为这样的话不能筛选出垃圾邮件，所以为了处理这种特殊情况，我们引入了laplace smoothing-拉普拉斯平滑。

拉普拉斯平滑主要思想：主要的思想是对词的个数+1，对训练数据进行平滑处理。当训练样本很大时，每个词的个数+1造成的概率变化并不大，在误差允许的范围之内。

经过拉普拉斯平滑后的

将该公式代入相应位置即可。

具体代码如下：

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)
        # 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):
    #清除标点符号
    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()
# 选取了第100封之后的邮件作为训练集，前面一百封邮件作为测试集
MNB.fit(X[100:], y[100:])

print("log_class_priors of spam", MNB.log_class_priors['spam']) #-0.6776
print("log_class_priors of ham", MNB.log_class_priors['ham']) #-0.7089


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)  # 0.98

运行结果：