精华内容
下载资源
问答
  • 机器学习发展比较广,且包括多个分支,本章侧重使用传统机器学习,从下一章开始是基于深度学习的文本分类。 学习目标 学会TF-IDF的原理和使用 使用sklearn的机器学习模型完成文本分类 机器学习模型 机器学习是对能...

    完成 赛题的数据数据刚刚结束,咋就又交作业了。还好顺利完成,对python 也比较熟悉了。今天学习用机器学习算法对新闻分类。

    基于机器学习的文本分类

    在本章我们将开始使用机器学习模型来解决文本分类。机器学习发展比较广,且包括多个分支,本章侧重使用传统机器学习,从下一章开始是基于深度学习的文本分类。

    学习目标

    学会TF-IDF的原理和使用
    使用sklearn的机器学习模型完成文本分类
    机器学习模型

    机器学习是对能通过经验自动改进的计算机算法的研究。机器学习通过历史数据训练出模型对应于人类对经验进行归纳的过程,机器学习利用模型对新数据进行预测对应于人类利用总结的规律对新问题进行预测的过程。

    机器学习有很多种分支,对于学习者来说应该优先掌握机器学习算法的分类,然后再其中一种机器学习算法进行学习。由于机器学习算法的分支和细节实在是太多,所以如果你一开始就被细节迷住了眼,你就很难知道全局是什么情况的。

    如果你是机器学习初学者,你应该知道如下的事情:

    机器学习能解决一定的问题,但不能奢求机器学习是万能的;
    机器学习算法有很多种,看具体问题需要什么,再来进行选择;
    每种机器学习算法有一定的偏好,需要具体问题具体分析;
    machine_learning_overview

    文本表示方法 Part1

    在机器学习算法的训练过程中,假设给定NN个样本,每个样本有MM个特征,这样组成了N×MN×M的样本矩阵,然后完成算法的训练和预测。同样的在计算机视觉中可以将图片的像素看作特征,每张图片看作hight×width×3的特征图,一个三维的矩阵来进入计算机进行计算。

    但是在自然语言领域,上述方法却不可行:文本是不定长度的。文本表示成计算机能够运算的数字或向量的方法一般称为词嵌入(Word Embedding)方法。词嵌入将不定长的文本转换到定长的空间内,是文本分类的第一步。

    One-hot

    这里的One-hot与数据挖掘任务中的操作是一致的,即将每一个单词使用一个离散的向量表示。具体将每个字/词编码一个索引,然后根据索引进行赋值。

    One-hot表示方法的例子如下:

    句子1:我 爱 北 京 天 安 门
    句子2:我 喜 欢 上 海
    首先对所有句子的字进行索引,即将每个字确定一个编号:

    {
    ‘我’: 1, ‘爱’: 2, ‘北’: 3, ‘京’: 4, ‘天’: 5,
    ‘安’: 6, ‘门’: 7, ‘喜’: 8, ‘欢’: 9, ‘上’: 10, ‘海’: 11
    }
    在这里共包括11个字,因此每个字可以转换为一个11维度稀疏向量:

    我:[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    爱:[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]

    海:[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
    Bag of Words

    Bag of Words(词袋表示),也称为Count Vectors,每个文档的字/词可以使用其出现次数来进行表示。

    句子1:我 爱 北 京 天 安 门
    句子2:我 喜 欢 上 海
    直接统计每个字出现的次数,并进行赋值:

    句子1:我 爱 北 京 天 安 门
    转换为 [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]

    句子2:我 喜 欢 上 海
    转换为 [1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
    在sklearn中可以直接CountVectorizer来实现这一步骤:

    from sklearn.feature_extraction.text import CountVectorizer
    corpus = [
    ‘This is the first document.’,
    ‘This document is the second document.’,
    ‘And this is the third one.’,
    ‘Is this the first document?’,
    ]
    vectorizer = CountVectorizer()
    vectorizer.fit_transform(corpus).toarray()
    N-gram

    N-gram与Count Vectors类似,不过加入了相邻单词组合成为新的单词,并进行计数。

    如果N取值为2,则句子1和句子2就变为:

    句子1:我爱 爱北 北京 京天 天安 安门
    句子2:我喜 喜欢 欢上 上海
    TF-IDF

    TF-IDF 分数由两部分组成:第一部分是词语频率(Term Frequency),第二部分是逆文档频率(Inverse Document Frequency)。其中计算语料库中文档总数除以含有该词语的文档数量,然后再取对数就是逆文档频率。

    TF(t)= 该词语在当前文档出现的次数 / 当前文档中词语的总数
    IDF(t)= log_e(文档总数 / 出现该词语的文档总数)
    基于机器学习的文本分类

    接下来我们将对比不同文本表示算法的精度,通过本地构建验证集计算F1得分。

    Count Vectors + RidgeClassifier

    import pandas as pd

    from sklearn.feature_extraction.text import CountVectorizer
    from sklearn.linear_model import RidgeClassifier
    from sklearn.metrics import f1_score

    train_df = pd.read_csv(’…/input/train_set.csv’, sep=’\t’, nrows=15000)

    vectorizer = CountVectorizer(max_features=3000)
    train_test = vectorizer.fit_transform(train_df[‘text’])

    clf = RidgeClassifier()
    clf.fit(train_test[:10000], train_df[‘label’].values[:10000])

    val_pred = clf.predict(train_test[10000:])
    print(f1_score(train_df[‘label’].values[10000:], val_pred, average=‘macro’))

    0.74

    TF-IDF + RidgeClassifier

    import pandas as pd

    from sklearn.feature_extraction.text import TfidfVectorizer
    from sklearn.linear_model import RidgeClassifier
    from sklearn.metrics import f1_score

    train_df = pd.read_csv(’…/input/train_set.csv’, sep=’\t’, nrows=15000)

    tfidf = TfidfVectorizer(ngram_range=(1,3), max_features=3000)
    train_test = tfidf.fit_transform(train_df[‘text’])

    clf = RidgeClassifier()
    clf.fit(train_test[:10000], train_df[‘label’].values[:10000])

    val_pred = clf.predict(train_test[10000:])
    print(f1_score(train_df[‘label’].values[10000:], val_pred, average=‘macro’))

    0.87

    本章小结

    本章我们介绍了基于机器学习的文本分类方法,并完成了两种方法的对比。

    本章作业

    尝试改变TF-IDF的参数,并验证精度
    尝试使用其他机器学习模型,完成训练和验证

    展开全文
  • 以复旦中文文本分类语料库为样本,用python实现的文本分类算法 由于训练集和测试集太大,所以给出的是训练集和测试集的下载地址,以及停用词表hlt_stop_words.txt Python版本为2.7 运行顺序: step1:corpus_segment...
  • 这份代码是我们专业的一个实验,内容包含了文本分词和文本分类。分别使用了正向最大匹配算法和KNN算法。分词速度平均153295词/秒,189100字符/秒。文本分类使用tf-idf计算单词权重进行特征选择,我测试时选择前100个...
  • 压缩包内容包含了文本分词和文本分类所必需的数据集(10000多份文档)、多份词典(包括停用词),python实现代码以及代码生成日志txt文件。
  • 20个新闻组文本分类 本笔记本包含使用数据集、使用和库的文本分类实现,以及使用库的一些模型解释。 本笔记本随附的博客文章:
  • 自然语言处理中一个很...本文主要介绍一些常见的文本分类模型,说是介绍,其实主要以代码和结果为主,并不会详细的介绍每个算法的思想、原理、推导过程等,那样的话,估计可以写一个7、8篇的系列了,另外我也发现很...

           自然语言处理中一个很常见的操作就是文本分类,比如一组新闻文本,通过分类模型,将新闻文本分为政治、体育、军事、娱乐、财经等等几大类。那么分类第一步就是文本向量化,前一篇博客讲了一些,本文可以说是前文的实践版本。本文主要介绍一些常见的文本分类模型,说是介绍,其实主要以代码和结果为主,并不会详细的介绍每个算法的思想、原理、推导过程等,那样的话,估计可以写一个7、8篇的系列了,另外我也发现很多博客都是理论为主,代码非常少,给人的感觉就是这件事我弄明白了,但具体如何干不知道,讲的似乎很难、很神秘,没有相应代码,让人望而生畏。所以本文还是偏工程一些,阅读本文的同学希望已经有了这些文本分类算法的理论基础。先说说我用的数据,约20万短文本,包含8个大类,分别为:餐饮、交通、购物、娱乐、居家等,每个大类约25000条数据,文本平均20个字左右,最短的文本仅有2个字。如下面所示:

    __label__1    天猫 超市 慕滋 五谷 无 添加 糖 粗粮 杂粮 消化 饼干 g 代 早餐 糕点
    __label__1    天猫 超市 满 减 云南 红 提 kg 提子 葡萄 新鲜 水果
    __label__1    天猫 超市 原装 进口 嘘 嘘 乐 成长 裤 纸尿裤 拉拉 裤 L19 片 Kg
    __label__1    天猫 超市 卫龙 小 面筋 g 零食 辣条 辣片 麻辣 素食 豆干 制品 大刀 肉
    __label__1    天猫 超市 康师傅 矿物质 水 ml 瓶 整箱 饮用水
    __label__1    天猫 超市 红牛 维生素 功能 饮料 整箱 装 原味 型 ml 罐 箱
    __label__1    天猫 超市 香楠 蛋羹 味 麻薯 夹心 麻 糬 糕点 休闲 零食 小吃 g
    __label__1    天猫 超市 蒙牛 特仑苏 醇 纤 牛奶 ml 盒 平衡 搭档 平衡 好搭档
    __label__1    天猫 超市 味全 每日 C 纯 果汁 胡萝卜 果蔬汁 ml16 截单
    __label__1    天猫 超市 金 菜地 豆干 五香 茶 干 g 豆腐干 特色 休闲 零食 豆制品
    __label__1    天猫 超市 新 希望 牛奶 香蕉 牛奶 ml 盒 箱 甜蜜 好 滋味
    __label__1    天猫 超市 良品 铺子 爆浆 麻薯 抹 茶味 g 糕点 点心 零食 特产 小吃
    __label__1    天猫 超市 森永 嗨 酸酸 哒 酸果 软糖 青 柠味 g 维 c 水果 糖果 零食
    __label__1    天猫 超市 桂格 即食 纯 燕麦片 粗粮 原味 冲 饮 谷物 早餐 g 袋装
    __label__1    天猫 超市 满 减 挪威 冰冻 青花鱼 柳 g 包 冷冻 海鲜 鱼肉 鲭 鱼
    __label__1    天猫 超市 甘 竹牌 豆豉 鲮鱼 罐头 g 盒 下 饭菜 特产 小吃 休闲 食品
    __label__1    天猫 超市 姚 太太 青口 梅 g 蜜饯 果脯 话梅 肉 梅子 青梅 酸甜 凉果
    __label__1    天猫 超市 蒙牛 特仑苏 醇 纤 牛奶 ml 盒 平衡 搭档 平衡 好搭档

           很多文本内容都是淘宝体,也就是商品标题,当然上面仅仅是个示例。我这里已经分好词,并且为了方便后面使用fastText分类模型,已经按照fastText格式做了排版,也就是第一项__label__1是标签, 后面是文本正文,这个训练集需要人工标记好,这是一件费时费力的事情。下面是不同分类模型代码,因为加了注释,所以这里就不一一解释了。
    import random
    import fasttext
    import numpy as np
    import tensorflow as tf
    from sklearn.svm import SVC
    from sklearn.naive_bayes import MultinomialNB
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.ensemble import GradientBoostingClassifier
    from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
    
    # 朴素贝叶斯算法
    def nb_model(train, train_label, test, test_label):
        clf_model = MultinomialNB(alpha=0.01)
        clf_model.fit(train, train_label)
        predict_results = clf_model.predict(test)
    
        count = 0
        predict_list = predict_results.tolist()
        for i, pred in enumerate(predict_list):
            if (pred == test_label[i]):
                count += 1
    
        print("nb_model_precision_score: " + str(float(count) / len(predict_list)))
    
    
    # K近邻算法
    def knn_model(train, train_label, test, test_label):
        knn_model = KNeighborsClassifier(n_neighbors=8)
        knn_model.fit(train, train_label)
        predict_results = knn_model.predict(test)
    
        count = 0
        predict_list = predict_results.tolist()
        for i, pred in enumerate(predict_list):
            if (pred == test_label[i]):
                count += 1
    
        print("knn_model_precision_score: " + str(float(count) / len(predict_list)))
        
    
    # 支持向量机算法
    def svm_model(train, train_label, test, test_label):
        svm_clf = SVC(kernel="linear", verbose=False)
        svm_clf.fit(train, train_label)
        predict_results = svm_clf.predict(test)
    
        count = 0
        predict_list = predict_results.tolist()
        for i, pred in enumerate(predict_list):
            if (pred == test_label[i]):
                count += 1
    
        print("svm_model_precision_score: " + str(float(count) / len(predict_list)))
            
    
    # 使用传统方法的文本分类
    def text_classification():
        count = 0
        test_text_list = []
        train_text_list = []
        test_label_list = []
        train_label_list = []
        total_text_list = []
        total_label_list = []
    
        print("start loading data...")
        finput = open("data/filter_total_half.txt", encoding='utf-8')
        for line in finput:
            count += 1
            text_array = line.split("\t", 1)
            if (len(text_array) != 2):
                continue
    
            # 保存全部样本
            total_text_list.append(text_array[1])
            total_label_list.append(text_array[0])
    
            # 划分训练集和测试集
            probability = random.random()
            if (probability > 0.2):
                train_text_list.append(text_array[1])
                train_label_list.append(text_array[0])
            else:
                test_text_list.append(text_array[1])
                test_label_list.append(text_array[0])
        finput.close()
        print("load data is finished...")
    
        print("start building vector model...")
        # 构建词典
        vec_total = CountVectorizer()
        vec_total.fit_transform(total_text_list)
    
        # 基于构建的词典分别统计训练集/测试集词频, 即每个词出现1次、2次、3次等
        vec_train = CountVectorizer(vocabulary=vec_total.vocabulary_)
        tf_train = vec_train.fit_transform(train_text_list)
    
        vec_test = CountVectorizer(vocabulary=vec_total.vocabulary_)
        tf_test = vec_test.fit_transform(test_text_list)
    
        # 进一步计算词频-逆文档频率
        tfidftransformer = TfidfTransformer()
        tfidf_train = tfidftransformer.fit(tf_train).transform(tf_train)
        tfidf_test = tfidftransformer.fit(tf_test).transform(tf_test)
        print("building vector model is finished...")
    
        # 朴素贝叶斯算法
        nb_model(tfidf_train, train_label_list, tfidf_test, test_label_list)
        # K近邻算法
        knn_model(tfidf_train, train_label_list, tfidf_test, test_label_list)
        # 支持向量机算法
        svm_model(tfidf_train, train_label_list, tfidf_test, test_label_list)
        print("building predict model is finished...")
        
        
    # 使用fastText的文本分类
    def fastText_model():
        foutput_test = open("data/data_test.txt", 'w', encoding='utf-8')
        foutput_train = open("data/data_train.txt", 'w', encoding='utf-8')
        with open("data/filter_total_half.txt", encoding='utf-8') as finput:
            for line in finput:
                probability = random.random()
                if (probability > 0.2):
                    foutput_train.write(line.strip() + "\n")
                else:
                    foutput_test.write(line.strip() + "\n")
        foutput_train.flush()
        foutput_train.close()
        foutput_test.flush()
        foutput_test.close()
        
        classifier = fasttext.supervised("data/data_train.txt", "data/cooking_fasttext_bkk.model", 
                              label_prefix="__label__", lr=0.25, dim=100,
                              silent=False, epoch=25, word_ngrams=3, loss="hs", bucket=2000000)
        
        result = classifier.test("data/data_test.txt")
        print(result.precision)
    
    
    if __name__ == '__main__':
        print("\n传统方法文本分类...")
        text_classification()
        print("\n----------------------------------------------\n")
        print("FastText文本分类...")
        fastText_model()

           程序运行结果如下:


           我还写了一个基于卷积神经网络的版本,修改自github,由于公司也有在用,这里就不把代码贴出来了。总体看,cnn的准确度最高,fastText次之。不过基于cnn的方法,需要事先训练词向量,训练过程也比较慢。而传统方法,如svm,准确度达0.95,已经很高了,从这一点也说明,不管是基于深度学习的卷积神经网络分类方法,还是传统的分类方法,其实模型反而是其次,最重要的是数据集的质量,模型选择和模型调参,对最终精度提升都是小幅度的,而数据集的质量高低则是精度提升的瓶颈,有时真得不怕麻烦,整理出一份高质量的数据集,才能训练出精度更准、召回更高的模型。看到这里,是不是很多同学觉得文本分类其实没什么神秘的,有现成的训练框架使用,如:sklearn,还有那么多文献资料可供查阅,唯独没有适合自己业务的训练集,整理训练集,这可能是整个模型训练过程中最花时间的事情了。当然,这里面也涉及很多模型调参细节,需要深入算法原理才能真正玩转。



    展开全文
  • 压缩包中包括python脚本和一个PPT。 在UtralEdit中打开这两个脚本NBayes_lib.py和NBayes_...PPT详解了朴素贝叶斯算法的原理以及这个文本分类器的程序思想和运行结果详解,希望对你能够有帮助,如果有任何问题,请留言!
  • 8种传统算法: k近邻算法、决策树、多层感知器、朴素贝叶斯(包括伯努利贝叶斯、高斯贝叶斯和多项式贝叶斯)、逻辑回归和支持向量机; 4种集成学习算法: 随机森林、AdaBoost、lightGBM和xgBoost; 2种深度...

    8种传统算法:

           k近邻算法、决策树、多层感知器、朴素贝叶斯(包括伯努利贝叶斯、高斯贝叶斯和多项式贝叶斯)、逻辑回归和支持向量机;

    4种集成学习算法:

          随机森林、AdaBoost、lightGBM和xgBoost;

    2种深度学习算法:

          前馈神经网络和LSTM。

          https://blog.csdn.net/qq_43012160/article/details/96303739           附带数据集和代码

         https://www.kesci.com/home/project/5cbbe1668c90d7002c810f79

     

    https://www.jianshu.com/p/dc00a5d597ed博客文章

    数据集:THUCnews

    https://pan.baidu.com/s/1XIZwRlG4-yynR9fSEAdRiA#list/path=%2F

    kxxa

    https://github.com/brightmart/text_classification

    https://blog.csdn.net/laobai1015/article/details/80415080

    展开全文
  • Python 文本分类

    千次阅读 2016-02-15 13:53:15
    概念朴素贝叶斯算法是一个直观的方法,使用每个属性属于某个类的概率来做预测。你可以使用这种监督性学习方法,对一个预测性建模问题进行概率建模。给定一个类,朴素贝叶斯假设每个属性归属于此类的概率独立于其余...

    原文地址:http://kekefund.com/2016/01/27/naive-bayes-classifier/

    概念

    朴素贝叶斯算法是一个直观的方法,使用每个属性属于某个类的概率来做预测。你可以使用这种监督性学习方法,对一个预测性建模问题进行概率建模。

    给定一个类,朴素贝叶斯假设每个属性归属于此类的概率独立于其余所有属性,从而简化了概率的计算。这种强假定产生了一个快速、有效的方法。

    给定一个属性值,其属于某个类的概率叫做条件概率。对于一个给定的类值,将每个属性的条件概率相乘,便得到一个数据样本属于某个类的概率。

    1、贝叶斯定理

    假设对于某个数据集,随机变量C表示样本为C类的概率,F1表示测试样本某特征出现的概率,套用基本贝叶斯公式,则如下所示:


    mathtex.cgi?P(C%20|%20F_{1})%20=%20\dfrac{P(CF_{1})}%20{P(F_{1})}%20=%20\dfrac{P(C)*P(F_{1}|C)}{P(F_{1})}

    上式表示对于某个样本,特征F1出现时,该样本被分为C类的条件概率。

    对该公式,有几个概念需要熟知:

    • 先验概率(Prior) 。P(C)是C的先验概率,可以从已有的训练集中计算分为C类的样本占所有样本的比重得出。

    • 证据(Evidence)。即上式P(F1),表示对于某测试样本,特征F1出现的概率。同样可以从训练集中F1特征对应样本所占总样本的比例得出。

    • 似然(likelihood)。即上式P(F1 | C),表示如果知道一个样本分为C类,那么他的特征为F1的概率是多少。

    对于多个特征而言,贝叶斯公式可以扩展如下:


    20160127gs2.jpg

    分子中存在一大串似然值。当特征很多的时候,这些似然值的计算是极其痛苦的。

    2、朴素的概念

    为了简化计算,朴素贝叶斯算法假设:“朴素的认为各个特征相互独立”。这样一来,上式的分子就简化成了:


    mathtex.cgi?P(C)*P(F_{1}|C)*P(F_{2}|C)...P(F_{n}|C)

    这个假设是认为各个特征之间是独立的,看上去确实是个很不科学的假设。因为很多情况下,各个特征之间是紧密联系的。然而在朴素贝叶斯的大量应用实践表明其工作的相当好。

    其次,由于朴素贝叶斯的工作原理是计算P(C=0|F_{1}…F_{n}) 和P(C=1|F_{1}…F_{n}), 并取最大值的那个作为其分类。而二者的分母是一模一样的。因此,我们又可以省略分母计算,从而进一步简化计算过程。

    另外,贝叶斯公式推导能够成立有个重要前期,就是各个证据(evidence)不能为0。也即对于任意特征Fx,P(Fx)不能为0。而显示某些特征未出现在测试集中的情况是可以发生的。因此实现上通常要做一些小的处理,例如把所有计数进行+1(加法平滑(additive smoothing,又叫拉普拉斯平滑(Laplace smothing))。而通过增大一个大于0的可调参数alpha进行平滑,就叫Lidstone平滑。

    朴素贝叶斯分类器的Python实现

    1,定义特征提取器

    
    In[21]: def gender_features(word):
    
    ...         return {'last_letter':word[-1]}
    
    In[22]: gender_features('Shrek')
    
    Out[22]: {'last_letter': 'k'}
    

    函数返回的字典被成为特征集,能把特征名称映射到它们的值。

    特征名称提供一个简短的、可读的特征描述;特征值是简单类型的值,如布尔、数字和字符串。

    2,准备数据

    
    In[24]: from nltk.corpus import names
    
    In[25]: import random
    
    In[26]: names = ([(name, 'male') for name in names.words('male.txt')] + [(name, 'female') for name in names.words('female.txt')])
    
    In[44]: random.shuffle(names)  #元素顺序打乱
    

    3,朴素贝叶斯分类器

    将特征集的结果链表划分为训练集和测试集。训练集用于训练新的“朴素贝叶斯”分类器。

    In[32]: featuresets = [(gender_features(n), g) for (n, g) in names]
    
    In[33]: train_set, test_set = featuresets[500:], featuresets[:500]
    
    In[34]: classifier = nltk.NaiveBayesClassifier.train(train_set)
    
    In[35]: classifier.classify(gender_features('Neo'))
    
    Out[35]: 'male'
    

    4,评估分类器

    准确度:

    
    In[39]: print nltk.classify.accuracy(classifier, test_set)
    
    0.602
    

    检查分类器,确定哪些特征对于区分名字的性别是最有效的:

    
    In[43]: classifier.show_most_informative_features(5)
    
    Most Informative Features
    
                 last_letter = u'a'           female : male   =     36.8 : 1.0
    
                 last_letter = u'k'             male : female =     35.3 : 1.0
    
                 last_letter = u'f'             male : female =     17.0 : 1.0
    
                 last_letter = u'p'             male : female =     14.0 : 1.0
    
                 last_letter = u'v'             male : female =     12.5 : 1.0
    

    以a结尾的女性是男性的36倍,这些比率成为似然比

    5,优化

    在处理大型语料库时,构建包含所有实例特征的单独链表会占用大量内存。可以使用函数 nltk.classify.apply_features, 类似生成器原理。

    
    In[46]: from nltk.classify import apply_features
    
    In[47]: train_set = apply_features(gender_features, names[500:])
    
    In[48]: test_set = apply_features(gender_features, names[:500])
    
    In[49]: type(train_set)
    
    Out[49]: nltk.util.LazyMap
    

    6,结果评估与改进

    将数据分为训练集、开发测试集和测试集

    训练集用于训练模型,开发测试集用于执行错误分析,测试集用于系统的最终评估。

    
    train_names = names[1500:]
    devtest_names = names[500:1500]
    test_names = names[:500]
    
    train_set = [(gender_features(n), g) for (n, g) in train_names]
    devtest_set = [(gender_features(n), g) for (n, g) in devtest_names]
    test_set = [(gender_features(n), g) for (n, g) in test_names]
    classifier = nltk.NaiveBayesClassifier.train(train_set)
    print nltk.classify.accuracy(classifier, devtest_set)
    Out: 0.794
    

    使用开发测试集生成分类器在预测名字性别时出现的错误列表:

    
    errors = []
    for (name, tag) in devtest_names:
        guess = classifier.classify(gender_features(name))
        if guess != tag:
            errors.append((tag, guess, name))
    
    for (tag, guess, name) in sorted(errors):
        print 'correct=%-8s guess=%-8s name=%-30s' % (tag, guess, name)
    
    
    ---------------------------------------
    
    Output:
    
    
    
    correct=female   guess=male     name=Adelind                       
    
    correct=female   guess=male     name=Alex                          
    
    correct=female   guess=male     name=Alyss                         
    
    correct=female   guess=male     name=Amber                         
    
    correct=female   guess=male     name=Austin                        
    
    correct=female   guess=male     name=Averil                        
    
    correct=female   guess=male     name=Beatrix  
    
    ...
    

    根据上面的错误列表改进特征提取器,比如发现yn结尾的名字大多以女性为主,但以n结尾的名字往往是男性,因此调整特征提取器使其包含两个字母后缀的特征:

    
    def gender_features(word):
        return {'suffix1':word[-1:],
                'suffix2':word[-2:]}
    
    
    ...
    
    print nltk.classify.accuracy(classifier, devtest_set)
    Out[]: 0.784
    

    参考

    http://blog.csdn.net/lsldd/article/details/41542107

    [书]Python自然语言处理 Steven Bird, Ewan Klein & Edward Loper

    展开全文
  • 文本分类算法LDA

    2015-02-09 21:34:28
    基于LDA文本分类python实现版本
  • python 基于LDA算法的长文本主题提取分类并预测类别

    千次阅读 多人点赞 2020-04-26 11:53:07
    python 基于LDA长文本主题提取并预测分类 Lda算法原理,知乎上有很完善的算法介绍,这里就不多废话了。 数据准备 这一阶段主要是对你的问题本进行处理,清洗你的数据。中文文本预处理,主要包括去空格、去表单符号、...
  • 为了在文本文件中执行机器学习算法, 我们首先要做的是将文本内容转化成数值形式的特征向量。 文本的预处理, 分词以及过滤停用词都被包含在一个可以构建特征字典和将文档转换成特征向量的高级组件中 >...
  • 文本分类算法

    2016-08-24 10:06:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • 16Python文本数据分析:新闻分类任务 (贝叶斯算法应用实例) ** 一、流程分析 ** 数据如下图:content为主体内容, 1.1 停用词:在语料中大量出现又没啥大用,会干扰统计分析,因此去掉。(例如:一个、一切、¥、#等...
  • 文本分类python实现-基于Xgboost算法

    千次阅读 2017-06-27 18:52:23
    训练集为评论文本,标签为 pos,neu,neg三种分类,train.csv的第一列为文本content,第二列为label。python的xgboost包安装方法,网上有很多详细的介绍 参数 XGBoost的作者把所有的参数分成了三类:1、
  • 本文为大家分享了Python文本特征抽取与向量化的具体代码,供大家参考,具体内容如下 假设我们刚看完诺兰的大片《星际穿越》,设想如何让机器来自动分析各位观众对电影的评价到底是“赞”(positive)还是“踩”...
  • 基于朴素贝叶斯分类器的文本分类程序 python
  • 《机器学习实战》系列博客是博主阅读《机器学习实战》这本书的笔记,包含对其中算法的理解和算法Python代码实现 另外博主这里有机器学习实战这本书的所有算法源代码和算法所用到的源文件,有需要的留言 =...
  • KNN算法实现文本分类 ascii 系统 5 账号 2 密码 2 分辨率 2 用户名 1 用户 1 软件 1 苹果 1 密码技术 1 宽度 1 火狐 1 0、rd-doc—count矩阵 分辨率 2 2 2 [1, 1] 用户名 1 1 2 [1, 1] 鼠标 0 1 ...
  • 这个是Python编写的一个情感文本分析程序,定义两种term weight实现,分别为TF 和BOOL,实现了特征选择算法。文件夹中附带数据集
  • 目录任务描述数据描述读取数据数据预处理可视化word2vec模型框架及拟合结果展示...具体任务是给定微博ID和微博内容,设计算法对微博内容进行情绪识别,判断微博内容是积极的、消极的还是中性的。 数据描述 数据集nCoV_
  • 文本分类python实现-基于SVM算法

    万次阅读 热门讨论 2016-10-29 20:59:27
    训练集为评论文本,标签为 pos,neu,neg三种分类,train.csv的第一列为文本content,第二列为label。可以单独使用SVC训练然后预测,也可以使用管道pipeline把训练和预测放在一块。 SVC的惩罚参数C:默认值是1.0。C越...
  • 文本分类算法的效果

    2017-06-15 09:55:00
    2019独角兽企业重金招聘Python工程师标准>>> ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 579
精华内容 231
关键字:

python文本分类算法

python 订阅