0
0

机器学习--使用朴素贝叶斯进行垃圾邮件分类

一、学习背景

垃圾邮件的问题一直困扰着人们，传统的垃圾邮件分类的方法主要有"关键词法"和"校验码法"等，然而这两种方法效果并不理想。其中，如果使用的是“关键词”法，垃圾邮件中如果这个关键词被拆开则可能识别不了，比如，“中奖”如果被拆成“中 --- 奖”可能会识别不了。后来，直到提出了使用“贝叶斯”的方法才使得垃圾邮件的分类达到一个较好的效果，而且随着邮件数目越来越多，贝叶斯分类的效果会更加好。

我们想采用的分类方法是通过多个词来判断是否为垃圾邮件，但这个概率难以估计，通过贝叶斯公式，可以转化为求垃圾邮件中这些词出现的概率。

二、贝叶斯公式

贝叶斯定理 由英国数学家贝叶斯 ( Thomas Bayes 1702-1761 ) 发展，用来描述两个条件 概率 之间的关系

已知两个独立事件A和B，事件B发生的前提下，事件A发生的概率可以表示为P(A|B)，即上图中橙色部分占红色部分的比例，即:

  • P(A) 称为”先验概率”，即在B事件发生之前，我们对A事件概率的一个判断。如：正常收到一封邮件，该邮件为垃圾邮件的概率就是“先验概率”

  • P(A|B)称为”后验概率”， 即在B事件发生之后，我们对A事件概率的重新评估。如：邮件中含有“中奖”这个词，该邮件为垃圾邮件的概率就是“后验概率”

  • P(B|A)/P(B)是可能性函数，这是一个调整因子，使得预估概率更接近真实概率。

  • 条件概率就是：后验概率　＝　先验概率 ｘ 调整因子

因为要计算两次概率，关于它们的分母，是这个样本的属性在全部样本中的概率。而这两次计算，它们的分母是不变的，所以我们只要计算分子就行。于是有了下面的结论：

即：

朴素贝叶斯分类器(Naïve Bayes Classifier)采用了“属性条件独立性假设”，即每个属性独立地对分类结果发生影响。为方便公式标记，不妨记P(C=c|X=x)为P(c|x)。在假设每个属性都独立的情况下，贝叶斯公式可以修改为：

分母是相同的，于是去掉分母，得：

最终我们利用这个公式，在代码中实现概率的计算来对样本进行分类。

三、使用朴素贝叶斯进行垃圾邮件分类

1.算法思路

分类标准：当 P（垃圾邮件|文字内容）> P（正常邮件|文字内容）时，我们认为该邮件为垃圾邮件，但是单凭单个词而做出判断误差肯定相当大，因此我们可以将所有的词一起进行联合判断。假设我们进行判断的词语有“获奖”、“贷款”、“无利息”，则需要判断P（垃圾邮件|获奖，贷款，无利息）与P（正常|获奖，贷款，无利息），使用贝叶斯公式，P（垃圾邮件|获奖，贷款，无利息）可以变为：

假设所有词语独立同分布，可以得到

同理可得P（正常|获奖，贷款，无利息）

因此，对P（垃圾邮件|获奖，贷款，无利息）与P（正常|获奖，贷款，无利息）的比较，只需要对分子进行对比。

但是如果对多个词的P（内容|正常/垃圾）进行相乘时，可能会因为某个词的概率很小从而导致最后的结果为0（超出计算机的精度），因此可以对P（内容|正常/垃圾）取自然对数，即ln P（内容|正常/垃圾）。

因此可以变为

2.数据集准备

数据来源于国外的一些垃圾邮件和正常邮件

其中ham是正常邮件，spam是垃圾邮件。

