本章重要批注文本分类的完好流程和相关算法，他们的硬盘里

原标题：用机器学习怎样鉴别不可描述的网站

本章知识点：中文分词，向量空间模型，TF-IDF方法，文本分类算法和评价指标
使用的算法：朴素的贝叶斯算法，KNN最近邻算法
python库：jieba分词，Scikit-Learning
本章目标：实现小型的文本分类系统
本章主要讲解文本分类的整体流程和相关算法

 转自：

全文大约3500字。读完可能需要下面这首歌的时间

---

首先什么是中文分词stop word？

前两天教师节，人工智能头条的某个精神股东粉群里，大家纷纷向当年为我们启蒙、给我们带来快乐的老师们表达感激之情。

2.1 文本挖掘和文本分类的概念

1，文本挖掘：指从大量的文本数据中抽取事先未知的，可理解的，最终可使用的知识的过程，同时运用这些知识更好的组织信息以便将来参考。
简言之，就是从非结构化的文本中寻找知识的过程
2，文本挖掘的细分领域：搜索和信息检索(IR)，文本聚类，文本分类，Web挖掘，信息抽取(IE)，自然语言处理（NLP),概念提取。
3，文本分类：为用户给出的每个文档找到所属的正确类别
4，文本分类的应用：文本检索，垃圾邮件过滤，网页分层目录自动生成元数据，题材检测
5，文本分类的方法：一是基于模式系统，二是分类模型

---

英文是以词为单位的，词和词之间是靠空格隔开，而中文是以字为单位，句子中所有的字连起来才能描述一个意思。例如，英文句子I
am a
student，用中文则为：“我是一个学生”。计算机可以很简单通过空格知道student是一个单词，但是不能很容易明白“学”、“生”两个字合起来才表示一个词。把中文的汉字序列切分成有意义的词，就是中文分词，有些人也称为切词。我是一个学生，分词的结果是：我
是 一个 学生。

很多人表示，他们的硬盘里，至今还保留着当时她们上课时候的视频。有一些现在网站上已经很难找到了，于是大家又纷纷开始互相交流跟随这些老师学习实践的心得体会。

2.2 文本分类项目

其次中文分词和搜索引擎关系与影响！

中文语言的文本分类技术和流程:

1）预处理：去除文本的噪声信息：HTML标签，文本格式转换
2）中文分词：使用中文分词器为文本分词，并去除停用词
3）构建词向量空间：统计文本词频，生成文本的词向量空间
4 )
权重策略–TF-IDF方法：使用TF-IDF发现特征词，并抽取为反映文档主题的特征
5）分类器：使用算法训练分类器
6）评价分类结果：分类器的测试结果分析

中文分词到底对搜索引擎有多大影响？对于搜索引擎来说，最重要的并不是找到所有结果，因为在上百亿的网页中找到所有结果没有太多的意义，没有人能看得完，最重要的是把最相关的结果排在最前面，这也称为相关度排序。中文分词的准确与否，常常直接影响到对搜索结果的相关度排序。笔者最近替朋友找一些关于日本和服的资料，在搜索引擎上输入“和服”，得到的结果就发现了很多问题。

👆禅师最喜欢的教师

2.2.1 文本预处理：

文本处理的核心任务：将非结构化的文本转换为结构化的形式，即向量空间模型

文本处理之前需要对不同类型的文本进行预处理

小谈：中文分词技术

后来禅师想起来，另一个人工智能头条的精神股东粉群西部世界里，有人提到过他写了一篇Chat，利用
NLP 来鉴别是普通网站和不可描述网站，还挺有点意思，一起来看看吧。

文本预处理的步骤：

1，选择处理的文本的范围：整个文档或其中段落
2，建立分类文本语料库：
训练集语料：已经分好类的文本资源。（文件名:train_corpus_small）
测试集语料：待分类的文本语料（本项目的测试语料随机选自训练语料）（文件名：test_corpus）
3，文本格式转换：统一转换为纯文本格式。（注意问题：乱码）
4，检测句子边界：标记句子结束

中文分词技术属于 自然语言处理技术范畴，对于一句话，人可以通过自己的知识来明白哪些是词，哪些不是词，但如何让计算机也能理解？其处理过程就是分词本章重要批注文本分类的完好流程和相关算法，他们的硬盘里。算法。

互联网中蕴含着海量的内容信息，基于这些信息的挖掘始终是诸多领域的研究热点。当然不同的领域需要的信息并不一致，有的研究需要的是文字信息，有的研究需要的是图片信息，有的研究需要的是音频信息，有的研究需要的是视频信息。

2.2.2 中文分词介绍

1，中文分词：将一个汉字序列（句子）切分成一个单独的词（中文自然语言处理的核心问题）
2，中文分词的算法：基于概率图模型的条件随机场（CRF）
3，分词后文本的结构化表示：词向量空间模型，主题模型，依存句法的树表示，RDF的图表示
4，本项目的分词系统：采用jieba分词
5, jieba分词支持的分词模式：默认切分，全切分，搜索引擎切分
6，jieba分词的代码见文件：对未分词语料库进行分词并持久化对象到一个dat文件(创建分词后的语料文件：train_corpus_seg)

#coding=utf-8

import sys
import os
import jieba

reload(sys)
sys.setdefaultencoding('utf-8')    # 配置UTF-8输出环境

#定义两个函数，用于读取和保存文件

def savefile(savpath,content):   # 定义一个用于保存文件的函数
    fp = open(savepath,"wb")
    fp.write(content)
    fp.close()

def readfile(path):    # 定义一个用于读取文件的函数
    fp = open(path,"rb")
    content = fp.read()
    fp.close()
    return content    #函数返回读取的内容


# 以下是整个语料库的分词主程序

corpus_path = "train_corpus_small/"   # 未分词分类语料库路径
seg_path = "train_corpus_seg/"  # 分词后分类语料库路径

catelist = os.listdir(corpus_path) #os.listdir获取cor_path下的所有子目录

for mydir in catelist:       # 遍历所有子目录
    class_path = corpus_path+mydir+"/"  #构造分类子目录的路径
    seg_dir = seg_path+mydir+"/"  #构造分词后的语料分类目录

    if not os.path.exists(seg_dir):  # 是否存在目录，如果没有则创建
        os.makedirs(seg_dir)

    file_list = os.listdir(class_path)  # 获取目录下的所有文件

    for file_path in file_list:      # 遍历目录下的所有文件
        fullname = class_path+file_path    #文件路径
        content = readfile(full.name).strip()   # 读取文件，strip()用于移除字符串头尾指定的字符，即移除头尾的空格
        content = content.replace("rn","").strip()  # 将空格和换行替代为无
        content_seg = jieba.cut(content)    # 利用jieba分词

        savefile(seg_dir+file_path," ".join(content_seg))   # 调用函数保存文件，保存路径为：seg_dir+file_path,用空格将分词后的词连接起来

print "中文语料分词结束"


#############################################################################

# 为了便于后续的向量空间模型的生成，分词后的文本还要转换为文本向量信息并对象化
# 引入Scikit-Learn的Bunch类

from sklearn.datasets.base import Bunch
bunch = Bunch{target_name=[],label=[],filename=[],contents=[]}

