精华内容
下载资源
问答
  • 自然语言处理项目
    千次阅读
    2018-06-11 11:12:00
    
    '''
    #2018-06-10  June Sunday the 23 week, the 161 day SZ
    数据来源:链接:https://pan.baidu.com/s/1_w7wOzNkUEaq3KAGco19EQ 密码:87o0
    朴素贝叶斯与应用
    文本分类问题
    经典的新闻主题分类,用朴素贝叶斯做。
    #还有点问题。无法正确读取数据。UnicodeDecodeError: 'charmap' codec can't decode byte 0x90 in position 41: character maps to <undefined>
    folder_path = 'D:/自然语言处理/第2课/Lecture_2/Lecture_2/Naive-Bayes-Text-Classifier/Database/SogouC/Sample'
    all_words_list, train_data_list, test_data_list, train_class_list, test_class_list = text_processing(folder_path,test_size=0.2)
    '''
    
    
    import os
    import time
    import random
    import codecs
    import jieba  #处理中文
    #import nltk  #处理英文
    import sklearn
    from sklearn.naive_bayes import MultinomialNB
    import numpy as np
    import pylab as pl
    import matplotlib.pyplot as plt
    
    import sys
    #reload(sys)
    #sys.setdefaultencoding('utf8')
    #粗暴的词去重
    def make_word_set(words_file):
        words_set = set()
        with open(words_file, 'r') as fp:
            for line in fp.readlines():
                word = line.strip().decode("utf-8")
                if len(word)>0 and word not in words_set: # 去重
                    words_set.add(word)
        return words_set
    # 文本处理,也就是样本生成过程
    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: # 怕内存爆掉,只取100个样本文件,你可以注释掉取完
                    break
                with open(os.path.join(new_folder_path, file), 'r') as fp:
                   raw = fp.read()
                ## 是的,随处可见的jieba中文分词
                #jieba.enable_parallel(4) # 开启并行分词模式,参数为并行进程数,不支持windows
                word_cut = jieba.cut(raw, cut_all=False) # 精确模式,返回的结构是一个可迭代的genertor
                word_list = list(word_cut) # genertor转化为list,每个词unicode格式
                #jieba.disable_parallel() # 关闭并行分词模式
                
                data_list.append(word_list) #训练集list
                class_list.append(folder.decode('utf-8')) #类别
                j += 1
        
        ## 粗暴地划分训练集和测试集
        data_class_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)
        
        #其实可以用sklearn自带的部分做
        #train_data_list, test_data_list, train_class_list, test_class_list = sklearn.cross_validation.train_test_split(data_list, class_list, test_size=test_size)
        
    
        # 统计词频放入all_words_dict
        all_words_dict = {}
        for word_list in train_data_list:
            for word in word_list:
                if all_words_dict.has_key(word):
                    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) # 内建函数sorted参数需为list
        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
    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: # feature_words的维度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
    # 文本特征
    def text_features(train_data_list, test_data_list, feature_words, flag='nltk'):
        def text_features(text, feature_words):
            text_words = set(text)
            ## -----------------------------------------------------------------------------------
            if flag == 'nltk':
                ## nltk特征 dict
                features = {word:1 if word in text_words else 0 for word in feature_words}
            elif flag == 'sklearn':
                ## sklearn特征 list
                features = [1 if word in text_words else 0 for word in feature_words]
            else:
                features = []
            ## -----------------------------------------------------------------------------------
            return features
        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
    # 分类,同时输出准确率等
    def text_classifier(train_feature_list, test_feature_list, train_class_list, test_class_list, flag='nltk'):
        ## -----------------------------------------------------------------------------------
        if flag == 'nltk':
            ## 使用nltk分类器
            train_flist = zip(train_feature_list, train_class_list)
            test_flist = zip(test_feature_list, test_class_list)
            classifier = nltk.classify.NaiveBayesClassifier.train(train_flist)
            test_accuracy = nltk.classify.accuracy(classifier, test_flist)
        elif flag == 'sklearn':
            ## sklearn分类器
            classifier = MultinomialNB().fit(train_feature_list, train_class_list)
            test_accuracy = classifier.score(test_feature_list, test_class_list)
        else:
            test_accuracy = []
        return test_accuracy
    print ("start")
    
    ## 文本预处理
    folder_path = 'D:/自然语言处理/第2课/Lecture_2/Lecture_2/Naive-Bayes-Text-Classifier/Database/SogouC/Sample'
    all_words_list, train_data_list, test_data_list, train_class_list, test_class_list = text_processing(folder_path,test_size=0.2)
    
    # 生成stopwords_set
    stopwords_file = 'D:\\自然语言处理\\第2课\\Lecture_2\\Lecture_2\\Naive-Bayes-Text-Classifier\\stopwords_cn.txt'
    stopwords_set = make_word_set(stopwords_file)
    
    ## 文本特征提取和分类
    # flag = 'nltk'
    flag = 'sklearn'
    deleteNs = range(0, 1000, 20)
    test_accuracy_list = []
    for deleteN in deleteNs:
        # feature_words = words_dict(all_words_list, deleteN)
        feature_words = words_dict(all_words_list, deleteN, stopwords_set)
        train_feature_list, test_feature_list = text_features(train_data_list, test_data_list, feature_words, flag)
        test_accuracy = text_classifier(train_feature_list, test_feature_list, train_class_list, test_class_list, flag)
        test_accuracy_list.append(test_accuracy)
    print (test_accuracy_list)
    
    # 结果评价
    #plt.figure()
    plt.plot(deleteNs, test_accuracy_list)
    plt.title('Relationship of deleteNs and test_accuracy')
    plt.xlabel('deleteNs')
    plt.ylabel('test_accuracy')
    plt.show()
    #plt.savefig('result.png')
    
    print ("finished")

    更多相关内容
  • PyTorch入门到进阶 实战计算机视觉与自然语言处理项目,完整版15章,附源码。 课程结合多个计算机视觉、自然语言处理实战案例、掌握同类型项目开发,在项目成型的过程中,带你熟悉企业项目的开发流程。 PyTorch是...
  • 随着对于深度学习研究的逐渐深入,在自然语言处理领域,出现了很多深度学习的模型,这些模型相比于传统的机器学习方法,在准确率等指标上面有了很大的提高。本课程拟就深度学习在自然语言处理领域的应用,从基础开始...
  • 给大家介绍一套课程,PyTorch入门到进阶 实战计算机视觉与自然语言处理项目,完整版15章,附源码,希望对大家学习有帮助。
  • 自然语言处理 自然语言处理项目
  • #NLP 项目 IITD 1
  • 通俗讲解BERT模型中所涉及的核心知识点(Transformer,self-attention等),基于google开源BERT项目从零开始讲解如何搭建自然语言处理通用框架,通过debug源码详细解读其中每一核心代码模块的功能与作用。最后基于...
  • 本课程通过一系列内容讲解和编码实战,按照由易到难,由浅入深的顺序展开,让学员在实践中,依次学习神经网络和深度学习,并且进行基于深度学习的自然语言处理技术编码实现,使得学员可以在编码中对机器学习有一个...
  • 自然语言处理通用解决方案】 需要熟悉word2vec,RNN网络模型,了解词向量如何建模 重点在于Transformer网络架构,BERT训练方法,实际应用 开源项目,都是现成的,套用进去就OK了 提供预训练模型,基本任务拿过来...
  • 自然语言处理(NLP)项目的基本流程

    千次阅读 多人点赞 2020-05-28 14:25:15
    刚入门自然语言处理的小伙伴,或者说已经接触了一段时间,但是一直不能够对自然语言处理项目的整个流程有一个大方向的把握,不知道自己目前所研究的点,是处于NLP项目的流程的哪部分,可以通过此文章来了解一下。

    摘要:刚入门自然语言处理的小伙伴,或者说已经接触了一段时间,但是一直不能够对自然语言处理项目的整个流程有一个大方向的把握,不知道自己目前所研究的点,是处于NLP项目的流程的哪部分,可以通过此文章来了解一下。

    一、基本流程

    基本流程

    1. 分词
      英文通过空格或者标点符号,就可以将词分开;而中文的分词会涉及很多问题(未登录词问题、分词歧义问题、分词不一致问题),所以会有各种不同分词的算法。

    2. 清洗
      我们需要对文本中无用的或者对理解文本没意义的字符进行清洗
      1)无用的标签:<html><div>
      2)特殊符号:!。。。
      3)停用词:a an the
      4)大写转小写

    3. 标准化
      在英文中进行标准化处理,就是将多个单词统一为同一个单词。
      例如:apple和apples都代表的是苹果,所以在文中不管是遇到apple还是apples,我们都用apple来统一表示。go gone went 都代表去的意思,同理,我们都用go来统一表示。

    4. 特征提取
      将标准化之后的词,表示为向量的形式。

    5. 建模
      各种AI的算法

    6. 评估
      对模型进行评估,选择最优的模型。

    二、分词

    分词工具

    例子:“南京市长江大桥”

    词典:["南京","市长","大桥","长江","江","市"]
    

    我们有这样一句话"南京市长江大桥",有一个词典[“南京”,“市长”,“江”,“大桥”,“长江”],怎么通过词典来进行分词呢?

    2.1 前向最大匹配(forward-max matching)

    前向最大匹配的前向意思是说,从前往后匹配。最大意思是说,我们匹配的词的长度越大越好,也就是这句话中分出来的词的数量越少越好。
    这里,我们假设这个最大长度max_len = 5:

    第一轮搜索:
    ①"南京市长江 大桥" 词典中没有南京市长江这个词,匹配失败
    ②"南京市长 江大桥" 词典中没有南京市长这个词,匹配失败
    ③"南京市长江大桥" 词典中没有南京市这个词,匹配失败
    ④"南京市长江大桥" 词典中有南京这个词,匹配成功,去除
    句子变为:“市长江大桥”

    第二轮搜索:
    ①"市长江大桥" 词典中没有市长江大桥这个词,匹配失败
    ②"市长江大桥" 词典中没有市长江大这个词,匹配失败
    ③"市长江大桥" 词典中没有市长江这个词,匹配失败
    ④"市长江大桥" 词典中有市长这个词,匹配成功,去除
    句子变为:“江大桥”

    第三轮搜索(句子长度已不足5,将max_len改为3):
    ①"江大桥" 词典中没有江大桥这个词,匹配失败
    ②"江大桥"" 词典中没有江大这个词,匹配失败
    ③"大桥" 词典中有这个词,匹配成功,去除
    句子变为:“大桥”

    第四轮搜索:
    ①"大桥" 词典中有大桥这个词,匹配成功,去除
    句子变为:"",说明已经处理完毕

    最终结果:“南京 / 市长 / 江 / 大桥”

    这个结果虽然勉强可以接受,可以认为它说的意思是,南京的市长名字叫江大桥,但是明显跟我们想要表达的或者想要理解的意思不一样,这就有了分词的歧义问题。
    如果我们的词典里有南京市这个词,那么结果就是"南京市/长江/大桥"。

    2.2 后向最大匹配(backward-max matching)

    后向最大匹配的后向意思是说,从后往前匹配。最大意思同样是说,我们匹配的词的长度越大越好。
    这里,我们同样假设这个最大长度max_len = 5:

    第一轮搜索:
    ①"南京市长江大桥 " 词典中没有市长江大桥这个词,匹配失败
    ②"南京市长江大桥 " 词典中没有长江大桥这个词,匹配失败
    ③"南京市长江大桥 " 词典中没有江大桥这个词,匹配失败
    ④"南京市长江大桥 " 词典中有大桥这个词,匹配成功,去除
    句子变为:“南京市长江”

    第二轮搜索:
    ①"南京市长江 " 词典中没有南京市长江这个词,匹配失败
    ②"南京市长江 " 词典中没有京市长江这个词,匹配失败
    ③"南京市长江 " 词典中没有市长江这个词,匹配失败
    ④"南京市长江 " 词典中有长江这个词,匹配成功,去除
    句子变为:“南京市”

    第三轮搜索(句子长度已不足5,将max_len改为3):
    ①"南京市 " 词典中没有南京市这个词,匹配失败
    ②"南京市 " 词典中没有京市这个词,匹配失败
    ③"南京 " 词典中有这个词,匹配成功,去除
    句子变为:“南京”

    第四轮搜索:
    ①"南京 " 词典中有南京这个词,匹配成功,去除
    句子变为:"",说明已经处理完毕

    最终结果:“南京 / 市 / 长江 / 大桥”

    相同的话,相同的词典,分出来的效果却不一样,导致了歧义问题。统计结果表明,单纯使用后向最大匹配算法的错误率略低于正向最大匹配算法。

    python代码实现:

    # -*- coding: utf-8 -*-
    # Author    : 不凡不弃
    # Datetime  : 2020/5/27 0027 13:39
    # description   : 分词
    
    dictionaries = ["南京", "市长", "大桥", "长江", "江", "市"]
    
    
    # 前向最大匹配
    def forward_max_matching(text, max_len=5):
        result = []
        text_ = text
        index = max_len
    
        while len(text_) > 0:
    
            if index == 0:
                print("分词失败,词典中没有这个词")
                return []
    
            if text_[:index] in dictionaries:
                result.append(text_[:index])
                text_ = text_[index:]
                index = 5
            else:
                index = index - 1
    
        return "".join(word + "/" for word in result)
    
    
    # 后向最大匹配
    def backward_max_matching(text, max_len=5):
        result = []
        text_ = text
        index = max_len
    
        while len(text_) > 0:
    
            if index == 0:
                print("分词失败,词典中没有这个词")
                return []
            # print(text_[-index:])
            if text_[-index:] in dictionaries:
                result.insert(0, text_[-index:])
                # result.append(text_[-index:])
                text_ = text_[:-index]
                index = 5
            else:
                index = index - 1
    
        return "".join(word + "/" for word in result)
    
    
    if __name__ == '__main__':
        content = "南京市长江大桥"
        forward_result = forward_max_matching(content)
        print("forward_result:", forward_result)
        backward_result = backward_max_matching(content)
        print("backward_result:", backward_result)
    
    

    以上分词算法的缺点有哪些?

    • 不能够细分(有可能效果更好)
    • 结果是局部最优
    • 效率低(词典列表如果很长的话,效率会很低)
    • 歧义(不能考虑语义)

    2.3 考虑语义

    例子:“经常有意见分歧”

    词典:["经常","有","意见","意","见","有意见","分歧","分","歧"]
    概率P(x){"经常":0.08,"有":0.04,"意见":0.08,"意":0.01,"见":0.005,"有意见":0.002,"分歧":0.04,"分":0.02, "歧":0.005}
    

    概率P(x)代表的是该词x在我们日常生活所见的文本中出现的概率。

    step1:我们根据词典,找出所有可能的分词情况,如下:

    • 经常 / 有意见 / 分歧
    • 经常 / 有意见 / 分 / 歧
    • 经常 / 有 / 意见 / 分歧
    • 经常 / 有 / 意见 / 分 / 歧

    step2:我们如果有一个语言模型,可以计算出每种情况属于中文语法的概率,我们选择最高的,也就是效果最好的。例如第一个情况的概率为:
    P ( 经 常 , 有 意 见 , 分 歧 ) = P ( 经 常 ) ∗ P ( 有 意 见 ) ∗ P ( 分 歧 ) = 0.08 ∗ 0.02 ∗ 0.04 = 0.000064 P(经常,有意见,分歧) = P(经常)*P(有意见)*P(分歧)=0.08*0.02*0.04=0.000064 P(,,)=P()P()P()=0.080.020.04=0.000064
    我们考虑到这样算的话值会很小,很容易造成内存溢出,所以引入 − l n -ln ln来计算,也就是由算P(x)的最大值变为算 − l n ( P ( x ) ) -ln(P(x)) ln(P(x))的最小值,

    -ln(P(x)){"经常":2.52,"有":3.21,"意见":2.52,"意":4.6,"见":5.29,"有意见":6.21,"分歧":3.21,"分":3.9, "歧":5.29}
    

    − l n ( P ( 经 常 , 有 意 见 , 分 歧 ) ) = − l n ( P ( 经 常 ) ∗ P ( 有 意 见 ) ∗ P ( 分 歧 ) ) = − l n ( P ( 经 常 ) − l n ( 有 意 见 ) − l n ( 分 歧 ) = 2.52 + 6.21 + 3.21 = 11.94 -ln(P(经常,有意见,分歧)) = -ln(P(经常)*P(有意见)*P(分歧))=-ln(P(经常)-ln(有意见)-ln(分歧)=2.52+6.21+3.21=11.94 ln(P(,,))=ln(P()P()P())=ln(P()ln()ln()=2.52+6.21+3.21=11.94

    但是这两步下来时间复杂度太高,并不可取。怎么能够优化一下呢?就是接下来的维特比算法

    维特比算法(viterbi)

    例子:“经常有意见分歧”

    我们仍然是有以下几个数据:

    词典:["经常","有","意见","意","见","有意见","分歧","分","歧"]
    概率P(x){"经常":0.08,"有":0.04,"意见":0.08,"意":0.01,"见":0.005,"有意见":0.002,"分歧":0.04,"分":0.02, "歧":0.005}
    -ln(P(x)){"经常":2.52,"有":3.21,"意见":2.52,"意":4.6,"见":5.29,"有意见":6.21,"分歧":3.21,"分":3.9, "歧":5.29}
    
    • 如果某个词不在字典中,我们将认为其 − l n ( P ( x ) ) -ln(P(x)) ln(P(x))值为20。

    我们构建以下的DAG(有向图),每一个边代表一个词,我们将-ln(P(x))的值标到边上,
    图
    − l n ( P ( x ) ) -ln(P(x)) ln(P(x))的最小值问题,就转变为求最短路径的问题。

    由图可以看出,路径 0—>②—>③—>⑤—>⑦ 所求的值最小,所以其就是最优结果:经常 / 有 / 意见 / 分歧
    那么我们应该怎样快速计算出来这个结果呢?

    我们设 f ( n ) f(n) f(n)代表从起点0到结点n的最短路径的值,所以我们想求的就是 f ( 7 ) f(7) f(7)

    ,我们考虑到结点⑦有2条路径:

    • 从结点⑤—>结点⑦: f ( 7 ) = f ( 5 ) + 3.21 f(7)=f(5)+3.21 f(7)=f(5)+3.21
    • 从结点⑥—>结点⑦: f ( 7 ) = f ( 6 ) + 5.29 f(7)=f(6)+5.29 f(7)=f(6)+5.29

    我们应该从2条路径中选择路径短的。

    在上面的第1条路径中, f ( 5 ) f(5) f(5)还是未知的,我们要求 f ( 5 ) f(5) f(5),同理我们发现到结点⑤的路径有3条路径:

    • 从结点②—>结点⑤: f ( 5 ) = f ( 2 ) + 6.21 f(5)=f(2)+6.21 f(5)=f(2)+6.21
    • 从结点③—>结点⑤: f ( 5 ) = f ( 3 ) + 2.52 f(5)=f(3)+2.52 f(5)=f(3)+2.52
    • 从结点④—>结点⑤: f ( 5 ) = f ( 4 ) + 20 f(5)=f(4)+20 f(5)=f(4)+20

    我们同样从3条路径中选择路径短的。以此类推,直到结点0,所有的路径值都可以算出来。我们维护一个列表来表示f(n)的各值:

    结点1234567
    f(n)202.525.7325.738.2512.511.46
    结点的上一个结点00

    第2行代表从起点0到该结点的最短路径的值,第3行代表在最短路径中的该节点的上一个结点。通过表,我们可以找到结点⑦的上一个结点⑤,结点⑤的上一个结点③,结点③的上一个结点②,结点②的上一个结点0,即路径:0—>②—>③—>⑤—>⑦

    python代码实现:

    # -*- coding: utf-8 -*-
    # Author    : 不凡不弃
    # Datetime  : 2020/5/27 0027 13:39
    # description   : 维特比算法(viterbi)
    import math
    import collections
    
    # 维特比算法(viterbi)
    def word_segmentation(text):
        ##################################################################################
        word_dictionaries = ["经常", "有", "意见", "意", "见", "有意见", "分歧", "分", "歧"]
        probability = {"经常": 0.08, "有": 0.04, "意见": 0.08, "意": 0.01, "见": 0.005, "有意见": 0.002, "分歧": 0.04, "分": 0.02,
                       "歧": 0.005}
        probability_ln = {key: -math.log(probability[key]) for key in probability}
    
        # 构造图的代码并没有实现,以下只是手工建立的图,为了说明 维特比算法
        ##################################################################################
    
        # 有向五环图,存储的格式:key是结点名,value是一个结点的所有上一个结点(以及边上的权重)
        graph = {
            0: {0: (0, "")},
            1: {0: (20, "经")},
            2: {0: (2.52, "经常"), 1: (20, "常")},
            3: {2: (3.21, "有")},
            4: {3: (20, "意")},
            5: {2: (6.21, "有意见"), 3: (2.52, "意见"), 4: (20, "见")},
            6: {5: (3.9, "分")},
            7: {5: (3.21, "分歧"), 6: (5.29, "歧")}
        }
        # 保存结点n的f(n)以及实现f(n)的上一个结点
        f = collections.OrderedDict()
    
        for key, value in graph.items():
            # 如果该节点的上一个结点还没有计算f(n),则直接比较大小;如果计算了f(n),则需要加上f(n)
            # 从该节点的所有上一个结点中选择f(n)值最小的
            min_temp = min((pre_node_value[0], pre_node_key) if pre_node_key not in f else (
                pre_node_value[0] + f[pre_node_key][0], pre_node_key) for pre_node_key, pre_node_value in value.items())
            f[key] = min_temp
    
        print(f)
        # 结果:OrderedDict([
        # (0, (0, 0)), (1, (20, 0)), (2, (2.52, 0)), (3, (5.73, 2)),
        # (4, (25.73, 3)), (5, (8.25, 3)), (6, (12.15, 5)), (7, (11.46, 5))
        # ])
    
        # 最后一个结点7
        last = next(reversed(f))
        # 第一个结点0
        first = next(iter(f))
        # 保存路径,最后一个结点先添入
        result = [last, ]
        # 最后一个结点的所有前一个结点
        pre_last = f[last]
    
        # 没到达第一个结点就一直循环
        while pre_last[1] is not first:
            # 加入一个路径结点X
            result.append(pre_last[1])
            # 定位到路径结点X的上一个结点
            pre_last = f[pre_last[1]]
        # 第一个结点添入
        result.append(first)
    
        print(result)
        # 结果:[7, 5, 3, 2, 0]
    
        text_result = []
        # 找到路径上边的词
        for i, num in enumerate(result):
            if i + 1 == len(result):
                break
            # print(i, num, result[i + 1])
            word = graph[num][result[i + 1]][1]
            # print(word)
            text_result.append(word)
        # 翻转一下
        text_result.reverse()
    
        return "".join(word + "/" for word in text_result)
    
    
    if __name__ == '__main__':
    
        content = "经常有意见分歧"
        word_segmentation_result = word_segmentation(content)
        print("word_segmentation_result:", word_segmentation_result)
    

    三、过滤词

    对于一个自然语言处理任务,我们通常先把停用词以及出现频率很低的词过滤掉。

    • 停用词,对于理解文章没有太大意义的词,比如"the"、“an”、“his”、“their”,但是,也需要考虑自己的应用场景,来决定过滤哪些停用词。停用词下载:链接:https://pan.baidu.com/s/1XRNPAAQIkaNO-8qb_DdctQ 提取码:86o0

    • 出现频率很低的词,比如1万个单词的文章里它只出现了一两次。

    如果不过滤掉它们,很可能对我们的语言模型产生负面的影响。

    四、单词和句子的表示

    词典:["我们","又","去","爬山","今天","你们","昨天","跑步"]
    

    假设我们有以上的一个词典,怎么用编码来唯一表示下面这几个词呢?
    我们 、爬山 、 跑步、 昨天

    4.1 one-hot编码

    one-hot编码的思想就是,查询词典,找到该词在词典中的位置,编码的时候将该位置写为1,其余位置写0。比如我们这样表示:

    我们爬山跑步昨天
    (1,0,0,0,0,0,0,0)(0,0,0,1,0,0,0,0)(0,0,0,0,0,0,0,1)(0,0,0,0,0,0,1,0)

    我们发现编码好的向量是一个8维的向量,即词典的大小(词典中有8个词)。

    怎么用编码来唯一表示下面这几个句子呢?

    • 我们 今天 去 爬山
    • 你们 昨天 跑步
    • 你们 又去 爬山 又去 跑步

    同样用one-hot思想,比如我们这样表示:

    我们 今天 去 爬山你们 昨天 跑步你们 又 去 爬山 又 去 跑步
    (1,0,1,1,1,0,0,0)(0,0,0,0,0,1,1,1)(0,1,1,1,0,1,0,1)

    我们发现编码好的向量仍是一个8维的向量,即词典的大小(词典中有8个词)。但是第三句话你们 又去 爬山 又去 跑步 只能标记一遍,且句子正确顺序没有表达出来。

    我们如果考虑次数如下:

    我们 今天 去 爬山你们 昨天 跑步你们 又 去 爬山 又 去 跑步
    (1,0,1,1,1,0,0,0)(0,0,0,0,0,1,1,1)(0,2,2,1,0,1,0,1)

    仍存在的问题:没有考虑语义,看不出来真正哪个词的重要性高,也就是说并不是出现的越多就越重要,并不是出现的越少越不重要。接下来的tf-idf解决这个问题。

    4.2 TF-IDF

    tf-idf公式: t f i d f ( w ) = t f ( d , w ) ∗ i d f ( w ) tfidf(w) = tf(d,w) * idf(w) tfidf(w)=tf(d,w)idf(w)

    • t f i d f ( w ) tfidf(w) tfidf(w)代表词 w w w在当前文档(句子)的重要性
    • t f ( d , w ) tf(d,w) tf(d,w)代表文档(句子) d 中 w d中w dw的词频,跟上一步一样,考虑了次数。
    • i d f ( w ) idf(w) idf(w)则是考虑单词的重要性,大致思想就是,有些单词,它在很多的文档(句子)中都会出现,比如he、the、a、here,一旦一些词在每个文档(句子)中都出现,我们反而不觉得它重要;相反,如果一个词没有在其他文档(句子)中出现,却在当前文档(句子)中出现,说明它在当前文档(句子)中的重要性是比较大的。 i d f ( w ) idf(w) idf(w)展开就是:

    i d f ( w ) = l n N N ( w ) idf(w) = ln\frac{N}{N(w)} idf(w)=lnN(w)N
    N N N代表语料中的文档(句子)总数, N ( w ) N(w) N(w)代表词 w w w出现在多少个文档(句子)中。比如有100个文档(句子), N = 100 N = 100 N=100,词 w w w在10个文档(句子)中出现, N ( w ) = 10 N(w) = 10 N(w)=10,则 i d f ( w ) = l n 10 idf(w) = ln10 idf(w)=ln10。也就是说词 w w w出现的文档(句子)数越少,词 w w w在该文档(句子)的重要性越大。

    词典:["我们","又","去","爬山","今天","你们","昨天","跑步"]
    

    怎么用 t f i d f ( w ) tfidf(w) tfidf(w)来表示下面这几个句子呢?

    • 我们 今天 去 爬山
    • 你们 昨天 跑步
    • 你们 又 去 爬山 又 去 跑步

    我们可以表示如下:

    我们 今天 去 爬山你们 昨天 跑步你们 又 去 爬山 又 去 跑步
    ( l n 3 , 0 , l n 3 2 , l n 3 2 , l n 3 , 0 , 0 , 0 ln3,0,ln\frac{3}{2},ln\frac{3}{2},ln3,0,0,0 ln3,0,ln23,ln23,ln3,0,0,0)( 0 , 0 , 0 , 0 , 0 , l n 3 2 , l n 3 , l n 3 2 0,0,0,0,0,ln\frac{3}{2},ln3,ln\frac{3}{2} 0,0,0,0,0,ln23,ln3,ln23)( 0 , 2 l n 3 , 2 l n 3 2 , l n 3 2 , 0 , l n 3 2 , 0 , l n 3 2 0,2ln3,2ln\frac{3}{2},ln\frac{3}{2},0,ln\frac{3}{2},0,ln\frac{3}{2} 0,2ln3,2ln23,ln23,0,ln23,0,ln23)
    存在的问题

    以上的两个表示方法one-hot编码和TF-IDF,存在2个缺点:

    • 词与词之间的相似度表达不出来
    我们爬山跑步昨天
    (1,0,0,0,0,0,0,0)(0,0,0,1,0,0,0,0)(0,0,0,0,0,0,0,1)(0,0,0,0,0,0,1,0)

    通过5.1 欧式距离公式,我们算得以上两两单词之前的相似度都是 2 \sqrt{2} 2 ,通过5.2 余弦相似度公式,算得以上两两单词之前的相似度都是 0 0 0,这显然都不符合实际情况

    • 向量维度太高,如果词典中有1万个单词,则一个单词的向量维度就是1万

    接下来的分布式表示方法词向量解决这2个问题

    4.3 词向量(Word embedding)

    如图,我们可以将8维的one-hot编码转变为4维的词向量:
    one-hot转词向量
    词向量的每一位上都有一个非零的数,我们再通过5.1 欧式距离公式,算得:
    d ( 我 们 , 爬 山 ) = 0.12 d_{(我们,爬山)} = \sqrt{0.12} d(,)=0.12
    词向量并不像之前的one-hot编码和TF-IDF可以直接简单的计算出来,它是需要深度学习模型来训练出来的,如图:

    五、句子的相似度(Sentence similarity)

    5.1 欧式距离

    欧式距离公式: d = ∣ s 1 − s 2 ∣ d = |s_{1} - s_{2}| d=s1s2

    其中 d d d代表两个句子之间的距离,距离越小,代表两个句子的相似度越高, s 1 s_{1} s1 s 2 s_{2} s2分别代表两个句子的向量。

    如果 s 1 = ( x 1 , x 2 , x 3 ) 、 s 2 = ( y 1 , y 2 , y 3 ) s_{1}=(x_{1},x_{2},x_{3}) 、s_{2}=(y_{1},y_{2},y_{3}) s1=(x1,x2,x3)s2=(y1,y2,y3),则
    d = ( x 1 − y 1 ) 2 + ( x 2 − y 2 ) 2 + ( x 3 − y 3 ) 2 d = \sqrt{(x_{1}-y_{1})^2+(x_{2}-y_{2})^2+(x_{3}-y_{3})^2} d=(x1y1)2+(x2y2)2+(x3y3)2

    • s 1 s_{1} s1:“我们今天去爬山” = (1,0,1,1,1,0,0,0)
    • s 2 s_{2} s2:“你们昨天跑步” = (0,0,0,0,0,1,1,1)
    • s 3 s_{3} s3:“你们又去爬山又去跑步” = (0,2,2,1,0,1,0,1)

    s 1 s_{1} s1 s 2 s_{2} s2的距离: d ( s 1 , s 2 ) = 1 + 0 + 1 + 1 + 1 + 1 + 1 + 1 = 7 d(s_{1},s_{2})=\sqrt{1+0+1+1+1+1+1+1}=\sqrt{7} d(s1,s2)=1+0+1+1+1+1+1+1 =7

    s 1 s_{1} s1 s 3 s_{3} s3的距离: d ( s 1 , s 3 ) = 1 + 4 + 1 + 0 + 1 + 1 + 0 + 1 = 9 d(s_{1},s_{3})=\sqrt{1+4+1+0+1+1+0+1}=\sqrt{9} d(s1,s3)=1+4+1+0+1+1+0+1 =9

    s 2 s_{2} s2 s 3 s_{3} s3的距离: d ( s 2 , s 3 ) = 0 + 4 + 4 + 1 + 0 + 0 + 1 + 0 = 10 d(s_{2},s_{3})=\sqrt{0+4+4+1+0+0+1+0}=\sqrt{10} d(s2,s3)=0+4+4+1+0+0+1+0 =10

    则我们认为 s 1 s_{1} s1 s 2 s_{2} s2的相似度最高,即 s i m ( s 1 , s 2 ) > s i m ( s 1 , s 3 ) > s i m ( s 2 , s 3 ) sim(s_{1},s_{2})>sim(s_{1},s_{3})>sim(s_{2},s_{3}) sim(s1,s2)>sim(s1,s3)>sim(s2,s3)

    欧式距离只考虑了向量的大小,并没有考虑向量的方向,余弦相似度则考虑了方向。

    5.2 余弦相似度(Cosine similarity)

    余弦相似度公式: d = s 1 ⋅ s 2 ∣ s 1 ∣ ∗ ∣ s 2 ∣ d = \frac{s_{1}·s_{2}}{|s_{1}|*|s_{2}|} d=s1s2s1s2

    其中 s 1 ⋅ s 2 s_{1}·s_{2} s1s2代表两个向量的内积, ∣ s 1 ∣ ∗ ∣ s 2 ∣ |s_{1}|*|s_{2}| s1s2代表两个向量距离的乘积。d越大,相似度越大,与欧式距离是相反的。

    如果 s 1 = ( x 1 , x 2 , x 3 ) 、 s 2 = ( y 1 , y 2 , y 3 ) s_{1}=(x_{1},x_{2},x_{3}) 、s_{2}=(y_{1},y_{2},y_{3}) s1=(x1,x2,x3)s2=(y1,y2,y3),则
    d = x 1 y 1 + x 2 y 2 + x 3 y 3 x 1 2 + x 2 2 + x 3 2 ∗ y 1 2 + y 2 2 + y 3 2 d = \frac{x_{1}y_{1}+x_{2}y_{2}+x_{3}y_{3}}{\sqrt{x_{1}^2+x_{2}^2+x_{3}^2}*\sqrt{y_{1}^2+y_{2}^2+y_{3}^2}} d=x12+x22+x32 y12+y22+y32 x1y1+x2y2+x3y3

    • s 1 s_{1} s1:“我们今天去爬山” = (1,0,1,1,1,0,0,0)
    • s 2 s_{2} s2:“你们昨天跑步” = (0,0,0,0,0,1,1,1)
    • s 3 s_{3} s3:“你们又去爬山又去跑步” = (0,2,2,1,0,1,0,1)

    s 1 s_{1} s1 s 2 s_{2} s2的相似度: d ( s 1 , s 2 ) = 0 d(s_{1},s_{2})=0 d(s1,s2)=0

    s 1 s_{1} s1 s 3 s_{3} s3的相似度: d ( s 1 , s 3 ) = 2 + 1 2 ∗ 11 d(s_{1},s_{3})=\frac{2+1}{2*\sqrt{11}} d(s1,s3)=211 2+1

    s 2 s_{2} s2 s 3 s_{3} s3的相似度: d ( s 2 , s 3 ) = 2 3 ∗ 11 d(s_{2},s_{3})=\frac{2}{\sqrt{3}*\sqrt{11}} d(s2,s3)=3 11 2

    则我们认为 s 1 s_{1} s1 s 3 s_{3} s3的相似度最高,即 s i m ( s 1 , s 3 ) > s i m ( s 2 , s 3 ) > s i m ( s 1 , s 2 ) sim(s_{1},s_{3})>sim(s_{2},s_{3})>sim(s_{1},s_{2}) sim(s1,s3)>sim(s2,s3)>sim(s1,s2)

    展开全文
  • 自然语言处理毕业自然语言处理毕业项目学习资料
  • ChineseNLPcorpus An collection of Chinese nlp corpus including basic Chinese syntactic wordset, ... 中文自然语言处理的语料集合,包括语义词、领域共时、历时语料库、评测语料库等。本项目简单谈谈自己对语...

    ChineseNLPcorpus

    An collection of Chinese nlp corpus including basic Chinese syntactic wordset, semantic wordset, historic corpus and evaluate corpus. 中文自然语言处理的语料集合,包括语义词、领域共时、历时语料库、评测语料库等。本项目简单谈谈自己对语言资源的感想以及目前自己进行语言资源构建的现状。
    项目地址:https://github.com/liuhuanyong/ChineseNLPCorpus

    介绍

      语言资源,本身是一个宽泛的概念,即语言+资源,语言指的是资源的限定域,资源=资+源,是资料的来源或者汇总,加在一起,也就形成了这样一种界定:任何语言单位形成的集合,都可以称为语言资源。语言资源是自然语言处理任务中的一个必不可少的组成部分,一方面语言资源是相关语言处理任务的支撑,为语言处理任务提供先验知识进行辅助,另一方面,语言处理任务也为语言资源提出了需求,并能够对语言资源的搭建、扩充起到技术性的支持作用。因此,随着自然语言处理技术的不断发展,自然语言处理需求在各个领域的不断扩张、应用,相关语言资源的构建占据了越来越为重要的地位。作者硕士期间所在的研究机构为国家语言资源监测与研究平面媒体中心,深受导师所传授的语言资源观熏陶,并在实际的学习、工作过程中,动手实践,形成了自己的一些浅薄的语言资源认识,现在写出来,供大家一起讨论,主要介绍一些自己对语言资源的搜索,搭建过程中的一些心得以及自己目前在语言资源建设上的一些工作。

    语言资源的分类

      介绍中说到,任何语言单位的集合都可以称为语言资源,比如我有一个个人的口头禅集合,这个就可以称为一个语言资源库,在你实际生活中进行言语活动时,你其实就在使用这个语言资源库。再比如说,一个班级中的学生名单,其实也可以当作是一种语言资源,这个语言资源在进行班级学生点名、考核的时候也大有帮助。当然,此处所讨论的语言资源是从自然语言处理应用的角度上出发的。总的来说,我把它归为以下两种类型:
    1、领域语料库
      领域语料库,是从语料的这个角度来讲的,这里的语料,界定成文本级别(以自然语句为基础级别形成的文本集合,即可以是句子、段落、篇章等)。领域语料库,可以根据不同的划分规则而形成不同的语料类别:
      1)根据所属领域,可以进一步细化成不同领域的语料库。包括金融领域语料、医药领域语料、教育领域语料、文学领域语料等等。
      2)根据所属目的,可以进一步细化为:评测语料(为自然语言处理技术pk而人工构造的一些评测语料,如ACE,MUC等国际评测中所出现的如semeval2014,snli等);工具语料(指供自然语言处理技术提供资源支撑的语料)
      3)根据语料加工程度的不同,可进一步分为:熟语料(指在自然语言单位上添加人工的标签标注,如经过分词、词性标注、命名实体识别、依存句法标注形成的语料),生语料(指直接收集而未经加工形成的语言资源集,如常见的微博语料,新闻语料等)
      4)根据语料语种的不同,可进一步分为:单语语料和多语语料,多语语料指的是平行语料,常见于机器翻译任务中的双语对齐语料(汉-阿平行语料库,汉-英平行语料库)等。
      5)根据语料规模的不同,可以进一步分为:小型语料库,中型语料库,大型语料库。至于小型、中型、大型的界定,可根据实际领域语料的规模而动态调整
    2、领域词库
      领域词库,指以句级以下语言单位形成的语言资源库,这个层级的语言单位可以是笔画、偏旁部首、字、词、短语等。同样的,领域词库也可以进一步细分。
      1)领域特征词库。这里所说的领域特征词库,指的是与领域强相关,具有领域区别能力形成的词语集合,如体育领域中常见的“篮球”、“足球”等词,文学领域常见的“令狐冲”、“鲁迅”等词,又如敏感词库等,这些词常常可作为分类特征而存在。
      2)语法语义词库。语义词库的侧重点在与语言的语法层面和语义层面:
      a)语法词库:北大的语法信息词典,北大的实体概念词典、Hownet语义词典这三类词典,这几个语法词库,在对词的语法功能上都做了不同的工作,对词的内部结构信息进行了详细的标注,如北大的语法信息词典,以词类为划分标准讲汉语的常用词进行了划分,并对词性、搭配(前接成分和后接成分)进行了详细的标注;Hownet语义词典从义项的角度对词的义元进行了分解和注释。
      b)语义词库:这类语义词,侧重点不在词语的内部语法结构,而在词语的整体语义上。这类词库,常见的词库有哈工大发布的同义词词林扩展版,这个词库将同义词按照语义的相近程度进行了不同层次的聚类,可以作为同义词扩展提供帮助。另一个是情感分析任务中常用的情感词典,这类词典主要公开的词典包括大连理工大学信息检索实验室公开的情感本体词库、hownet、香港中文大学、台湾清华大学公开的情感词库(具体包括情感词库、否定词库、强度词库)等。另外,工业界,有boson公开的微博情感词库(词的规模比较大,但标注信息不是很精准)。还有的,则是中文的反义词库等,这个可以参考我的github项目,里面对这些词库也有一些涉及。

    语言资源的问题

      语言资源的搭建,指的是语言资源的整个搭建过程。其实是要解决四个问题,一个是语言资源的收集问题;二是语言资源的融合标准化问题;三是语言资源的动态更新问题;四是语言资源的共享与联盟问题。下面就这四点展开阐述:
      1、语言资源收集的问题。语言资源搜索过程中有三步走策略,在这个步骤完成之后,会得到一系列的词库。这些词库可能初期不会特别完善,往往还需要人工使用启发式规则进行人工去噪的工作。
      2,语言资源的融合标准化问题。通过不同方式收集起来的语言资源,往往会存在一个格式不对称的问题,这有点像知识图谱中的知识融合问题。因此,为了解决这个问题,我们通常需要制定一个标准化的语言资源格式,例如,在构建情感词表的过程当中,有的情感词表没有强度标记,有的强度值范围不一样,有的情感词表的标记不一,这个时候往往需要标准化,给定一个标准化的样式,再将不同来源的情感词按照这个标记做相应的调整。我在实际的工作过程中,常常把这种问题类别成知识图谱构建过程中的schema搭建问题,信息抽取过程中的slot-definition问题。先把规范和标准搭好,再去统一标准化。
      3,语言资源的动态更新问题。知识和信息的价值,在很大程度上都在于它的一种实时性,语言资源作为一种常识性知识库,能够保证自身的一种与时俱进,将能够最大限度地发挥自身的价值。而从实践的角度上来说,语言资源的动态更新,可以靠人工去维持,去动态及时更新,也可以建立一种动态监测和更新机制,让机器自动地去更新。这类其实可以参考知识图谱更新的相关工作。
      4,语言资源的共享与联盟问题。语言资源是否共享,其实是一个与业务敏感以及开源意识想结合的一种决策,有的资源因为某种业务敏感或者开源意识不够open而无法共享,当然还有其他因素成分在,不过,语言资源最好是需要共享的,这样能够最大力度的发挥语言资源在各个领域的应用。语言资源的联盟问题,更像是对开源语言资源的一种链接与互联。这类问题是对当前的资源零散、碎片化问题的一个思考,前面也说到,目前情感分析的词表有很多个,语法和语义词库也有很多个,但每个人在构建时的出发点不同,构建者也分布在不同的高校或机构当中,这些资源虽然在个数上会有增长,但随着时间的推移,这种零散化的现象将会越来越严重。

    语言资源的实践

    作者在学习和工作之余,根据语言资源搭建策略,构建起了语义词库、领域词库、领域语料库、评测语料库。种类约50种,具体如下:

    语义知识库

    类型名称介绍
    语义词库语法信息词典汉语词语的语法功能分类、词语的语法属性描述
    语义词库Hownet义原词典董振东老师研制,汉语词语义原分类
    语义词库程度副词词典表示程度的词
    语义词库现代汉语词典现代汉语词典, txt版本
    语义词库否定词词典对意义进行反转的词典
    语义词库同义词词林词典哈工大同义词词典
    语义词库反义词词典反义词词表,1.5W对
    语义词库同义词词典同义词词典,5.5W对
    语义词库schema概念词典互动百科概念体系,百度百科概念体系
    语义词库停用词自然语言处理用停用词词表

    领域词库

    类型名称介绍
    领域词库搜狗输入法领域词库超过1W个领域的搜狗输入法词库txt版本
    领域词库职位词典基于百万级拉钩JD网抽取形成的职位词典
    领域词库敏感词词词库敏感词词库,包括政治、反动等词
    领域词库情感词词库大连理工、知网、港中大、台大、boson等公开情感词典

    领域语料库

    类型名称介绍
    领域语料库人民日报标注语料1998年人民日报分词语料库
    领域语料库20类小说文本集合20个领域(武侠、恐怖等)小说集合,7K+小说文本
    领域语料库字幕网70W字幕文本语料字幕网字幕文件解析,70W字幕文本语料
    领域语料库内涵段子50W等语料基于内涵段子采集,50W短文本
    领域语料库歌词14W语料基于公开歌词网采集,14W首歌曲歌词
    领域语料库职位JD语料基于公开职位采集,213W职位jd
    领域语料库古诗词语料唐诗宋词语料集合,10W篇
    领域语料库相声剧本语料基于公开相声剧本网站采集,6K篇
    领域语料库中文维基百科语料中文简体版,98W篇
    领域语料库法务问答语料法务咨询问答对,22W
    领域语料库股票问答语料股票相关咨询问答对,10W
    领域语料库携程攻略50W携程攻略文本集,50W篇
    领域语料库法律案例语料17W17W法律案例语料,带案例标签
    领域语料库人民日报历时语料库1946-20031946-2003,133W篇
    领域语料库参考消息历时语料库1957-20021957-2002,57W篇
    领域语料库腾讯滚动新闻历时语料库2009-2016腾讯历时滚动新闻(13板块)
    领域语料库酒店评论语料酒店评论数据7K条
    领域语料库外卖点评语料外卖评论数据1.2W条
    领域语料库京东商品评论语料10类商品6W条
    领域语料库新浪微博情感语料正文及评论10W条
    领域语料库细粒度微博情感语料喜悦、愤怒、厌恶、低落等标签共36W条
    领域语料库电影评论语料电影评分评论语料,200W+条
    领域语料库餐馆点评语料餐馆点评语料,440W条
    领域语料库亚马逊商品评论语料亚马逊商品评论语料,720W条

    评测语料库

    类型名称介绍
    评测语料库问句匹配英文question相似问句6.5W对,中文微众银行问句集1000对
    评测语料库命名实体识别中文电子病历命名实体识别、微软MSR命名实体识别5W条
    评测语料库情感分析斯坦福sentibank
    评测语料库实体关系抽取中文人物关系数据集、英文SEMEVAL2008评测数据集(NYT,NYTfilter)
    评测语料库文本蕴含英文snli,multinli数据集116W,中文文本蕴含数据集100W
    评测语料库音乐问句解析音乐问句解析数据集1.2W
    评测语料库幽默计算中文幽默计算数据集(幽默类型、幽默等级、隐喻类型、隐喻等级分类等)
    评测语料库阅读理解squad数据集
    评测语料库知识图谱补全知识图谱链接数据集(FB15K, FB40K, Freebase, WN18,WordNet)
    评测语料库中文实体链接基于中文百科知识的实体链接数据集1.3K
    评测语料库中文自动问答中文智能问答数据集,两个任务(问句意图分类,航空、酒店、火车客服问答)
    评测语料库中文罪行分类法律智能评测数据集,288W

    总结

    1、本项目阐述了语言资源的相关感想,并给出了目前语言资源的构建现状,目前为止收集了四个大类共50小类的语言资源数据集。
    2、本项目中所涉及到的报告内容均来源于网上公开资源,对此免责声明。
    3、如果有需要用到以上作者收集到的这些语料库,可以联系作者获取。
    4、自然语言处理,是人工智能皇冠上的一颗明珠,懂语言者得天下,语言资源在自然语言处理中扮演着举足轻重的作用,懂语言资源者,分得天下。目前开放的网络环境,对语言资源的大繁荣提供了很大的契机。语言资源构建是一门学问,也是一种手段,现在自然语言处理技术也对语言资源的构建提供了技术上的支持,如何把握语言资源搜索策略,搭建策略,重点解决语言资源的动态更新、共享与联盟问题,将是语言资源建设未来需要解决的问题。

    本项目地址:https://github.com/liuhuanyong/ChineseNLPCorpus

    如有自然语言处理、知识图谱、事理图谱、社会计算、语言资源建设等问题或合作,可联系我:
    1、我的github项目介绍:https://liuhuanyong.github.io
    2、我的csdn博客:https://blog.csdn.net/lhy2014
    3、刘焕勇,中国科学院软件研究所,lhy_in_blcu@126.com

    展开全文
  • AI工程师-自然语言处理实战课程旨在用最接地气的方式讲解复杂的算法原理,基于真实数据集,通过实际案例进行项目实战。整个体系内容包括200+课时,20个项目实战,完美覆盖当下热门技术与经典框架实战。学习路线主要...
  • PyTorch起源 Facebook人工智能研究(FAIR)2017年Github开源 PyTorch VS TensorFlow Pytorch 简洁 动态计算 visdom 部署不方便 TensorFlow 接口复杂 静态图(TF2.0 已经引入动态图) Tensorbord ......

    PyTorch起源

    Facebook人工智能研究(FAIR)2017年Github开源

    PyTorch VS TensorFlow

    Pytorch
    • 简洁
    • 动态计算
    • visdom
    • 部署不方便
    TensorFlow
    • 接口复杂
    • 静态图(TF2.0 已经引入动态图)
    • Tensorbord
    • 部署方便(TF serving)

    静态图与动态图

    • 动态图:编号程序即可执行
    • 静态图:先搭建计算图。后运行。(代码复杂,调试不直观)
    静态图

    在这里插入图片描述

    动态图在这里插入图片描述
    展开全文
  • 1.1什么是pytorch pytorch是一个基于Numpy的科学计算包,向他的使用者提供两大功能 作为numpy的替代者,向用户提供GPU强大功能的能力; 作为一款深度学习的平台,向用户提供最大的灵活性和速度 ...
  • 本文作者为自然语言处理NLP初学者整理了一份庞大的自然语言处理项目领域的概览,包括了很多人工智能应用程序。选取的参考文献与资料都侧重于最新的深度学习研究成果。这些自然语言处理项目资源能为想要深入钻研一个...
  • NLP入门+实战必读,一文可以教会你最常见的10种自然语言处理技术(附代码)电子版
  • github https://github.com/sea-boat/nlp_lab nlp_lab some code about nlp. doc2txt tf-idf cnn text classify hmm cws crf ner
  • 一个简单的自然语言处理例子

    千次阅读 2018-09-20 21:30:43
    例子是我学习的教程的一个例子,收集了一些客户对于饭店的评价,目标是将他们进行分类,分成好评和差评。...NLTK是一个高效的Python构建的平台,用来处理人类自然语言数据。它提供了易于使用的接口...
  • 精通Python自然语言处理 用Python开发令人惊讶的NLP项目 自然语言处理任务 掌握利用Python设计和构建给予NLP的应用的实践
  • CS11-711高级自然语言处理(在卡耐基梅隆大学的语言技术研究所)是一门自然语言处理的入门级研究生课程,目标是有兴趣在该领域进行前沿研究的学生。其中,我们描述了自然语言处理的基本任务,如句法、语义和篇章分析,...
  • 什么是自然语言处理(NLP)?

    千次阅读 2021-02-23 15:19:02
    什么是自然语言处理(NLP)? 你有没有和聊天机器人互动过?或者你是否向虚拟助手,例如Siri、Alexa或你车上的车载娱乐系统发出过某些请求?你使用过在线翻译吗?相信我们绝大多数人都与这些人工智能互动过,人类不断...
  • 自然语言处理实战 TextCNN文本分类

    千人学习 2020-06-26 17:47:20
    适用人群 (1)想要从事NLP的在校学生、NLP研发工程师 (2)自然语言处理从业者、深度学习爱好者 课程简介 短文本分类作为自然语言处理的基础技术之一NLP领域的热门应用,常用在对话语言平台,文章分类,智能客服,FAQ...
  • 自然语言处理(NLP)学习路线总结

    万次阅读 多人点赞 2019-03-20 21:01:53
    自然语言处理概述 自然语言处理入门基础 自然语言处理的主要技术范畴 自然语言处理基本点 特征处理 模型选择 NLP常用工具 NLP语言模型 快速入门NLP方法 自然语言处理...
  • 通俗讲解BERT模型中所涉及的核心知识点(Transformer,self-attention等),基于google开源BERT项目从零开始讲解如何搭建自然语言处理通用框架,通过debug源码详细解读其中每一核心代码模块的功能与作用。
  • AI工程师-自然语言处理实战课程旨在用最接地气的方式讲解复杂的算法原理,基于真实数据集,通过实际案例进行项目实战。 整个体系内容包括200+课时,20个项目实战,完美覆盖当下热门技术与经典框架实战。 学习路线...
  • AI工程师-自然语言处理实战课程旨在用最接地气的方式讲解复杂的算法原理,基于真实数据集,通过实际案例进行项目实战。整个体系内容包括200+课时,20个项目实战,完美覆盖当下热门技术与经典框架实战。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 162,311
精华内容 64,924
关键字:

自然语言处理项目