中文邮件分类[朴素贝叶斯、支持向量机、Logistic,TF-IDF,词袋模型]

读研第一次写博客，会不定时将自己做的小项目分享到这，加油

第二次更改增加了特征工程，新加文本长度和符号比例两个特征，预测精确度达到了95.7%，比原来增加了2.1%，见本文第6节

由于有人问起代码测试有问题，我将所有代码放在文章末尾了，可以一次测试没有错误，关键点把邮件，stop_word放在运行目录下，导入路径写自己的运行路径即可

2021年11月30日--Walker

本文为垃圾邮件分类的小作业

1. 问题描述

判断一封邮件是否为垃圾邮件，需要根据邮件的相关信息如发件人、发送时间、邮件主题、邮件内容等进行判断，本文主要对邮件的内容进行分析和建模，对邮件分为两类，即垃圾邮件和正常邮件。

1.1 数据集介绍

本文的数据集为156个中文邮件样本，文件名为i.txt(i=0,...,155),存放于"F:\3大语言数据分析\python 语言与数据分析\python_homework\附件1"中，其中前127个邮件即(0.txt-126.txt)为垃圾邮件，后面29个邮件即(127.txt-155.txt)为正常邮件。中文邮件提取码：72pb

1.2 数据预处理

1.2.1 数据准备

第一步：导入文本数据，将所有的txt文件存入data中，data的每一行是一个txt邮件样本。我们利用python的pandas库，将这156个邮件读取出来。

#导入基本的模块
import pandas as pd
import numpy as np

#读取数据
filename='F:/3大语言数据分析/python 语言与数据分析/python_homework/附件1'
data=[]
n=156
for i in range(n):
    path=filename+'\\'+'{}.txt'.format(i)#i.txt邮件路径
    f=open(path,'r',encoding='utf-8')#打开i.txt邮件
    data.append(f.read())#将邮件存放在data中
    f.close
data=pd.DataFrame(data)#data中每一行是一个邮件样本
data.columns=['text']
print(data.head())#查看前5个txt邮件内容
print(data.info())#查看邮件数据集基本信息

 

 第二步：为每一封邮件打上标签。记垃圾邮件为1，正常邮件为0，注意前127个邮件为垃圾邮件，后29个邮件为正常邮件。

label=np.zeros([156,1])
label[:127]=1
data['label']=label
print(data.head())
print(data['label'].value_counts())#查看数据标签分布，垃圾邮件1有127个，正常邮件0有29个

 第三步：提取文本内容的特征。

X=data['text']

1.2.2 数据清洗

由于文本邮件里对于我们的分类任务有太多没有意义的词汇和符号，我们需要将其删除掉。通常我们将这类词汇称为停用词。中文停用词下载链接中文停用词提取码：j28e

中文的停用词库保存在"F:\3大语言数据分析\python 语言与数据分析\python_homework\stop_words.txt"中

进行文本分词，删除无效字符和停用词。所用模块：jieba，re

#导入所需模块
import re
import string
import jieba
#导入停用词
with open(r'F:\3大语言数据分析\python 语言与数据分析\python_homework\stop_words.txt',
          encoding="utf8") as f:
    stopword_list=f.readlines()

#定义分词函数
def tokenize_data(data):
    tokens =[' '.join(jieba.cut(item)) for item in data]
    tokens = [token.strip() for token in tokens]#分词后的数据
    return tokens

X_tokens=tokenize_data(X)

#定义删除分词后的无用字符函数
def remove_unuseful_characaters(tokens):
    #先将空格符以及换行符删除，以及非单词字符进行删除
    tokens1=[]
    for i in range(len(tokens)):
        tokens1.append(re.sub(r'\W','',tokens[i].replace(' ','').replace('\n','')))
    return tokens1

X_tokens1=remove_unuseful_characaters(X_tokens)

#删除停用词函数
def remove_stop_words(tokens1):
    filtered_tokens = [token for token in tokens1 if token not in stopword_list]
    return filtered_tokens

X_tokens2=remove_stop_words(X_tokens1)

#再次使用分词技术，将整理后的文本进行分词
X_tokens3=tokenize_data(X_tokens2)