# Bunch类提供键值对的对象形式
#target_name:所有分类集名称列表
#label:每个文件的分类标签列表
#filename：文件路径
#contents：分词后的文件词向量形式

wordbag_path = "train_word_bad/train_set.dat"  #分词语料Bunch对象持久化文件路径
seg_path = "train_corpus_seg/"   #分词后分类语料库路径（同上）

catelist = os.listdir(seg_path)  # 获取分词后语料库的所有子目录（子目录名是类别名）
bunch.target_name.extend(catelist)   # 将所有类别信息保存到Bunch对象

for mydir in catelist:     # 遍历所有子目录
    class_path = seg_path+mydir+"/" # 构造子目录路径
    file_list = os.listdir(class_path)    # 获取子目录内的所有文件
    for file_path in file_list:     # 遍历目录内所有文件
        fullname = class_path+file_path    # 构造文件路径
        bunch.label.append(mydir)      # 保存当前文件的分类标签（mydir为子目录即类别名）
        bunch.filenames.append(fullname)  # 保存当前文件的文件路径（full_name为文件路径）
        bunch.contents.append(readfile(fullname).strip())  # 保存文件词向量（调用readfile函数读取文件内容）

file_obj = open(wordbad_path,"wb")  # 打开前面构造的持久化文件的路径，准备写入
pickle.dump(bunch,file_obj)   # pickle模块持久化信息，bunch是要持久化的文件，已添加了信息。file_obj是路径
file_obj.close()
#　之所以要持久化，类似游戏中途存档，分词后，划分一个阶段，将分词好的文件存档，后面再运行就不用重复分词了

print "构建文本对象结束！！"      

# 持久化后生成一个train_set.dat文件，保存着所有训练集文件的所有分类信息
# 保存着每个文件的文件名，文件所属分类和词向量

现有的分词算法可分为三大类：基于字符串匹配的分词方法、基于理解的分词方法和基于统计的分词方法。

2.2.3 Scikit-Learn库简介

1、基于字符串匹配的分词方法

本文就是根据网页的文字信息来对网站进行分类。当然为了简化问题的复杂性，将以一个二分类问题为例，即如何鉴别一个网站是不可描述网站还是普通网站。你可能也注意
QQ
浏览器会提示用户访问的网站可能会包含色情信息，就可能用到类似的方法。本次的分享主要以英文网站的网站进行分析，主要是这类网站在国外的一些国家是合法的。其他语言的网站，方法类似。

1，模块分类：

1）分类和回归算法：广义线性模型，支持向量机，kNN,朴素贝叶斯，决策树，特征选择
2）聚类算法：K-means
3）维度约简：PCA
4）模型选择:交叉验证
5）数据预处理：标准化，去除均值率和方差缩放，正规化，二值化，编码分类特征，缺失值的插补

这种方法又叫做机械分词方法，它是按照一定的策略将待分析的汉字串与一个“充分大的”机器词典中的词条进行配，若在词典中找到某个字符串，则匹配成功（识别出一个词）。按照扫描方向的不同，串匹配分词方法可以分为正向匹配和逆向匹配；按照不同长度优先匹配的情况，可以分为最大（最长）匹配和最小（最短）匹配；按照是否与词性标注过程相结合，又可以分为单纯分词方法和分词与标注相结合的一体化方法。常用的几种机械分词方法如下：

一，哪些信息是网站关键的语料信息

2.2.4 向量空间模型：文本分类的结构化方法

1，向量空间模型：将文本表示为一个向量，该向量的每个特征表示为文本中出现的词
2，停用词：文本分类前，自动过滤掉某些字或词，以节省储存空间。根据停用词表去除，表可下载。代码见文件

1）正向最大匹配法（由左到右的方向）；

搜索引擎改变了很多人的上网方式，以前如果你要上网，可能得记住很多的域名或者
IP。但是现在如果你想访问某个网站，首先想到的是通过搜索引擎进行关键字搜索。比如我想访问一个名为村中少年的博客，那么只要在搜索引擎输入村中少年这类关键词就可以了。图1是搜索村中少年博客时候的效果图：

2.2.5 权重策略：TF-IDF方法

1，词向量空间模型：将文本中的词转换为数字，整个文本集转换为维度相等的词向量矩阵（简单理解，抽取出不重复的每个词，以词出现的次数表示文本）
2，归一化：指以概率的形式表示，例如：0，1/5,0,0,1/5,2/5,0,0,也称为：词频TF（仅针对该文档自身）
3，词条的文档频率IDF： 针对所有文档的词频

2）逆向最大匹配法（由右到左的方向）；

TF-IDF权重策略：计算文本的权重向量

1，TF-IDF的含义：词频逆文档频率。如果某个词在一篇文章中出现的频率高（词频高），并且在其他文章中很少出现（文档频率低），则认为该词具有很好的类别区分能力，适合用来分类。IDF其实是对TF起抵消作用。
2，词频TF的定义：某一个给定的词语在该文件中出现的频率（对词数的归一化）
3，逆文件频率IDF：某一特定词语的IDF，由总文件数除以包含该词语的文件的数目，再将商取对数
4，TF-IDF的计算：TF与IDF的乘积
5，将分词后的持久化语料库文件dat利用TF-IDF策略转化，并持久化的代码见文件

#coding=utf-8

import sys
import os 
from sklearn.datasets.base import Bunch  # 导入Bunch类
import cPickle as pickle  #导入持久化类

from sklearn import feature_extraction
from sklearn.feature_extraction.text import TfidfTransformer   # TF-IDF向量转换类
from sklearn.feature_extraction.text import TfidfVectorizer   # TF-IDF向量生成类


reload(sys)
sys.setdefaultencoding('utf-8')  #UTF-8输出环境

# 读取和写入Bunch对象的函数

def readbunchobj(path):   # 读取bunch对象函数
    file_obj = open(path,"rb")
    bunch = pickle.load(file_obj)  # 使用pickle.load反序列化对象
    file_obj.cloase()
    return bunch

def writebunchobj(path,bunchobj):   # 写入bunch对象函数
    file_obj = open(path,"wb")
    pickle.dump(bunchobj,file_obj)   # 持久化对象
    file_obj.close()

###################################从训练集生成TF-IDF向量词袋

# 1，导入分词后的词向量Bunch对象
path = "train_word_bag/train_set.dat"  # 词向量空间保存路径（就是分词后持久化的文件路径）
bunch = readbunchobj(path)   # 调用函数读取bunch对象，赋值给bunch

# 2，构想TF-IDF词向量空间对象,也是一个Bunch对象
tfidfspace = Bunch(target_name=bunch.target_name,label=bunch.label,filenames=bunch.filenames,tdm=[],vocabulary=[])     # 构建Bunch对象，将bunch的部分值赋给他

# 3，使用TfidfVectorizer初始化向量空间模型
vectorizer = TfidfVectorizer(stop_words=stpwrdlist,sublinear_tf=True,max_df=0.5)
transformer=TfidfTransformer()   # 创建一个该类的实例，该类会统计每个词语的TF-IDF权值
# 文本转化为词频矩阵，单独保存字典文件
tfidfspace.tdm = vectorilzer.fit_transform(bunch.contents)  # 将bunch.content的内容……赋给模型的tdm值
tfidfspace.vocabulary = vectorizer.vocabulary   # ？？？？？？？？？？？？？？？？

