精华内容
下载资源
问答
  • 由于要打包成exe的关系,我将原本项目多一个文件集成到一个python文件(合并文件)里,只保留了使用该系统所需要函数,方便打包,通俗地讲就是,生成生成词向量过程,装袋过程,模型训练过程,以及一些...
  • 然后,该模型可以使用已经正确标注好词性的句子进行训练,从而识别由该字典中其他词组成的新句子中所有词的词性。NLTK 和 spaCy 都具备词性标注功能。我们在这里使用 spaCy,因为它更快、更精确。另外词性标注允许...

    词性(POS)标注可以使用语言模型来完成,这个语言模型包含词及其所有可能词性组成的字典。然后,该模型可以使用已经正确标注好词性的句子进行训练,从而识别由该字典中其他词组成的新句子中所有词的词性。NLTK 和 spaCy 都具备词性标注功能。我们在这里使用 spaCy,因为它更快、更精确。另外词性标注允许提取一个句子中实体之间的关系。

    import spacy
    import en_core_web_md
    from spacy.displacy import render
    import pandas as pd
    from collections import OrderedDict
    from spacy.matcher import Matcher
    
    en_model = en_core_web_md.load()
    sentence = ("In 1541, Desoto met the Pascagoula, Desoto wrote in his journal that the Pascagoula people " +
                    "ranged as far north as the confluence of the Leaf and Chickasawhay rivers at 30.4, -88.5.")
    parsed_sent = en_model(sentence)
    print(parsed_sent)
    # spaCy 没有识别出纬度/经度对中的经度
    print(parsed_sent.ents)
    # spaCy 使用了“OntoNotes 5”词性标注标签体系
    print(' '.join(['{}_{}'.format(tok, tok.tag_) for tok in parsed_sent]))
    
    # 可视化依存树
    # spaCy 解析的句子还包含嵌套字典表示的依存树
    # render():
    #   docs (list or Doc):可视化的文档。
    #   page (bool):将标记呈现为完整的HTML页面。
    #   options (dict):特定于Visualiser的选项,例如 颜色。
    with open('pascagoula.html', 'w') as f:
        f.write(render(docs=parsed_sent, page=True, options=dict(compact=True)))
    
    # 以表格形式列出所有的词条标签
    def token_dict(token):
        ordered_dict = OrderedDict(ORTH=token.orth_, LEMMA=token.lemma_,
                    POS=token.pos_, TAG=token.tag_, DEP=token.dep_)
        return ordered_dict
    
    def doc_dataframe(doc):
        return pd.DataFrame([token_dict(tok) for tok in doc])
    
    print(doc_dataframe(parsed_sent))
    
    # 示例 spaCy 词性标注模式
    '''
        一个模式由一个或多个`token_specs`组成,其中`token_spec`
        是将属性ID映射到值的字典,并且可以选择
        关键字“ op”下的量词运算符。可用的量词是:
        
        '!':通过要求精确匹配0次来求反。
        '?':允许模式匹配0或1次,从而使其成为可选模式。
        '+':要求模式匹配1次或多次。
        '*':允许模式零次或多次。
    '''
    pattern = [{'TAG': 'NNP', 'OP': '+'}, {'IS_ALPHA': True, 'OP': '*'},
                {'LEMMA': 'meet'}, {'IS_ALPHA': True, 'OP': '*'}, {'TAG': 'NNP', 'OP': '+'}]
    
    # 用 spaCy 创建词性标注模式匹配器
    matcher = Matcher(en_model.vocab)
    # 将匹配规则添加到匹配器
    '''
        key (unicode):匹配ID。
        patterns (list):为给定键添加的模式。
        on_match (callable):匹配时执行的可选回调。
    '''
    matcher.add('met', None, pattern)
    # print(help(matcher.add))
    m = matcher(parsed_sent)
    print(m)
    print(parsed_sent[m[0][1]:m[0][2]])
    print('+' * 50)
    
    # 使用词性标注模式匹配器看看对于维基百科中类似句子的效果
    doc = en_model("October 24: Lewis and Clark met their first Mandan Chief, Big White.")
    m = matcher(doc)
    print(m)
    print(doc[m[0][1]:m[0][2]])
    print('+' * 50)
    doc = en_model("On 11 October 1986, Gorbachev and Reagan met at a house.")
    m = matcher(doc)
    print(m)
    print('+' * 50)
    
    # 组合多个模式得到更鲁棒的模式匹配器
    # 再添加一个模式,允许动词在主语和宾语名词之后出现
    doc = en_model("On 11 October 1986, Gorbachev and Reagan met at a house, Clark met their first Mandan Chief.")
    pattern2 = [{'TAG': 'NNP', 'OP': '+'}, {'LEMMA': 'and'}, {'TAG': 'NNP', 'OP': '+'},
                {'IS_ALPHA': True, 'OP': '*'}, {'LEMMA': 'meet'}]
    # 在不删除前一个模式的情况下添加另一个模式
    matcher.add('met2', None, pattern2)
    m = matcher(doc)
    print(m)
    # 最长的匹配是匹配列表中的最后一个
    for i in range(len(m)):
        print(doc[m[i][1]:m[i][2]])
    
    展开全文
  • 清华大学thulac中分分词词法包,包含有中文分词和词性标注,从测试精度和速度看,效果还不错,github上有提供c++和python代码,c++代码包含有训练和测试代码,python代码只有测试代码,速度也较慢,github地址为:...

         清华大学的thulac中分分词词法包,包含有中文分词和词性标注,从测试精度和速度看,效果还不错,github上有提供c++和python代码,c++代码包含有训练和测试代码,python代码只有测试代码,速度也较慢,github地址为:https://github.com/thunlp/THULAC。

         根据github上提出的参考文献,完全无法看懂代码和文章有什么关系,代码也比较难以理解,因此在记录一下自己对于代码分词原理的理解,希望对于后续研究的人有些帮助。

          认真的研究了一下c++代码,发现thulac代码与基于压缩感知机原理的中文分词类似,同样采用来7个特征,首先对于输入文本,生成所有字的特征,同时初始化一个dat数组,一个特征权重数组fl_weights,fl_weights大小语总的特征数目相等,即每个特征对于于fl_weights的一个权重值,dat为特征在fl_weights中对于的权重的索引,即我们要查找某个特征featurefl_weights对于的权重,首先需要查找datfeature对于的索引index,得到index后我们便可以得到feature对于的权重为fl_weights[index]。那么dat是怎么索引的呢,如果总的features个数为N,那么dat的大小也要为N,当通常随着训练数据的增大,生成的特征数目也会很大,这dat就需要花费很大的内存,那么thulac中是怎么做的呢?

           首先说一下压缩感知机算法中特征的生成,对于输入句子s中的每个字wi,会根据其前后2个字生成7个特征,这7个特征分别为wi-2wi-1,wi-1wi-1wi,wi,wiwi+1wi+1,wi+1wi+2Thulac中在这7个特征后面添加了一个separator=’ ’即空格;对于分词,我们需要预测每个字属于BMES的权重,因此,最后需要生成每个特征对于于BMES的特征,所以对每个句子中的每个字实际会生成7×4=28个特征。关于thulac中特征生成C++代码如下:

    inline void feature_generation(RawSentence& seq,
                    Indexer<RawSentence>& indexer,
                    Counter<Word>* bigram_counter=NULL){
            int mid=0;
            int left=0;int left2=0;
            int right=0;int right2=0;
            RawSentence key;
            RawSentence bigram;
            for(int i=0;i<seq.size();i++){
                mid=seq[i];
                left=(i>0)?(seq[i-1]):(SENTENCE_BOUNDARY);
                left2=((i-2)>=0)?(seq[i-2]):(SENTENCE_BOUNDARY);
                right=((i+1)<seq.size())?(seq[i+1]):(SENTENCE_BOUNDARY);
                right2=((i+2)<seq.size())?(seq[i+2]):(SENTENCE_BOUNDARY);
                
                if(bigram_counter){
                    if(i==0){
                        bigram.clear();
                        bigram.push_back(left2);bigram.push_back(left);
                        bigram_counter->update(bigram);
                        bigram.clear();
                        bigram.push_back(left);bigram.push_back(mid);
                        bigram_counter->update(bigram);
                        bigram.clear();
                        bigram.push_back(mid);bigram.push_back(right);
                        bigram_counter->update(bigram);
                    }else{
                        bigram.clear();
                        bigram.push_back(right);bigram.push_back(right2);
                        bigram_counter->update(bigram);
                    }
                }
                
                key.clear();
                key.push_back(mid);key.push_back(SEPERATOR);key.push_back('1');
                indexer.get_index(key);//indexer.dict为push(key),即最后一个放进indexer的key为indexer.dict[0],indexer.list则相反,最后一个key=indexer.list[-1]
                key.clear();
                key.push_back(left);key.push_back(SEPERATOR);key.push_back('2');
                indexer.get_index(key);//indexer保存的为特征的索引值,indexer[i]={ , , }
                key.clear();
                key.push_back(right);key.push_back(SEPERATOR);key.push_back('3');
                indexer.get_index(key);
                
                key.clear();
                key.push_back(left);key.push_back(mid);key.push_back(SEPERATOR);key.push_back('1');
                indexer.get_index(key);
                key.clear();
                key.push_back(mid);key.push_back(right);key.push_back(SEPERATOR);key.push_back('2');
                indexer.get_index(key);
                key.clear();
                key.push_back(left2);key.push_back(left);key.push_back(SEPERATOR);key.push_back('3');
                indexer.get_index(key);
                key.clear();
                key.push_back(right);key.push_back(right2);key.push_back(SEPERATOR);key.push_back('4');
                indexer.get_index(key);
            }
        };

           代码中key用于提取每个特征,并将所有特征保存到indexer

    接下来讲一下dat的生成,我们知道,对于所有的特征,其中有某些特征的第一项或这前两项是相同的,例如总的特征数为N,其中有M个特征的第一项是相同的,那么我们就可以用dat的前M个元素保存这M个特征的第一项,接下来查找第一项相同的情况下,第二项相同的项保存到dat,dat生成的具体代码实现如下:

     void make_dat(std::vector<KeyValue>& lexicon,int no_prefix=0){
            std::sort(lexicon.begin(),lexicon.end(),&compare_words);
    
            int size=(int)lexicon.size();
            std::vector<int> children;
            Word prefix;
            prefix.clear();
            gen_children(lexicon,0,prefix,children);//第一个字的特征children
            int base=assign(0,children,true);//给dat复制
            dat[0].base=base;
            for(int i=0;i<(int)lexicon.size();i++){
                Word& word=lexicon[i].key;
                //std::cout<<word<<"\n";
                //std::cout.flush();
                int off=get_info(word);
                if(off<=0)off=(int)word.size();
                for(int offset=off;offset<=(int)word.size();offset++){
                    prefix.clear();
                    for(int j=0;j<offset;j++)prefix.push_back(word[j]);
                    int p_base=-get_info(prefix);
                    
                    gen_children(lexicon,i,prefix,children);
                    int base=assign(p_base,children,offset==(int)word.size());
                }
                off=-get_info(word);
                if(no_prefix){
                    dat[off].base=lexicon[i].value;
                }else{
                    dat[dat[off].base].base=lexicon[i].value;
                }
    			/*
                if(i&&(i%100000==0)){
                    printf("%f\r",(double)i/size);
                    std::cout.flush();
                }
    			*/
            }
    
        }

           得到dat后,那么对于输入句子查找中每个字对应的特征索引,对于只含有一个字的特征的索引保存在uni_base,相邻两个字的特征对应索引保存在bi_base,,例如对于相邻两个字ch1,ch2uni_base,bi_base特征为uni_base[ch1]=dat[ch1].base+separatorbi_base[ch1ch2]=dat[dat[ch1].base+ch2]+separator

    此部分代码如下:

    /*
         * 找出以ch1 ch2为字符的dat的下标
         * */
        inline void find_bases(int dat_size,int ch1,int ch2,int& uni_base,int&bi_base){
            if(ch1>32 &&ch1<128)ch1+=65248;//对于标点符号,数字、中英文字符,其indx为ascii码+65248
            if(ch2>32 &&ch2<128)ch2+=65248;
            if(dat[ch1].check){
                uni_base=-1;bi_base=-1;return;//如果dat[ch1].check=1,则不匹配,返回为uni_base=-1
            }
            uni_base=dat[ch1].base+SEPERATOR;//uni_base为dat[ch1].base+空格
            int ind=dat[ch1].base+ch2;
            if(ind>=dat_size||dat[ind].check!=ch1){
                bi_base=-1;return;
            }
            bi_base=dat[ind].base+SEPERATOR;
        }

           得到特征索引后,便可以通过索引uni_base,bi_base查找特征矩阵分类fl_weights中每个特征对应的权重,之后通过解码得到预测标签,

    Dp代码如下:

    /** The DP algorithm(s) for path labeling */
    inline int dp_decode(
            int l_size,///标签个数
            int* ll_weights,///标签间权重
            int node_count,///节点个数
            Node* nodes,///节点数据
            int* values,///value for i-th node with j-th label
            Alpha_Beta* alphas,///alpha value (and the pointer) for i-th node with j-th label
            int* result,
            int** pre_labels=NULL,///每种标签可能的前导标签(以-1结尾)
            int** allowed_label_lists=NULL///每个节点可能的标签列表
            ){
        //calculate alphas
        int node_id;
        int* p_node_id;
        int* p_pre_label;
        int* p_allowed_label;//指向当前字所有可能标签的数组的指针
        register int k;//当前字的前一个节点可能的标签(的编号)
        register int j;//当前字某一个可能的标签(的编号)
        register Alpha_Beta* tmp;
        Alpha_Beta best;best.node_id=-1;
        Alpha_Beta* pre_alpha;
        int score;
        
        for(int i=0;i<node_count*l_size;i++)alphas[i].node_id=-2;
        for(int i=0;i<node_count;i++){//for each node
            p_allowed_label=allowed_label_lists?allowed_label_lists[i]:NULL;
            j=-1;
            int max_value=0;
            int has_max_value=0;
            while((p_allowed_label?
                        ((j=(*(p_allowed_label++)))!=-1)://如果有指定,则按照列表来
                        ((++j)!=l_size))){//否则枚举
                if((!has_max_value) || (max_value<values[i*l_size+j])){
                    has_max_value=1;
                    max_value=values[i*l_size+j];
                }
            }
            p_allowed_label=allowed_label_lists?allowed_label_lists[i]:NULL;
            j=-1;
            while((p_allowed_label?//遍历寻找当前结点属于j标签的得分,找到最大的得分的j为当前结点的标签
                        ((j=(*(p_allowed_label++)))!=-1)://如果有指定,则按照列表来
                        ((++j)!=l_size))){//否则枚举
                //if(max_value-20000>values[i*l_size+j])continue;//
                tmp=&alphas[i*l_size+j];//当前的j标签
                tmp->value=0;
                p_node_id=nodes[i].predecessors;//取所有前继节点
                p_pre_label=pre_labels?pre_labels[j]:NULL;
                while((node_id=*(p_node_id++))>=0){//枚举前继节点,遍历所有的前向结点,结算前向结点转移到当前标签j的得分,去最大的得分
                    k=-1;
                    while(p_pre_label?
                            ((k=(*p_pre_label++))!=-1):
                            ((++k)!=l_size)
                            ){
                        pre_alpha=alphas+node_id*l_size+k;
                        if(pre_alpha->node_id==-2)continue;//not reachable
                        score=pre_alpha->value+ll_weights[k*l_size+j];//前一节结点转移得分等于前一个结点的得分+前一个标签转移到当前标签的得分
                        if((tmp->node_id<0)||(score>tmp->value)){//如果当前的结点id小于0或者当前的结点值小于score
                            tmp->value=score;
                            tmp->node_id=node_id;
                            tmp->label_id=k;
                        }
                    }
                }
                tmp->value+=values[i*l_size+j];//当前结点的值+当前结点的第j个标签对应的权重
                
                if((nodes[i].type==1)||(nodes[i].type==3))//如果当前结点的类型为1或3,则id=-1
                    tmp->node_id=-1;
                if(nodes[i].type>=0){
                    if((best.node_id==-1)||(best.value<tmp->value)){
                        best.value=tmp->value;
                        best.node_id=i;
                        best.label_id=j;
                    }
                }
            }
            //std::cout<<i<<" "<<best.value<<"\n";
        }
        //find the path and label the nodes of it.
        tmp=&best;//当前等于最大得分的结点
        while(tmp->node_id>=0){
            result[tmp->node_id]=tmp->label_id;//
            tmp=&(alphas[(tmp->node_id)*l_size+(tmp->label_id)]);
        }
        //debug
        /*(for(int i=0;i<node_count;i++){//for each node
            p_allowed_label=allowed_label_lists?allowed_label_lists[i]:NULL;   
            j=-1;
            std::cerr<<values[i*l_size+result[i]]<<" ";
            while((p_allowed_label?
                        ((j=(*(p_allowed_label++)))!=-1)://如果有指定,则按照列表来
                        ((++j)!=l_size))){//否则枚举
                tmp=&alphas[i*l_size+j];
                std::cerr<<values[i*l_size+j]<<" ";  
            }
            std::cerr<<"\n";
        }
        std::cerr<<"\n";*/
        //end of debug
        return best.value;
    };
    

            参数更新,压缩感知机中,预测值与输入值相等,则对应的特征权重+1,预测值语输入值不相等,则对应的特征权重-1;与压缩感知机中特征权重更新不同,thulac中,参数更新为对于所有的输入标签,其对应的特征的权重+1,对于所有的预测标签,其特征权重-1;此部分代码如下:

     //update
                this->ngram_feature->update_weights(sequence,len,gold_standard,1,steps);//更新每个特征对应的权重
                this->ngram_feature->update_weights(sequence,len,result,-1,steps);
                for(int i=0;i<len-1;i++){
                    this->model->update_ll_weight(gold_standard[i],gold_standard[i+1],1,steps);//更新状态转移矩阵
                    this->model->update_ll_weight(result[i],result[i+1],-1,steps);
           代码中,ll_weight为每个标签的状态转移矩阵。


    展开全文
  • 希望机器能像人一样去理解,以人类自然语言为载体的文本所包含的信息,并完成一些特定任务 内容中文分词、词性标注、命名实体识别、关系抽取、关键词提取、信息抽取、依存分析、词嵌入…… 应用篇章理解、文本摘要...

    1. NLP 走近自然语言处理

    概念
    Natural Language Processing/Understanding,自然语言处理/理解

    日常对话、办公写作、上网浏览

    希望机器能像人一样去理解,以人类自然语言为载体的文本所包含的信息,并完成一些特定任务

    内容
    中文分词、词性标注、命名实体识别、关系抽取、关键词提取、信息抽取、依存分析、词嵌入……

    应用
    篇章理解、文本摘要、情感分析、知识图谱、文本翻译、问答系统、聊天机器人……


    2. NLP 使用jieba分词处理文本,中文分词,关键词提取,词性标注

    https://github.com/fxsjy/jieba

    jieba:基于前缀词典进行词图扫描,构成全部可能分词结果的有向无环图,动态规划查找最大概率路径

    1. 中文分词:jieba.cut
    import jieba

    seg_list = jieba.cut("我来到北京清华大学", cut_all=True)
    print("Full Mode: " + "/ ".join(seg_list)) # 全模式

    seg_list = jieba.cut("我来到北京清华大学", cut_all=False)
    print("Default Mode: " + "/ ".join(seg_list)) # 精确模式

    seg_list = jieba.cut("他来到了网易杭研大厦") # 默认是精确模式
    print(", ".join(seg_list))

    seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所,后在日本京都大学深造") # 搜索引擎模式
    print(", ".join(seg_list))

    2 .关键词提取:jieba.analyse.extract_tags
    import jieba.analyse
    基于TF-IDF:jieba.analyse.extract_tags(sentence, topK=20, withWeight=False, allowPOS=())
    基于TextRank:jieba.analyse.textrank(sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v'))

    使用 add_word(word, freq=None, tag=None) 和 del_word(word) 可在程序中动态修改词典。
    使用 suggest_freq(segment, tune=True) 可调节单个词语的词频,使其能(或不能)被分出来。

    sentence 为待提取的文本
    topK 为返回几个 TF/IDF 权重最大的关键词,默认值为 20
    withWeight 为是否一并返回关键词权重值,默认值为 False
    allowPOS 仅包括指定词性的词,默认值为空,即不筛选


    3 .词性标注:jieba.posseg.cut()

    import jieba.posseg as pseg
    words = pseg.cut("我爱北京天安门")
    for word, flag in words:
    print('%s, %s' % (word, flag))

    我 r
    爱 v
    北京 ns
    天安门 ns

    4. 并行分词

    原理:将目标文本按行分隔后,把各行文本分配到多个 Python 进程并行分词,然后归并结果,从而获得分词速度的可观提升
    基于 python 自带的 multiprocessing 模块,目前暂不支持 Windows
    用法:
    jieba.enable_parallel(4) # 开启并行分词模式,参数为并行进程数
    jieba.disable_parallel() # 关闭并行分词模式
    例子:https://github.com/fxsjy/jieba/blob/master/test/parallel/test_file.py
    实验结果:在 4 核 3.4GHz Linux 机器上,对金庸全集进行精确分词,获得了 1MB/s 的速度,是单进程版的 3.3 倍。
    注意:并行分词仅支持默认分词器 jieba.dt 和 jieba.posseg.dt。

    5. Tokenize:返回词语在原文的起止位置
    注意,输入参数只接受 unicode
    默认模式
    result = jieba.tokenize(u'永和服装饰品有限公司')
    for tk in result:
    print("word %s\t\t start: %d \t\t end:%d" % (tk[0],tk[1],tk[2]))
    word 永和 start: 0 end:2
    word 服装 start: 2 end:4
    word 饰品 start: 4 end:6
    word 有限公司 start: 6 end:10

    搜索模式
    result = jieba.tokenize(u'永和服装饰品有限公司', mode='search')
    for tk in result:
    print("word %s\t\t start: %d \t\t end:%d" % (tk[0],tk[1],tk[2]))
    word 永和 start: 0 end:2
    word 服装 start: 2 end:4
    word 饰品 start: 4 end:6
    word 有限 start: 6 end:8
    word 公司 start: 8 end:10
    word 有限公司 start: 6 end:10

    Segmentation speed

    1.5 MB / Second in Full Mode
    400 KB / Second in Default Mode
    Test Env: Intel(R) Core(TM) i7-2600 CPU @ 3.4GHz;《围城》.txt

    词性列表
    1. 名词 (1个一类,7个二类,5个三类)
    n 名词
    nr 人名
    nr1 汉语姓氏
    nr2 汉语名字
    nrj 日语人名
    nrf 音译人名
    ns 地名
    nsf 音译地名
    nt 机构团体名
    nz 其它专名
    nl 名词性惯用语
    ng 名词性语素

    2. 时间词(1个一类,1个二类)
    t 时间词
    tg 时间词性语素

    3. 处所词(1个一类)
    s 处所词 (家中、门外、境内、西方……)

    4. 方位词(1个一类)
    f 方位词

    5. 动词(1个一类,9个二类)
    v 动词
    vd 副动词
    vn 名动词
    vshi 动词“是”
    vyou 动词“有”
    vf 趋向动词
    vx 形式动词
    vi 不及物动词(内动词)
    vl 动词性惯用语
    vg 动词性语素

    6. 形容词(1个一类,4个二类)
    a 形容词
    ad 副形词
    an 名形词
    ag 形容词性语素
    al 形容词性惯用语

    7. 区别词(1个一类,2个二类)
    b 区别词 (主要、整个、所有……)
    bl 区别词性惯用语

    8. 状态词(1个一类)
    z 状态词

    9. 代词(1个一类,4个二类,6个三类)
    r 代词
    rr 人称代词
    rz 指示代词
    rzt 时间指示代词
    rzs 处所指示代词
    rzv 谓词性指示代词
    ry 疑问代词
    ryt 时间疑问代词
    rys 处所疑问代词
    ryv 谓词性疑问代词
    rg 代词性语素

    10. 数词(1个一类,1个二类)
    m 数词
    mq 数量词

    11. 量词(1个一类,2个二类)
    q 量词
    qv 动量词
    qt 时量词

    12. 副词(1个一类)
    d 副词

    13. 介词(1个一类,2个二类)
    p 介词
    pba 介词“把”
    pbei 介词“被”

    14. 连词(1个一类,1个二类)
    c 连词
    cc 并列连词

    15. 助词(1个一类,15个二类)
    u 助词
    uzhe 着
    ule 了 喽
    uguo 过
    ude1 的 底
    ude2 地
    ude3 得
    usuo 所
    udeng 等 等等 云云
    uyy 一样 一般 似的 般
    udh 的话
    uls 来讲 来说 而言 说来
    uzhi 之
    ulian 连 (“连小学生都会”)

    16. 叹词(1个一类)
    e 叹词

    17. 语气词(1个一类)
    y 语气词(delete yg)

    18. 拟声词(1个一类)
    o 拟声词

    19. 前缀(1个一类)
    h 前缀

    20. 后缀(1个一类)
    k 后缀

    21. 字符串(1个一类,2个二类)
    x 字符串
    xx 非语素字
    xu 网址URL

    22. 标点符号(1个一类,16个二类)
    w 标点符号
    wkz 左括号,全角:( 〔 [ { 《 【 〖 〈 半角:( [ { <
    wky 右括号,全角:) 〕 ] } 》 】 〗 〉 半角: ) ] { >
    wyz 左引号,全角:“ ‘ 『
    wyy 右引号,全角:” ’ 』
    wj 句号,全角:。
    ww 问号,全角:? 半角:?
    wt 叹号,全角:! 半角:!
    wd 逗号,全角:, 半角:,
    wf 分号,全角:; 半角: ;
    wn 顿号,全角:、
    wm 冒号,全角:: 半角: :
    ws 省略号,全角:…… …
    wp 破折号,全角:—— -- ——- 半角:--- ----
    wb 百分号千分号,全角:% ‰ 半角:%
    wh 单位符号,全角:¥ $ £ ° ℃ 半角:$


    文本挖掘主要有哪些功能

    自然语言处理技术文本挖掘功能:
    * 涉黄涉政检测:对文本内容做涉黄涉政检测,满足相应政策要求;
    * 垃圾评论过滤:在论坛发言或用户评论中,过滤文本中的垃圾广告,提升文本总体质量;
    * 情感分析:对用户评论等文本内容做情感分析,指导决策与运营;
    * 自动标签提取:自动提取文本重要内容生成关键性标签,在此基础之上拓展更多功能形式;
    * 文本自动分类:通过对文本内容进行分析,给出文本所属的类别和置信度,支持二级分类.


    NLP WordEmbedding的概念和实现

    背景
    如何表示词语所包含的语义?

    苹果?水果?Iphone?
    苹果、梨子,这两个词相关吗?

    语言的表示
    符号主义:Bags-of-word,维度高、过于稀疏、缺乏语义、模型简单
    分布式表示:Word Embedding,维度低、更为稠密、包含语义、训练复杂

    Word Embedding
    核心思想:语义相关的词语,具有相似的上下文环境,例如, 苹果和梨子
    所做的事情:将每个词语训练成,词向量

    实践
    基于gensim包和中文维基语料
    gensim:http://radimrehurek.com/gensim/models/word2vec.html
    中文维基分词语料:链接 https://pan.baidu.com/s/1qXKIPp6 密码 kade

    pip install gensim

    # 加载包
    from gensim.models import Word2Vec
    from gensim.models.word2vec import LineSentence

    # 训练模型
    sentences = LineSentence('wiki.zh.word.text')
    model = Word2Vec(sentences, size=128, window=5, min_count=5, workers=4)

    # 保存模型
    model.save('word_embedding_128')

    # 加载模型
    model = Word2Vec.load("word_embedding_128")

    # 使用模型
    items = model.most_similar(u'中国')
    model.similarity(u'男人', u'女人')

     

    demo 2017.11.29 by denny shenzhen

     

    import sys
    import jieba
    import jieba.analyse
    import jieba.posseg as posg


    sentence=u'''深圳新闻网讯 10月30日,世界城市日——全球城市竞争力论坛在广州举行。会上,中国社科院财经战略研究院和联合国人类住区规划署发布了《全球城市竞争力报告2017-2018》(以下简称《报告》)。

    《报告》称,通过对全球1007个城市的“经济竞争力”进行测度后,深圳在“经济竞争力”这项评选中位于第六名。上海、广州、北京分列全球第14、15、20名。

    北上广深,不仅有最繁华的建筑群,最多元的包容性,同时也是很多人改变命运的圆梦场。“经济竞争力”是对现有存量的排名,但对青年们来说,增量的部分(即未来)显得更为重要。《报告》也提供了一个可供参考的指标——“可持续竞争力”,即在未来保持全球竞争力的可持续性。

    在未来“可持续竞争力”排名上,除了北京高于“经济竞争力”指标,其他几座城市的可持续竞争力指标都低于其经济竞争力排名,深圳全球排名第35位。

    科技与金融正在主导全球经济,占据全球价值链的主要部分,尤其是信息科技企业的影响力正变得越来越大。科技中心城市在全球城市体系中的地位不断上升。

    综合2017年各城市所拥有最具价值品牌数量和近十年变化情况等因素,《报告》还提出了未来“新型全球城市”排名,在排名前50的城市当中,北京、深圳、上海、广州皆在其列,而“新一线城市”中仅有杭州入围。“未来的竞争将持续转向以城市经济为单元的竞争”,美国独立经济智库米尔肯研究所亚洲中心研究部董事、总经理黄华跃说。(记者李佳佳'''
    #kw=jieba.analyse.extract_tags(sentence,topK=20,withWeight=True,allowPOS=('n','nr','ns'))
    # kw=jieba.analyse.textrank(sentence,topK=20,withWeight=True,allowPOS=('ns','n','vn','v'))
    # for item in kw:
    # print(item[0],item[1])

    cixingDict = {
    'n': '名词','nr': '人名','nr1': '汉语姓氏','nr2': '汉语名字','nrj': '日语人名','nrf': '音译人名','ns': '地名','nsf': '音译地名',
    'nt': '机构团体名','nz': '其它专名','nl': '名词性惯用语','ng': '名词性语素','t': '时间词','tg': '时间词性语素','s':'处所词',
    'f':'方位词','v': '动词','vd': '副动词','vn': '名动词','vshi': '动词“是”','vyou': '动词“有”','vf': '趋向动词','vx': '形式动词',
    'vi': '不及物动词(内动词)','vl': '动词性惯用语','vg': '动词性语素','a': '形容词','ad': '副形词','an': '名形词','ag': '形容词性语素',
    'al': '形容词性惯用语','b': '区别词 (主要、整个、所有……)','bl': '区别词性惯用语','z': '状态词','r': '代词','rr': '人称代词',
    'rz': '指示代词','rzt': '时间指示代词','rzs': '处所指示代词','rzv': '谓词性指示代词','ry': '疑问代词','ryt': '时间疑问代词',
    'rys': '处所疑问代词','ryv': '谓词性疑问代词','rg': '代词性语素','m': '数词','mq': '数量词','q': '量词','qv': '动量词','qt': '时量词',
    'd':'副词','p': '介词','pba': '介词“把”','pbei': '介词“被”','c': '连词','cc': '并列连词','e':'叹词','y': '语气词',
    'o': '拟声词','h': '前缀','k': '后缀','x': '标点符号','xx': '非语素字','xu': '网址URL',
    'u': '助词',
    'uzhe': '着',
    'ule': ' 了 喽',
    'ul': '助词',
    'uj': '助词2',
    'uguo': '过',
    'ude1': '的 底',
    'ude2': '地',
    'ude3': '得',
    'usuo': '所',
    'udeng': '等 等等 云云',
    'uyy': '一样 一般 似的 般',
    'udh': '的话',
    'uls': '来讲 来说 而言 说来',
    'uzhi': '之',
    'ulian': '连 ',

    'w': '标点符号2',
    'wkz': '左括号,全角:( 〔 [ { 《 【 〖 〈 半角:( [ { <',
    'wky': '右括号,全角:) 〕 ] } 》 】 〗 〉 半角: ) ] { >',
    'wyz': '左引号,全角:『',
    'wyy': '右引号,全角:"" 』',
    'wj': '句号,全角:。',
    'ww': '问号,全角:? 半角:?',
    'wt': '叹号,全角:! 半角:!',
    'wd': '逗号,全角:, 半角:',
    'wf': '分号,全角:; 半角:',
    'wn': '顿号,全角:、',
    'wm': '冒号,全角:: 半角: ',
    'ws': '省略号,全角:…… …',
    'wp': '破折号,全角:—— -- ——- 半角:--- ----',
    'wb': '百分号千分号,全角:% ‰ 半角:%',
    'wh': '单位符号,全角:¥ $ £ ° ℃ 半角:$'
    }

    #seg_lig=jieba.cut('习平:担当党的崇高使命 矢志永远奋斗',cut_all=True)
    #print("full_name"+ "/ ".join(seg_lig))

    # seg_lig2=jieba.cut('习平:担当党的崇高使命 矢志永远奋斗',cut_all=False)
    # for item in seg_lig2:
    # print(item)
    # print("default_name"+ "/ ".join(seg_lig2))

    # seg_lig3=jieba.cut_for_search('平:担当党的崇高使命 矢志永远奋斗')
    # print("search_name"+ ", ".join(seg_lig3))
    #
    # ci xing analysis
    def cixingAnalysis(inputtxt):
    word=posg.cut(inputtxt)
    for work,flag in word:
    try:
    print(work,cixingDict[flag])
    except KeyError as e:
    print('except',e)

    # ci xing tongji
    def cixingTongji(inputtxt):
    word=posg.cut(inputtxt)
    n_type={}

    for work,flag in word:
    if flag not in n_type:
    n_type[flag] = 1
    else:
    n_type[flag] += 1

    sorted(n_type.items(),key=lambda d:d[1],reverse=False)
    print(n_type)

    cixingAnalysis(sentence)
    cixingTongji(sentence)


     

    demo :

    利用HMM进行词性标注

    隐马尔科夫模型(HMM)是什么?说白了,就是一个数学模型,用一堆数学符号和参数表示而已,包括隐藏状态集合、观察符号集合、初始概率向量pi, 状态转移矩阵A,混淆矩阵B。
      隐马尔科夫模型(HMM)的三大基本问题与解决方案包括:
      1. 对于一个观察序列匹配最可能的系统——评估,使用前向算法(forward algorithm)解决;
      2. 对于已生成的一个观察序列,确定最可能的隐藏状态序列——解码,使用维特比算法(Viterbi algorithm)解决;
      3. 对于已生成的观察序列,决定最可能的模型参数——学习,使用前向-后向算法(forward-backward algorithm)解决。

    可以解释为:
      1、对词性标注问题进行提炼:词性标注本质上是一个分类问题,对于句子中的每一个单词W,找到一个合适的词类类别T,也就是词性标记,不过词性标注考虑的是整体标记的好坏,既整个句子的序列标记问题;
      2、抽象为数学模型:对于分类问题,有很多现成的数学模型和框架可以套用,譬如HMM、最大熵模型、条件随机场、SVM等等;
      3、求出模型的解:上述模型和框架一旦可以套用,如何求解就基本确定好了,就像HMM中不仅描述了三大基本问题,并相应的给出了求解方案一样;
      4、验证模型的合理性:就是词性标注的准确率等评测指标了,在自然语言处理中属于必不可少的评测环节;
      5、解释现实问题:如果词性标注的各项指标够好,就可以利用该数学模型构造一个词性标注器来解决某种语言的标注问题了!
      词性标注的数学建模就这样了,自然语言处理中的多数分类问题与此相似。这里讲得是HMM的应用,所以其他模型暂且不表,以后有机会有条件了我们再说。


    word2vec
    使用word2vec训练一个高质量的同义词库将"非标准表述" 映射到 "标准表述",这就是Synonyms的起源.

     

     

    文本进行分词:jieba.cut(line.strip(),cut_all = False)
    统计 词频:jieba.lcut(line.strip(),cut_all = False)
    动态调整词典:jieba.suggest_freq(segment,tune=True)可以调节每个单个词语的词频,使其能/不能被分出来。
    jieba.suggest_freq(('中','将'),tune=True) #True表示希望分出来,False表示不希望分出来。


    Facebook FastText:模型简单,训练速度非常快
    fasttext是facebook开源的一个词向量与文本分类工具
    就是把文档中所有词通过lookup table变成向量,取平均后直接用线性分类器得到分类结果

    对比gensim的word2vec word2vec&doc2vec词向量模型
    作为一个处理可变长度文本的总结性方法,Quoc Le 和 Tomas Mikolov 提出了 Doc2Vec方法。除了增加一个段落向量以外,这个方法几乎等同于 Word2Vec。

     

    中文自然语言处理分析

    1.关键词提取

    基于 TF-IDF 算法的关键词抽取:特征选取
    •jieba.analyse.extract_tags(sentence, topK=20, withWeight=False, allowPOS=())◾sentence 为待提取的文本
    ◾topK 为返回几个 TF/IDF 权重最大的关键词,默认值为 20
    ◾withWeight 为是否一并返回关键词权重值,默认值为 False
    ◾allowPOS 仅包括指定词性的词,默认值为空,即不筛选

    基于 TextRank 算法的关键词抽取:从本篇文档中提取关键词
    •jieba.analyse.textrank(sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v')) 直接使用,接口相同,注意默认过滤词性。
    •jieba.analyse.TextRank() 新建自定义 TextRank 实例


    2.LDA主题模型
    .载入停用词
    .转换成合适的格式
    .词袋模型dictionary = corpora.Dictionary(sentences)
    corpus = [dictionary.doc2bow(sentence) for sentence in sentences]

    .LDA建模lda = gensim.models.ldamodel.LdaModel(corpus=corpus, id2word=dictionary, num_topics=20)
    print lda.print_topic(3, topn=5)
    处理可变长度文本的总结性方法 Doc2Vec方法


    用深度学习做文本分类:

    1.CNN做文本分类

    2 LSTM:long short term memory 捕捉时序信息的长短时记忆神经网络

    3.GRU分类器

    展开全文
  • nlp---使用NLTK进行建构词性标注器

    千次阅读 2018-01-31 15:03:43
    自然语言是人类在沟通中形成一套规则体系。规则有强有弱,比如非正式场合使用口语,正式场合下书面语。...句法:Syntax,句子结构或成分构成与关系的规范。 词法:Lexical,词构词,变化等规...
    自然语言是人类在沟通中形成的一套规则体系。规则有强有弱,比如非正式场合使用口语,正式场合下的书面语。要处理自然语言,也要遵循这些形成的规则,否则就会得出令人无法理解的结论。下面介绍一些术语的简单区别。
    文法:等同于语法(grammar),文章的书写规范,用来描述语言及其结构,它包含句法和词法规范。
    句法:Syntax,句子的结构或成分的构成与关系的规范。
    词法:Lexical,词的构词,变化等的规范。
    
    词性标注,或POS(Part Of Speech),是一种分析句子成分的方法,通过它来识别每个词的词性。
    

    下面简要列举POS的tagset含意,详细可看nltk.help.brown_tagset()

    标记词性示例
    ADJ形容词new, good, high, special, big, local
    ADV动词really, already, still, early, now
    CONJ连词and, or, but, if, while, although
    DET限定词the, a, some, most, every, no
    EX存在量词there, there’s
    MOD情态动词will, can, would, may, must, should
    NN名词year,home,costs,time
    NNP专有名词April,China,Washington
    NUM数词fourth,2016, 09:30
    PRON代词he,they,us
    P介词on,over,with,of
    TO词toto
    UH叹词ah,ha,oops
    VB 动词
    VBD动词过去式made,said,went
    VBG现在分词going,lying,playing
    VBN过去分词taken,given,gone
    WHwh限定词who,where,when,what

    1 使用NLTK对英文进行词性标注

    1.1 词性标注示例

    import nltk
    
    sent="I am going to Beijing tomorrow";
    tokens = nltk.word_tokenize(sent)
    taged_sent = nltk.pos_tag(tokens)
    print taged_sent 
    #[('I', 'PRP'), ('am', 'VBP'), ('going', 'VBG'), ('to', 'TO'), ('Beijing', 'NNP'), ('tomorrow', 'NN'), ('.', '.')]

    1.2 语料库的已标注数据

    语料类提供了下列方法可以返回预标注数据。

    方法说明
    tagged_words(fileids,categories)返回标注数据,以词列表的形式
    tagged_sents(fileids,categories)返回标注数据,以句子列表形式
    tagged_paras(fileids,categories)返回标注数据,以文章列表形式

    2 标注器

    2.1 默认标注器

    最简单的词性标注器是将所有词都标注为名词NN。这种标注器没有太大的价值。正确率很低。下面演示NLTK提供的默认标注器的用法。

    import nltk
    from nltk.corpus import brown
    
    default_tagger = nltk.DefaultTagger('NN')
    sents = 'I am going to Beijing.'
    print default_tagger.tag(sents) 
    #[('I', 'NN'), ('am', 'NN'), ('going', 'NN'), ('to', 'NN'), ('Beijing', 'NN')]
    
    tagged_sents = brown.tagged_sents(categories='news')
    print default_tagger.evaluate(tagged_sents) #0.131304

    2.2 基于规则的标注器

    从默认标注器的评估来看,只有13%的正确率。为了改进这一效果,我们使用一些规则来提高正确率。比如对于ing结尾则柡注为VG,ed结尾则标注为VD。可以通过正则表达式标注器实现这个想法。

    import nltk
    from nltk.corpus import brown
    
    pattern =[
        (r'.*ing$','VBG'),
        (r'.*ed$','VBD'),
        (r'.*es$','VBZ'),
        (r'.*\'s$','NN$'),
        (r'.*s$','NNS'),
        (r'.*', 'NN')  #未匹配的仍标注为NN
    ]
    sents = 'I am going to Beijing.'
    
    tagger = nltk.RegexpTagger(pattern)
    print tagger.tag(nltk.word_tokenize(sents))
    #[('I', 'NN'), ('am', 'NN'), ('going', 'VBG'), ('to', 'NN'), ('Beijing', 'VBG'), ('.', 'NN')]
    
    tagged_sents = brown.tagged_sents(categories='news')
    print default_tagger.evaluate(tagged_sents) #0.1875

    2.3 基于查表的标注器

    经过增加简单的规则,可以提升默认标注器的准确度,但仍不够好。为此我们统计一下部分高频词的词性,比如经常出现的100个词的词性。利用单个词的词性的统计知识来进行标注,这就是Unigram模型的思想。

    import nltk
    from nltk.corpus import brown
    
    fdist = nltk.FreqDist(brown.words(categories='news'))
    common_word = fdist.most_common(100)
    
    cfdist = nltk.ConditionalFreqDist(brown.tagged_words(categories='news'))
    table= dict((word, cfdist[word].max()) for (word, _) in common_word)
    
    uni_tagger = nltk.UnigramTagger(model=table,backoff=nltk.DefaultTagger('NN'))
    print uni_tagger.evaluate(tagged_sents) #0.5817

    只利用前100个词的历史统计数据便能获得58%的正确率,加大这个词的数量更可以继续提升标注的正确率,当为8000时可以达到90%的正确率。这里我们对不在这100个词的其他词统一回退到默认标注器。

    3 训练N-gram标注器

    3.1 一般N-gram标注

    在上一节中,已经使用了1-Gram,即Unigram标注器。考虑更多的上下文,便有了2/3-gram,这里统称为N-gram。注意,更长的上正文并不能带来准确度的提升。 
    除了向N-gram标注器提供词表模型,另外一种构建标注器的方法是训练。N-gram标注器的构建函数如下:__init__(train=None, model=None, backoff=None),可以将标注好的语料作为训练数据,用于构建一个标注器。

    import nltk
    from nltk.corpus import brown
    
    brown_tagged_sents = brown.tagged_sents(categories='news')
    train_num = int(len(brown_tagged_sents) * 0.9)
    x_train =  brown_tagged_sents[0:train_num]
    x_test =   brown_tagged_sents[train_num:]
    tagger = nltk.UnigramTagger(train=x_train)
    print tagger.evaluate(x_test)  #0.81

    对于UniGram,使用90%的数据进行训练,在余下10%的数据上测试的准确率为81%。如果改为BiGram,则正确率会下降到10%左右。

    3.2 组合标注器

    可以利用backoff参数,将多个组合标注器组合起来,以提高识别精确率。

    import nltk
    from nltk.corpus import brown
    pattern =[
        (r'.*ing$','VBG'),
        (r'.*ed$','VBD'),
        (r'.*es$','VBZ'),
        (r'.*\'s$','NN$'),
        (r'.*s$','NNS'),
        (r'.*', 'NN')  #未匹配的仍标注为NN
    ]
    brown_tagged_sents = brown.tagged_sents(categories='news')
    train_num = int(len(brown_tagged_sents) * 0.9)
    x_train =  brown_tagged_sents[0:train_num]
    x_test =   brown_tagged_sents[train_num:]
    
    t0 = nltk.RegexpTagger(pattern)
    t1 = nltk.UnigramTagger(x_train, backoff=t0)
    t2 = nltk.BigramTagger(x_train, backoff=t1)
    print t2.evaluate(x_test)  #0.863

    从上面可以看出,不需要任何的语言学知识,只需要借助统计数据便可以使得词性标注做的足够好。  
    对于中文,只要有标注语料,也可以按照上面的过程训练N-gram标注器。

    4 更进一步

    nltk.tag.BrillTagger实现了基于转换的标注,在基础标注器的结果上,对输出进行基于规则的修正,实现更高的准确度。

    5 示例:中文标注器的训练

    下面基于Unigram训练一个中文词性标注器,语料使用网上可以下载得到的人民日报98年1月的标注资料。百度网盘链接

    # coding=utf-8
    import nltk
    import json
    
    lines = open('9801.txt').readlines()
    all_tagged_sents = []
    
    for line in lines:
        line = line.decode('utf-8')
        sent = line.split()
        tagged_sent = []
        for item in sent:
            pair = nltk.str2tuple(item)
            tagged_sent.append(pair)
    
        if len(tagged_sent)>0:
            all_tagged_sents.append(tagged_sent)
    
    train_size = int(len(all_tagged_sents)*0.8)
    x_train = all_tagged_sents[:train_size]
    x_test = all_tagged_sents[train_size:]
    
    tagger = nltk.UnigramTagger(train=x_train,backoff=nltk.DefaultTagger('n'))
    
    tokens = nltk.word_tokenize(u'我 认为 不丹 的 被动 卷入 不 构成 此次 对峙 的 主要 因素。')
    tagged = tagger.tag(tokens)
    print json.dumps(tagged,encoding='UTF-8', ensure_ascii=False) 
    #["我", "R"], ["认为", "V"], ["不丹", "n"], ["的", "U"], ["被动", "A"], ["卷入", "V"], ["不", "D"], ["构成", "V"], ["此次", "R"], ["对峙", "V"], ["的", "U"], ["主要", "B"], ["因素。", "n"]
    print tagger.evaluate(x_test) #0.871

    简单的训练,标注器便取得了87.1%的成绩,还是不错的。


    展开全文
  • 希望机器能像人一样去理解,以人类自然语言为载体的文本所包含的信息,并完成一些特定任务 内容 中文分词、词性标注、命名实体识别、关系抽取、关键词提取、信息抽取、依存分析、词嵌入…… 应用 篇章理解、文本...
  • 在相同词性的同义词集之间,建立了以下关系:下位词-高位词,实例类,部分全部,反义词关系,领域关系。 对于动词,描述了因果关系包含关系。 在具有相同含义不同词性的同义词集之间也建立了词性同义词链接。 ...
  • 哈尔滨工业大学计算机学院中文电子病历研究成果,包含CEMR句法树库构建,中文分词与词性标注,实体和实体关系语料构建
  • Python中提供“静态”语言特定数据(标记器异常、停止词、细粒度到粗粒度词性标记映射规则)、训练用于预测词性标记统计模型,依赖关系和命名实体(在一个大标记语料库上训练并作为二进制权重包含)和Gensim这样...
  • 该过程使用自然语言概念(词性)来识别可用于识别数据库表和表列单词。 基于Open NLP语法文件以及其他配置文件使用有助于将自然语言转换为查询语言。 确定了哪些表和哪些列包含相关数据后,下一步就是创建SQL...
  • 词性标记是依存句法分析的预处理操作,依存句法分析,是在词性标记的基础上结合词语间的关系,动宾关系,主谓关系等来进行分析,这种名词短语是包含着词语间的关系的,不是单纯的词性标记,需要通过句法分析来进行...
  • 基于Pytorch和torchtext自然语言处理深度学习框架,包含序列标注、文本分类、句子关系、文本生成、结构分析、五大功能模块,已实现了命名实体识别、中文分词、词性标注、语义角色标注、情感分析、关系抽取、语言...
  • english.7z

    2020-07-24 16:27:28
    包含英文单词,中文翻译,单词的词性及多种词义,执行SQL语句就可以生成表,支持SQL Server,MySQL等多种关系型数据库。
  • 中文长句句式较复杂,经常包含多个实体特点以及数据稀疏问题给中文关系探测和关系抽取任务带了挑战. 为了解决上述问题,提出了一种基于句法语义特征实体关系抽取方法. 通过将两个实体各自依存句法关系进行...
  • 机器阅读(一)--整体概述

    千次阅读 2019-06-06 20:18:16
    主要包含:机器阅读起因和发展历史;MRC数学形式;MRC与QA区别;MRC常见数据集和关键模型 发展动机 传统NLP任务 1) 词性分析 part-of-speech tagging :判断词性 2) 命名实体识别 named entity recognition...
  • 2.7.3 结果包含的内容和小标题的使用 2.7.4 撰写结果的注意事项 2.8 如何撰写讨论 2.8.1 讨论的意义和作用 2.8.2 讨论的主要内容 2.8.3 讨论写作的注意事项 2.8.4 讨论中的“结论”如何撰写 2.9 如何表达致谢 2.9.1 ...
  • -词性对单词定义-句子中短语动词-句子中名词,副词,形容词短语-句子中搭配-音频:聆听整个句子或只听想要单词-您可以在句子中注册并保存单词在您词汇表中或者您也可以通过单击URL栏旁边BeFluent图标...
  • pytorch之LSTM(四)

    2021-01-17 13:55:16
    1、序列模型和长期记忆网络 至此,我们已经看到了各种前馈网络。...对于LSTM,对于序列中每个元素,都有一个对应隐藏状态ht,原则上可以包含序列中任意点信息。我们可以使用隐藏状态来预测语言模.
  • Stanford NLP 团队发布了包含 53 种语言预训练模型自然语言处理工具包 StanfordNLP,该工具包支持 Python 3.6 及之后版本,并基于 PyTorch,支持多种语言完整文本分析管道,包括分词、词性标注、词形归并和依存...
  • 模式识别第五课

    2018-03-26 21:51:23
    2.2产生式与判别式模式几个简单的图模型,隐马尔可夫模型(HMM)作业:写产生式模式和...HMMS 自然语言处理中的词性标注2.2.3 比较naive 贝叶斯假设,有两个做法来让产生式模型包含依赖关系三个优点:对于处理隐含变...
  • 16 NLP 走近自然语言处理

    千次阅读 2018-08-18 15:51:46
    希望机器能像人一样去理解,以人类自然语言为载体的文本所包含的信息,并完成一些特定任务   内容 中文分词、词性标注、命名实体识别、关系抽取、关键词提取、信息抽取、依存分析、词嵌入……   应用 篇章...
  • 自然语言处理综述

    2019-02-01 20:32:54
    自然语言处理技术分类 工业界NLP四大任务: ...自然语言推理是NLP高级别的任务之一,不过自然语言推理包含的内容比较多,机器阅读,问答系统和对话等本质上都属于自然语言推理。文本蕴含任务(te...
  • - 以BiLSTM等模型为基础,提供知识图谱关系抽取 中文分词 词性标注 命名实体识别 情感分析 新词发现 关键词 文本摘要 文本聚类等功能、用unet实现对文档表格自动检测,表格重建、NLP事件提取文献资源列表 、 金融...
  • 经典两阶段框架,在 Faster R-CNN模型基础上添加分割分支,得到掩码结果,实现了掩码和类别预测关系的解藕,可得到像素级别检测结果。 MS-COCO 基于ResNet 50 Mask mAP(0.50: 0.95) = 31.4% RetinaNet 经典...
  • 第二个通过语法分析、分词算法等技术发现错误词库未包含的错误。 校对需要实现的功能: 1、要求提供足够多的错误词库,错误库覆盖常见字词错误。 2、实现语法分析和语料库统计相结合的方法,具备汉语切分技术、汉语...
  • funNLP_fighting41love.tar.gz

    2019-10-20 15:05:11
    中文自然语言处理工具集(断句/分词/词性标注/组块/句法分析/语义分析/NER/N元语法/HMM/代词消解/情感分析/拼写检查、XLM:Facebook跨语言预训练语言模型、用基于BERT微调和特征提取方法来进行知识图谱百度百科...
  • 本README包含各个功能典型例子,部分函数详细用法可在文档中找到: 文档 具体功能如下: 目录: 基本处理 精细分词分句 可包含指定词和类别分词。充分考虑省略号,双引号等特殊标点分句。 文本清洗 ...

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

包含的词性关系