【某航】tf-idf文本特征提取与SVM分类——数据挖掘导论

代码链接：github代码

1.任务要求

（1）将数据集Case1-classification.zip中的email文件转换成列表数据，利用tf-idf方法提取其中的特征

（2）使用SVM分类文本类型，通过5折交叉验证检测分类结果，输出precision, recall, F1-score（可以使用LIBSVM实现SVM）

2.数据预处理与特征提取

数据预处理：Emails_classify/Emails_classify_Proprocessing.py 文件中执行。
下面详细描述提取特征方法：
读取文章内容：从第四行——末尾，避免前两行邮件收发人信息影响内容；
去除标点符号：使用正则表达式去除标点符号，并用一个空格分隔每个单词；
词干提取：将所有的单词转化为小写，利用nltk包SnowballStemmer进行词干提取；
词形还原：判断单词词性，利用nltk包WordNetLemmatizer根据词性将其还原成原始形态，例如running——run；
去除停用词：下载nltk包中的标准stopwords，对每一个单词进行判断，例如是删除’the’等词汇；
特征提取：采用tf-idf方法，计算在每一个邮件中，每一个单词及其相对应的value。

亮点：

采用两种方法进行分词：词形还原，词干提取

词形还原（lemmatization），是把一个任何形式的语言词汇还原为一般形式（能表达完整语义），而**词干提取（stemming）**是抽取词的词干或词根形式（不一定能够表达完整语义）。词形还原和词干提取是词形规范化的两类重要方式，都能够达到有效归并词形的目的，二者既有联系也有区别。

在原理上，词干提取主要是采用“缩减”的方法，将词转换为词干，如将“cats”处理为“cat”，将“effective”处理为“effect”。而词形还原主要采用“转变”的方法，将词转变为其原形，如将“drove”处理为“drive”，将“driving”处理为“drive”。

在应用领域上，同样各有侧重。虽然二者均被应用于信息检索和文本处理中，但侧重不同。词干提取更多被应用于信息检索领域，如Solr、Lucene等，用于扩展检索，粒度较粗。词形还原更主要被应用于文本挖掘、自然语言处理，用于更细粒度、更为准确的文本分析和表达。

在本课题中，分别采用了这两种方法生成特征数据lemmatization_preed_data.csv 和 stemming_preed_data.csv。通过两文件的对比分析，可以看到，两者分类结果类似，词干提取文件较小，是一种较粗粒度的检索方式，词形还原文件较大，并且大多数单词拥有一定含义，可以被用来文本挖掘情感分析等。

3.SVM分类

SVM分类：Emails_classify/Emails_classify_svm.py 文件中执行。

SVM分类，调用sklearn-learn中的SVM分类。采用svm.SVC 分类方法，核函数可以通过命令行进行自主选择，一般默认为‘RBF’。运行缓存定位800MB，尽量加快训练速度。

通过数据读取，数据格式划分，建立模型，模型拟合，计算评价指标，完成整个训练。

在训练过程中，可以选择采用不同的核函数类型（常用rbf类型或linear类型）；另外，采用KFold五折自动训练（必须训练前打乱数据顺序分组），利用metrics计算precision, recall, f1_score三类评价指标具体数值。

结果：

SVM分类模型一般用线性核和高斯核，也就是Linear核 与RBF核 。在本实验中，在上述两种特征数据的基础上，分别运用两种核函数进行测试，结果保存在文件夹下的txt文件中。

对比两种不同核函数，我们发现，采用线性linear核函数的消耗时间较短，因为，一般情况下，linear适用于线性可分的情况，参数少，速度快，对于一般数据，分类效果已经很理想了，RBF核：主要用于线性不可分的情形。参数多，分类结果非常依赖于参数（在这里使用的是默认设置参数），在参数表现方面，两种方法训练得到的评价指标很接近，在综合性能表现方面，rbf核的表现较好，如果可以采用5折交叉验证自动寻找rbf参数，可能回达到更好的效果。