# 4,持久化TF-IDF向量词袋
space_path = "train_word_bag/tfidfspace.dat"   # 词向量词袋保存路径
writebunchobj(space_path,tfidfspace)  # 调用写入函数，持久化对象

3）最少切分（使每一句中切出的词数最小）。

红色部分便是匹配上搜索关键词的部分，一个页面能够展示 10
个条目，每个条目的标题就是相应网站网站的的 title，对应网页的
<title></title>
中间的内容，每个条目所对应的剩下文字部分便是网站的 deion，是网页中诸如
<meta name=”deion” content= 的部分。

2.2.6 使用朴素贝叶斯分类模块

常用的文本分类方法：kNN最近邻算法，朴素贝叶斯算法，支持向量机算法

本节选择朴素贝叶斯算法进行文本分类，测试集随机选取自训练集的文档集合，每个分类取10个文档

训练步骤和训练集相同：分词 (文件test_corpus) 》生成文件词向量文件 》
生成词向量模型。

（不同点：在训练词向量模型时，需加载训练集词袋，将测试集生成的词向量映射到训练集词袋的词典中，生成向量空间模型。）代码见文件。

#1,导入分词后的词向量Bunch对象
path = "test_word_bag/test_set.dat"   # 词向量空间保存路径
bunch = readbunchobj(path)  # 调用函数读取bunch对象，赋值给bunch

#2，构建测试集TF-IDF向量空间testspace
testspace = Bunch(target_name=bunch.target_name,label+bunch.label,filenames=bunch.filenames.tdm=[],vocabulary=[])   

#3, 导入训练集的词袋(多这一步，与训练集不同)
trainbunch = readbunchobj("train_word_bag/tfidfspace.dat")  # tfidfspace.dat文件是训练集使用TF-IDF策略并持久化生成的

#4, 使用TfidfVectorizer初始化向量空间模型
vectorizer=TfidfVectorizer(stop_words=stpwrdlst,sublinear_tf=True,max_df=0.5,vocabulary=trainbunch.vocabulary)
transformer=TfidfTransformer()    # 创建一个该类的实例，该类会统计每个词语的TF-IDF权值
testspace.tdm=vectorizer.fit_transform(bunch.contents)   
testspace.vocabulary=trainbunch.vocabulary

#5, 创建词袋并持久化
space_path = "test_word_bag/testspace.dat"  #词向量空间保存路径
writebunchobj(space_path,testspace)  # 调用写入函数，持久化对象

执行多项式贝叶斯算法进行测试文本分类，并返回分类精度，代码见文件

# 执行多项式贝叶斯算法并进行测试文本分类，并返回分类精度

#1，导入多项式贝叶斯算法包
from sklearn.naive_bayes import MultinomialNB #导入多项式贝叶斯算法包

#2,执行预测

trainpath = "train_word_bag/tfidfspace.dat"
train_set = readbunchobj(trainpath)     #导入训练集向量空间

testpath = "test_word_bag/testspace.dat"
test_set = readbunchobj(testpath)        # 导入测试集向量空间

#应用朴素贝叶斯算法
# alpha:0.001   alpha越小，迭代次数越多，精度越高
clf = MultinomialNB(alpha = 0.001).fit(train_set.tdm,train_set.label)

# 预测分类结果
predicted = clf.predict(test_set.tdm)
total = len(predicted);rate = 0
for flabel,file_name,expct_cate in zip(test_set.label,test_set.filenames,predicted):
    if flabel !=expct_cate:
        rate+=1
        print file_name,":实际类别：",flabel,"-->预测类别：",expct-cate

print "error rate:",float(rate)*100/float(total),"%"

还可以将上述各种方法相互组合，例如，可以将正向最大匹配方法和逆向最大匹配方法结合起来构成双向匹配法。由于汉语单字成词的特点，正向最小匹配和逆向最小匹配一般很少使用。一般说来，逆向匹配的切分精度略高于正向匹配，遇到的歧义现象也较少。统计结果表明，单纯使用正向最大匹配的错误率为1/169，单纯使用逆向最大匹配的错误率为1/245。但这种精度还远远不能满足实际的需要。实际使用的分词系统，都是把机械分词作为一种初分手段，还需通过利用各种其它的语言信息来进一步提高切分的准确率。

搜索引擎的工作原理就是首先将互联网上大部分的网页抓取下来，并按照一定的索引进行存储形成快照，每个条目的标题就是原网站
title（通常是 60 个字节左右，也就是 30 个汉字或者 60
各英文字母，当然搜索引擎也会对于 title
做一定的处理，例如去除一些无用的词），条目的描述部分通常对应原网站
deion。

2.2.7 分类结果评估

机器学习领域的算法评估的指标：
（1）召回率（查全率）：检索出的相关文档数和文档库中所有的相关文档数的比率，是衡量检索系统的查全率
召回率=系统检索到的相关文件/系统所有相关的文档总数
（2）准确率（精度）：检索出的相关文档数与检索出的文档总数的比率
准确率=系统检索到的相关文件/系统所有检索到的文件总数
（3）Fp-Measure
Fp=(p2+1)PR/(p2P+R),P是准确率，R是召回率
p=1时，就是F1-Measure
文本分类项目的分类评估结果评估：代码见文件

import numpy as np
from sklearn import metrics

def metrics_result(actual,predict):
    print '精度：{0:3f}'.format(metrics.precision_score(actual,predict))
    print '召回:{0:0.3f}'.format(metrics.recall_score(actual,predict))
    print 'f1-score:{0:3f}'.format(metrics.f1_score(actual,predict))

metrics_result(test_set.label,predicted)

#输出形式如
#精度：0.991
#召回：0.990
#f1-score:0.990

一种方法是改进扫描方式，称为特征扫描或标志切分，优先在待分析字符串中识别和切分出一些带有明显特征的词，以这些词作为断点，可将原字符串分为较小的串再来进机械分词，从而减少匹配的错误率。另一种方法是将分词和词类标注结合起来，利用丰富的词类信息对分词决策提供帮助，并且在标注过程中又反过来对分词结果进行检验、调整，从而极大地提高切分的准确率。

当在搜索框中输入关键词时候，会去和其存储网页进行匹配，将符合匹配的网页按照个网页的权重分页进行显示。当然网页的权重包含很多方面，例如广告付费类权重就非常的高，一般会在靠前的位置显示。对于一般的网站，其权重包括网页的点击次数，以及和关键词匹配的程度等来决定显示的前后顺序。

2.3 分类算法：朴素贝叶斯

本节主要讨论朴素贝叶斯算法的基本原理和python实现

对于机械分词方法，可以建立一个一般的模型，在这方面有专业的学术论文，这里不做详细论述。

