贝叶斯公式

「朴素贝叶斯」

具体理论就不详细讲解了，网上一搜一大把。其核心思想就是： 朴素贝叶斯 = 条件独立假设 + 贝叶斯方法。运行速度快，在满足分布独立这一假设条件下分类效果好，但对于训练集中没有出现过的词语要平滑处理，数值型变量特征默认符合正态分布。

「Python实现」

导入停用词

导入停用词库，同时使用strip()方法剔除不需要的空白符，包括（'\n', '\r', '\t', ' '）

def make_word_set(words_file):
    words_set = set()
    with codecs.open(words_file,'r','utf-8') as fp:
        for line in fp:
            word = line.strip()
            if len(word) > 0 and word not in words_set:
                words_set.add(word)
    return words_set

文本处理，样本生成

每个新闻文本txt文件在各自所属类别的文件夹中，结构如下：

"folder_path"
　｜
　｜－－ C000008 －－ 1.txt / 2.txt / ... / 19.txt
　｜－－ C000010
　｜－－ C000013
　｜－－ ...
　｜－－ C000024

这里使用os.listdir()读取指定目录下的所有文件夹名（即分类类别），遍历各自文件夹（类别）内的文本文件，对每一个txt文件进行文本切词，同时利用zip()函数使每个新闻文本与所属类别一一对应，一共有90条数据。

为了随机抽取训练与测试数据集，用random.shuffle()打乱顺序，并选取20%的数据用于测试，同时把特征数据与类别数据各自分开。

最后对训练数据集中的词语进行词频统计。这里有使用sorted()函数进行排序，方法为sorted(iterable, cmp = None, key = None, reverse = False)，其中参数含义如下：

iterable：是可迭代类型（我这里的可迭代类型为字典）
cmp：用于比较的函数，比较什么由key决定（这里没用到）
key：用列表元素的某个属性或函数进行作为关键字（这里使用字典中的“值”大小作为关键字排序）
reverse：排序规则，True为降序（False为升序）

def text_processing(folder_path, test_size = 0.2):
    folder_list = os.listdir(folder_path)
    data_list = []
    class_list = []
    # 遍历文件夹
    for folder in folder_list:
        new_folder_path = os.path.join(folder_path,folder)
        files = os.listdir(new_folder_path)
        j = 1
        for file in files:
            if j > 100: # 防止内存爆掉
                break
            with codecs.open(os.path.join(new_folder_path, file), 'r', 'utf-8') as fp:
                raw = fp.read()
                word_cut = jieba.cut(raw, cut_all = False)
                word_list = list(word_cut)
                data_list.append(word_list) # 训练集
                class_list.append(folder)   # 类别
                j += 1      

    # 划分训练集和测试集
    data_class_list = list(zip(data_list, class_list))
    random.shuffle(data_class_list)    # 打乱顺序
    index = int(len(data_class_list) * test_size) + 1   # 抽取测试数据集的占比
    train_list = data_class_list[index:]
    test_list = data_class_list[:index]
    train_data_list,train_class_list = zip(*train_list) # 特征与标签
    test_data_list,test_class_list = zip(*test_list) 

    # 统计词频
    all_words_dict = {}
    for word_list in train_data_list:
        for word in word_list:
            if word in all_words_dict:
                all_words_dict[word] += 1
            else:
                all_words_dict[word] = 1
            
    # 降序排序（key函数）
    all_words_tuple_list = sorted(all_words_dict.items(),key = lambda f:f[1], reverse = True)
    all_words_list = list(zip(*all_words_tuple_list))[0]
    
    return all_words_list, train_data_list, test_data_list, train_class_list, test_class_list

特征选择

这里我们仅选取词频坐高的1000个特征词（维度），并剔除数字与停用词。

def words_dict(all_words_list,deleteN,stopwords_set=set()):
    feature_words = []
    n = 1
    for t in range(deleteN,len(all_words_list),1):
        if n > 1000:    # 最多取1000个维度
            break
        if not all_words_list[t].isdigit() and all_words_list[t] not in stopwords_set and 1 < len(all_words_list[t]) < 5:
            feature_words.append(all_words_list[t])
            n += 1
    return feature_words

用选取的特征词构建0-1矩阵

对训练数据集train_data_list中每篇切完词之后的文档构建特征向量（由上述1000个特征词组成），若出现则取值为1，否则为0。于是90篇文章构建出了[90,1000]维度的0-1矩阵（其中71行为训练数据，19行为测试数据）。

训练集如下：

0-1矩阵如下：

def text_features(train_data_list, test_data_list, feature_words):
    def text_features(text,feature_words):
        # text = train_data_list[0]
        text_words = set(text)
        features = [1 if word in text_words else 0 for word in feature_words]
        return features
        
    # 0,1的矩阵（1000列-维度）    
    train_feature_list = [text_features(text, feature_words) for text in train_data_list]
    test_feature_list = [text_features(text, feature_words) for text in test_data_list]
    return train_feature_list,test_feature_list