查阅资料发现，吴恩达的机器学习课程中讲到，如果Feature的数量很大，跟样本数量差不多，这时候的情况大部分都是线性可分的，选用linear核较好；一般情况下，rbf核函数能够胜任绝大多数中情况，它是一种局部性强的核函数，其可以将一个样本映射到一个更高维的空间内，该核函数是应用最广的一个，无论大样本还是小样本都有比较好的性能，因此大多数情况下在不知道用什么核函数的时候，优先使用rbf高斯核函数。但终归来说，如果选用哪种核函数，还是要在测试集上验证之后才可以评判模型好坏，避免出现过拟合的现象。

对比两种不同特征数据集的结果，采用词形还原特征训练时间稍长，因为文件较大，包含的词向量更多，在训练结果的对比分析上，两种特征数据集的结果类似，详细看词形还原的recall值较高，precision和f1 score值较低，综合表现上采用词干提取的训练效果较佳，也正印证了在检索分类的情况下，推荐采取词干提取的方式进行特征提取。

4*.SMO算法

SMO算法：Emails_classify/Emails_classify_SMO.py 文件中执行。

SMO(Sequential Minimal Optimization)序列最小化算法就是一个二次规划优化算法。SMO算法的目标就是求出一些列的alpha和b，一旦求出这些alpha，就可以计算出权重向量，并求出分割超平面。SMO算法的工作原理是：每次循环中选择两个alpha进行优化处理。一旦找到一对合适的alpha，那么就增大其中一个，同时减少另一个。

根据已知SMO算法流程，编写SMO算法。直接运行Emails_classify_SMO.py文件即可，会显示相关b和alpha的输出。

# 数据预处理Emails_classify_Proprocessing.py
import re
import os
import argparse
import pandas as pd
from nltk.corpus import stopwords
from nltk.stem import SnowballStemmer
from sklearn.feature_extraction.text import TfidfVectorizer
from nltk import word_tokenize, pos_tag
from nltk.corpus import wordnet
from nltk.stem import WordNetLemmatizer

def del_punctuation(content):
    """
    删除标点，保证单词之间仅有一个空格
    :param content: 文件内容
    :return: 文件内容
    """
    content = re.sub("[\\\'\t\n\.\!\/_,$%^*()\[\]+\"<>\-:]+|[|+——！，。？?、~@#￥%……&*（）]+", " ", content)
    content = ' '.join(content.split())
    return content

def stemming(content):
    """
    词干提取stemming
    :param content: 文件内容
    :return: 文件内容
    """
    stemmer = SnowballStemmer("english")  # 选择目标语言为英语
    all_words = content.split(' ')
    new_content = []
    for word in all_words:
        new_word = stemmer.stem(word.lower())  # Stem a word 并且转化为小写
        if new_word != ' ':
            new_content.append(new_word)
    return " ".join(new_content)

def get_wordnet_pos(tag):
    """
    获取单词的词性
    :param tag: 词性
    :return: 词类型
    """
    if tag.startswith('J'):
        return wordnet.ADJ
    elif tag.startswith('V'):
        return wordnet.VERB
    elif tag.startswith('N'):
        return wordnet.NOUN
    elif tag.startswith('R'):
        return wordnet.ADV
    else:
        return None

def lemmatization(content):
    """
    词形还原 lemmatization
    :param content: 文件内容
    :return: 文件内容
    """
    all_words = word_tokenize(content)  # 分词
    tagged_sent = pos_tag(all_words)  # 获取单词词性

    wnl = WordNetLemmatizer()
    new_content = []
    for tag in tagged_sent:
        wordnet_pos = get_wordnet_pos(tag[1]) or wordnet.NOUN
        new_content.append(wnl.lemmatize(tag[0], pos=wordnet_pos))  # 词形还原
    return " ".join(new_content)

def remove_stop_words(content):
    """
    去停用词
    :param content: 文件内容
    :return: 文件内容
    """
    stopwords_list = stopwords.words('english')
    all_words = content.split(' ')
    new_content = []
    for word in all_words: 
        if word not in stopwords_list:
            new_content.append(word)
    return " ".join(new_content)

def tfidf(file_list, label):
    """
    特征提取 采用tfidf
    :param file_list: 合成的总文件
    :param label: 每个文件的类别标签
    :return: dataframe 表格
    """
    vectorizer = TfidfVectorizer()
    vectors = vectorizer.fit_transform(file_list)
    feature_names = vectorizer.get_feature_names()
    dense = vectors.todense()
    denselist = dense.tolist()
    df = pd.DataFrame(denselist, columns=feature_names)
    df['@label'] = label

    print(df)
    return df