搜索引擎会去和网页的哪些内容进行匹配呢？如前面所述，通常是网页的
title、deion 和
keywords。由于关键词匹配的程度越高的网站显示在前的概率较大，因此很多网站为了提高自己的排名，都会进行
SEO 的优化，而 title、deion 和 keywords 是 SEO
优化的重要方面。至于不可描述网站，更是如此。有段时间《中国焦虑图鉴》这篇文章中也提到。由于搜索引擎并不会公开收取以及赌博、黄色网站广告费让他们排到前面。所以这些网站只能利用
SEO，强行把自己刷到前面。直到被搜索引擎发现，赶紧对它们“降权”处理。尽管如此，这些黄色网站如果能把自己刷到前几位一两个小时，就能够大赚一笔。

2.3.1 贝叶斯公式推导

朴素贝叶斯文本分类的思想：它认为词袋中的两两词之间是相互独立的，即一个对象的特征向量中的每个维度都是相互独立的。
朴素贝叶斯分类的定义:
（1），设x={a1,a2,^am}为一个待分类项，而每个a为x的一个特征属性
（2），有类别集合C={y1,y2,……yn}.
（3），计算P(y1|x),P(y2|x),……,P(yn|x)
（4），如果P（yk|x）=max{P1,P2,……,Pn}，则x属于yk

— 计算第（3）步的各个条件概率：
（1）找到一个已知分类的待分类集合，即训练集
（2）统计得到在各个类别下的各个特征属性的条件概率估计，即：
P(a1|y1),P(a2|y2),……，P(am|y1)
P(a1|y2),P(a2|y2),……，P（am|y2）
……
（3），如果各个特征属性是条件独立的，根据贝叶斯定理有：
P(yi|x) = P(x|yi)*P(yi)/P(x)
分母对于所有类别为常数，故只需将分子最大化即可

故，贝叶斯分类的流程为：
第一阶段 ： 训练数据生成训练样本集：TF-IDF
第二阶段： 对每个类别计算P(yi)
第三阶段：对每个特征属性计算所有划分的条件概率
第四阶段：对每个类别计算P(x|yi)P(yi)
第五阶段：以P(x|yi)P(yi)的最大项作为x的所属类别

2、基于理解的分词方法

由上述分析可以知道 title、deion 和 keywords
等一些关键的网页信息对于不可描述网站来说都是经过精心设计的，和网页所要表述内容的匹配度非常之高。尤其很多网站在国外有些国家是合法的，因此对于经营这些网站的人员来说，优化这些信息一定是必然。我曾经看过一份数据显示在某段时间某搜索引擎前十名中，绝大多数的色情相关的。因此我们可以将其作为关键的语料信息。

2.3.2 朴素贝叶斯算法实现

样例：使用简单的英文语料作为数据集，代码见文件

# 编写导入的数据
def loadDataSet():
    postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
                 ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                 ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him','my'],
                 ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                 ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                 ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
                # 使用简单的英语语料作为数据集，有6个文本

    classVec = [0,1,0,1,0,1]     # 文本对应的类别

    return postingList,classVec  # postingList是训练集文本，classVec是每个文本对应的分类

###########################################################################

# 编写贝叶斯算法（sklearn已有贝叶斯算法包，现在是理解贝叶斯算法原理后，自己编写算法代码）


#（1）编写一个贝叶斯算法类，并创建默认的构造方法

class NBayes(object):     # 创建贝叶斯算法类

    def __init__(self):       #初始化类的属性
        self.vocabulary = []  #词典
        self.idf = 0          #词典的IDF权值向量
        self.tf = 0           #训练集的权值矩阵
        self.tdm = 0          #P(x|yi)
        self.Pcates = {}      #P(yi)是一个类别词典P(yi)的值：{类别1：概率，类别2：概率}
        self.labels = []      #对应每个文本的分类，是一个外部导入的列表
        self.doclength = 0    #训练集文本数
        self.vocablen = 0     #词典词长
        self.testset = 0      #测试集 


#（2）导入和训练数据集，生成算法必需的参数和数据结构

def train_set(self,trainset,classVec):  # 传入训练集文本和对应的分类类别

    self.cate_prob(classVec)    # 计算每个分类在数据集中的概率P(yi)，cate_prob函数在下面创建
    self.doclength = len(trainset) # 用len函数计算训练集trainset的文本数，赋给类的doclength属性

    tempset = set()  # 使用set(),初始化一个空的集合：是一个无序不重复元素集
    [tempset.add(word) for doc in trainset for word in doc] #生成词典  ，add是往集合添加元素
    # doc遍历trainset,word遍历doc，再将word添加进tempset集合里
    # 训练集文本trainset实际上是一个矩阵，doc遍历取得向量，即单个文本，word遍历取得文本内的词，再添加进集合
    self.vocabulary = list(tempset) # 将tempset转换为列表list，添加进类的vocabulary属性，即词典
    self.vocablen = len(self.vocabulary) #len函数计算词典的长度（这里的词典实际上是一个不重复的词袋空间）

    self.calc_wordfreq(trainset)  # 计算数据集的词频（word frequency）：tf和idf ，调用了calc_wordfred函数，传入训练集trainset
    self.build_tdm()  # 按分类累计向量空间的每维值P(x|yi)，调用了build_tdm函数


# (3) cate_prob函数：计算数据集中 每个分类的概率P(yi)

def cate_prob(self,classVec):  # 该函数用于计算每个类别在数据集中的概率，被上面的train_set函数调用
    self.labels = classVec     # classVec是导入的训练集文本对应的类别
    labeltemps = set(self.labels)  # 获取全部分类，set()集合：无序不重复元素集，本例就两类：{0,1}
    for labeltemp in labeltemps:    # 遍历所有分类{0,1}
        self.labels.count(labeltemp)  #统计self.labels里类别的个数：类别0的个数和类别1的个数
        self.Pcates[labeltemp] = float(self.labels.count(labeltemp))/float(len(self.labels))
        # 每种类别个数/类别类别总数：6，在Pcates字典里，创建键值对{'0':概率，'1':概率}


# (4) calc_wordfred函数：生成普通的词频向量  TF-IDF

def calc_wordfred(self,trainset):   # 用于计算词袋（词典）内每个词的词频，被上面的train_set函数调用

    self.idf = np.zeros([1,self.vocablen]) # 全0矩阵，矩阵大小：1x词典长度，self.vocablen是上面计算出的词典长度（词袋长）
    self.tf = np.zeros([self.doclength,self.vocablen]) #构造全0矩阵：训练集文件数x词典数，doclength是上面计算出的训练集文本数：6，vocablen是计算出的词典长度 
    #构造训练集的IDF和TF向量模型，IDF是一行，TF是文档数，行，初始化全为0

    for indx in xrange(self.doclength):  # xrange与range用法相同，结果不同，生成的不是列表，而是生成器，适合数字序列较大时，不用一开始就开辟内存空间
    # indx遍历训练集文本数列表，indx取得的是数
        for word in trainset[indx]: #word 遍历trainset中的每一文本的词，##word取得的是词
            self.tf[indx,self.vocabulary.index(word)] +=1    # 权值矩阵的第index行，第k列，加1
            # 词典列表的index方法,返回word的索引位置k
            #  生成了TF词频矩阵

        for signleword in set(trainset[indx]):  # signleword遍历训练集文本里每一文本构成的集合（取得每一文本不重复的词），
            self.idf[0,self.vocabulary.index(signleword)] +=1  # idf权值矩阵的第k个加1
            #index返回每一文本不重复词的索引位置
            #生成IDF矩阵           