3.数据导入

  1. import os
  2. import re
  3. import string
  4. import math
  1. DATA_DIR = 'enron'
  2. target_names = ['ham', 'spam']
  3. def get_data(DATA_DIR):
  4.     subfolders = ['enron%d' % i for i in range(1,7)] #获得enron下面的文件夹
  5.     data = []
  6.     target = []
  7.     for subfolder in subfolders:
  8.         #垃圾邮件 spam
  9.         spam_files = os.listdir(os.path.join(DATA_DIR, subfolder, 'spam')) #将文件夹路径进行组合
  10.         for spam_file in spam_files: #遍历所有垃圾文件
  11.             with open(os.path.join(DATA_DIR, subfolder, 'spam', spam_file), encoding="latin-1") as f:
  12.                 data.append(f.read())
  13.                 target.append(1)
  14.         #正常邮件 pam
  15.         ham_files = os.listdir(os.path.join(DATA_DIR, subfolder, 'ham'))
  16.         for ham_file in ham_files:
  17.             with open(os.path.join(DATA_DIR, subfolder, 'ham', ham_file), encoding="latin-1") as f:
  18.                 data.append(f.read())
  19.                 target.append(0)
  20.     return data, target
  21.  
  22. X, y = get_data(DATA_DIR)
  23. #print(X,y)

邮件内容存储在data中，标签存储在target当中，“1”表示为垃圾邮件，“0”表示为正常邮件。下图为截取部分结果。

4.分析数据并进行算法训练

定义一个类对数据进行预处理

  1. class SpamDetector_1(object):
  2.     #清除空格
  3.     def clean(self, s):
  4.         translator = str.maketrans("", "", string.punctuation)
  5.         return s.translate(translator)
  6.     #分开每个单词
  7.     def tokenize(self, text):
  8.         text = self.clean(text).lower()
  9.         return re.split("\W+", text)
  10.     #计算某个单词出现的次数
  11.     def get_word_counts(self, words):
  12.         word_counts = {}
  13.         for word in words:
  14.             word_counts[word] = word_counts.get(word, 0.0) + 1.0
  15.         return word_counts

计算P（垃圾邮件）和P（正常邮件）；词汇表（即正常邮件和垃圾邮件中出现的所有单词，方便进行拉普拉斯平滑）；垃圾邮件和非垃圾邮件的词频，即给定词在垃圾邮件和非垃圾邮件中出现的次数。选取了第100封之后的邮件作为训练集，前面一百封邮件作为测试集。

  1. class SpamDetector_2(SpamDetector_1):
  2.     # X:data,Y:target标签（垃圾邮件或正常邮件）
  3.     def fit(self, X, Y):
  4.         self.num_messages = {}
  5.         self.log_class_priors = {}
  6.         self.word_counts = {}
  7.         # 建立一个集合存储所有出现的单词
  8.         self.vocab = set()
  9.         # 统计spam和ham邮件的个数
  10.         self.num_messages['spam'] = sum(1 for label in Y if label == 1)
  11.         self.num_messages['ham'] = sum(1 for label in Y if label == 0)
  12.  
  13.         # 计算先验概率，即所有的邮件中，垃圾邮件和正常邮件所占的比例
  14.         self.log_class_priors['spam'] = math.log(
  15.             self.num_messages['spam'] / (self.num_messages['spam'] + self.num_messages['ham']))
  16.         self.log_class_priors['ham'] = math.log(
  17.             self.num_messages['ham'] / (self.num_messages['spam'] + self.num_messages['ham']))
  18.  
  19.         self.word_counts['spam'] = {}
  20.         self.word_counts['ham'] = {}
  21.  
  22.         for x, y in zip(X, Y):
  23.             c = 'spam' if y == 1 else 'ham'
  24.             # 构建一个字典存储单封邮件中的单词以及其个数
  25.             counts = self.get_word_counts(self.tokenize(x))
  26.             for word, count in counts.items():
  27.                 if word not in self.vocab:
  28.                     self.vocab.add(word)#确保self.vocab中含有所有邮件中的单词
  29.                 # 下面语句是为了计算垃圾邮件和非垃圾邮件的词频，即给定词在垃圾邮件和非垃圾邮件中出现的次数。
  30.                 # c是0或1，垃圾邮件的标签
  31.                 if word not in self.word_counts[c]:
  32.                     self.word_counts[c][word] = 0.0
  33.                 self.word_counts[c][word] += count
  34.  
  35. MNB = SpamDetector_2()
  36. MNB.fit(X[100:], y[100:])