if __name__ == '__main__':

    # 可配置式方法选择
    parser = argparse.ArgumentParser(description='Choose the method(stemming or lemmatization)')
    parser.add_argument('--method', '-m', help='method 词干提取stemming或词性还原lemmatization，非必要参数，但有默认值', default = 'stemming')
    args = parser.parse_args()
    method = args.method

    file_r_list = []  # 存储所有的文件内容
    label = []  # 存储类别结果，'baseball':1; 'hockey':-1

    for type_name in ['baseball', 'hockey']:
        url = 'dataset/Case1-classification/' + type_name
        for file_name in os.listdir(url):
            try:
                file = open(url + '/' + file_name, 'r', encoding='latin-1')
                lines = file.readlines()
            except Exception as e:
                print(url + '/' + file_name + '无法打开')
                print(e)
                continue

            # 读取每一封邮件“第四行——末尾”，并存入content中
            content = ''
            for i in range(3, len(lines)):
                content += lines[i]

            # 数据预处理：1. 去除标点符号；2. 词性还原/词干提取; 3. 去除停用词
            content = del_punctuation(content)
            if method == 'stemming':
                content = stemming(content)
            elif method == 'lemmatization':
                content = lemmatization(content)
            content = remove_stop_words(content)

            file_r_list.append(content)

            # 数据打标签
            if type_name == 'baseball':
                label.append(1)
            elif type_name == 'hockey':
                label.append(-1)

    preed_data = tfidf(file_r_list, label)

    preed_data.to_csv(method + '_preed_data.csv', index = False)

## SVM分类 Emails_classify_svm.py
import time
import argparse
import numpy as np
import pandas as pd
from sklearn import svm
from sklearn.model_selection import KFold
from sklearn import metrics

if __name__ == "__main__":

    # 可配置式运行文件
    parser = argparse.ArgumentParser(description='Choose the kernel and data_file')
    parser.add_argument('--method', '-m', help='method 选择核函数(linear or rbf or poly or sigmoid)', default = 'rbf')
    parser.add_argument('--file', '-f', help='file 选择采用数据集类型(stemming or lemmatization)', default='stemming')
    args = parser.parse_args()
    method = args.method
    file = args.file

    data = pd.read_table(file + '_preed_data.csv', header=0, encoding='utf-8', sep=",", index_col=0)
    data = data.as_matrix()[1:][1:]
    X, y = data[:, 0:-1], data[:, -1].astype(int)

    kf = KFold(n_splits=5, shuffle = True) # 五折训练，打乱数据顺序

    precisionList = []
    recallList = []
    f1List = []

    i = 1 # 表征五折训练的次数

    time_start = time.time()
    print(file + "_preed_data.csv 数据读取完成，开始五折SVM训练，method = "+ method)

    for train_index, val_index in kf.split(X):

        time_kfold_start = time.time()
        X_train, X_val, y_train, y_val = X[train_index], X[val_index], y[train_index], y[val_index]

        # 建立模型
        clf = svm.SVC(kernel=method, gamma = 'scale', cache_size = 800)

        # 模型拟合
        clf.fit(X_train, y_train)

        #模型预测
        y_pred = clf.predict(X_val)

        # 计算评价指标：precision, recall, f1_score
        precision = metrics.precision_score(y_val, y_pred)
        recall = metrics.recall_score(y_val, y_pred)
        f1 = metrics.f1_score(y_val, y_pred)
        precisionList.append(precision)
        recallList.append(recall)
        f1List.append(f1)

        time_kfold_end = time.time()
        print("KFold_" + str(i))
        print("time consumption:" + str(time_kfold_end - time_kfold_start) + "s")
        print("precision:" + str(precision))
        print("recall:" + str(recall))
        print("f1:" + str(f1))
        i += 1

    time_end = time.time()
    print("************五折训练全部完成************")
    print("total time consumption:" + str(time_end - time_start) + "s")
    print("average precision:" + str(np.mean(precisionList)))
    print("average recall:" + str(np.mean(recallList)))
    print("average f1:" + str(np.mean(f1List)))