## 实际上本函数生成的是训练集的TF矩阵和词袋的IDF矩阵（绝对数形式，非频率）        


# (5) build_tdm函数：按分类累计计算向量空间的每维值P(x|yi)，已知类别为yi，求是x的概率

def build_tdm(self):   #计算P(x|yi)，被train_set函数调用

    self.tdm = np.zeros([len(self.Pcates),self.vocablen])  #构造全0矩阵，大小：类别词典长度2（在cate_prob函数里）x 词典长度（train_set函数里）
    sumlist = np.zeros([len(self.Pcates),1])  # 构造全0矩阵：大小：类别词典长度x1
    #统计每个分类的总值，sumlist两行一列

    for indx in xrange(self.doclength):    #indx遍历训练集文本数生成的列表[0,1,2,3,4,5]，取得的是数字 

        #将同一类别的词向量空间值tf加总
        #即：tf权值矩阵值，六行，分为两类，同类相加，变为两行
        self.tdm[self.labels[indx]] += self.tf[indx]   # labels[indx]是训练集文本对应类别里的第indx个（在cate_prob函数里）即[0,1,0,1,0,1]里的第indx个，对应tdm的第某行
        # tf[indx]是tf权值矩阵的第indx行（在calc_wordfred函数里）

        #统计每个分类的总值--是一个标量
        sumlist[self.labels[indx]] = np.sum(self.tdm[self.labels[indx]]) 
        #利用np.sum计算tdm矩阵的和，赋值给sumlist矩阵的？
        # sumlist得到的结果：0：总值
                            #1：总值

    self.tdm = self.tdm/sumlist   # tdm即:P(x|yi)=P(xyi)/P(yi)
    #得到的结果tdm是一个两行，词典长列的矩阵，表示着P(a1|yi),P(a2|yi)……
  #tdm是一个向量，sumlist是一个值


(3)-(5)函数都被train_set函数调用  
#####################################################################################



# (6) map2vocab函数：将测试集映射到当前字典

def map2vocab(self,testdata):  # 传入测试集数据 testdata
    self.testset = np.zeros([1,self.vocablen])  #构造全0矩阵，大小：1*词典长度
    for word in testdata:    # word遍历测试集（某个文本）
        self.testset[0,self.vocabulary.index(word)] +=1 # testset矩阵的第k个加1
        # vocabulary.index(word)返回字典的与word匹配的词的索引位置
# 本函数是将测试集文档转换为以频数表示的[   ]矩阵   


# (7) predict函数：预测分类结果，输出预测的分类类别

def predict(self,testset):    #传入测试集数据

    if np.shape(testset)[1] != self.vocablen: #如果测试集长度与词典长度不相等，则退出程序
        print "输出错误"
        exit(0)

    predvalue = 0  #初始化类别概率
    predclass = ""  # 初始化类别名称

    for tdm_vect,keyclass in zip(self.tdm,self.Pcates): 
       #P(x|yi) P(yi)    #      变量tdm，计算最大分类值
    #zip函数将tdm和Pcates打包成元组，并返回元组组成的列表。
    #tdm是P(x|yi),Pacates是类别词典P(yi)

        temp = np.sum(testset*tdm_vect*self.Pacate[keyclass])  #测试集testset乘tdm_vect乘Pcates[keyclass]  ，并求和
        #测试集向量*P
        if temp > predvalue:  
            predvalue = temp
            predclass = keyclass
    return predclass   # 输出预测的类别（概率最大的类别）

#########################################################################

#算法的改进：为普通的词频向量使用TF-IDF策略

#calc_tfidf函数：以TF-IDF方式生成向量空间

def calc_tfidf(self,trainset):        # 传入训练集数据
    self.idf = np.zeros([1,self.vocablen])   #构造全0矩阵，大小：1*词典长度
    self.tf = np.zeros([self.doclength,self.vocablen])  #构造全0矩阵，大小：文本数*词典长度

    for indx in xrange(self.doclength):   #indx遍历文本数生成的列表，取得的是数字      
        for word in trainset[indx]:        #word遍历训练集的第indx个文本里的词
            self.tf[indx,self.vocabulary.index(word)]+=1  #tf矩阵的某个值加1
            #消除不同句长导致的偏差
        self.tf[indx] = self.tf[indx]/float(len(trainset[indx]))  #计算的是频率而不是频数

        for signleword in set(trainset[indx]):
            self.idf[0,self.vocabulary.index(signleword)] +=1
    self.idf = np.log(float(self.doclength)/self.idf)

    self.tf = np.multiply(self.tf,self.idf) # 矩阵与向量的点乘TFxIDF

######################################################################

#执行创建的朴素贝叶斯类，获取执行结果

#coding=utf-8

import sys
import os
from numpy import *
import numpy as np
from NBayes_lib import *

dataSet,listClasses = loadDataSet() 

 # 导入外部数据集,loadDataSet是自己创建的函数，返回值为两个，postingList是训练集文本，classVec是每个文本对应的分类
# dataset为句子的词向量
# listclass为句子所属类别 [0,1,0,1,0,1]

nb = NBayes()  #实例化 NBayes是我们创建的贝叶斯算法类
nb.train_set(dataSet,listClasses) # 训练数据集。train_set是创建的类的函数，用于训练
nb.map2vocab(dataSet[0])   # 随机选择一个测试句 #map2vocab函数将测试集映射到当前词典
print nb.predict(nb.testset)  # 输出分类结果，predict函数用于预测分类结果，输出预测的分类类别

# 最后运行程序，看似没有数据间传递，实则是在类属性中已定义好并赋值给属性

---

这种分词方法是通过让计算机模拟人对句子的理解，达到识别词的效果。其基本思想就是在分词的同时进行句法、语义分析，利用句法信息和语义信息来处理歧义现象。它通常包括三个部分：分词子系统、句法语义子系统、总控部分。在总控部分的协调下，分词子系统可以获得有关词、句子等的句法和语义信息来对分词歧义进行判断，即它模拟了人对句子的理解过程。这种分词方法需要使用大量的语言知识和信息。由于汉语语言知识的笼统、复杂性，难以将各种语言信息组织成机器可直接读取的形式，因此目前基于理解的分词系统还处在试验阶段。

二，语料信息的获取

2.4 分类算法：KNN

KNN算法：计算向量间的距离衡量相似度来进行文本分类

3、基于统计的分词方法

现在其实面临的是一个二分类的问题，即判断一个网站是不可描述网站还是正常的网站。这个问题可以归结为
NLP
领域的文本分类问题。而对于文本分类来说的第一步就是语料的获取。在第一部分也已经分析了，相关语料就是网站的
title，deion 以及 keywords。

2.4.1 KNN算法的原理

1，算法思想：如果一个样本在特征空间的k个最近邻（最近似）的样本中的大多数都属于某一类别，则该样本也属于这个类别，k是由自己定义的外部变量。

2，KNN算法的步骤：