现在我们通过删除无效字符以及停用词后，得到了较为干净的文本，我们利用词云对数据清洗后的垃圾邮件和正常邮件可视化，如下图：(注意下载词云需要用到simhei.ttf） simhei.ttf提取码：q64d

#绘制垃圾邮件和正常邮件的词云
spam_email=X_tokens3[:127]#垃圾邮件词
norm_email=X_tokens3[127:]#正常邮件词
spam=''.join([item for item in spam_email])#将所有垃圾邮件的垃圾词合并在一起
norm=''.join([item for item in norm_email])#将所有正常邮件的正常词合并在一起
#替换一些词频较大的无用词，#个别python被分在正常邮件可能属于错误的标签，为了使得词云可视化对比显#著，替换该词（影响不大
spam_new=spam.replace('的','').replace('在','').replace('和','').replace('与','').replace('了','').replace('您','')
norm_new=norm.replace('的','').replace('在','').replace('和','').replace('与','').replace('是','').replace('了','').replace('Python','').replace('python','')

from wordcloud import WordCloud
font = r'C:\Windows\Fonts\simfang.ttf'
wc1 = WordCloud(background_color='white',collocations=False, font_path=font, width=1400, height=1400, margin=2)
wc1.generate(spam_new)
# 保存图片
wc1.to_file(r"wordcloud1.png") # 按照设置的像素宽高度保存绘制好的词云图，比下面程序显示更清晰
# 4.显示图片
# 以图片的形式显示词云
fig=plt.figure(figsize=(6,4.3))
plt.rcParams['font.sans-serif']=['SimHei']
plt.imshow(wc1)
# 关闭图像坐标系
plt.axis("off")
plt.show()
#另一张图
fig=plt.figure(figsize=(6,4.3))
plt.rcParams['font.sans-serif']=['SimHei']
wc2 = WordCloud(background_color='white',collocations=False, font_path=font, width=1400, height=1400, margin=2)
wc2.generate(norm_new)
wc2.to_file(r"wordcloud2.png")
plt.imshow(wc2)
# 关闭图像坐标系
plt.axis("off")
plt.show()

图1 邮件文本可视化

从图1可以看出，垃圾邮件的文本词语跟人工智能相关，正常邮件是一些记录性描述性文字，与人工智能高新技术无关的文本。接下来我们对处理后的文本数据进行向量化，考虑两种模型分别向量化：TF-IDF模型、词袋模型。下面我们简单介绍下两种模型的原理。

2. 文本向量化

2.1 TF-IDF模型

TF是词频，IDF是逆文本频率，两者结合用于度量词对于某篇文本的重要程度。一般地，词的重要程度会随其所属文本中出现的次数的增加而增加；但同时也会因为其在文本集合中出现的次数过多重要性反而降低。基于此，定义 词在文本中的词频为：

其中，表示词在文本中出现的次数；文本包含个不同的词，表示文本的总词数，越大，词对文本的重要性越大。

 另一方面，词的逆文本频率(IDF)定义为：

其中，表示总的文本数，表示包含词i的文本数，越大，词可能越重要。

为了综合考虑率两个指标的影响，利用TF-IDF指标来评价词i在文本j的重要性，其计算公式如下：

 

越大， 词对文本 越重要。

#导入tf-idf模块
from sklearn.feature_extraction.text import TfidfVectorizer

#TF-IDF模型
def tfidf_vector(tokens3,ngram_range=(1, 1)):
    vectorizer=TfidfVectorizer(max_df=0.5,#最大的频率，即单词在所有文档的出现率
                              norm='l2',
                              smooth_idf=True,#idf值采用平滑公式
                              use_idf=True,
                              ngram_range=ngram_range)
    X=vectorizer.fit_transform(tokens3)
    return X
X_tf=tfidf_vector(X_tokens3,ngram_range=(1, 1))#将上文中整理后的文本X,用TF-IDF处理成向量
X_tf=X_tf.toarray()
X_train_tf,X_test_tf,y_train_tf,y_test_tf=train_test_split(X_tf,data['label'],random_state=42,test_size=0.3)#划分训练集和测试集

2.2 词袋模型

 词袋模型(Bow,Bag of Words)不考虑文本中词与词之间的上下文关系，仅仅只考虑所有词的权重即词在文本中出现的频率，类似于将所有词语装进一个袋子里，并假设所有词都是独立的

生成文本的词袋模型分为三步：

i.分词；ii.统计词频；iii.特征标准化

#导入基本模块
from sklearn.feature_extraction.text import CountVectorizer

#词袋模型
def bow_vector(tokens3,ngram_range=(1, 1)):
    vectorizer=CountVectorizer(max_df=0.5,ngram_range=ngram_range)
    X=vectorizer.fit_transform(tokens3)
    return X
X_bow=bow_vector(X_tokens3,ngram_range=(1, 1))
X_bow=X_bow.toarray()
X_train_bow,X_test_bow,y_train_bow,y_test_bow=train_test_split(X_bow,data['label'],random_state=42,test_size=0.3)

3. 文本分类建模

本文拟采用朴素贝叶斯模型对邮件进行分类。并通过对比其他方法：如支持向量机、Logistic回归等传统的方法进行对比，实验结果证明，对于垃圾邮件分类，朴素贝叶斯的效果较好。

#导入朴素贝叶斯模型、支持向量机、Logistic回归模型
from sklearn.naive_bayes import MultinomialNB
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
mnb=MultinomialNB()#最佳参数在10^-8到10^-7,alpha=0.00000009
svm=SVC(probability=True)
lr=LogisticRegression()

#导入评价函数模块
from sklearn.metrics import confusion_matrix,f1_score,roc_curve,auc,recall_score
from sklearn.metrics import precision_recall_curve,accuracy_score,precision_score
#导入交叉验证模块
from sklearn.model_selection import cross_val_score,cross_validate


#分类器训练
def email_classifier_model(classifier,train_X,train_y,test_X,test_y):
    #建立模型
    model=classifier.fit(train_X,train_y)
    #预测模型
    predict=model.predict(test_X)
    #训练混淆矩阵
    print('训练混淆矩阵:\n',confusion_matrix(train_y,model.predict(train_X)))
    #绘制训练器的ROC曲线
    fpr,tpr,thresholds=roc_curve(train_y,model.predict_proba(train_X)[:,1],pos_label=1)
    roc_auc=auc(fpr,tpr)
    #plt.plot(fpr,tpr,color='r',linewidth=2,label='ROC curve (area=%0.5f)' % roc_auc)
    #plt.plot([0,1],[0,1],color='navy',linewidth=2,linestyle='--')
    
    get_metrics(true_labels=test_y,predict_labels=predict)
    return fpr,tpr,thresholds,roc_auc

#评估模型,用于多分类average='weighted'考虑不平衡数据进行加权，按每个标签的真实实例数来加权
#本文为二分类不需要考虑
def get_metrics(true_labels,predict_labels):
    #预测正确的样本/预测总样本量
    print('准确率:',accuracy_score(true_labels,predict_labels))
    #预测为正类且预测正确的数量/预测为正类的数量
    print('查准率:',precision_score(true_labels,predict_labels))
    #预测为正类且预测正确的数量/真实为正类的数量
    print('召回率:',recall_score(true_labels,predict_labels))
    #F1=2XPXR/(P+R)
    print('F1分数:',f1_score(true_labels,predict_labels))

 分别用这3种模型对垃圾邮件进行分类,代码如下：

#tf_idf
#朴素贝叶斯
mnb_fpr,mnb_tpr,mnb_thresholds,mnb_roc_auc=email_classifier_model(mnb,X_train_tf,y_train_tf,
                                                                  X_test_tf,y_test_tf)
#支持向量机
svm_fpr,svm_tpr,svm_thresholds,svm_roc_auc=email_classifier_model(svm,X_train_tf,y_train_tf,
                                                                  X_test_tf,y_test_tf)
#Logistic回归
lr_fpr,lr_tpr,lr_thresholds,lr_roc_auc=email_classifier_model(lr,X_train_tf,y_train_tf,
                                                                  X_test_tf,y_test_tf)
#词频模型
mnb_fpr_bow,mnb_tpr_bow,mnb_thresholds_bow,mnb_roc_auc_bow=email_classifier_model(mnb,X_train_bow,y_train_bow,
                                                                  X_test_bow,y_test_bow)
svm_fpr_bow,svm_tpr_bow,svm_thresholds_bow,svm_roc_auc_bow=email_classifier_model(svm,X_train_bow,y_train_bow,
                                                                  X_test_bow,y_test_bow)
lr_fpr_bow,lr_tpr_bow,lr_thresholds_bow,lr_roc_auc_bow=email_classifier_model(lr,X_train_bow,y_train_bow,
                                                                  X_test_bow,y_test_bow)

 4. 实验结果

 4.1 原始参数下的实验结果

 我们分别在TF-IDF与词袋模型两种向量化文本以及未调节参数的条件下，使用3种算法模型进行分类评估，实验结果如下。

表1 不同方式向量化下3种模型的预测效果对

TF-IDF下的分类模型	训练精确度	测试精确度
朴素贝叶斯	0.85	0.787
支持向量机	0.99	0.787
Logistic回归	0.82	0.787

BOW下的分类模型	训练精确度	测试精确度
朴素贝叶斯	0.99	0.81
支持向量机	0.87	0.787
Logistic回归	1.0	0.808

在使用各个3种分类算法的原始参数时，对于TF-IDF的向量化方法，支持向量机在训练集上精确度达到0.99表现最好，而在测试集上，3种算法的精确度是相同的，支持向量机存在较大的过拟合；对于BOW下的向量化方法，朴素贝叶斯和Logistic在训练集上表现最好，朴素贝叶斯测试精确度是最高的为0.81。

绘制ROC曲线观察，3种模型在邮件分类的泛化能力。代码如下(以TF-IDF为例）：

#ROC曲线
classifiers=[mnb,svm,lr]
legends=['基准线','朴素贝叶斯','支持向量机','Logistic']
def ROC(classifiers,train_X,train_y,test_X,test_y):
    models=[classifier.fit(train_X,train_y) for classifier in classifiers]
    plt.figure(figsize=(14,8.6))
    plt.rcParams['font.sans-serif']=['SimHei']
    plt.rcParams.update({'font.size':15})
    plt.plot([0,1],[0,1],color='navy',linewidth=2,linestyle='--')
    for model in models:
        fpr,tpr,thresholds=roc_curve(test_y,model.predict_proba(test_X)[:,1],pos_label=1)
        roc_auc=auc(fpr,tpr)
        plt.plot(fpr,tpr,linewidth=2,label='ROC curve (area=%0.5f)' % roc_auc)
        plt.legend([legend for legend in legends])
        plt.xlim([-0.01,1.01])
        plt.ylim([-0.01,1.01])
        plt.xlabel('FPR')
        plt.ylabel('TPR')
        plt.title('TF-IDF-ROC曲线',fontproperties='SimHei')
    plt.savefig('原始TF-IDF-roc曲线.png',dpi=300,bbox_inches='tight')
#tf-idf
ROC(classifiers,X_train_tf,y_train_tf,X_test_tf,y_test_tf)

 图2 TF-IDF下3种模型的ROC曲线图

显然，从图1可知，在未进行参数调优时，用TF-IDF向量化，支持向量机和朴素贝叶斯有着近似的表现效果，其泛化能力相当，Logistic表现最差。

 图3 BOW下3种模型的ROC曲线图

从图2可知，未调节参数对邮件进行分类时，在BOW向量化下，3种模型中Logistic的模型表现能力最好，其次是朴素贝叶斯，表现最差的是支持向量机。

总体上来讲，两种向量化方式，3种模型的泛化能力是相当的，我们通过对训练精确度和测试精确度求其平均值可以得到如下表:

表2 综合条件下3种模型的效果对比​

邮件分类模型	训练精确度平均值	测试精确度平均值
朴素贝叶斯	0.92	0.7985
支持向量机	0.93	0.787
Logistic	0.91	0.7975

从表2得知，对于邮件分类，3种模型的训练精确度几乎差别不大，但在泛化能力上，朴素贝叶斯更优。接下来，我们希望通过参数调优，让模型的泛化能力更高，表现效果更好，为此，我们对朴素贝叶斯的参数进行网格搜索，利用交叉验证评价模型的泛化能力。

4.2 网格搜索与交叉验证下的实验结果

我们将交叉验证的k固定为5，接着将朴素贝叶斯的参数设置为 ,利用网格搜索化找寻测试精确度最好所对应的参数值，再利用交叉验证评得到模型的训练平均分数。代码如下：

def email_GridSearchCV(estimator,alphas,k,train_X,train_y,test_X,test_y):
    accuracy=[]
    for alpha in alphas:
        model=estimator(alpha)
        model=model.fit(train_X,train_y)
        predict_y=model.predict(test_X)
        ac=accuracy_score(test_y,predict_y)
        accuracy.append(ac)
    best_alpha_index=accuracy.index(max(accuracy))
    best_accuracy=accuracy[best_alpha_index]
    best_alpha=alphas[best_alpha_index]
    CV_score=cross_val_score(estimator(best_alpha),train_X,train_y,cv=k)
    CV_score_mean=CV_score.mean()
    print('最佳的参数alpha:{}'.format(best_alpha),'对应的测试精确度:{}'.format(best_accuracy))
    print('交叉验证平均分数:{}'.format(CV_score_mean))
    return accuracy,best_alpha, CV_score_mean  

#tf-idf
alphas=[1e-10,1e-7,1e-3,1e-1,0.5,1]
k=5
email_GridSearchCV(MultinomialNB,alphas,k,X_train_tf,y_train_tf,X_test_tf,y_test_tf)

理论上，也会对交叉验证的k进行搜索本文，在手动尝试几次，发现k=5较好，所有固定了k值，也可以通过循环程序对k进行寻优。最后结果如下：

由网格搜索和交叉验证结果可知，在TF-IDF下，朴素贝叶斯的最佳参数，交叉验证平均分数为0.935，在测试集上的精确度达到0.936，其泛化能力是非常好的。比原始参数的测试集精确度高17.2%，可见参数优化后的模型表现效果得到了巨大提升。

下面我们将朴素贝叶斯原始的参数与优化后参数的ROC曲线绘制一下，观察效果。

model1=mnb.fit(X_train_tf,y_train_tf)
model2=MultinomialNB(alpha=0.1).fit(X_train_tf,y_train_tf)
plt.figure(figsize=(14,8.6))
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams.update({'font.size':15})
plt.plot([0,1],[0,1],color='navy',linewidth=2,linestyle='--')
    
fpr1,tpr1,thresholds1=roc_curve(y_test_tf,model1.predict_proba(X_test_tf)[:,1],pos_label=1)
fpr2,tpr2,thresholds2=roc_curve(y_test_tf,model2.predict_proba(X_test_tf)[:,1],pos_label=1)
roc_auc1=auc(fpr1,tpr1)
roc_auc2=auc(fpr2,tpr2)
plt.plot(fpr1,tpr1,linewidth=2,color='#14446A',label='ROC curve (area=%0.5f)' % roc_auc1)
plt.plot(fpr2,tpr2,linewidth=2,color='#DE7D2C',label='ROC curve (area=%0.5f)' % roc_auc2)
plt.legend(['基准线','原始参数alpha=1','优化后的参数alpha=0.1'])
plt.xlim([-0.01,1.01])
plt.ylim([-0.01,1.01])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.title('TF-ITF-ROC曲线',fontproperties='SimHei')
plt.savefig('原始_优化曲线.png',dpi=300,bbox_inches='tight')

 图4 原始参数和优化后参数的ROC曲线对比图

5. 总结

本文通过两种文本向量化的方式即TF-IDF和词袋模型对中文文本邮件进行预处理，利用朴素贝叶斯、支持向量机、Logistic回归3种模型分别在两种向量化方式下进行建模分析，在未调整参数的条件下，通过对比各个模型在对应向量化方式的训练精确度和测试精度以及分析ROC曲线图，得出3种模型对邮件进行分类的训练精确度差距不大，在测试数据上综合平均精确度分别为0.7985、0.787、0.7975，实验结果表明朴素贝叶斯对垃圾邮件分类的泛化能力较好。

在此基础上，我们利用网格搜索和交叉验证的方法，在TF-IDF向量化文本下，对朴素贝叶斯分类模型的参数进行网格搜索分析，参数设置为 ,,最终得到朴素贝叶斯模型表现最优的参数,对应交叉验证平均精确度为0.935，测试集精确度为0.936，比原始参数高17.2%,证明了网格搜索和交叉验证后我们模型的参数选取的优越性和可靠性，同时通过分析原始参数和最优参数条件下的ROC曲线，也证明了模型的可靠性。

6. 改：加特征工程

我们尝试在现有文本内容的基础上，增加描述文本长度和符号比例的特征量。我们想看一看，垃圾邮件和邮件的文本长度的分布以及符号占比的分布是否有差异。

#特征工程
#观察垃圾邮件和正常邮件文本的长度，符号长度的分布是否有区别
data['text length']=data['text'].apply(lambda x: len(x) -x.count(' '))#文本非空格长度
#定义文本标点符号的比例函数：标点符号长度/非空格文本总长度
def text_punc_percentage(text):
    count=sum([1 for char in text if char in string.punctuation])
    return round(count/(len(text)-text.count(' ')),3)*100
data['punc%']=data.text.apply(lambda x: text_punc_percentage(x))

接下来绘制文本长度和符号比例的分布图

#文本长度和字符比例分布可视化
fig=plt.figure(figsize=(14,4.3))
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams.update({'font.size':15})

fig.add_subplot(121)
sns.distplot(data['text length'][data.label == 1])
sns.distplot(data['text length'][data.label == 0])
plt.legend(['垃圾邮件','正常邮件'])
plt.title('邮件文本长度分布')
fig.add_subplot(122)
sns.distplot(data['punc%'][data.label == 1])
sns.distplot(data['punc%'][data.label == 0])
plt.legend(['垃圾邮件','正常邮件'])
plt.title('邮件文本符号占比分布')
plt.savefig('./文本长度与符号比例的分布.png',dpi=300,bbox_inches='tight')

图 5 文本长度与符号占比的分布 

 从图4可以看出来，垃圾邮件和正常邮件的文本长度整体上没有太大差距，但是正常邮件的文本长度更倾向于短文本，而垃圾邮件也存在一些较长的文本长度，因此不能忽略这个特征；而对于符号占比，两者的分布有明显的差距，正常邮件的符号占比大概率是比较低的，而垃圾邮件比正常邮件的符号占比整体上要大一点。因此我们考虑在文本向量处理之后，加入这两个特征。

分别2.1节TF-IDF，2.2词袋模型下加入特征量

#2.1节，TF-IDF下
#将特征工程的文本长度和字符比例加入模型特征变量
X_tf_new=pd.DataFrame(X_tf).join(data[['text length','punc%']])
X_train_tf,X_test_tf,y_train_tf,y_test_tf=train_test_split(X_tf_new,data['label'],random_state=42,test_size=0.3)

#2.2节，Bow下
#将特征工程的文本长度和字符比例加入模型特征变量
X_bow_new=pd.DataFrame(X_bow).join(data[['text length','punc%']])
X_train_bow,X_test_bow,y_train_bow,y_test_bow=train_test_split(X_bow_new,data['label'],random_state=42,test_size=0.3)

将新加入的特征，利用交叉验证和网格搜索化，找寻最佳alpha以及对应的训练和测试准确度

alphas=[1e-1000,1e-15,1e-10,1e-7,1e-3,1e-1,0.5,1]
k=5
#tf-idf
email_GridSearchCV(MultinomialNB,alphas,k,X_train_tf,y_train_tf,X_test_tf,y_test_tf)
#bow
email_GridSearchCV(MultinomialNB,alphas,k,X_train_bow,y_train_bow,X_test_bow,y_test_bow)

得到TF-IDF下，实验结果如下

即朴素贝叶斯不采用平滑方式，最优参数，测试精确度为0.957，比之前不加入特征量的最优精确度高2.1%，交叉验证平均分数为0.936，比之前不加入特征量的交叉验证平均分数提高了0.1%，泛化性能得到了提高。

由此可见，朴素贝叶斯分类器对于特征处理这块有较高的敏感性，因此对于文本分类，在没有数据量增加的条件下，最优的方法是尝试增加对模型适用的特征量，可能效果更好。

全部代码如下，亲测没错误

#导入基本的模块
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import seaborn as sns
#读取数据
filename='F:/3大语言数据分析/python 语言与数据分析/python_homework/附件1'
data=[]
n=156
for i in range(n):
    path=filename+'\\'+'{}.txt'.format(i)#i.txt邮件路径
    f=open(path,'r',encoding='utf-8')#打开i.txt邮件
    data.append(f.read())#将邮件存放在data中
    f.close
data=pd.DataFrame(data)#data中每一行是一个邮件样本
data.columns=['text']
print(data.head())#查看前5个txt邮件内容
print(data.info())#查看邮件数据集基本信息

label=np.zeros([156,1])
label[:127]=1
data['label']=label
print(data.head())
print(data['label'].value_counts())#查看数据标签分布，垃圾邮件1有127个，正常邮件0有29个
X=data['text']

#导入所需模块
import re
import string
import jieba
#导入停用词
with open(r'F:\3大语言数据分析\python 语言与数据分析\python_homework\stop_words.txt',
          encoding="utf8") as f:
    stopword_list=f.readlines()

#定义分词函数
def tokenize_data(data):
    tokens =[' '.join(jieba.cut(item)) for item in data]
    tokens = [token.strip() for token in tokens]#分词后的数据
    return tokens

X_tokens=tokenize_data(X)

#定义删除分词后的无用字符函数
def remove_unuseful_characaters(tokens):
    #先将空格符以及换行符删除，以及非单词字符进行删除
    tokens1=[]
    for i in range(len(tokens)):
        tokens1.append(re.sub(r'\W','',tokens[i].replace(' ','').replace('\n','')))
    return tokens1

X_tokens1=remove_unuseful_characaters(X_tokens)

#删除停用词函数
def remove_stop_words(tokens1):
    filtered_tokens = [token for token in tokens1 if token not in stopword_list]
    return filtered_tokens

X_tokens2=remove_stop_words(X_tokens1)

#再次使用分词技术，将整理后的文本进行分词
X_tokens3=tokenize_data(X_tokens2)

#绘制垃圾邮件和正常邮件的词云
spam_email=X_tokens3[:127]#垃圾邮件词
norm_email=X_tokens3[127:]#正常邮件词
spam=''.join([item for item in spam_email])#将所有垃圾邮件的垃圾词合并在一起
norm=''.join([item for item in norm_email])#将所有正常邮件的正常词合并在一起
#替换一些词频较大的无用词，#个别python被分在正常邮件可能属于错误的标签，为了使得词云可视化对比显#著，替换该词（影响不大
spam_new=spam.replace('的','').replace('在','').replace('和','').replace('与','').replace('了','').replace('您','')
norm_new=norm.replace('的','').replace('在','').replace('和','').replace('与','').replace('是','').replace('了','').replace('Python','').replace('python','')

from wordcloud import WordCloud
font = r'C:\Windows\Fonts\simfang.ttf'
wc1 = WordCloud(background_color='white',collocations=False, font_path=font, width=1400, height=1400, margin=2)
wc1.generate(spam_new)
# 保存图片
wc1.to_file(r"wordcloud1.png") # 按照设置的像素宽高度保存绘制好的词云图，比下面程序显示更清晰
# 4.显示图片
# 以图片的形式显示词云
fig=plt.figure(figsize=(6,4.3))
plt.rcParams['font.sans-serif']=['SimHei']
plt.imshow(wc1)
# 关闭图像坐标系
plt.axis("off")
plt.show()
#另一张图
fig=plt.figure(figsize=(6,4.3))
plt.rcParams['font.sans-serif']=['SimHei']
wc2 = WordCloud(background_color='white',collocations=False, font_path=font, width=1400, height=1400, margin=2)
wc2.generate(norm_new)
wc2.to_file(r"wordcloud2.png")
plt.imshow(wc2)
# 关闭图像坐标系
plt.axis("off")
plt.show()

#导入tf-idf模块
from sklearn.feature_extraction.text import TfidfVectorizer

#TF-IDF模型
def tfidf_vector(tokens3,ngram_range=(1, 1)):
    vectorizer=TfidfVectorizer(max_df=0.5,#最大的频率，即单词在所有文档的出现率
                              norm='l2',
                              smooth_idf=True,#idf值采用平滑公式
                              use_idf=True,
                              ngram_range=ngram_range)
    X=vectorizer.fit_transform(tokens3)
    return X
X_tf=tfidf_vector(X_tokens3,ngram_range=(1, 1))#将上文中整理后的文本X,用TF-IDF处理成向量
X_tf=X_tf.toarray()
X_train_tf,X_test_tf,y_train_tf,y_test_tf=train_test_split(X_tf,data['label'],random_state=42,test_size=0.3)#划分训练集和测试集

#导入基本模块
from sklearn.feature_extraction.text import CountVectorizer

#词袋模型
def bow_vector(tokens3,ngram_range=(1, 1)):
    vectorizer=CountVectorizer(max_df=0.5,ngram_range=ngram_range)
    X=vectorizer.fit_transform(tokens3)
    return X
X_bow=bow_vector(X_tokens3,ngram_range=(1, 1))
X_bow=X_bow.toarray()
X_train_bow,X_test_bow,y_train_bow,y_test_bow=train_test_split(X_bow,data['label'],random_state=42,test_size=0.3)

#导入朴素贝叶斯模型、支持向量机、Logistic回归模型
from sklearn.naive_bayes import MultinomialNB
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
mnb=MultinomialNB()#最佳参数在10^-8到10^-7,alpha=0.00000009
svm=SVC(probability=True)
lr=LogisticRegression()

#导入评价函数模块
from sklearn.metrics import confusion_matrix,f1_score,roc_curve,auc,recall_score
from sklearn.metrics import precision_recall_curve,accuracy_score,precision_score
#导入交叉验证模块
from sklearn.model_selection import cross_val_score,cross_validate


#分类器训练
def email_classifier_model(classifier,train_X,train_y,test_X,test_y):
    #建立模型
    model=classifier.fit(train_X,train_y)
    #预测模型
    predict=model.predict(test_X)
    #训练混淆矩阵
    print('训练混淆矩阵:\n',confusion_matrix(train_y,model.predict(train_X)))
    #绘制训练器的ROC曲线
    fpr,tpr,thresholds=roc_curve(train_y,model.predict_proba(train_X)[:,1],pos_label=1)
    roc_auc=auc(fpr,tpr)
    #plt.plot(fpr,tpr,color='r',linewidth=2,label='ROC curve (area=%0.5f)' % roc_auc)
    #plt.plot([0,1],[0,1],color='navy',linewidth=2,linestyle='--')
    
    get_metrics(true_labels=test_y,predict_labels=predict)
    return fpr,tpr,thresholds,roc_auc

#评估模型,用于多分类average='weighted'考虑不平衡数据进行加权，按每个标签的真实实例数来加权
#本文为二分类不需要考虑
def get_metrics(true_labels,predict_labels):
    #预测正确的样本/预测总样本量
    print('准确率:',accuracy_score(true_labels,predict_labels))
    #预测为正类且预测正确的数量/预测为正类的数量
    print('查准率:',precision_score(true_labels,predict_labels))
    #预测为正类且预测正确的数量/真实为正类的数量
    print('召回率:',recall_score(true_labels,predict_labels))
    #F1=2XPXR/(P+R)
    print('F1分数:',f1_score(true_labels,predict_labels))

#tf_idf
#朴素贝叶斯
mnb_fpr_tf,mnb_tpr_tf,mnb_thresholds_tf,mnb_roc_auc_tf=email_classifier_model(mnb,X_train_tf,y_train_tf,
                                                                  X_test_tf,y_test_tf)
#支持向量机
svm_fpr_tf,svm_tpr_tf,svm_thresholds_tf,svm_roc_auc_tf=email_classifier_model(svm,X_train_tf,y_train_tf,
                                                                  X_test_tf,y_test_tf)
#Logistic回归
lr_fpr_tf,lr_tpr_tf,lr_thresholds_tf,lr_roc_auc_tf=email_classifier_model(lr,X_train_tf,y_train_tf,
                                                                  X_test_tf,y_test_tf)
#词频模型
mnb_fpr_bow,mnb_tpr_bow,mnb_thresholds_bow,mnb_roc_auc_bow=email_classifier_model(mnb,X_train_bow,y_train_bow,
                                                                  X_test_bow,y_test_bow)
svm_fpr_bow,svm_tpr_bow,svm_thresholds_bow,svm_roc_auc_bow=email_classifier_model(svm,X_train_bow,y_train_bow,
                                                                  X_test_bow,y_test_bow)
lr_fpr_bow,lr_tpr_bow,lr_thresholds_bow,lr_roc_auc_bow=email_classifier_model(lr,X_train_bow,y_train_bow,
                                                                  X_test_bow,y_test_bow)

#ROC曲线
classifiers=[mnb,svm,lr]
legends=['基准线','朴素贝叶斯','支持向量机','Logistic']
def ROC(classifiers,train_X,train_y,test_X,test_y):
    models=[classifier.fit(train_X,train_y) for classifier in classifiers]
    plt.figure(figsize=(14,8.6))
    plt.rcParams['font.sans-serif']=['SimHei']
    plt.rcParams.update({'font.size':15})
    plt.plot([0,1],[0,1],color='navy',linewidth=2,linestyle='--')
    for model in models:
        fpr,tpr,thresholds=roc_curve(test_y,model.predict_proba(test_X)[:,1],pos_label=1)
        roc_auc=auc(fpr,tpr)
        plt.plot(fpr,tpr,linewidth=2,label='ROC curve (area=%0.5f)' % roc_auc)
        plt.legend([legend for legend in legends])
        plt.xlim([-0.01,1.01])
        plt.ylim([-0.01,1.01])
        plt.xlabel('FPR')
        plt.ylabel('TPR')
        plt.title('TF-IDF-ROC曲线',fontproperties='SimHei')
    plt.savefig('原始TF-IDF-roc曲线.png',dpi=300,bbox_inches='tight')
#tf-idf
ROC(classifiers,X_train_tf,y_train_tf,X_test_tf,y_test_tf)

def email_GridSearchCV(estimator,alphas,k,train_X,train_y,test_X,test_y):
    accuracy=[]
    for alpha in alphas:
        model=estimator(alpha)
        model=model.fit(train_X,train_y)
        predict_y=model.predict(test_X)
        ac=accuracy_score(test_y,predict_y)
        accuracy.append(ac)
    best_alpha_index=accuracy.index(max(accuracy))
    best_accuracy=accuracy[best_alpha_index]
    best_alpha=alphas[best_alpha_index]
    CV_score=cross_val_score(estimator(best_alpha),train_X,train_y,cv=k)
    CV_score_mean=CV_score.mean()
    print('最佳的参数alpha:{}'.format(best_alpha),'对应的测试精确度:{}'.format(best_accuracy))
    print('交叉验证平均分数:{}'.format(CV_score_mean))
    return accuracy,best_alpha, CV_score_mean
#tf-idf
alphas=[1e-10,1e-7,1e-3,1e-1,0.5,1]
k=5
email_GridSearchCV(MultinomialNB,alphas,k,X_train_tf,y_train_tf,X_test_tf,y_test_tf)

model1=mnb.fit(X_train_tf,y_train_tf)
model2=MultinomialNB(alpha=0.1).fit(X_train_tf,y_train_tf)
plt.figure(figsize=(14,8.6))
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams.update({'font.size':15})
plt.plot([0,1],[0,1],color='navy',linewidth=2,linestyle='--')
    
fpr1,tpr1,thresholds1=roc_curve(y_test_tf,model1.predict_proba(X_test_tf)[:,1],pos_label=1)
fpr2,tpr2,thresholds2=roc_curve(y_test_tf,model2.predict_proba(X_test_tf)[:,1],pos_label=1)
roc_auc1=auc(fpr1,tpr1)
roc_auc2=auc(fpr2,tpr2)
plt.plot(fpr1,tpr1,linewidth=2,color='#14446A',label='ROC curve (area=%0.5f)' % roc_auc1)
plt.plot(fpr2,tpr2,linewidth=2,color='#DE7D2C',label='ROC curve (area=%0.5f)' % roc_auc2)
plt.legend(['基准线','原始参数alpha=1','优化后的参数alpha=0.1'])
plt.xlim([-0.01,1.01])
plt.ylim([-0.01,1.01])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.title('TF-ITF-ROC曲线',fontproperties='SimHei')
plt.savefig('原始_优化曲线.png',dpi=300,bbox_inches='tight')

#特征工程
#观察垃圾邮件和正常邮件文本的长度，符号长度的分布是否有区别
data['text length']=data['text'].apply(lambda x: len(x) -x.count(' '))#文本非空格长度
#定义文本标点符号的比例函数：标点符号长度/非空格文本总长度
def text_punc_percentage(text):
    count=sum([1 for char in text if char in string.punctuation])
    return round(count/(len(text)-text.count(' ')),3)*100
data['punc%']=data.text.apply(lambda x: text_punc_percentage(x))
#文本长度和字符比例分布可视化
import seaborn as sns
fig=plt.figure(figsize=(14,4.3))
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams.update({'font.size':15})

fig.add_subplot(121)
sns.distplot(data['text length'][data.label == 1])
sns.distplot(data['text length'][data.label == 0])
plt.legend(['垃圾邮件','正常邮件'])
plt.title('邮件文本长度分布')
fig.add_subplot(122)
sns.distplot(data['punc%'][data.label == 1])
sns.distplot(data['punc%'][data.label == 0])
plt.legend(['垃圾邮件','正常邮件'])
plt.title('邮件文本符号占比分布')
plt.savefig('./文本长度与符号比例的分布.png',dpi=300,bbox_inches='tight')

#2.1节，TF-IDF下
#将特征工程的文本长度和字符比例加入模型特征变量
X_tf_new=pd.DataFrame(X_tf).join(data[['text length','punc%']])
X_train_tf,X_test_tf,y_train_tf,y_test_tf=train_test_split(X_tf_new,data['label'],random_state=42,test_size=0.3)

#2.2节，Bow下
#将特征工程的文本长度和字符比例加入模型特征变量
X_bow_new=pd.DataFrame(X_bow).join(data[['text length','punc%']])
X_train_bow,X_test_bow,y_train_bow,y_test_bow=train_test_split(X_bow_new,data['label'],random_state=42,test_size=0.3)
alphas=[1e-1000,1e-15,1e-10,1e-7,1e-3,1e-1,0.5,1]
k=5
#tf-idf
email_GridSearchCV(MultinomialNB,alphas,k,X_train_tf,y_train_tf,X_test_tf,y_test_tf)
#bow
email_GridSearchCV(MultinomialNB,alphas,k,X_train_bow,y_train_bow,X_test_bow,y_test_bow)

参考资源以及数据集下载链接：

python_NLP实战之中文垃圾邮件分类

中文邮件提取码：72pb