## SMO算法实现Emails_classify_SMO.py
#-*-coding:utf-8-*-

from numpy import *
import numpy as np

#定义存储变量的类
class opStruct():
    def __init__(self,dataMatIn,classLabels,C,toler,kTup,kTup1):
        self.X = dataMatIn                        #数据
        self.labelMat = classLabels               #标签
        self.C = C                                #容忍度
        self.toler = toler                        #误差的容忍度
        self.m = shape(dataMatIn)[0]              #数据的个数
        self.alphas = mat(zeros((self.m,1)))      #alpha 值，每个数据对应一个alpha
        self.b = 0                                # 常数项
        self.eCache = mat(zeros((self.m,2)))      #保存误差和下表
        self.k = mat(zeros((self.m,self.m)))
        for i in range(self.m):
            self.k[:,i] = kernelTrans(self.X,self.X[i,:],kTup,kTup1) 

def getrightfile(filename1,filename2):
    """
    载入数据
    """
    a = np.load(filename1)
    b = np.load(filename2)
    dataMatIn = a.tolist()
    classLabels = b.tolist()
    return dataMatIn,classLabels

def kernelTrans(X,A,kTup,kTup1):
    """
    加入核函数
    """
    m,n = shape(X)
    k = mat(zeros((m,1)))
    if kTup == 'lin':
        k = X * A.T
    elif kTup == 'rbf':
        for j in range(m):
            deltaRow = X[j,:] - A #每一行减去A，在自己乘
            k[j] = deltaRow * deltaRow.T
        k = exp(k/(-1 * kTup1 ** 2)) #就是利用的公式
    return k

def clipAlpha(ai,H,L):
    """
    保证alpha必须在范围内
    """
    if ai > H:
        ai = H
    elif ai < L :
        ai = L
    return ai

def selectJrand(i,oS):
    """
    随机选择第二个不同的alpha
    """
    j = i
    while i == j:
        j = int(np.random.uniform(0,oS.m))
    return j

def calcEk(oS,k):
    """
    计算误差
    """
    fXk = float((multiply(oS.alphas,oS.labelMat)).T*oS.k[:,k] + oS.b) #预测值
    Ek = fXk - oS.labelMat[k] #误差值
    return Ek

def selectJ(i,oS,Ei):
    """
    选择第二个alpha 并且相差最大的
    """
    maxK = -1
    maxDelaE = 0
    Ej = 0
    oS.eCache[i] = [1,Ei]
    validEcaheList = nonzero(oS.eCache[:,0].A)[0]
    if len(validEcaheList) > 0:
        for k in validEcaheList:
            if k == i: #取不同的 alpha
                continue
            Ek = calcEk(oS,k) #计算k的与测试与真实值之间的误差
            deltaE = abs(Ei - Ek) #找与Ei 距离最远的
            if maxDelaE < deltaE:
                maxDelaE = deltaE  
                maxK = k     #与Ei差别最大的K
                Ej = Ek      #K的误差
        return maxK,Ej
    else:
        j = selectJrand(i,oS)
        Ej = calcEk(oS,j) #计算预测值和真实值的误差
    return j,Ej

def updateEk(oS,k):
    """
    更新误差
    """
    Ek = calcEk(oS,k)
    oS.eCache[k] = [1,Ek]