第一阶段：确定k值（就是最近邻的个数），一般是奇数
第二阶段：确定距离度量公式，文本分类一般使用夹角余弦，得出待分类数据点与所有已知类别的样本点，从中选择距离最近的k个样本
夹角余弦公式：cos =AB/|A|*|B|
第三阶段:统计k个样本点中各个类别的数量，哪个类别的数量最多，就把数据点分为什么类别

从形式上看，词是稳定的字的组合，因此在上下文中，相邻的字同时出现的次数越多，就越有可能构成一个词。因此字与字相邻共现的频率或概率能够较好的反映成词的可信度。可以对语料中相邻共现的各个字的组合的频度进行统计，计算它们的互现信息。定义两个字的互现信息，计算两个汉字X、Y的相邻共现概率。互现信息体现了汉字之间结合关系的紧密程度。当紧密程度高于某一个阈值时，便可认为此字组可能构成了一个词。这种方法只需对语料中的字组频度进行统计，不需要切分词典，因而又叫做无词典分词法或统计取词方法。但这种方法也有一定的局限性，会经常抽出一些共现频度高、但并不是词的常用字组，例如“这一”、“之一”、“有的”、“我的”、“许多的”等，并且对常用词的识别精度差，时空开销大。实际应用的统计分词系统都要使用一部基本的分词词典（常用词词典）进行串匹配分词，同时使用统计方法识别一些新的词，即将串频统计和串匹配结合起来，既发挥匹配分词切分速度快、效率高的特点，又利用了无词典分词结合上下文识别生词、自动消除歧义的优点。

如何获取这些数据，可以通过 alex
排名靠前的网站，利用爬虫进行获取。本文对于正常数据的获取，选取 alex
排名前 4500 的网站，通过爬虫，提取网页的 title 和 deion 以及 keywords
作为原始文本。对于色情数据的获取亦然，通过爬虫对已经已经积累的 4500
个的站点进行文本收集。由于这部数据是敏感数据，因此数据集无法向大家公开，还请见量。

2.4.2 kNN算法的python实现

#coding=utf-8

#第一阶段，导入所需要的库，进行数据的初始化

import sys
import os
from numpy import *
import numpy as *
import operator
from Nbayes_lib import *

# 配置utf-8输出环境

reload(sys)
sys.setdefaultencoding('utf-8')

k=3

#第二阶段：实现夹角余弦的距离公式

def cosdist(vector1,vector2):
    return dot(vector1,vector2)/(linalg.norm(vector1)*linalg.norm(vector2)) # 夹角余弦公式;AB/|A||B|   

#第三阶段：KNN实现分类器

#KNN分类器

#测试集:testdata;训练集：trainSet;类别标签;listClasses; k：k个邻居数

def classify(testdata,trainSet,listClasses,k):
    dataSetSize=trainSet.shape[0]     #返回样本的行数,(shape返回行数和列数)
    distances=array(zeros(dataSetSize))  #构造一个全0数组，大小为；

    for indx in xrange(dataSetSize):   #计算测试集与训练集之间的距离：夹角余弦
        distances[indx]=cosdist(testdata,trainSet[indx])
        sortedDisIndicies=argsort(-distances)
        classCount={}
        for i in range(k)：#获取角度最小的前k项作为参考项
            #按排序顺序返回样本集对应的类别标签
            voteIlabel=listClasses[sortedDistIndices[i]]
            #为字典classCount赋值，相同key，其value加1
            classCount[voteIlabel]=classCount.get(voteIlabel,0) +1

        #对分类字典classCount按value重新排序
        #sorted(data.iteritems(),key=operator.itemgetter[1],reverse=True)
        #classCount.iteritems();字典迭代器函数
        #key ；排序参数；operator.itemgetter(1):多级排序
        sortedClassCount=sorted(classCount.iteritem(),key=operator.itemgetter(1),reverse=True)
        return sortedClassCount[0][0]   #返回排序最高的一项

# 最后使用KNN算法实现文本分类

dataSet,listClasses=loadDataSet()
nb.NBayes()
nb.train_set(dataSet,listClasses)  #使用之前贝叶斯分类阶段的数据集及生成的TF向量进行分类

print classify(nb.tf[3],nb.tf,listClasses,k)

到底哪种分词算法的准确度更高，目前并无定论。对于任何一个成熟的分词系统来说，不可能单独依靠某一种算法来实现，都需要综合不同的算法。笔者了解，海量科技的分词算法就采用“复方分词法”，所谓复方，相当于用中药中的复方概念，即用不同的药才综合起来去医治疾病，同样，对于中文词的识别，需要多种算法来处理不同的问题。

爬虫的实现是一个很大的主题，本文篇幅有限，不在讨论，可以参考已有的一些技术博客。总体来说应对本文场景爬虫是很简单的，即发起一个
HTTP 或者 HTTPS 链接，对返回的数据进行清洗提取即可，使用 python
的一些模块几条语句就可以搞定。我在数据获取过程中使用的是 nodejs
编写的爬虫，每次同时发起 1000 个请求，4500
个站点几分钟就搞定了。由于异步请求是 nodejs
优势之一，如果在时间方面有较高要求的，可以考虑 nodejs（但是 nodejs
异步的编程和常见语言的编程差别较大，学习起来有一定的难度），如果没有建议使用
python，主要是后续的机器学习，python
是最热门的语言，包含众多的基础模块。

2.5 结语

本章讲解了机器学习的两个算法：朴素贝叶斯算法和K最近邻算法

介绍了文本分类的6个主要步骤：
1）文本预处理
2）中文分词
3）构建词向量空间
4）权重策略—-TF-IDF方法
5）朴素贝叶斯算法器
6）评价分类结果

分词中的难题

三，分词，去停用词形成词向量特征

有了成熟的分词算法，是否就能容易的解决中文分词的问题呢？事实远非如此。中文是一种十分复杂的语言，让计算机理解中文语言更是困难。在中文分词过程中，有两大难题一直没有完全突破。

在获取一定的文本数据之后，需要对这些原始的数据进行处理，最重要的就是分词。英文分词比之中文的分词要简单不少，因为英文中词与词之间时有明显的间隔区分，例如空格和一些标点符号等。中文的话，由于词语是由一些字组成的，整体要麻烦些，而且还有不同场景下的歧义问题。当然
python 提供了诸如 jieba
等强大的分词模块，非常方便，但是总体来说英文分词还要注意以下几点：

1、歧义识别

1. 将每一行单词全部转化为小写，排除大小写的干扰。因为在本文场景下大小写词语所代表的含义基本相同，不予区分
2. 切词，依据就是空格，逗号等分隔符，将句子切分成一个个的单词。当然由于本文的语料全部来源于网页，这其中词语的分隔都会具有一些网页的属性，比如语料中会由很多特殊的符号，如
   | – _ , &# 等符号，需要进行排除
3. 排除一些停用词。所谓的停用词通常指的是英语中的冠词，副词等，经过上一步骤切分出来的单词可能会包括
   an，and，another，any
   等。因此需要将这些无意义词去除掉当然你也可以使用 nltk
   中自带的停用词（from nltk.corpus import
   stopwords），但是有的时候会根据具体的应用场景，加入相应的停用词，因此自定义停用词词典可能灵活性更高一些。比如在上一步骤中会切分出“&#”等等符号，因此需要将
   &#
   加入到停用词中。关于停止词，我这里面使用了一个较为常用的停用词字典，同时加入了在网页中一些常见停用词。