5.测试算法

对测试集进行测试，判断是垃圾邮件还是正常邮件，并计算出准确度

  1. class SpamDetector(SpamDetector_2):
  2.     def predict(self, X):
  3.         result = []
  4.         flag_1 = 0
  5.         # 遍历所有的测试集
  6.         for x in X:
  7.             counts = self.get_word_counts(self.tokenize(x))  # 生成可以记录单词以及该单词出现的次数的字典
  8.             spam_score = 0
  9.             ham_score = 0
  10.             flag_2 = 0
  11.             for word, _ in counts.items():
  12.                 if word not in self.vocab: continue
  13.  
  14.                 #下面计算P(内容|垃圾邮件)和P(内容|正常邮件),所有的单词都要进行拉普拉斯平滑
  15.                 else:
  16.                     # 该单词存在于正常邮件的训练集和垃圾邮件的训练集当中
  17.                     if word in self.word_counts['spam'].keys() and word in self.word_counts['ham'].keys():
  18.                         log_w_given_spam = math.log(
  19.                             (self.word_counts['spam'][word] + 1) / (sum(self.word_counts['spam'].values()) + len(self.vocab)))
  20.                         log_w_given_ham = math.log(
  21.                             (self.word_counts['ham'][word] + 1) / (sum(self.word_counts['ham'].values()) + len(
  22.                                 self.vocab)))
  23.                     # 该单词存在于垃圾邮件的训练集当中,但不存在于正常邮件的训练集当中
  24.                     if word in self.word_counts['spam'].keys() and word not in self.word_counts['ham'].keys():
  25.                         log_w_given_spam = math.log(
  26.                             (self.word_counts['spam'][word] + 1) / (sum(self.word_counts['spam'].values()) + len(self.vocab)))
  27.                         log_w_given_ham = math.log( 1 / (sum(self.word_counts['ham'].values()) + len(
  28.                                 self.vocab)))
  29.                     # 该单词存在于正常邮件的训练集当中,但不存在于垃圾邮件的训练集当中
  30.                     if word not in self.word_counts['spam'].keys() and word in self.word_counts['ham'].keys():
  31.                         log_w_given_spam = math.log( 1 / (sum(self.word_counts['spam'].values()) + len(self.vocab)))
  32.                         log_w_given_ham = math.log(
  33.                             (self.word_counts['ham'][word] + 1) / (sum(self.word_counts['ham'].values()) + len(
  34.                                 self.vocab)))
  35.  
  36.                 # 把计算到的P(内容|垃圾邮件)和P(内容|正常邮件)加起来
  37.                 spam_score += log_w_given_spam
  38.                 ham_score += log_w_given_ham
  39.  
  40.                 flag_2 += 1
  41.  
  42.                 # 最后，还要把先验加上去，即P(垃圾邮件)和P(正常邮件)
  43.                 spam_score += self.log_class_priors['spam']
  44.                 ham_score += self.log_class_priors['ham']
  45.  
  46.             # 最后进行预测，如果spam_score > ham_score则标志为1，即垃圾邮件
  47.             if spam_score > ham_score:
  48.                 result.append(1)
  49.             else:
  50.                 result.append(0)
  51.  
  52.             flag_1 += 1
  53.  
  54.         return result
  1. MNB = SpamDetector()
  2. MNB.fit(X[100:], y[100:])
  3. pred = MNB.predict(X[:100])
  4. true = y[:100]
  5.  
  6. accuracy = 0
  7. for i in range(100):
  8.     if pred[i] == true[i]:
  9.         accuracy += 1
  10. print(accuracy)

最后得到准确率为99％

标签： 分类 人工智能
本文转载自: https://blog.csdn.net/jimei2011/article/details/128068976
版权归原作者 梦里她落 所有， 如有侵权，请联系我们删除。
登录后发布评论

“机器学习--使用朴素贝叶斯进行垃圾邮件分类”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？