精华内容
下载资源
问答
  • pyltp目前支持puthon3.6不支持3.7 用python3.7安装了很久都没有安装成功 ...sents = SentenceSplitter.split('元芳你怎么看?我就趴窗口上看呗!') # 分句 print('\n'.join(sents)) 切割句子。 分词 imp...

    pyltp目前支持puthon3.6不支持3.7

    用python3.7安装了很久都没有安装成功

    无奈换成了3.6

     分句

    from pyltp import SentenceSplitter
    sents = SentenceSplitter.split('元芳你怎么看?我就趴窗口上看呗!')  # 分句
    print('\n'.join(sents))

    切割句子。

     

     分词

    import os
    from pyltp import Segmentor
    LTP_DATA_DIR='D:\Python3.6\ltp3.4\ltp3.4'
    cws_model_path=os.path.join(LTP_DATA_DIR,'cws.model')
    segmentor=Segmentor()
    segmentor.load(cws_model_path)
    words=segmentor.segment('熊高雄你吃饭了吗')
    print(type(words))
    print('\t'.join(words))
    segmentor.release()

     

     来源https://www.jianshu.com/p/f78453f5d1ca

    展开全文
  • 2、如果标注0和1,数据的格式是怎么样的,我要怎么进行分类器的构建,还有两种数据类型的特征构建? 3、有什么适合此情况的分类算法吗? 本人真的才学疏浅,找了很多资料还是没有弄懂接下来一步该如何进行,跪求大家...
  • 利用机器学习算法进行文本分类利用机器学习算法进行文本分类 一监督式分类建立在训练语料基础上的分类 特征提取器和朴素贝叶斯分类器 过拟合当特征过多 错误分析 二实例文本分类和词性标注 文本分类 词性标注决策树...

    关于分类文本,有三个问题
    1. 怎么识别出文本中用于明显分类的特征
    2. 怎么构建自动分类文本的模型
    3. 相关的语言知识

    按照这个思路,进行了艰苦学习(手动捂脸)。


    一、监督式分类:建立在训练语料基础上的分类

    训练过程中,特征提取器将输入转化为特征集,并且记录对应的正确分类。生成模型。预测过程中,未见过的输入被转换特征集,通过模型产生预测标签。

    特征提取器和朴素贝叶斯分类器

    特征提取器返回字典,这个字典被称为特征集。然后利用
    nltk自带的朴素贝叶斯分类器 NaiveBayesClassifier 生成分类器。并且可以用nltk.classify.accuracy(分类器,测试集) 测试准确度。

    import nltk
    from nltk.corpus import names
    import random
    
    def gender_features(word): #特征提取器
        return {'last_letter':word[-1]} #特征集就是最后一个字母
    
    names = [(name,'male') for name in names.words('male.txt')]+[(name,'female') for name in names.words('female.txt')]
    random.shuffle(names)#将序列打乱
    
    features = [(gender_features(n),g) for (n,g) in names]#返回对应的特征和标签
    
    train,test = features[500:],features[:500] #训练集和测试集
    classifier = nltk.NaiveBayesClassifier.train(train) #生成分类器
    
    print('Neo is a',classifier.classify(gender_features('Neo')))#分类
    
    print(nltk.classify.accuracy(classifier,test)) #测试准确度
    
    classifier.show_most_informative_features(5)#得到似然比,检测对于哪些特征有用

    当然,当我们训练大的语料库的时候,链表会占用很大内存。这时候nltk提供了:apply_features,会生成链表,但是不会在内存中存储所有对象。

    from nltk.classify import apply_features
    train_set = apply_features(gender_features,names[500:])
    test_set = apply_features(gender_features,names[:500])

    过拟合:当特征过多

    当特征过多的时候(特征集的键值过多),会对一般化的新例子不起作用,称为过拟合。如果抉择特征集的大小,需要不停的测试,找到最吻合的特征集。

    错误分析

    为了使特征提取器准确度更高,一般将源数据分为两大部分,三小部分:
    - 开发集:
    - 训练集:负责开发
    - 开发测试集:负责错误分析
    - 测试集:负责最终评估

    下面是查找报错信息的案例:

    import nltk
    from nltk.corpus import names
    import random
    
    def gender_features(word): #特征提取器
        return {'last_letter':word[-1]} #特征集就是最后一个字母
    
    names = [(name,'male') for name in names.words('male.txt')]+[(name,'female') for name in names.words('female.txt')]
    
    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))
    ######################记录报错的案例###############################
    errors = []
    for (name,tag) in devtest_names:
        guess = classifier.classify(gender_features(name))
        if guess!=tag:
            errors.append((tag,guess,name))
    ##################################################################

    我们发现准确度低,因为倒数第二个字母也很有关联。所以我们可以改进特征提取器:

    def gender_features(word): #特征提取器
        return {'last_letter':word[-1],'last__letter':word[-2]} #特征集就是最后一个字母和倒数第二个字母

    观察结果,发现,准确度提高了12%。重复这个过程,使得特征提取器更加完善。


    二、实例:文本分类和词性标注

    文本分类

    这里的分类标签选成词汇,通过对文本前N个词的观察,得到预测标签。

    import nltk
    from nltk.corpus import movie_reviews
    
    all_words = nltk.FreqDist(w.lower() for w in movie_reviews.words())
    word_features = all_words.most_common(2) #前两千个最常出现的单词
    
    def document_features(document):
        document_words = set(document)
        features = {}
        for (word,freq) in word_features:
            features['contains(%s)'%word] = (word in document_words) #参数文档中是否包含word:True/False
        return features
    
    documents = [(list(movie_reviews.words(fileid)),category) for category in movie_reviews.categories() for fileid in movie_reviews.fileids(category)]
    random.shuffle(documents)
    
    features = [(document_features(d),c)for (d,c) in documents]
    train_set,test_set = features[100:],features[:100]
    
    classifier = nltk.NaiveBayesClassifier.train(train_set)
    print(nltk.classify.accuracy(classifier,test_set))

    词性标注:“决策树”分类器

    这里的分类器是决策树分类器:DecisionTreeClassifier。可以通过classifier.pseudocode(depth = ?) 这查询深度为depth的树,并且打印出来。顺便表示,我再走下面的程序的时候,电脑炸了。建议在集群上运行。

    from nltk.corpus import brown
    import nltk
    
    suffix_fdist = nltk.FreqDist()
    for word in brown.words():
        word = word.lower()
        #suffix_fdist.inc(word[-1:]) python2
        suffix_fdist[word[-1:]] += 1 #python3
        suffix_fdist[word[-2:]] += 1
        suffix_fdist[word[-3:]] += 1
    
    common_suffixes = suffix_fdist.most_common(100) #获得常见特征链表
    #定义特征提取器:
    def pos_features(word):
        features = {}
        for (suffix,times) in common_suffixes:
            features['endswith(%s)' % suffix] = word.lower().endswith(suffix)
        return features
    
    tagged_words = brown.tagged_words(categories='news')
    featuresets = [(pos_features(n),g)for (n,g) in tagged_words]
    size = int(len(featuresets)*0.1)
    
    train_set , test_set= featuresets[size:], featuresets[:size]
    classifier = nltk.DecisionTreeClassifier.train(train_set) #“决策树分类器”
    print(nltk.classify.accuracy(classifier,test_set))

    三、更近一步的连续分类或贪婪序列分类:在朴素贝叶斯和“决策树”之后

    这种分类模型是为了获取相关分类之间的依赖关系。为第一个输入找到最佳标签,然后再次基础上找到对应的下一个输入的最佳标签。不断重复,以至所有输入都被贴上标签。所以,我们需要提供一个参数history,用来扩展特征。
    事实证明,我的电脑又炸了。

    利用联合分类器模型进行词性标注:

    import nltk
    from nltk.corpus import brown
    #带有历史的特征提取器
    def pos_features(sentence,i,history):
        features = {'suffix(1)':sentence[i][-1:],\
                   'suffix(2)':sentence[i][-2:],\
                   'suffix(3)':sentence[i][-3:]}
        if i==0:#当它在分界线的时候,没有前置word 和 word-tag
            features['prev-word'] = '<START>'
            features['prev-tag'] = '<START>'
        else:#记录前面的history
            features['prev-word'] = sentence[i-1]
            features['prev-tag'] = history[i-1]
        return features
    
    ''' 
    ###########流程式###############
    tagged_sents = brown.tagged_sents(categories="news")
    size = int(len(tagged_sents)*0.1)
    train_sents,test_sents = tagged_sents[size:],tagged_sents[:size]
    
    train_set = []
    
    for tagged_sent in train_sents:
        untagged_set = nltk.tag.untag(tagged_sent) 
        history = []
        for i,(word,tag) in enumerate(tagged_sent):
            featureset = pos_features(untagged_set,i,history)
            history.append(tag)
            train_set.append((featureset,tag))
        classifier = nltk.NaiveBayesClassifier.train(train_set)
    '''
    #########类思想重写##################
    
    class ConsecutivePosTagger(nltk.TaggerI): #这里定义新的选择器类,继承nltk.TaggerI
        def __init__(self,train_sents):
            train_set = []
            for tagged_sent in train_sents:
                untagged_set = nltk.tag.untag(tagged_sent) #去标签化
                history = []
                for i,(word,tag) in enumerate(tagged_sent):
                    featureset = pos_features(untagged_set,i,history)
                    history.append(tag) #将tag添加进去
                    train_set.append((featureset,tag)) #拿到了训练集
                self.classifier = nltk.NaiveBayesClassifier.train(train_set) #创建训练模型
    
        def tag(self,sentence): #必须定义tag方法
            history = []
            for i,word in enumerate(sentence):
                featureset = pos_features(sentence,i,history)
                tag = self.classifier.classify(featureset)
                history.append(tag)
            return zip(sentence,history)
    
    tagged_sents = brown.tagged_sents(categories="news")
    size = int(len(tagged_sents)*0.1)
    train_sents,test_sents = tagged_sents[size:],tagged_sents[:size]
    #print(train_sents)
    tagger = ConsecutivePosTagger(train_sents)
    print(tagger.evaluate(test_sents))

    四、评估

    之前我们选择测试集和开发集,都是在一个原有集合下。这样,示例相似程度很大,不利于推广到其他数据集。而评估最简单的度量就是准确度,即:accuracy()函数。除了这个,精确度、召回率和F-度量值也确实影响了准确度。

    - 精确度:发现项目中多少是相关的。TP/(TP+FP)
    - 召回率:表示相关项目发现了多少。TP(TP+FN)
    - F-度量值:精确度和召回率的调和平均数。
    其中,T:true;P:Positive;F:false;N:negative。组合即可。例如TP:真阳性(正确识别为相关的),TN:真阴性(相关项目中错误识别为不想关的)


    五、三种分类器的总结

    之前我们发现。同样的特征集,朴素贝叶斯分类器就可以轻松跑完,但是决策树分类器不行。除了过拟合的因素外,还是因为树结构强迫特征按照特定的顺序检查,即便他是重复的,而在回溯的过程中,又有重复运算,导致时间和空间的双重浪费。
    朴素贝叶斯分类器允许所有恩正“并行”起作用,从计算每个标签的先验概率开始。并且建立朴素贝叶斯的时候采用了平滑技术(在给定的贝叶斯模型上)。
    最后的最大熵分类器,使用搜索技术找出一组能最大限度的提高分类器性能的参数。由于他会用迭代优化技术选择参数,花费时间很长。


    六、后记

    努力地看书了,然而还是没有看懂。感觉是因为相应的数学知识和算法知识没到位。以后积累充足会重看。
    当然,对于现在用的层面来说,较深入的了解原理,基本可以解决大多数问题。但是要是做到算法优化,还是要自己去调参,或者改进算法。
    由于博主水平有限,希望各路大牛不li赐教。


    欢迎进一步交流本博文相关内容:
    博客园地址 : http://www.cnblogs.com/AsuraDong/
    CSDN地址 : http://blog.csdn.net/asuradong
    也可以致信进行交流 : xiaochiyijiu@163.com
    欢迎转载 , 但请指明出处  :  )


    展开全文
  • 利用文本分析技术进行关于两个商品数据集(Amazon和 Google的众多商品的数据记录文件)的实体识别。 在我的下载里可以找到实验数据。 【我不太明白这个下载积分怎么设置哎,没看到修改积分的按钮之类的,它就自动...

    、目的

    掌握并理解实体识别的方法

    理解TF-IDF算法

     

    二、环境

    Windows10操作系统、Python3.6、PyCharm

     

    三、内容

    利用文本分析技术进行关于两个商品数据集(Amazon和 Google的众多商品的数据记录文件)的实体识别。

    在我的下载里可以找到实验数据。

    【我不太明白这个下载积分怎么设置哎,没看到修改积分的按钮之类的,它就自动给我弄成5积分了,其实我没想要这么多,对大家来说有点儿贵,如果有人知道怎么修改积分设置可以联系我,我给它改成1积分或者直接免费就行了,谢谢咯!】

     

    四、步骤

    1、打开文件,并将数据存放到列表中。

    def OpenFile():
        fileA = open('Amazon_small.csv', 'rt', encoding='utf-8')
        readers = csv.reader(fileA)
        # 跳过表头
        next(fileA)
        for line in readers:
            Amazon.append(line)
        # print(Amazon)
        print()
    
        fileG = open('Google_small.csv', 'rt', encoding='utf-8')
        readers = csv.reader(fileG)
        # 跳过表头
        next(fileG)
        for line in readers:
            Google.append(line)
        # print(Google)
        print()
    
        with open('stopwords.txt', 'rt') as fileS:
            readers = reader(fileS)
            for line in readers:
                # print(line[0])
                StopWord.append(line[0])
            StopWord.append('')
        # print(StopWord)
        print()
    
        fileA.close()
        fileG.close()
        fileS.close()

     

    如下图分别是Amazon_small.csv(部分)、Google_small.csv(部分)和stopwords.txt(部分)对应的列表。

     

    2、分割文本,得到有效Tokens

        三个参数分别为读文件后形成的列表(上面三个列表)、输出列表(形式是:每一行的id以及它对应的tokens)、关键词列表(除了id之外的全部token组成的列表)。

    def GetTokens(inputlist, outputlist, keylist):
        # 对于每一行数据
        for line in inputlist:
            string = ''
            # print(line[0])
            # 对于每一行数据的每一个元素
            for index in range(len(line)):
                # print(len(line))
                # print(line[index])
                # 如果是最后一个元素则其后不需要再加上空格
                if index == len(line) - 1:
                    string = string + line[index]
                # 除了id之外并且不是最后一个元素的字段,最后要加上一个空格分割
                if index != 0:
                    string = string + line[index] + ' '
            # print(string)
            # string即为除了id之外,用空格连接各字段的总字符串
            # 对该字符串按空格进行分割
            split_list = string.lower().split(' ')
            tokens = []
            for n in split_list:
                # print(n)
                if n not in StopWord:
                    tokens.append(n)
                    keylist.append(n)
            # print(tokens)
            id_tokens = []
            id_tokens.append(line[0])
            id_tokens.append(tokens)
            outputlist.append(id_tokens)
        # print(outputlist)

       

    输出结果:

     

    3、求TF值

    TF(token)=该token在tokens中的出现次数/tokens中的总token

    为计算分子,这里另外写了一个计算列表中每个元素个数的函数count,输入参数是一个用于统计的列表,并返回一个字典,里面是每个元素以及其在列表中出现的次数。

    def GetTFTokens(inputlist, outputlist):
        for term in inputlist:
            tokencount = count(term[1])
            list2 = []
            for key in tokencount:
                list1 = []
                list1.append(key)
                TF = tokencount[key] / (len(term[1]) - 1)
                list1.append(TF)
                list2.append(list1)
            # print(list2)
            list3 = []
            list3.append(term[0])
            list3.append(list2)
            outputlist.append(list3)
        # print(outputlist[0])
    
    def count(list):
        result = {}
        for i in list:
            result[i] = list.count(i)

     

    输出结果:

     

    4、求TF-IDF

    def GetTFIDFTokens(list1, list2, outputlist):
        tokens_number = len(list1)
        AorG_dictionary = dictionary(list2)
        for i in list1:
            temp = []
                # 根据关键字在字典中取得出现行数
                count = AorG_dictionary[j[0]]
                ls = []
                ls.append(j[0])
                # 求得TF_IDF
                ls.append(tokens_number / count * j[1])
                temp.append(ls)
            outputlist.append(temp)
    
    def dictionary(a):
        # 对列表a进行计数,并返回一个字典
        return dict(Counter(a))

        输出结果:

     

    5、优化算法实现

    (1)计算模

    def compute_norms(inputlist, outputlist):
        for i in inputlist:
            norms = 0
            for j in i:
                norms = norms + j[1] * j[1]
                outputlist.append(norms)

    (2)计算Google的逆向索引

    def reverse(list):
        for keywords in Google_keywords:
            list = []
            for n in range(len(Google_tokens)):
                if keywords in Google_tokens[n][1]:
                    list.append(n)
            Google_reverse_dictionary[keywords] = list

             输出结果:

    (3)算法实现

    def reverse_index(a):
        for i in range(len(a)):
            temp = a[i][1]
            for j in range(len(temp)):
                if temp[j][0] in Google_reverse_dictionary:
                    # 若该id已在字典中,则先取出原来的index列表,再添加当前行号
                    ls = Google_reverse_dictionary[temp[j][0]]
                    ls.append(i)
                    Google_reverse_dictionary[temp[j][0]] = ls
                else:
                    # 若该id不在字典中,则直接插入当前行号组成的列表
                    ls = []
                    ls.append(i)
                    Google_reverse_dictionary[temp[j][0]] = ls
    
    def perfect_mapping(a, b, c, d):
        for i in range(len(a)):
            # 记录最大余弦相似度和对应的index
            max_index = 0
            max_cos = 0
            index = []
            # 对a中一行数据的所有token查找其是否在Google_reverse_dictionary中,若在,将所有行号存到index列表中
            for k in a[i]:
                if k[0] in Google_reverse_dictionary:
                    for t in Google_reverse_dictionary[k[0]]:
                        if t not in index:
                            index.append(t)
            # 查找所有与该行数据有关(在Google中同样出现过该token)的行
            for s in index:
                temp = 0
                for t in a[i]:
                    for m in b[s]:
                        # 若id相同,则TF_IDF相乘
                        if t[0] == m[0]:
                            temp = temp + t[1] * m[1]
                current_cos = temp / Amazon_norms[i] * Google_norms[s]
                # 若该行的余弦相似度比之前的大,则更新max_cos和max_index
                if current_cos > max_cos:
                    max_cos = current_cos
                    max_index = s
            ls = [c[i][0], d[max_index][0]]
            # 完成匹配
            Amazon_Google_perfectMapping.append(ls)

    输出结果:

    导出到文件中:

    name = ['Amazon', 'Google']
    test = pd.DataFrame(columns=name, data=Amazon_Google_perfectMapping)
    print(test)
    test.to_csv('result.csv', encoding='utf_8')

    输出结果对照(左边是我实验得出的结果,右边是已有的数据,两个文件的id顺序不太一样):

     

    展开全文
  • 版权声明:更多原创文章请访问: ...1. 怎么识别出文本中用于明显分类的特征  2. 怎么构建自动分类文本的模型  3. 相关的语言知识 按照这个思路,进行了艰苦学习(手动捂脸)。 一、监督式分类:建立...

    版权声明:更多原创文章请访问: http://yuanxin.me/ https://blog.csdn.net/AsuraDong/article/details/73302999

    ​​​​​​​关于分类文本,有三个问题 

    1. 怎么识别出文本中用于明显分类的特征 
    2. 怎么构建自动分类文本的模型 
    3. 相关的语言知识

    按照这个思路,进行了艰苦学习(手动捂脸)。


    一、监督式分类:建立在训练语料基础上的分类

    训练过程中,特征提取器将输入转化为特征集,并且记录对应的正确分类。生成模型。预测过程中,未见过的输入被转换特征集,通过模型产生预测标签。

    特征提取器和朴素贝叶斯分类器

    特征提取器返回字典,这个字典被称为特征集。然后利用 
    nltk自带的朴素贝叶斯分类器 NaiveBayesClassifier 生成分类器。并且可以用nltk.classify.accuracy(分类器,测试集) 测试准确度。

    import nltk
    from nltk.corpus import names
    import random
    
    def gender_features(word): #特征提取器
        return {'last_letter':word[-1]} #特征集就是最后一个字母
    
    names = [(name,'male') for name in names.words('male.txt')]+[(name,'female') for name in names.words('female.txt')]
    random.shuffle(names)#将序列打乱
    
    features = [(gender_features(n),g) for (n,g) in names]#返回对应的特征和标签
    
    train,test = features[500:],features[:500] #训练集和测试集
    classifier = nltk.NaiveBayesClassifier.train(train) #生成分类器
    
    print('Neo is a',classifier.classify(gender_features('Neo')))#分类
    
    print(nltk.classify.accuracy(classifier,test)) #测试准确度
    
    classifier.show_most_informative_features(5)#得到似然比,检测对于哪些特征有用

    当然,当我们训练大的语料库的时候,链表会占用很大内存。这时候nltk提供了:apply_features,会生成链表,但是不会在内存中存储所有对象。

    from nltk.classify import apply_features
    train_set = apply_features(gender_features,names[500:])
    test_set = apply_features(gender_features,names[:500])

    过拟合:当特征过多

    当特征过多的时候(特征集的键值过多),会对一般化的新例子不起作用,称为过拟合。如果抉择特征集的大小,需要不停的测试,找到最吻合的特征集。

    错误分析

    为了使特征提取器准确度更高,一般将源数据分为两大部分,三小部分: 
    - 开发集: 
    - 训练集:负责开发 
    - 开发测试集:负责错误分析 
    - 测试集:负责最终评估

    下面是查找报错信息的案例:

    import nltk
    from nltk.corpus import names
    import random
    
    def gender_features(word): #特征提取器
        return {'last_letter':word[-1]} #特征集就是最后一个字母
    
    names = [(name,'male') for name in names.words('male.txt')]+[(name,'female') for name in names.words('female.txt')]
    
    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))
    ######################记录报错的案例###############################
    errors = []
    for (name,tag) in devtest_names:
        guess = classifier.classify(gender_features(name))
        if guess!=tag:
            errors.append((tag,guess,name))
    ##################################################################

    我们发现准确度低,因为倒数第二个字母也很有关联。所以我们可以改进特征提取器:

    def gender_features(word): #特征提取器
        return {'last_letter':word[-1],'last__letter':word[-2]} #特征集就是最后一个字母和倒数第二个字母

    观察结果,发现,准确度提高了12%。重复这个过程,使得特征提取器更加完善。


    二、实例:文本分类和词性标注

    文本分类

    这里的分类标签选成词汇,通过对文本前N个词的观察,得到预测标签。

    import nltk
    from nltk.corpus import movie_reviews
    
    all_words = nltk.FreqDist(w.lower() for w in movie_reviews.words())
    word_features = all_words.most_common(2) #前两千个最常出现的单词
    
    def document_features(document):
        document_words = set(document)
        features = {}
        for (word,freq) in word_features:
            features['contains(%s)'%word] = (word in document_words) #参数文档中是否包含word:True/False
        return features
    
    documents = [(list(movie_reviews.words(fileid)),category) for category in movie_reviews.categories() for fileid in movie_reviews.fileids(category)]
    random.shuffle(documents)
    
    features = [(document_features(d),c)for (d,c) in documents]
    train_set,test_set = features[100:],features[:100]
    
    classifier = nltk.NaiveBayesClassifier.train(train_set)
    print(nltk.classify.accuracy(classifier,test_set))

    词性标注:“决策树”分类器

    这里的分类器是决策树分类器:DecisionTreeClassifier。可以通过classifier.pseudocode(depth = ?) 这查询深度为depth的树,并且打印出来。顺便表示,我再走下面的程序的时候,电脑炸了。建议在集群上运行。

    from nltk.corpus import brown
    import nltk
    
    suffix_fdist = nltk.FreqDist()
    for word in brown.words():
        word = word.lower()
        #suffix_fdist.inc(word[-1:]) python2
        suffix_fdist[word[-1:]] += 1 #python3
        suffix_fdist[word[-2:]] += 1
        suffix_fdist[word[-3:]] += 1
    
    common_suffixes = suffix_fdist.most_common(100) #获得常见特征链表
    #定义特征提取器:
    def pos_features(word):
        features = {}
        for (suffix,times) in common_suffixes:
            features['endswith(%s)' % suffix] = word.lower().endswith(suffix)
        return features
    
    tagged_words = brown.tagged_words(categories='news')
    featuresets = [(pos_features(n),g)for (n,g) in tagged_words]
    size = int(len(featuresets)*0.1)
    
    train_set , test_set= featuresets[size:], featuresets[:size]
    classifier = nltk.DecisionTreeClassifier.train(train_set) #“决策树分类器”
    print(nltk.classify.accuracy(classifier,test_set))

    三、更近一步的连续分类或贪婪序列分类:在朴素贝叶斯和“决策树”之后

    这种分类模型是为了获取相关分类之间的依赖关系。为第一个输入找到最佳标签,然后再次基础上找到对应的下一个输入的最佳标签。不断重复,以至所有输入都被贴上标签。所以,我们需要提供一个参数history,用来扩展特征。
    事实证明,我的电脑又炸了。

    利用联合分类器模型进行词性标注:

    import nltk
    from nltk.corpus import brown
    #带有历史的特征提取器
    def pos_features(sentence,i,history):
        features = {'suffix(1)':sentence[i][-1:],\
                   'suffix(2)':sentence[i][-2:],\
                   'suffix(3)':sentence[i][-3:]}
        if i==0:#当它在分界线的时候,没有前置word 和 word-tag
            features['prev-word'] = '<START>'
            features['prev-tag'] = '<START>'
        else:#记录前面的history
            features['prev-word'] = sentence[i-1]
            features['prev-tag'] = history[i-1]
        return features
    
    ''' 
    ###########流程式###############
    tagged_sents = brown.tagged_sents(categories="news")
    size = int(len(tagged_sents)*0.1)
    train_sents,test_sents = tagged_sents[size:],tagged_sents[:size]
    
    train_set = []
    
    for tagged_sent in train_sents:
        untagged_set = nltk.tag.untag(tagged_sent) 
        history = []
        for i,(word,tag) in enumerate(tagged_sent):
            featureset = pos_features(untagged_set,i,history)
            history.append(tag)
            train_set.append((featureset,tag))
        classifier = nltk.NaiveBayesClassifier.train(train_set)
    '''
    #########类思想重写##################
    
    class ConsecutivePosTagger(nltk.TaggerI): #这里定义新的选择器类,继承nltk.TaggerI
        def __init__(self,train_sents):
            train_set = []
            for tagged_sent in train_sents:
                untagged_set = nltk.tag.untag(tagged_sent) #去标签化
                history = []
                for i,(word,tag) in enumerate(tagged_sent):
                    featureset = pos_features(untagged_set,i,history)
                    history.append(tag) #将tag添加进去
                    train_set.append((featureset,tag)) #拿到了训练集
                self.classifier = nltk.NaiveBayesClassifier.train(train_set) #创建训练模型
    
        def tag(self,sentence): #必须定义tag方法
            history = []
            for i,word in enumerate(sentence):
                featureset = pos_features(sentence,i,history)
                tag = self.classifier.classify(featureset)
                history.append(tag)
            return zip(sentence,history)
    
    tagged_sents = brown.tagged_sents(categories="news")
    size = int(len(tagged_sents)*0.1)
    train_sents,test_sents = tagged_sents[size:],tagged_sents[:size]
    #print(train_sents)
    tagger = ConsecutivePosTagger(train_sents)
    print(tagger.evaluate(test_sents))

    四、评估

    之前我们选择测试集和开发集,都是在一个原有集合下。这样,示例相似程度很大,不利于推广到其他数据集。而评估最简单的度量就是准确度,即:accuracy()函数。除了这个,精确度、召回率和F-度量值也确实影响了准确度。

    - 精确度:发现项目中多少是相关的。TP/(TP+FP) 
    - 召回率:表示相关项目发现了多少。TP(TP+FN) 
    - F-度量值:精确度和召回率的调和平均数。 
    其中,T:true;P:Positive;F:false;N:negative。组合即可。例如TP:真阳性(正确识别为相关的),TN:真阴性(相关项目中错误识别为不想关的)


    五、三种分类器的总结

    之前我们发现。同样的特征集,朴素贝叶斯分类器就可以轻松跑完,但是决策树分类器不行。除了过拟合的因素外,还是因为树结构强迫特征按照特定的顺序检查,即便他是重复的,而在回溯的过程中,又有重复运算,导致时间和空间的双重浪费。
    朴素贝叶斯分类器允许所有恩正“并行”起作用,从计算每个标签的先验概率开始。并且建立朴素贝叶斯的时候采用了平滑技术(在给定的贝叶斯模型上)。
    最后的最大熵分类器,使用搜索技术找出一组能最大限度的提高分类器性能的参数。由于他会用迭代优化技术选择参数,花费时间很长。


    六、后记

    努力地看书了,然而还是没有看懂。感觉是因为相应的数学知识和算法知识没到位。以后积累充足会重看。
    当然,对于现在用的层面来说,较深入的了解原理,基本可以解决大多数问题。但是要是做到算法优化,还是要自己去调参,或者改进算法。
    由于博主水平有限,希望各路大牛不li赐教。

    展开全文
  • 读书笔记:伍多·库卡茨《质性文本分析:方法、实践与软件使用指南》 一、这篇文章、这本书或这篇论文的中心思想、核心观点是什么? 核心观点:质性数据如何系统化分析?三大主要方法:主题分析、评估分析和类型建构...
  • 在使用Python进行数据分析时,Jupyter Notebook是一个非常强力的工具,在数据集不是很大的情况下,我们可以使用pandas轻松对txt或csv等纯文本格式数据进行读写。然而当数据集的维度或者体积很大时,将数据保存并加载...
  • 来源 | 早起Python(ID:zaoqi-python)编译 | 刘早起(有删改)头图 | CSDN下载自东方IC在使用 Python 进行数据分析时,Jupyter Notebook 是一个非常强力的工具,在数据集不是很大的情况下,我们可以使用 pandas 轻松对...
  • 在数据分析业务中经常要处理数据文件。我们知道,对于数据库中的数据,使用SQL来查询是非常方便快捷的,所以很容易想到把文件数据先导入到数据库再用SQL来查询。但是文件数据导入数据库本身也是很繁琐的工作,那么有...
  • 和英文与拉丁语系不同,中文是紧凑连接的,词与词之间不用空格来分割,而当我们进行自然语言处理或者语音识别,或者进行其他的文本操作时,在大部分情况下,词汇是文本的核心,是进行文本处理的前提,因此需要一个...
  • 目录一、需求分析总体概述:替换文件名称的替换如果文件夹或文本文件(各类后缀文件)的名称中存在某个字符串,则将他替换为另外的字符串。文件内容的替换如果文本文件(各类后缀文件)的内容中存在某个字符串,则将他...
  • 文本分析------简单篇

    2015-09-23 11:50:50
    我只想用形象简单的方式,让大家了解文本分析具体是什么,怎么进行机器学习过程,所谓高大上的东西只是自己没有勇气去了解而已。 文本分析顾名思义就是对文本进行统计处理,然后让机器学习一些文本特征,然后进行...
  • 举个例子,比如都是感冒,症状也就是哪几样,头痛,流涕等,但每个医生对每个患者的描述却不同, 有头痛或流涕症状的不一定就是感冒,需要做的功能就是从病历描述中读懂语意,...求问:我该怎么做? 难度究竟有多大?
  • 对文章中的有效关键词进行分析,是内容推荐算法的核心。这种推荐主要是针对在文本中出现频率较高的词。但是在每篇文章中,往往出现次数最多是“的”“是”“在”等等,这些词称为“停用词”,表示对结果毫无用处,...
  • 作者|Manmohan Singh 编译|VK 来源|Towards Datas Science ...这种分析过程也称为探索性文本分析(ETA)。运用K-means、Tf-IDF、词频等方法对这些文本数据进行分析。此外,ETA在数据清理过程中也很有用。 我们还使用
  • python文本分析 __机器学习之LDA模型

    千次阅读 2018-10-27 14:20:13
    __机器学习之LDA模型项目背景项目需求项目流程爬取数据并导出数据分析及训练模型导入所需模块数据预处理情感分析分词训练模型项目结论差评 项目背景 现在大家在进行网购过程中,肯定会看商品的相关评论,然后再...
  • 背景 在日常的生活中,我们可能会经常需要...这些场景都支持索引排序和检索,否则怎么叫变态呢。 按长相相似度排序 比如最近的王宝强和马蓉的事件,估计很多人会拿宋喆的照片进行相似度的搜索,八卦八卦。 说起图像...
  • 利用Keras实现的CNN进行文本分类 上一篇博文已经分析了CNN如何应用在文本分类中: https://blog.csdn.net/qq_43012160/article/details/96572537 这一篇我们来讲一讲怎么用keras实现一个CNN并用它来文本分类。 先放...
  • 【NLP】新闻文本分类文本分析句子分布分析断句情况分析 在上一节中,进行读取完成数据集后,还可以对数据集进行数据分析的操作。虽然对于非结构数据并不需要做很多的数据分析,但通过数据分析还是可以找出一些规律。...
  • 分分钟教你使用豌豆BI快速开始进行数据分析!Step 1:准备数据,建立数据源点开如下界面,在【主题集】下点击【新建主题表】,选择准备好的数据类型,如图所示,豌豆BI支持EXCELTXTCSVTXT这些最常用的文件类型导入,...
  • 聚类分析是一种无监督机器学习(训练样本的标记信息是未知的)算法,它的目标是将相似的对象归到同一个簇中...下面就带着这几个问题,以我工作中的一个业务需求为例,来学习一下怎么对中文文本进行聚类。(此文略长...
  • 读写文本格式的数据pd.read_csv()pd.read_table()这一种应该是最常用的读取数据的方法了,根据数据的混乱程度可以在后面加上读取的限定方法,常用的如下:导出文本文件:data.to_csv()2.读取/导出文本文件with open...
  • 路过的各位看过情感分析的,求帮忙推荐一些材料,我之前看了一些用朴素贝叶斯进行文本情感分析的一些资料,但是总有一些地方不太明白,求一些基本的计算的例子(链接也行): 朴素贝叶斯进行语句(或文本)情感...
  • 当对一个或多个人的谈话进行记录时,采用一种高度准确和自动化的方式将口语提取为文本非常有用。转换成文字后,便可以将其用于进一步分析或用作其他功能。...
  • 目录 一、监督式分类:建立在训练语料基础上的分类 特征提取器和朴素贝叶斯分类器 过拟合:当特征过多 错误分析 二、实例:文本分类和词性标注 ...怎么识别出文本中用于明显分类的特征 怎么构建...
  • 我在利用Stanford Parser对文本进行分析时发现有些结果和我想得到有些不同,想通过训练分析器来获得我想要的结果。 但是我在斯坦福自然语言小组的官网上只看到一些简单的训练命令,还有说道要用宾州树库来训练,我在...
  • 使用python对数据进行计算分析,数据文件一般需要进行导入并处理为可直接使用的格式。打开: 使用python的内置函数open(),会创建一个file对象。使用该对象的方法可以对文件进行操作。file_object = open(file_name)...
  • 最近正在用nltk 对中文网络商品评论进行褒贬情感分类,计算评论的信息熵(entropy)、互信息(point mutual information)和困惑值(perplexity)等(不过这些概念我其实也还理解不深...只是nltk 提供了相应方法)。...
  • 之前开始做语义理解的时候,笔者采用的是比较粗暴的方法进行匹配。...本文只是简单的阐述一下意图分析的典型思路和方法,并实现一个基本的意图分类器,而无意系统的探究意图分类。更详细的探讨后...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 298
精华内容 119
关键字:

怎么进行文本分析