4. 提取词干。由于英文的特殊性，一个词会有多种状态，比如
   stop，stops，stopping 的词干都是
   stop，通常情况所表示的含义都是相同的，只需要 stop
   一个即可。但是对于我们的二分类应用场景来说，我一开始没有做词干的提取因为不可描述网站中的
   hottest 和常见网站中共的 hot
   还是有点差异的。当然这一步可以根据具体的应用场景以及识别结果进行选择。
5. 排除数字。数字在一些不可描述网站中时经常出现的，但是为了我这边还是将其排除，比如
   1080
   在不可描述网站和正常的网站中出现的概率都很高，表示视频的分辨率，当然这一步也是可选的。当然数字也可以加入停止词中，但是由于数字数量较多，同时比较好鉴别（isdigit()
   函数鉴别即可），因此对于数字的排除单独拿出来。

歧义是指同样的一句话，可能有两种或者更多的切分方法。例如：表面的，因为“表面”和“面的”都是词，那么这个短语就可以分成“表面
的”和“表
面的”。这种称为交叉歧义。像这种交叉歧义十分常见，前面举的“和服”的例子，其实就是因为交叉歧义引起的错误。“化妆和服装”可以分成“化妆
和 服装”或者“化妆 和服
装”。由于没有人的知识去理解，计算机很难知道到底哪个方案正确。

使用 python 的 jieba 模块结合上述所述的 5
个步骤，得到若干单词，相应代码为：

交叉歧义相对组合歧义来说是还算比较容易处理，组合歧义就必需根据整个句子来判断了。例如，在句子“这个门把手坏了”中，“把手”是个词，但在句子“请把手拿开”中，“把手”就不是一个词；在句子“将军任命了一名中将”中，“中将”是个词，但在句子“产量三年中将增长两倍”中，“中将”就不再是词。这些词计算机又如何去识别?

如果交叉歧义和组合歧义计算机都能解决的话，在歧义中还有一个难题，是真歧义。真歧义意思是给出一句话，由人去判断也不知道哪个应该是词，哪个应该不是词。例如：“乒乓球拍卖完了”，可以切分成“乒乓
球拍 卖 完 了”、也可切分成“乒乓球 拍卖 完
了”，如果没有上下文其他的句子，恐怕谁也不知道“拍卖”在这里算不算一个词。

以正常网站和不可描述网站的 deion 为例，对应的词云图如下：

2、新词识别

新词，专业术语称为未登录词。也就是那些在字典中都没有收录过，但又确实能称为词的那些词。最典型的是人名，人可以很容易理解句子“王军虎去广州了”中，“王军虎”是个词，因为是一个人的名字，但要是让计算机去识别就困难了。如果把“王军虎”做为一个词收录到字典中去，全世界有那么多名字，而且每时每刻都有新增的人名，收录这些人名本身就是一项巨大的工程。即使这项工作可以完成，还是会存在问题，例如：在句子“王军虎头虎脑的”中，“王军虎”还能不能算词？

👆图2

新词中除了人名以外，还有机构名、地名、产品名、商标名、简称、省略语等都是很难处理的问题，而且这些又正好是人们经常使用的词，因此对于搜索引擎来说，分词系统中的新词识别十分重要。目前新词识别准确率已经成为评价一个分词系统好坏的重要标志之一。

中文分词的应用

👆图3

目前在自然语言处理技术中，中文处理技术比西文处理技术要落后很大一段距离，许多西文的处理方法中文不能直接采用，就是因为中文必需有分词这道工序。中文分词是其他中文信息处理的基础，搜索引擎只是中文分词的一个应用。其他的比如机器翻译（MT）、语音合成、自动分类、自动摘要、自动校对等等，都需要用到分词。因为中文需要分词，可能会影响一些研究，但同时也为一些企业带来机会，因为国外的计算机处理技术要想进入中国市场，首先也是要解决中文分词问题。在中文研究方面，相比外国人来说，中国人有十分明显的优势。

可以看到对于正常的网站来说
free，online，news，games，business，world，latest
是较为热门的词汇；对于不可描述网站来说，图中显示较大是对应较为热门的词汇。

分词准确性对搜索引擎来说十分重要，但如果分词速度太慢，即使准确性再高，对于搜索引擎来说也是不可用的，因为搜索引擎需要处理数以亿计的网页，如果分词耗用的时间过长，会严重影响搜索引擎内容更新的速度。因此对于搜索引擎来说，分词的准确性和速度，二者都需要达到很高的要求。目前研究中文分词的大多是科研院校，清华、北大、中科院、北京语言学院、东北大学、IBM研究院、微软中国研究院等都有自己的研究队伍，而真正专业研究中文分词的商业公司除了海量科技以外，几乎没有了。科研院校研究的技术，大部分不能很快产品化，而一个专业公司的力量毕竟有限，看来中文分词技术要想更好的服务于更多的产品，还有很长一段路要走。。。

有了一个个单词之后，需要将这些单词转化为一些模型能够接受的输入形式，也就是词向量。一种常见的方法就是构建一个
N * M 的矩阵，M 大小是所有文本中词的个数；N
的大小是所有文本个数，在本文的环境中就是 title，deion 或者 keywords
的（即网站的）个数。

一、什么是停用词？ 
停用词(Stop Words)
，词典译为“电脑检索中的虚字、非检索用字”。在SEO中，为节省存储空间和提高搜索效率，搜索引擎在索引页面或处理搜索请求时会自动忽略某些字或词，这些字或词即被称为Stop
Words(停用词)。 
停用词一定程度上相当于过滤词(Filter
Words)，不过过滤词的范围更大一些，包含黄色、政治等敏感信息的关键词都会被视做过滤词加以处理，停用词本身则没有这个限制。通常意义上，停用词(Stop
Words)大致可分为如下两类： 
1、使用十分广泛，甚至是过于频繁的一些单词。比如英文的“i”、“is”、“what”，中文的“我”、“就”之类词几乎在每个文档上均会出现，查询这样的词搜索引擎就无法保证能够给出真正相关的搜索结果，难于缩小搜索范围提高搜索结果的准确性，同时还会降低搜索的效率。因此，在真正的工作中，Google和百度等搜索引擎会忽略掉特定的常用词，在搜索的时候，如果我们使用了太多的停用词，也同样有可能无法得到非常精确的结果，甚至是可能大量毫不相关的搜索结果。 
2、文本中出现频率很高，但实际意义又不大的词。这一类主要包括了语气助词、副词、介词、连词等，通常自身并无明确意义，只有将其放入一个完整的句子中才有一定作用的词语。如常见的“的”、“在”、“和”、“接着”之类，比如“SEO研究院是原创的SEO博客”这句话中的“是”、“的”就是两个停用词。 
二、Stop Words对SEO的影响 
文档中如果大量使用Stop
words容易对页面中的有效信息造成噪音干扰，所以搜索引擎在运算之前都要对所索引的信息进行消除噪音的处理。了解了Stop
Words，在网页内容中适当地减少停用词出现的频率，可以有效地帮助我们提高关键词密度，在网页标题标签中避免出现停用词能够让所优化的关键词更集中、更突出。

