精华内容
下载资源
问答
  • pyltp引入外部词典

    千次阅读 2020-03-26 12:10:37
    大家好,今天跟大家介绍一下在文本学习过程中,为什么引入外部词典以及引入外部词典之后又什么变化。 为什么引入外部词典 怎么引入(外部词典的配置) ...

      大家好,今天跟大家介绍一下在文本学习过程中,为什么要引入外部词典以及引入外部词典之后又什么变化。

    1. 为什么引入外部词典
    2. 怎么引入(外部词典的配置)
        一、为什么引入?
      pyltp分词支持用户使用自定义词典,分词外部词典本身是一个文本文件(*.txt)。每行指定一个词,编码必须为UTF-8。(保存文件的时候,设置编码为UTF-8)。
      在这里插入图片描述
      代码注意以下几点:
      1、改变模型文件路径!
      2、外部词典的加载路径代码。(如下图)
      在这里插入图片描述
      完整代码如下:
    # -*- coding: utf-8 -*-
    import os
    from pyltp import Segmentor, Postagger
    # 分词
    LTP_DATA_DIR = 'E:\Python\pyltp\ltp\ltp\ltp_data'  # ltp模型目录的路径
    cws_model_path = os.path.join(LTP_DATA_DIR, 'cws.model')  # 分词模型路径,模型名称为`cws.model`
    lexicon_path = os.path.join(LTP_DATA_DIR, 'E:\Python\pyltp\ltp\ltp\ltp_data\lexicon.txt')  # 参数lexicon是自定义词典的文件路径
    segmentor = Segmentor()
    segmentor.load_with_lexicon(cws_model_path, lexicon_path)
    sent = '据韩联社12月28日反映,美国防部发言人杰夫·莫莱尔27日表示,美国防部长盖茨将于2011年1月14日访问韩国。2010年2月28日中国刘军报道'
    words = segmentor.segment(sent)  # 分词
    # 词性标注
    pos_model_path = os.path.join(LTP_DATA_DIR, 'pos.model')  # 词性标注模型路径,模型名称为`pos.model`
    postagger = Postagger()  # 初始化实例
    postagger.load(pos_model_path)  # 加载模型
    postags = postagger.postag(words)  # 词性标注
    ner_model_path = os.path.join(LTP_DATA_DIR, 'ner.model')   # 命名实体识别模型路径,模型名称为`pos.model`
    from pyltp import NamedEntityRecognizer
    recognizer = NamedEntityRecognizer() # 初始化实例
    recognizer.load(ner_model_path)  # 加载模型
    # netags = recognizer.recognize(words, postags)  # 命名实体识别
    # 提取识别结果中的人名,地名,组织机构名
    persons, places, orgs = set(), set(), set()
    netags = list(recognizer.recognize(words, postags))  # 命名实体识别
    print(netags)
    # print(netags)
    i = 0
    for tag, word in zip(netags, words):
        j = i
        # 人名
        if 'Nh' in tag:
            if str(tag).startswith('S'):
                persons.add(word)
            elif str(tag).startswith('B'):
                union_person = word
                while netags[j] != 'E-Nh':
                    j += 1
                    if j < len(words):
                        union_person += words[j]
                persons.add(union_person)
        # 地名
        if 'Ns' in tag:
            if str(tag).startswith('S'):
                places.add(word)
            elif str(tag).startswith('B'):
                union_place = word
                while netags[j] != 'E-Ns':
                    j += 1
                    if j < len(words):
                        union_place += words[j]
                places.add(union_place)
        # 机构名
        if 'Ni' in tag:
            if str(tag).startswith('S'):
                orgs.add(word)
            elif str(tag).startswith('B'):
                union_org = word
                while netags[j] != 'E-Ni':
                    j += 1
                    if j < len(words):
                        union_org += words[j]
                orgs.add(union_org)
        i += 1
    print('人名:', ','.join(persons))
    print('地名:', ','.join(places))
    print('组织机构:', ','.join(orgs))
    # 释放模型
    segmentor.release()
    postagger.release()
    recognizer.release()
    

    我加入的外部词典如下图:
    在这里插入图片描述
    结果如下:
    在这里插入图片描述
    倘若不引入外部词典,那么分词的时对于某些词解析不是很对,导致其他工作的错误。
    但是,外部词典的使用倘若用户数据很大,比如一本书,网络上应该是有现有的词典,供大家使用。
    本片文章就写到这啦,祝大家生活愉快。

    展开全文
  • :Morpheus将领先的图形查询语言Cypher引入领先的分布式处理平台Spark
  • 角度搜索过滤器应用 一个有角度的应用程序,可演示过滤器搜索功能以及引入突出显示搜索的自定义指令
  • C++17引入的模块为什么能加快编译速度?


    https://www.zhihu.com/question/37330979/answer/73595024


    作者:hearts zh
    链接:https://www.zhihu.com/question/37330979/answer/71692790
    来源:知乎
    著作权归作者所有,转载请联系作者获得授权。

    首先要说明的是,模块(module)在不同编程语言的并不完全一样,只是名字相同而已。查查英英词典,module: unit, part, component, segment, element。大概就是整体的一小部分的意思。软件里面一般指可以重用的部分。不同语言对于这个东西显然有不同的理解/定义。不细表。

    要回答你的问题,首先要理解为啥c++编译慢呢?这要从C说起。C一开始采用了拷贝-插入模型。#include关键字,就是把另外一个文件原封不动的拷贝到现在的文件。为啥这样设计,我也不敢乱说,但这样设计,带来了一些常用的用法,这些用法在10多年前C++世界,甚至在现在的嵌入式世界,都蛮流行的。比如说,
    //common.h
    #define DEBUG
    
    //main.c
    #include "common.h"
    #include "a.h"
    
    int main() {
      #ifdef DEBUG
      debug_buffer[0] = 1;
      debug_print_buffer();
      #endif
      return 0;
    }
      
    
    //a.h
    #include "common.h"
    #ifdef DEBUG
    extern int debug_buffer[10000000];
    extern void debug_print_buffer();
    #endif
    
    
    //a.c
    #include "a.h"
    #ifdef DEBUG
    int debug_buffer[10000000];
    void debug_print_buffer() {}
    #endif 
    


    代码随便写的凑合着看,大概意思就酱。这种用法,只有拷贝-插入模式才有用。common里面的#define DEBUG影响了a.h,a.c和main.c。

    当然也带来了一系列负面影响,例如如果a.h #include了common.h, b.h也#include了 common.h,如果a.h #include b.h的话呢,common.h就被拷贝插入了2次。不但影响编译速度,而且重复定义了common.h里面的东西。所以呢,对于c和c++来说,所有的.h里,都要写一些奇怪的东西防止被#include 2次。这大家都知道了,就不深入了。

    以上为C。其实没有什么大问题。为什么到C++就变成问题了呢?这要从C/C++编译的另一面说起。从编译角度来讲,C/C++是每个.c, .cpp文件单独编译,最后放到一起链接。例如你有a.c和b.c,其实a.c和b.c是分别编译,最后放到一起连接成可执行文件或者库。

    这其实是完全没问题的,因为分别编译好处是显而易见的,一旦b.c被更新了,a.c不需要重新编译一遍。加快了编译速度。

    那你说有什么问题?问题就在c++中 .h 文件太长了!!特别是.h文件中还有模板!

    对于C,.h文件无非就是函数声明之类的一些东西,但C++ .h文件是类,可以有类的成员定义,是模板,必须有模板的成员定义。

    #include <iostream>根据某些实现,带来上万行的拷贝-插入,里面还全是模板。

    假设a.cpp里有iostream,b.cpp里有iostream,因为分别编译,带来2万行的拷贝-插入。你有10000个.cpp文件就是10000*10000行的拷贝-插入重复编译。当然第一次编译很慢,之后因为你一般不会更新所有.cpp,会快一点,但也相当慢。

    你说,为什么不把iostream编译一次,存起来,存到cache,其他的文件直接用?原因也很简单,不行!

    iostream里面的具体实现,取决于include他的文件的环境。例如iostream里面有一个#ifdef DEBUG,那么#include <iostream>时,是否#define DEBUG取决了iostream里的东西并不一样。根本没法cache。

    ------------------------------------------------------------------

    以上。那么module在C++中是什么?module的设计准则之一,就是module是独立的,不受import module的文件的环境影响。当然,module也不影响别人。于是编译好的module就可以被cache起来,具体编译器可以采用不同实现。可以cache到文件,内存,等等地方。

    展开全文
  • scala包和引入

    千次阅读 2016-07-23 10:54:26
    scala包和引入 1.scala包 scala的包和Java中的包的目的是相同的:管理大型程序中的名称。 要增加条目到包中,可以将其包含在包语句里面,如: package org{ package cai{ package test{ class MyClass /...

    scala包和引入


    1.scala包

    scala的包和Java中的包的目的是相同的:管理大型程序中的名称。
    要增加条目到包中,可以将其包含在包语句里面,如:
    package org{
        package cai{
           package test{
               class MyClass
                // ......
           }
       }
    }


    MyClass就可以在任何地方以org.cai.test.MyClass被访问。

    **源文件的目录和包之间并没有强制的关联关系,并不需要将MyClass.scala放在org/cai/test目录下面。

    **可以在一个.scala文件中定义多个包的内容,如:
    //包org.cai.test
    package org{
        package cai{
           package test{
               class MyClass1
                // ......
           }
       }
    }
    
    //包org.yong.test
    package org{
        package yong{
           package test{
               class MyClass2
                 //......
           }
       }
    }


    2.包的作用域

    scala的包和其它作用域一样支持嵌套。可以在程序中访问上层作用域中的名称。
    有时候包的引入会发生冲突,这个时候我们可以通过绝对包名进行引入:
    绝对包名以“_root_”开始。
    val test = new _root_.scala.collection.mutable.ArrayBuffer[claaName]


    3.串联式包语句

    包语句可以包含一个串(路径区段),这样的包语法限定了可见的成员。
    package org.cai.test{
        //org和org.cai的成员在这里不可见
        package pack1{
           class MyClass
            //......
       }
    }


    4.文件顶部标记法

    和Java类似,在源文件顶部声明包。
    如:
    package org.cai.test
    package yong
    class MyClass
    //......
    
    
    //这等同于
    package org{
        package cai{
           package test{
               package yong{
                  class MyClass1
                   // ......
               }
           }
       }
    }

    注意:在上例子中,文件所有的内容都属于org.cai.test.yong包,但是org.cai.test包的内容是可见的,可以被直接引用。

    5.包对象

    包可以包含类、对象和特质,但是不能包含函数或变量的定义。这是Java虚拟机的局限。

    每一个包都可以有一个包对象,需要在父包中定义它,且名称与子包一样。
    例如:
    package org.cai.test
    
    package object people{
      val defaultName = "cy"
    }
    
    package people{
      class Person{
        var name = defaultName //从包对象拿到常量
      }
      //......
    }

    defaultName不需要加限定词,因为它位于同一个包内。在其它地方,这个常量可以用org.cai.test.people.defaultName来访问到。包对象会被编译成带有静态方法和字段的JVM类,名为package.class,位于相应的包下。

    6.包可见性

    在Java中,没有被声明为private、protected和public的类成员在包含该类的包中可见,在scala中,可以通过修饰符达到同样的效果。
    //声明方法在自己的包中可见
    package org.cai.test
    class Person{
        private[test] def func = ""
        //......
    
    }
    
    
    //将方法的可见度提升到上一层
    package org.cai.test
    class Person{
        private[cai] def func = ""
        //......
    }


    7.包的引入


    scala引入包和java一样。
    import org.cai._  "_"和Java中的"*"通配符一样,表示引入对应路径下的所有类或对象的所有成员。

    在scala中,import语句可以出现在任何地方,并不是仅仅限于文件顶部。

    import进来的成员的作用效果延伸到包含该语句的块末尾。



    8.包重命名和隐藏方法

    (1)包重命名
    如果要引入包中的多个成员,可以使用选取器,如下:
    import java.awt.{Color,Font}

    可以重命名选取的包成员:
    import java.util.{HashMap=>JavaHashMap}

    这样一来,JavaHashMap就是java.util.HashMap

    (2)隐藏方法
    “成员 => _”将隐藏某一个成员而不是重命名,这仅仅在需要引入其它同

    名成员时候有用,如:

    import java.util.{HashMap=>_,_}
    import scala.collection.mutable._
    现在,HashMap无二义性地指向scala.collection.mutable.HashMap,因为java.util.HashMap被隐藏了。

    9.隐式引入

    每一个scala程序都隐式地引入了如下代码:
    import java.lang._
    import scala._
    import Predef._

    和Java程序一样,lang包总是被引入,接下来引入scala包,这个引入会覆盖之前的引入,最后,Predef包被引入,这个包中包含了很多有用的函数。




    >>>>>__以上内容摘自:《快学Scala》  [美]Cay S. Horstmann著   电子工业出版社__<<<<<





    展开全文
  • Scala 包和引入

    千次阅读 2015-12-10 22:22:59
    摘自《快学Scala》0.重点 包可以像内部类那样...引入语句可以引入包,类和对象 引入语句可以出现在任何位置 引入语句可以重命名和隐藏特定成员 java.lang, scala和Predef 总是被引入 包Scala的包和Java的包或者C++的

    摘自《快学Scala》

    0.重点

    • 包可以像内部类那样嵌套
    • 包路径不是绝对路径
    • 包声明链x.y.z并不自动将中间包x和x.y变成可见
    • 位于文件顶部不带花括号的包声明在整个文件范围内有效
    • 包对象可以持有函数和变量
    • 引入语句可以引入包,类和对象
    • 引入语句可以出现在任何位置
    • 引入语句可以重命名和隐藏特定成员
    • java.lang, scala和Predef 总是被引入

    Scala的包和Java的包或者C++的命名空间的目的是相同的:管理大型程序中的名称。
    如:
    Map这个名称可以同时出现在scala.collection.immutable和scala.collection.mutable包而不会冲突。要访问它们中的任何一个,可以使用完全限定的名称scala.collection.immutable.Map或scala.collection.mutable.Map,也可以使用引入语句提供一个更短小的别名。
    要增加条目到包中,可以将其包含在包语句当中,如:

    package com{
        package horstmann{
            package impatient{
                class Employee
                ...
            }
        }
    }

    这样,类名Employee就可以在任意位置以com.horstmann.impatient.Employee访问到了。
    与对象或类的定义不同,同一个包可以定义在多个文件当中。上面这段代码可能出现在Employ.scala中,另一个名为Manager.scala的文件可能会包含:

    package com{
        package horstmann{
            package impatient{
                class Manager
                ...
            }
        }
    }

    **不需要将Employee.scala和Manager.scala放在com/hortmann/impatient目录中。

    2.作用域规则

    在Scala中,包的作用域比起Java更加前后一致。Scala的包和其他作用域一样支持嵌套,你可以访问上层作用域中的名称。如:

    package com{
        package horstmann{
            package Utils{
                def percentOf(value:Double,rate:Double)=value * rate /100
                ...
            }
            package impatient{
                class Employee{
                    def giveRaise(rate:scala.Double){
                        salary += Utils.percentOf(salary, rate)
                    }
                }
            }
        }
    }

    绝对包名:

    val subordinates = _root_.scala.collection.mutable.ArrayBuffer[Employee]

    3.串联式包语句

    package com.horstmann.impatient{
        //com和com.horstmann的成员在这里不可见
        package people{
            clas Person
            ...
        }
    }

    这样的包语句限制了可见的成员,现在com.horstmann.collection包不再能够以collection访问到了。

    4.文件顶部标记法

    除了用嵌套标记法以外,也可以在文件顶部使用package语句,不带花括号。例如:

    package com.horstmann.impatient
    package people
    
    class Person
    ...

    这等同于

    package com.horstmann.impatient{
        package people{
    
            class Person
            ...
            //直到文件末尾
        }
    }

    如果文件中的所有代码属于同一个包的话(这也是通常的情形),这是更好的做法。
    在上面的示例中,文件的所有内容都属于com.horstmann.impatient.people,但com.horstmann.impatient包的内容是可见的,可以被直接饮用。

    5.包对象

    包可以包含类,对象和特质,但不能包含函数或变量的定义。
    每个包都可以有一个包对象,你需要在父包中定义它,且名称与子包一样,例如:

    package com.hordstmann.impatient
    package object people{
        val defaultName = "John Q.Public"
    
    }
    package people{
        class Person{
            var name = defaultName //从包对象拿到的常量
        }
        ...
    }
    
    //defaultName不需要加限定词,因为它位于同一个包内,在其他地方,这个常量可以用com.horstmann.impatient,.people.defaultName访问。
    

    6.包可见性

    以下方法在它自己的包中可见:

    package com.horstmann.impatient.people
    class Person{
        private[people] def description = "A person with name " + name
        ...
    }
    //可以将可见度延展到上层包
    private[impatient] def description = "A person with name " + name

    7.引入

    引入语句让你可以使用更短的名称而不是原来较长的名称:

    import java.awt.Color

    这样,就可以在代码中写Color而不是java.awt.Color了。

    //引入某个包的全部成员:
    import java.awt._
    
    //引入类或对象的所有成员:
    import java.awt.Color._
    val c1 =RED //Color.RED
    val c2 =- decode("#ff0000")  //Color.decode

    8.任何地方都可以声明引入

    在Scala中,import语句可以出现在任何地方,并不仅限于文件顶部。import的效果一直延伸到包含该语句的块末尾。

    class Manager{
        import scala.collection.mutable._
        val subordinates = new ArrayBuffer[Employee]
    }

    通过将引用放置在需要这些引入的地方,可以大幅减少可能的名称冲突。

    9.重命名和隐藏方法

    //选取器 {}
    import java.awt.{Color, Font}
    //选取器语法还允许重命名选到的成员
    import java.util.{HashMap => JavaHashMap}
    import scala.collection.mutable._
    
    //这样,JavaHashMap就是java.util.HashMap,而HashMap则对应scala.collection.mutable.HashMap
    
    //选取器HashMap=>_将隐藏某个成员名而不是重命名它,这仅在你需要引入其他成员时有用:
    import java.util.{HashMap => _,_}
    import scala.collection.mutable._
    //现在,HashMap无二义的指向scala.collection.mutable.HashMap,因为java.util.HashMap被隐藏起来了。

    10.隐式引入

    每个Scala程序都隐式的以如下代码开始:

    import java.lang._
    import scala._
    import Predef._
    展开全文
  • vue路由引入步骤

    千次阅读 2018-04-23 17:56:05
    vue路由引入步骤:        .base{  width:320px;  height:300px;  background:#ddd;  border:3px solid #1b6d85;  padding:12px;  text-align: center;  }  
  • lxml包引入错误

    万次阅读 2012-04-25 17:55:36
    在使用第三方包lxml引入etree模块时报错: >>> from lxml import etree Traceback (most recent call last): File "", line 1, in ? ImportError: dynamic module does not define init function (initetree) ...
  • 本文讲了讲我们在解决序列标注问题中将分类标签引入RNN网络结构的一次不成功的尝试。
  • JavaWeb 项目引入高德地图功能

    千次阅读 2013-11-26 11:01:47
    JavaWeb 项目引入高德地图功能系列功能。
  • 当某些特定的在jieba的词典中没有并且需要准确切分出来时,这是就需要在切分过程中引入自定义词典。自定义词典以TXT文件形式输入,每个占据一行。然后再Python中读取即可。 示例:user_dict.txt的内容为
  • 这个显然是由 Joe Celko 引入的。 其他人描述了相同的技术,但没有命名或对 Yii 框架使用不同的术语 入门 1.安装包含类: require_once( ' MenuNested.php ' ) ; 2.为这个类创建对象 $model = new MenuNested ...
  • 该模型引入潜在特征模型以利用丰富的向量信息弥补内容稀疏,在改进的生成过程中每个双的词汇的生成受到主题—词汇多项分布和潜在特征模型的共同影响。模型中的参数通过吉布斯采样算法进行估计。在真实的短文本...
  • Node.js开发入门—引入UIBootstrap

    千次阅读 2015-09-02 07:13:50
    ”里的AngularDemo为基础,我说到的目录什么的,都遵循express应用的默认目录结构。 UI Bootstrap UI Bootstrap在github上有一个简单介绍: Native AngularJS (Angular) directives for Bootstrap. ...
  • 命题和联结 ( 命题 | 命题符号化 | 真值联结 | 否 | 合取 | 析取 | 非真值联结 | 蕴涵 | 等价 )
  • 数理逻辑量词的引入

    千次阅读 2015-06-28 01:43:43
    什么呢?  科普数学需要一套公认的数学语言,也就是说,使用一套符号体系表达意思。但是,数学符号不是一般人生来就懂得的,而且比较难于记忆。 比如,量词(Quantifer)符号“∃”与“∀”,前者表示...
  • 引入知识注意力机制的实体分类

    千次阅读 2018-04-08 20:17:20
    实体分类相关论文阅读第三篇:Improving Neural Fine-Grained Entity Typing With Knowledge Attention前两篇文章链接:引入注意力机制的细粒度实体分类 细粒度实体类型分类的神经网络结构这篇论文来自清华大学...
  • 使用 npm/yarn 引入插件

    千次阅读 2020-04-02 12:14:42
    jQuery 约定俗称的是 $ 检查 jQuery 是否引入成功,可以通过 console.log($) 的方式查看 可以按照上述方法在 main.js 文件中引入 css 文件 import './reset.css' 注意:如要安装 yarn,一定不要通过 npm 来安装它,...
  • 引入无穷小微积分的合理性

    千次阅读 2017-11-19 01:26:53
    引入无穷小微积分的合理性我们设想,在实数集合R上,、定义了算术四则运算:+、-、×、÷,以及实数的大小顺序关系:≤。给定形式表达式:2+6,11+4,3×2,…,等等,等等(尽量多地设想)。我们规定,两个形式...
  • vue2项目引入社交分享插件vshare

    千次阅读 2018-11-20 10:04:20
    提供多种风格按钮,代码加载更快,引入社会化流量,提升网页抓取速度等优点。 github地址:https://github.com/1006008051/vshare,欢迎star。 安装 npm install vshare -S 使用 注入 // ES6 import vshare from ...
  • 莫绍揆先生在授课中大量使用逻辑“量词”,感觉怪怪的,不知是什么人发明的这玩意儿。 实际情况是,“量词”的引入是逻辑学发展历史上的一个标志性的“转折点”。应该说,有了“量词”就有了“量词语句”,从而也就...
  • vue-cli项目引入highcharts的3D图表

    千次阅读 2019-12-30 14:23:18
    1、npm安装highchart npm install highcharts --save npm install vue-...2、在main.js引入 import highcharts from 'highcharts' import VueHighCharts from 'vue-highcharts' import highcharts3d from ...
  • 一.简介 &amp;nbsp; &amp;nbsp;&...注意力机制是在Encoder与Deconder架构中针对输出不同的序列(分词)在输入序列中所...‘i’这个的翻译明显与“我”这个输入对应,与后面“喜欢足球”的关系不大,因...
  • javascript实现划标记划搜索功能 软件开发网是一个专业的收集各类脚本学习资料的网站,尽量修正错误打造精品脚本类学习网站,我们为大家游戏脚本资源,源码,软件,asp,php,javascript等编程资料,是网页制作,网络...
  • 自然语言处理----停用

    千次阅读 2018-09-21 11:08:47
    自定义词典和停用引入 自定义词典是我们在分词的时候避免把我们需要的词组分成小而导入的,而停用,则是我们在分词过程中,将对我们分词过程中的干扰排除在外的词典。 import re import jieba import ...
  • 关于相似性以及文档特征、特征有太多种说法。弄得好乱,而且没有一个清晰逻辑与归类,包括一些经典书籍里面也分得概念模糊,所以擅自分一分。 ————————————————————————————...
  • 文章目录前言当推荐系统遇上知识图谱模型结构引入知识方法当文本匹配遇上知识图谱模型结构引入知识方法当预训练模型遇上知识图谱模型结构引入知识方法总结 前言   NLP任务中,常见的做法是根据当前输入进行建模,...
  • 问题描述:页面引入一个js文件,其中定义了函数或对象,然后在页面中调用函数或对象时,在IE6会报“语法错误”或“缺少对象”。在IE6+或者IE7却运行正常。 问题分析:这个对象在引入的JS文件中是存在的,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 125,441
精华内容 50,176
关键字:

引入什么词