def innerL(i,oS):
    """
    SMO 优化
    """
    Ei = calcEk(oS,i)
    #在误差允许的范围外，如果小于规定的误差，就不需要更新了
    if ((oS.labelMat[i] * Ei ) <= oS.toler and oS.alphas[i] <= oS.C) or\
            ((oS.labelMat[i] * Ei) <= oS.toler and oS.alphas[i] >= 0):
        j,Ej = selectJ(i,oS,Ei)  #选择另一个alphaj和预测值与真实值的差
        alphaIold = oS.alphas[i].copy() #复制alpha，因为后边会用到
        alphaJold = oS.alphas[j].copy()
 
        if (oS.labelMat[i] != oS.labelMat[j]): #两个类别不一样 一个正类 一个负类
            L = max(0,oS.labelMat[j] - oS.labelMat[i])  # 约束条件 博客里有
            H = min(oS.C,oS.C + oS.alphas[j] - oS.alphas[i])
        else:
            L = max(0,oS.alphas[j] + oS.alphas[i] - oS.C)
            H = min(oS.C,oS.alphas[j] + oS.alphas[i])
 
        if L == H:
            print('L == H')
            return 0
            
        #利用核函数
        eta = 2.0 * oS.k[i,j] - oS.k[i,i] - oS.k[j,j]
        if eta > 0:
            return 0
        oS.alphas[j] -= oS.labelMat[j] * (Ei - Ej)/eta  #就是按最后的公式求解
        oS.alphas[j] = clipAlpha(oS.alphas[j],H,L)  #在L，H范围内
        updateEk(oS,j)
 
        if (oS.alphas[j] - alphaJold) < 0.0001:
            return 0
 
        oS.alphas[i] += oS.labelMat[j] * oS.labelMat[i] * (alphaJold - oS.alphas[j])
        updateEk(oS,i)

        #利用核函数的
        b1 = oS.b - Ei - oS.labelMat[i] * oS.k[i,i] * (oS.alphas[i] - alphaIold) - oS.labelMat[j] * oS.k[i,j] * (oS.alphas[j] - alphaJold)
        b2 = oS.b - Ej - oS.labelMat[i] * oS.k[i,j] * (oS.alphas[i] - alphaIold) - oS.labelMat[j] * oS.k[j,j] * (oS.alphas[j] - alphaJold)
 
        #跟新b
        if oS.alphas[i] < oS.C and oS.alphas[i] > 0:
            oS.b = b1
        elif oS.alphas[j] < oS.C and oS.alphas[j] > 0:
            oS.b = b2
        else:
            oS.b = (b1 + b2)/2.0
        return 1
    else:
        return 0

def calcWs(alpha,dataArr,classLabels):
    """
    计算alpha 获得分类的权重向量
    :param alpha:
    :param dataArr: 训练数据
    :param classLabels: 训练标签
    :return:
    """
    X = mat(dataArr)
    labelMat = mat(classLabels).T #变成列向量
    m,n = shape(X)
    w  =zeros((n,1)) #w的个数与 数据的维数一样
    for i in range(m):
        w += multiply(alpha[i] * labelMat[i],X[i,:].T) #alpha[i] * labelMat[i]就是一个常数  X[i,:]每（行）个数据，因为w为列向量，所以需要转置
    return w

def smoP(dataMatIn,classLabels,C,toler,maxIter,kTup ='lin',kTup1=0):
    """
    核心主函数
    :param dataMatIn: 训练数据
    :param classLabels: 训练标签
    :param C: 常量
    :param toler:容错度
    :param maxIter: 最大迭代次数
    :param kTup: 核函数类型参数
    :param kTup1: 核函数类型参数
    :return:
    """
    oS = opStruct(mat(dataMatIn),mat(classLabels).T,C,toler,kTup,kTup1)
    iter = 0
    entireSet = True
    alphaPairedChanged = 0
    while (iter < maxIter) and ((alphaPairedChanged > 0) or (entireSet)):
        alphaPairedChanged = 0
        if entireSet:
            # 遍历所有的数据 进行更新
            for i in range(oS.m):
                alphaPairedChanged += innerL(i,oS)
            iter += 1
        else:
            nonBoundIs = nonzero((oS.alphas.A > 0) * (oS.alphas.A < oS.C))[0]
            for i in nonBoundIs:
                alphaPairedChanged += innerL(i,oS)
            iter += 1
 
        if entireSet:
            entireSet = False
        elif (alphaPairedChanged == 0):
            entireSet = True
    return oS.b,oS.alphas

if __name__ == '__main__':
    dataMatIn,classLabels = getrightfile('smo_mail_list.npy','smo_label_list.npy')
    b,alphas =smoP(dataMatIn,classLabels,C=0.6,toler=0.001,maxIter=40,kTup = 'lin',kTup1=1)
    print(b,alphas)

## 安装文本处理包install_database.py
import nltk

nltk.download('stopwords')
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')

代码链接：github代码

如果感觉对你有所帮助，不妨点个赞，关注一波，激励博主持续更新！