矩阵每一行的值，就是经过上述方法切词之后，词库中每一个词在该 title
上出现的频率，当然对于没有在该 title 出现的词（存在于其他 title 中）计为
0 即可。

 

可以预见，最终形成的是一个稀疏矩阵。Sklearn
也提供了一些方法，来进行文本到数值的转换，例如
CountVectorizer，TfidfVectorizer，HashingVectorizer。由前面的分析可知，title，deion，keywords
是较为特殊的文本，会出现很多关键词的堆积，尤其对于不可描述网站，同时相应的预料数据有限，因此本文使用的是
CountVectorizer 来进行简单的词频统计即可，代码如下：

四，模型的训练识别以及比较；

有了第三个步骤的词向量的数值特征，接下来就是训练模型的选择了。对于文本分类问题来说，较为经典的就是朴素贝叶斯模型了。贝叶斯定理如下：

P(A|B) = P(B|A) P(A) / P(B)

表示的是 A 在 B 条件下的概率等于 B 在 A 条件下的概率乘以A出现概率除以 B
出现概率。对应到我们这个场景就是 B 是每一个 title 的特征，设
B=F1F2…Fn，即上述形成的稀疏矩阵的每一行，表示的是在该 title
中，词库中所有词在对应位置上出现的频率。

A={0,1}，表示具体的类别，即是不可描述网站还是普通网站。因此上述公式可以表示为：

对于 P(Fn|C)
表示的某个类别下某个单词的概率（P(sex|0)，表示不可描述网站集合中所有词中，sex
单词出现的概率），P(C)
表示某个类别的文本占比（p(0)表示不可描述网站数量占比），这些都是可以对文本进行统计得到的。而
P(F1F2…Fn)
是一个与类别无关的量，可以不与计算。因此可以看出最终是计算具有 F1F2…Fn
特征的文本属于不可描述网站（P(0|F1F2…Fn)）和普通网站（P(1|F1F2…Fn)）的概率，哪个概率大就归为那一类。当然关于朴素贝叶斯模型的原理，由于篇幅有限，就不过的阐述了。

由前面分析发现 title，deion 以及 keywords
对于搜索引擎都是较为重要的信息，因此分别提取了网页的 title，deion 以及
keywords，并单独测试每一份的语料数据。

如果直接使用 train_test_split
对所有语料进行切分，则有可能会使得正常语料和色情语料在训练和策测试数据中的比例不一致，为了保证结果的可靠性，使用
train_test_split 分别对于正常语料和色情语料按照 7:3
的比例进行切分。然后将每一分切分后的训练和测试数据进行合并，使用朴素贝叶斯模型对于数据进行预测，采用多项式模型，代码如下：

通过多次随机的按照 7:3
的比例切分正常语料和色情语料分别作为训练集和测试集发现，以

deion（0.8921404682274248，0.9054515050167224，0.8979933110367893，0.9037792642140468，0.8904682274247492）

keywords（0.8912319644839067，0.8890122086570478，0.8901220865704772，0.8912319644839067，0.8856825749167592）

作为语料数据的时候，识别结果最好，都集中在 90% 左右。

而以title（0.8081884464385867，0.8059450364554123，0.8132361189007291，0.8104318564217611，0.8093101514301738）
的效果最差，集中在 81% 左右。

分析原因发现，经过切词后，有不少的 title 为空，或者 title
只有很少单词的情况。形成的特征较弱，这种单词较少的情况是导致识别率不高的重要原因。例如
title 只有一个单词
video，由于该词在色情语料中属于高频词汇，在正常词汇中出现的频率也不低，因此只根据
title 就使得识别结果会随着语料的不同而不同。虽然对于搜索引擎来说，title
的权重大于 deion，deion 的权重大于 keywords。

但是对本文所述场景来说 deion 的权重大于 keywords；keywords 的权重大于
title。也就是说当网页没有 deion 时候，考虑使用 keywords
作为语料输入；当网页没有 deion，keywords 时候，考虑使用 title
作为语料输入。

可以看到通将 4000+ 网站个作为训练的输入，以及 1700+
网站作为测试。识别准确率稳定在 90%
左右，证明说明该方法是可行的，具有一定的应用价值。

当然在分析最终识别结果的过程中，还发现起始很多的色情语料被标记成了正常语料。原因在于，正常语料的来源是
alex 排名靠前的网站。在这其中是有部分的不可描述网站的。

同时相关的调查也发现不可描述网站的用户滞留时间要高于普通的网站，同时不可描述网站以视频为主，因此其流量很大，排名靠前的不在少数。

所以对于正常语料的筛选，也是一份很重要的工作。通过对于误识别结果的分析，是可以筛选出一份较为准确的语料库的，但其中的工作量也是比较多。

如果进一步排除其中的错误的标注，那么对于识别的准确率会有进一步的提升。

当然虽然正常和不可描述网站都是
4500+，但是我只提取了英文网站的信息，对于像日文等网站都进行了排除，实际上有效的英文不可描述网站语料为
3500+，有效的英文正常网站为 2300+。

因为排名靠前的正常网站有很多的中文以及其他国家的网站，而对于不可描述网站来说，英文占多数。

由于每个类别的占比对于概率的计算会有一定影响的，因此这一点也是值的注意的。

当然还可以使用决策树以及 SVM
等模型来做分类预测，但是实际的测试效果并没有朴素贝叶斯好，以 deion
作为输入为例，决策树的识别率为 85% 左右。

个人认为本文的应用场景和贝叶斯的的思想是一致的，通过判断该语句属于某一类别的概率来决定其归属，具体通过句子中单词的概率进行计算所的。当然实际生产过程中模型的选择还是依赖于具体的应用场景和效果。

五，基于本文所述方法的扩展应用

前面所讨论的是一个二分类的问题，总体来看使用文本分类中的一些常见的方法取得了不错的效果。

既然不可描述网站能够通过该方法被识别出来，那么推测其他类型的网站应该也可以被识别。

例如新闻，游戏，股票，音乐，等类别的网站，那么有没有一种方法能够根据访问的网站，自动的将其归类呢。

当然本文所讨论的不可描述网站的识别的应用场景还是较为有限的，如果是企业或者教育网的出口处，该方法就可能没法起作用。对于以
HTTP 协议传输的网站来说，能够获取明文，方法依然有效。

但是越来越多的网站已经迁移到
HTTPS，无法获取明文信息，该方法就不起作用了。

在面对加密通信报文情况下的数据时候，如何来识别不可描述网站呢？当然关于这方面，我有幸做过一些研究和实践。如果对这种场景下面识别感兴趣的同学，可以在我的的读者圈留言。我会再写一篇跟大家一同探讨。

本文首发于GitChat，未经授权不得转载，转载需与GitChat联系。返回搜狐，查看更多

责任编辑：

www.2979.com, 机器学习, 股, 股票, 视频, 金沙国际唯一官网网址

---