精华内容
下载资源
问答
  • 豆瓣的几篇博文,大概介绍了一下对应分析的ca包中的ca分析函数mjca()函数,具体算法具体参数的意思并没有细说 http://www.douban.com/note/236880884/ http://www.douban.com/note/236615553/ ...

     对应分析(correspondence analysis, CA)是在因子分析的基础上发展起来的方法,通过对原始数据采用适当的标度方法,把R型因子分析(对变量)和Q型因子分析(对样品)结合起来,同时得到两方面的结果。对应分析是一种维度缩减方法,特别的,可以在同一因子平面上表现变量和样品,从而直观的揭示所研究的变量和样品之间的内在联系。
        因子分析最早由法国学者Benzecri (1973)提出,现已有广泛的应用,特别在社会科学研究,市场分析等领域,对应分析已经成为一种常用的数据分析方法。[1]

    ca分析

    用的数据是smoke

     none light medium heavy
    SM    4     2      3     2
    JM    4     3      7     4
    SE   25    10     12     4
    JE   18    24     33    13
    SC   10     6      7     2

    行是体重和列是人名

    library(ca)

    data("smoke")

    ca(smoke)

    即可查看ca分析的结果

    names(ca(smoke)) 抽烟者姓名,即列名

    summary(ca(smoke))

    plot(ca(smoke))基本图形样式[2],plot中的map参数默认是symmetric即对称分布;具体格式可参考文章2

    这里还是说一下吧

    plot(x, dim = c(1,2), map = "symmetric", what = c("all", "all"),
    mass = c(FALSE, FALSE), contrib = c("none", "none"),
    col = c("#0000FF", "#FF0000"), pch = c(16, 1, 17, 24),
    labels = c(2, 2), arrows = c(FALSE, FALSE), ...)
     
    可选的图形参数
    "symmetric" (default) 对称分布
    "rowprincipal" 行数据为主
    "colprincipal" 列数据为主
    "symbiplot" 主成分分析的biplot绘图
    "rowgab"
    "colgab"
    "rowgreen"行作为主坐标列作为标准坐标的情形
    "colgreen"

    plot(ca(smoke), mass = TRUE, contrib = "absolute",map = "rowgreen", arrows = c(FALSE, TRUE))

    行作为主坐标列作为标准坐标的情形

    三维图:

    install.packages("rgl")

    library(rgl)

    plot3d.ca(ca(smoke, nd=3)) nd参数:Number of dimensions to be included in the output;即输出中包含的维度数目

    ################################################

    多重相关分析:

    引用数据:wg93 dataset
     
    这个数据集是国际社会调查计划关于1993年环境的调查:德国西部地区的样本
    作为调查记录的数据框,包含了关于科学态度的四个问题,各自对应一个5分的标度
    (1=强烈同意,5=强烈反对),同时数据框中还有3个人口统计学变量:性别,年龄和教育程度。
     数据集大小 817x7

    library(ca)
    data("wg93")
    mjca(wg93[,1:4])

    head(wg93[,1:4])
      A B C D
    1 2 3 4 3
    2 3 4 2 3
    3 2 3 2 4
    4 2 2 2 2
    5 3 3 3 3
    6 3 4 4 5

    绘图:plot( mjca(wg93[,1:4]))

    #换Burt矩阵的方法再作一次
    #先看看Burt矩阵:(共20行20列,这里是一部分)
    #这个矩阵由anacor包的burtTable( )函数生成

    summary(mjca(wg93[,1:4], lambda = "Burt"))

    plot(mjca(wg93[,1:4], lambda = "Burt"))

    貌似作图效果差异不大

    ######################################################3

    ade4 :  cca介绍

    典范对应分析(canonical correspondence analusis, CCA),是基于对应分析发展而来的一种排序方法,将对应分析与多元回归分析相结合,每一步计算均与环境因子进行回归,又称多元直接梯度分析。其基本思路是在对应分析的迭代过程中,每次得到的样方排序坐标值均与环境因子进行多元线性回归。CCA要求两个数据矩阵,一个是植被数据矩阵,一个是环境数据矩阵。首先计算出一组样方排序值和种类排序值(同对应分析),然后将样方排序值与环境因子用回归分析方法结合起来,这样得到的样方排序值即反映了样方种类组成及生态重要值对群落的作用,同时也反映了环境因子的影响,再用样方排序值加权平均求种类排序值,使种类排序坐标值值也简介地与环境因子相联系
    library(ade4)

    data(rpjdl)

    rpjdl$mil
        ROCH C.25 C.50 C1 C2 C4 C8 C16
    1     80    5    0  0  0  0  0   0
    2     80   10    1  1  0  0  0   0
    3      5   90    1  0  0  0  0   0
    4     20   70    1  0  0  0  0   0
    5     20   80    5  1  0  0  0   0

    millog <- log(rpjdl$mil + 1)
    iv1 <- cca(rpjdl$fau, millog, scan = FALSE)
    plot(iv1)
    s.corcircle(iv1$as)
    s.label(iv1$c1, 2, 1, clab = 0.5, xlim = c(-4,4))
    s.label(iv1$ls, 2, 1, clab = 0, cpoi = 1, add.p = TRUE) 加点
    s.match(iv1$ls, iv1$li, 2, 1, clab = 0.5)
    s.arrow(iv1$fa)
    s.label(iv1$l1, 2, 1, clab = 0, cpoi = 1.5)
    s.label(iv1$co, 2, 1, add.plot = TRUE)
    s.distri(iv1$l1, rpjdl$fau, 2, 1, cell = 0, csta = 0.33)
    s.label(iv1$co, 2, 1, clab = 0.75, add.plot = TRUE)  加表识
    par(mfrow = c(1,2))
    s.corcircle(iv1$cor, 2, 1) 
    s.arrow(iv1$fa, 2, 1)
    par(mfrow = c(1,1))

    是由对应分析CA/RA修改而产生的新方法。它是把CA/RA和多元回归结合起来,每一步计算结果都与环境因子进行回归,而详细地研究植被与环境的关系。Braak把这一方法用于多元直接梯度分析,以区别前面简单的直接梯度分析。CCA要求两个数据矩阵。一个是植被数据矩阵;一个是环境数据矩阵。不同于以前的直接梯度分析,CCA可以结合多个环境因子一起分析从而更好地反映群落与环境的关系。在种类和环境因子不特别多的情况下,CCA可以将样方排序,种类排序及环境因子排序表示在一个图上,可以直观地看出它们之间的关系。CCA的基本思路是在CA/RA迭代过程中,每次得到的样方坐标都要与环境因子相结合,其结合方式为多元线性回归
    (参见,《数量生态学》张金屯

    关键问题:

            (1)RDA或CCA的选择问题:RDA是基于线性模型,CCA是基于单峰模型。一般我们会选择CCA来做直接梯度分析。但是如果CCA排序的效果不太好,就可以考虑是不是用RDA分析。RDA或CCA选择原则:先用species-sample资料做DCA分析,看分析结果中Lengths of gradient 的第一轴的大小,如果大于4.0,就应该选CCA,如果3.0-4.0之间,选RDACCA均可,如果小于3.0, RDA的结果要好于CCA。

          (2)计算单个环境因子的贡献率:CCA分析里面所得到的累计贡献率是所有环境因子的贡献率,怎么得到每个环境因子的贡献率:生成三个矩阵,第一个是物种样方矩阵,第二个是目标环境因子矩阵,第三个是剔除目标环境因子矩阵后的环境因子矩阵。分别输入Canoco软件中,这样CCA分析得到的特征根贡献率即是单个目标环境因子的贡献率。

    ###################################

    发现还有一个包,vegan

    library(permute)
    library(vegan)

    vare.pca <- rda(varespec)
    vare.pca

    plot(vare.pca)

    sum(apply(varespec, 2, var))

    biplot(vare.pca, scaling = -1)

    vare.pca <- rda(varespec, scale = TRUE)
    vare.pca

    plot(vare.pca, scaling = 3)

    dim(varespec)



    先列出来几篇文章

    豆瓣的几篇博文,大概介绍了一下对应分析的ca包中的ca分析函数和mjca()函数,具体算法和具体参数的意思并没有细说

    1 : http://www.douban.com/note/236615553/

    2:http://www.douban.com/note/236880884/

    3:http://www.douban.com/note/237832019/

    典型相关分析

    4:http://blog.csdn.net/statdm/article/details/7585113

    5:http://blog.sina.com.cn/s/blog_b5c8908c0101eddd.html




    http://www.cnblogs.com/medo/archive/2010/01/02/1637839.html



    展开全文
  • python自然语言处理的第10章 分析句子的意思,这一章在拆解英语的语法及对应于计算机语言的概念内容变得更深更多,相应地需要理解记忆的东西增多。整章读下来很吃力,可能大致有了个理解。 我们已经有了分析器...

    python自然语言处理的第10章 分析句子的意思,这一章在拆解英语的语法及对应于计算机语言的概念和内容变得更深更多,相应地需要理解和记忆的东西增多。整章读下来很吃力,可能大致有了个理解。

    我们已经有了分析器和基于特征的语法,我们能否做一些类似分析句子的意思这样有用的事情?

    • 本章的目的是要回答下列问题:
    1. 我们如何能表示自然语言的意思,使计算机能够处理这些表示?
    2. 我们怎样才能将意思表示与无限的句子集合关联
    3. 我们怎样才能使用程序来连接句子的意思表示到知识的存储?
    import nltk
    

    1 自然语言理解

    1.1 查询数据库

    在这里插入图片描述
    在这里插入图片描述

    """
    文法sql0.fcfg说明如何将句子意思表示与句子分析串联组装。
    每个短语结构规则为特征SEM构建值作补充。你可以看到这些补充非常简单;
    在每一种情况下,我们对分割的子成分用字符串连接操作+来组成父成分的值。
    
    """
    import nltk
    nltk.data.show_cfg('grammars/book_grammars/sql0.fcfg')
    
    """
    % start S
    S[SEM=(?np + WHERE + ?vp)] -> NP[SEM=?np] VP[SEM=?vp]
    VP[SEM=(?v + ?pp)] -> IV[SEM=?v] PP[SEM=?pp]
    VP[SEM=(?v + ?ap)] -> IV[SEM=?v] AP[SEM=?ap]
    NP[SEM=(?det + ?n)] -> Det[SEM=?det] N[SEM=?n]
    PP[SEM=(?p + ?np)] -> P[SEM=?p] NP[SEM=?np]
    AP[SEM=?pp] -> A[SEM=?a] PP[SEM=?pp]
    NP[SEM='Country="greece"'] -> 'Greece'
    NP[SEM='Country="china"'] -> 'China'
    Det[SEM='SELECT'] -> 'Which' | 'What'
    N[SEM='City FROM city_table'] -> 'cities'
    IV[SEM=''] -> 'are'
    A -> 'located'
    P[SEM=''] -> 'in'
    """
    
    # 这使我们能够分析SQL查询:
    from nltk import load_parser
    cp = load_parser('grammars/book_grammars/sql0.fcfg')
    query = 'What cities are located in China'
    trees = next(cp.parse(query.split()))
    answer = trees[0].label()['SEM']
    answer2 = trees[1].label()['SEM']
    q = ' '
    q = ' '.join(answer) + " WHERE" 
    q = q + ' '.join(answer2)
    print(q)
    
    # SELECT City FROM city_table WHERE  Country="china"
    
    
    # 最后,我们在数据库city.db上执行查询,检索出一些结果
    from nltk.sem import chat80
    
    rows = chat80.sql_query('corpora/city_database/city.db',q)
    for r in rows: 
        print(r[0])  # 由于每行r是一个单元素的元组,我们输出元组的成员,而不是元组本身
    
    "canton chungking dairen harbin kowloon mukden peking shanghai sian tientsin"
    

    在这里插入图片描述
    在这里插入图片描述
    要达到能够从句子到后来的生成的数据库SQL语句,也就是独立于任何的查询语言,我们应该建立一个经典的逻辑的标准解释。逻辑形式更加的抽象,更加的通用。

    1.2 自然语言、语义和逻辑

    • 语义:第一个是在某些情况下,陈述句非真即假。第二个是名词短语和专有名词的定义指的是世界上的东西。
    • 模型:
      在这里插入图片描述
      在本章后面,我们将使用模型来帮助评估英语句子的真假,并用这种方式来说明表示意思的一些方法。然而,在进入更多细节之前,让我们将从更广阔的角度进行讨论,回到我们在1.5节简要提到过的主题。一台计算机可以理解句子的意思吗?我们该如何判断它是否能理解﹖这类似与问:“计算机能思考吗?”

    2命题逻辑

    1. 命题逻辑使我们能只表示语言结构的对应与句子的特定连接词的那些部分。
    2. 命题逻辑的基本表达式是命题符号,通常写作P、Q、R等。
      在这里插入图片描述
    # NLTKs Expression object can process logical expressions into various subclasses of Expression
    import nltk
    read_expr = nltk.sem.Expression.fromstring
    print(read_expr('-(P & Q)'))
    print(read_expr('P & Q'))
    print(read_expr('P <-> -- P'))
    

    From a computational perspective,** logics give us an important tool for performing inference**.

    1. Suppose you state that Freedonia is not to the north of Sylvania, and you give as your reasons that Sylvania is to the north of Freedonia. In this case, you have produced an argument.
    2. The sentence Sylvania is to the north of Freedonia is the assumption of the argument while Freedonia is not to the north of Sylvania is the conclusion.
    3. The step of moving from one or more ssumptions to a conclusion is called inference. Informally, it is common to write arguments in a format where the conclusion is preceded by therefore.

    在这里插入图片描述

    """
    参数可以通过使用证明系统来测试“句法有效性”。在稍后的10.3节中我们会再多讲一些这个。
    NLTK中的 inference模块通过一个第三方定理证明器Prover9的接口,可以进行逻辑证明。推理机制的输入首先必须用LogicParser()分析成逻辑表达式。
    """
    lp = nltk.sem.Expression.fromstring
    SnF = read_expr('SnF')
    NotFnS = read_expr('-FnS')
    R = read_expr('SnF -> -FnS')
    prover = nltk.Prover9()
    prover.prove(NotFnS, [SnF, R])
    

    一个命题逻辑的模型需要为每个可能的公式分配值True或False。

    val = nltk.Valuation([('P', True), ('Q', True), ('R', False)])
    """
    我们使用一个配对的链表初始化一个估值,每个配对由一个语义符号和一个语义值组成。
    所产生的对象基本上只是一个字典,映射逻辑符号(作为字符串处理)为适当的值
    """
    val['P']
    
    dom = set()
    g = nltk.Assignment(dom)
    
    # 让我们用val初始化模型 m:
    m = nltk.Model(dom, val) 
    
    # 每一个模型都有一个evaluate()方法,可以确定逻辑表达式,如命题逻辑的公式,的语义值;
    # 当然,这些值取决于最初我们分配给命题符号如P、Q和R的真值。
    print(m.evaluate('(P & Q)', g))
    print(m.evaluate('(P & R)', g))
    print(m.evaluate('(P | R)', g))
    

    在这里插入图片描述

    3 一阶逻辑

    本章的剩余部分,我们将通过翻译自然语言表达式为一阶逻辑来表示它们的意思。
    下一步我们将描述如何构造一阶逻辑公式,然后是这样的公式如何用来评估模型。

    3.1 句法

    在这里插入图片描述

    read_expr = nltk.sem.Expression.fromstring
    expr = read_expr('walk(angus)', type_check=True)
    print(expr.argument)
    print(expr.argument.type)
    print(expr.function)
    print(expr.function.type)
    

    为什么我们在这个例子的结尾看到<e,?>呢?
    虽然类型检查器会尝试推断出尽可能多的类型,在这种情况下,它并没有能够推断出 walk的类型,所以其结果的类型是未知的。
    虽然我们期望walk的类型是<e, t>,迄今为止类型检查器知道的,在这个上下文中可能是一些其他类型,如<e,e>或<e,<e, t>>。
    要帮助类型检查器,我们需要指定一个信号,作为一个字典来实施,明确的与非逻辑常量类型关联:

    sig = {'walk': '<e, t>'}
    expr = read_expr('walk(angus)', signature=sig)
    expr.function.type
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    >>> read_expr = nltk.sem.Expression.fromstring
    >>> read_expr('dog(cyril)').free()
    set()
    >>> read_expr('dog(x)').free()
    {Variable('x')}
    >>> read_expr('own(angus, cyril)').free()
    set()
    >>> read_expr('exists x.dog(x)').free()
    set()
    >>> read_expr('((some x. walk(x)) -> sing(x))').free()
    {Variable('x')}
    >>> read_expr('exists x.own(y, x)').free()
    
    >>> read_expr('dog(x)').free()
    {Variable('x')}
    >>> read_expr('own(angus, cyril)').free()
    set()
    >>> read_expr('exists x.dog(x)').free()
    set()
    >>> read_expr('((some x. walk(x)) -> sing(x))').free()
    {Variable('x')}
    >>> read_expr('exists x.own(y, x)').free()
    

    3.2 一阶定理证明

    在这里插入图片描述

    >>> NotFnS = read_expr('-north_of(f, s)')  #  [1]
    >>> SnF = read_expr('north_of(s, f)')    #   [2]
    >>> R = read_expr('all x. all y. (north_of(x, y) -> -north_of(y, x))')   #  [3]
    >>> prover = nltk.Prover9()   #  [4]
    >>> prover.prove(NotFnS, [SnF, R])   # [5]
    

    3.3 一阶逻辑语言总结

    在这里插入图片描述

    3.4 真值模型

    在这里插入图片描述
    在这里插入图片描述

    >>> v = """
    ... bertie => b
    ... olive => o
    ... cyril => c
    ... boy => {b}
    ... girl => {o}
    ... dog => {c}
    ... walk => {o, c}
    ... see => {(b, o), (c, b), (o, c)}
    ... """
    >>> val = nltk.Valuation.fromstring(v)
    >>> print(val)
    {'bertie': 'b',
     'boy': {('b',)},
     'cyril': 'c',
     'dog': {('c',)},
     'girl': {('o',)},
     'olive': 'o',
     'see': {('o', 'c'), ('c', 'b'), ('b', 'o')},
     'walk': {('c',), ('o',)}}
    

    3.5 独立变量和赋值

    在这里插入图片描述
    在这里插入图片描述

    3.6 量化

    在这里插入图片描述

    >>> fmla1 = read_expr('girl(x) | boy(x)')
    >>> m.satisfiers(fmla1, 'x', g)
    {'b', 'o'}
    >>> fmla2 = read_expr('girl(x) -> walk(x)')
    >>> m.satisfiers(fmla2, 'x', g)
    {'c', 'b', 'o'}
    >>> fmla3 = read_expr('walk(x) -> girl(x)')
    >>> m.satisfiers(fmla3, 'x', g)
    {'b', 'o'}
    

    3.7 量词范围歧义

    在这里插入图片描述

    >>> v2 = """
    ... bruce => b
    ... elspeth => e
    ... julia => j
    ... matthew => m
    ... person => {b, e, j, m}
    ... admire => {(j, b), (b, b), (m, e), (e, m)}
    ... """
    >>> val2 = nltk.Valuation.fromstring(v2)
    
    >>> dom2 = val2.domain
    >>> m2 = nltk.Model(dom2, val2)
    >>> g2 = nltk.Assignment(dom2)
    >>> fmla4 = read_expr('(person(x) -> exists y.(person(y) & admire(x, y)))')
    >>> m2.satisfiers(fmla4, 'x', g2)
    
    >>> fmla5 = read_expr('(person(y) & all x.(person(x) -> admire(x, y)))')
    >>> m2.satisfiers(fmla5, 'y', g2)
    set()
    

    在这里插入图片描述

    >>> fmla6 = read_expr('(person(y) & all x.((x = bruce | x = julia) -> admire(x, y)))')
    >>> m2.satisfiers(fmla6, 'y', g2)
    {'b'}
    

    3.8 模型的建立

    在这里插入图片描述

    >>> a3 = read_expr('exists x.(man(x) & walks(x))')
    >>> c1 = read_expr('mortal(socrates)')
    >>> c2 = read_expr('-mortal(socrates)')
    >>> mb = nltk.Mace(5)
    >>> print(mb.build_model(None, [a3, c1]))
    True
    >>> print(mb.build_model(None, [a3, c2]))
    True
    >>> print(mb.build_model(None, [c1, c2]))
    False
    
    >>> a4 = read_expr('exists y. (woman(y) & all x. (man(x) -> love(x,y)))')
    >>> a5 = read_expr('man(adam)')
    >>> a6 = read_expr('woman(eve)')
    >>> g = read_expr('love(adam,eve)')
    >>> mc = nltk.MaceCommand(g, assumptions=[a4, a5, a6])
    >>> mc.build_model()
    True
    
    >>> print(mc.valuation)
    {'C1': 'b',
     'adam': 'a',
     'eve': 'a',
     'love': {('a', 'b')},
     'man': {('a',)},
     'woman': {('a',), ('b',)}}
    

    在这里插入图片描述

    >>> a7 = read_expr('all x. (man(x) -> -woman(x))')
    >>> g = read_expr('love(adam,eve)')
    >>> mc = nltk.MaceCommand(g, assumptions=[a4, a5, a6, a7])
    >>> mc.build_model()
    True
    >>> print(mc.valuation)
    {'C1': 'c',
     'adam': 'a',
     'eve': 'b',
     'love': {('a', 'c')},
     'man': {('a',)},
     'woman': {('c',), ('b',)}}
    

    On reflection, we can see that there is nothing in our premises which says that Eve is the only woman in the domain of discourse, so the countermodel in fact is acceptable. If we wanted to rule it out, we would have to add a further assumption such as exists y. all x. (woman(x) -> (x = y)) to ensure that there is only one woman in the model.

    4 英语句子的语义

    4.1 基于特征的文法中的合成语义学

    在这里插入图片描述

    4.2 λ演算

    在这里插入图片描述
    在这里插入图片描述

    >>> read_expr = nltk.sem.Expression.fromstring
    >>> expr = read_expr(r'\x.(walk(x) & chew_gum(x))')
    >>> expr
    <LambdaExpression \x.(walk(x) & chew_gum(x))>
    >>> expr.free()
    set()
    >>> print(read_expr(r'\x.(walk(x) & chew_gum(y))'))
    \x.(walk(x) & chew_gum(y))
    
    >>> expr = read_expr(r'\x.(walk(x) & chew_gum(x))(gerald)')
    >>> print(expr)
    \x.(walk(x) & chew_gum(x))(gerald)
    >>> print(expr.simplify()) [1]
    (walk(gerald) & chew_gum(gerald))
    

    在这里插入图片描述

    >>> print(read_expr(r'\x.\y.(dog(x) & own(y, x))(cyril)').simplify())
    \y.(dog(cyril) & own(y,cyril))
    >>> print(read_expr(r'\x y.(dog(x) & own(y, x))(cyril, angus)').simplify()) [1]
    (dog(cyril) & own(angus,cyril))
    
    >>> expr1 = read_expr('exists x.P(x)')
    >>> print(expr1)
    exists x.P(x)
    >>> expr2 = expr1.alpha_convert(nltk.sem.Variable('z'))
    >>> print(expr2)
    exists z.P(z)
    >>> expr1 == expr2
    True
    
    >>> expr3 = read_expr('\P.(exists x.P(x))(\y.see(y, x))')
    >>> print(expr3)
    (\P.exists x.P(x))(\y.see(y,x))
    >>> print(expr3.simplify())
    exists z1.see(z1,x)
    

    4.3 量化的NP

    在这里插入图片描述
    在这里插入图片描述

    4.4 及物动词

    在这里插入图片描述

    >>> read_expr = nltk.sem.Expression.fromstring
    >>> tvp = read_expr(r'\X x.X(\y.chase(x,y))')
    >>> np = read_expr(r'(\P.exists x.(dog(x) & P(x)))')
    >>> vp = nltk.sem.ApplicationExpression(tvp, np)
    >>> print(vp)
    (\X x.X(\y.chase(x,y)))(\P.exists x.(dog(x) & P(x)))
    >>> print(vp.simplify())
    \x.exists z2.(dog(z2) & chase(x,z2))
    

    在这里插入图片描述

    >>> from nltk import load_parser
    >>> parser = load_parser('grammars/book_grammars/simple-sem.fcfg', trace=0)
    >>> sentence = 'Angus gives a bone to every dog'
    >>> tokens = sentence.split()
    >>> for tree in parser.parse(tokens):
    ...     print(tree.label()['SEM'])
    all z2.(dog(z2) -> exists z1.(bone(z1) & give(angus,z1,z2)))
    

    在这里插入图片描述

    >>> sents = ['Irene walks', 'Cyril bites an ankle']
    >>> grammar_file = 'grammars/book_grammars/simple-sem.fcfg'
    >>> for results in nltk.interpret_sents(sents, grammar_file):
    ...     for (synrep, semrep) in results:
    ...         print(synrep)
    (S[SEM=<walk(irene)>]
      (NP[-LOC, NUM='sg', SEM=<\P.P(irene)>]
        (PropN[-LOC, NUM='sg', SEM=<\P.P(irene)>] Irene))
      (VP[NUM='sg', SEM=<\x.walk(x)>]
        (IV[NUM='sg', SEM=<\x.walk(x)>, TNS='pres'] walks)))
    (S[SEM=<exists z3.(ankle(z3) & bite(cyril,z3))>]
      (NP[-LOC, NUM='sg', SEM=<\P.P(cyril)>]
        (PropN[-LOC, NUM='sg', SEM=<\P.P(cyril)>] Cyril))
      (VP[NUM='sg', SEM=<\x.exists z3.(ankle(z3) & bite(x,z3))>]
        (TV[NUM='sg', SEM=<\X x.X(\y.bite(x,y))>, TNS='pres'] bites)
        (NP[NUM='sg', SEM=<\Q.exists x.(ankle(x) & Q(x))>]
          (Det[NUM='sg', SEM=<\P Q.exists x.(P(x) & Q(x))>] an)
          (Nom[NUM='sg', SEM=<\x.ankle(x)>]
            (N[NUM='sg', SEM=<\x.ankle(x)>] ankle)))))
    

    在这里插入图片描述

    >>> v = """
    ... bertie => b
    ... olive => o
    ... cyril => c
    ... boy => {b}
    ... girl => {o}
    ... dog => {c}
    ... walk => {o, c}
    ... see => {(b, o), (c, b), (o, c)}
    ... """
    >>> val = nltk.Valuation.fromstring(v)
    >>> g = nltk.Assignment(val.domain)
    >>> m = nltk.Model(val.domain, val)
    >>> sent = 'Cyril sees every boy'
    >>> grammar_file = 'grammars/book_grammars/simple-sem.fcfg'
    >>> results = nltk.evaluate_sents([sent], grammar_file, m, g)[0]
    >>> for (syntree, semrep, value) in results:
    ...     print(semrep)
    ...     print(value)
    all z4.(boy(z4) -> see(cyril,z4))
    True
    

    4.5 再述量词歧义

    在这里插入图片描述
    在这里插入图片描述

    >>> from nltk.sem import cooper_storage as cs
    >>> sentence = 'every girl chases a dog'
    >>> trees = cs.parse_with_bindops(sentence, grammar='grammars/book_grammars/storage.fcfg')
    >>> semrep = trees[0].label()['SEM']
    >>> cs_semrep = cs.CooperStore(semrep)
    >>> print(cs_semrep.core)
    chase(z2,z4)
    >>> for bo in cs_semrep.store:
    ...     print(bo)
    bo(\P.all x.(girl(x) -> P(x)),z2)
    bo(\P.exists x.(dog(x) & P(x)),z4)
    
    >>> cs_semrep.s_retrieve(trace=True)
    Permutation 1
       (\P.all x.(girl(x) -> P(x)))(\z2.chase(z2,z4))
       (\P.exists x.(dog(x) & P(x)))(\z4.all x.(girl(x) -> chase(x,z4)))
    Permutation 2
       (\P.exists x.(dog(x) & P(x)))(\z4.chase(z2,z4))
       (\P.all x.(girl(x) -> P(x)))(\z2.exists x.(dog(x) & chase(z2,x)))
    
    >>> for reading in cs_semrep.readings:
    ...     print(reading)
    exists x.(dog(x) & all z3.(girl(z3) -> chase(z3,x)))
    all x.(girl(x) -> exists z4.(dog(z4) & chase(x,z4)))
    

    5段落语义层

    段落中的一个句子的解释依赖它前面的句子。

    5.1 段落表示理论

    在这里插入图片描述

    """
    为了解析文法 drt.fcfg,我们在 load_parser()调用中指定特征结构中的SEM值用DrtParser解析替代默认的LogicParser。
    """
    >>> from nltk import load_parser
    >>> parser = load_parser('grammars/book_grammars/drt.fcfg', logic_parser=nltk.sem.drt.DrtParser())
    >>> trees = list(parser.parse('Angus owns a dog'.split()))
    >>> print(trees[0].label()['SEM'].simplify())
    ([x,z2],[Angus(x), dog(z2), own(x,z2)])
    

    5.2 段落处理

    我们解释一句话时会使用丰富的上下文知识,一部分取决于前面的内容,一部分取决于我们的背景假设。DRT提供了一个句子的含义如何集成到前面段落表示中的理论,但是在前面的讨论中明显缺少这两个部分。首先,一直没有尝试纳入任何一种推理;第二,我们只处理了个别句子。这些遗漏由模块nltk.inference.discourse纠正。

    >>> dt = nltk.DiscourseTester(['A student dances', 'Every student is a person'])
    >>> dt.readings()
    
    s0 readings:
    
    s0-r0: exists x.(student(x) & dance(x))
    
    s1 readings:
    
    s1-r0: all x.(student(x) -> person(x))
    
    >>> dt.add_sentence('No person dances', consistchk=True)
    Inconsistent discourse: d0 ['s0-r0', 's1-r0', 's2-r0']:
        s0-r0: exists x.(student(x) & dance(x))
        s1-r0: all x.(student(x) -> person(x))
        s2-r0: -exists x.(person(x) & dance(x))
    
    >>> dt.retract_sentence('No person dances', verbose=True)
    Current sentences are
    s0: A student dances
    s1: Every student is a person
    
    >>> dt.add_sentence('A person dances', informchk=True)
    Sentence 'A person dances' under reading 'exists x.(person(x) & dance(x))':
    Not informative relative to thread 'd0'
    

    discourse模块可适应语义歧义,筛选出不可接受的读法。下面的例子调用Glue语义和 DRT。由于Glue语义模块被配置为使用的覆盖面广的Malt依存关系分析器,输入(Every dog chases a boy.He runs.)需要分词和标注。

    >>> from nltk.tag import RegexpTagger
    >>> tagger = RegexpTagger(
    ...     [('^(chases|runs)$', 'VB'),
    ...      ('^(a)$', 'ex_quant'),
    ...      ('^(every)$', 'univ_quant'),
    ...      ('^(dog|boy)$', 'NN'),
    ...      ('^(He)$', 'PRP')
    ... ])
    >>> rc = nltk.DrtGlueReadingCommand(depparser=nltk.MaltParser(tagger=tagger))
    >>> dt = nltk.DiscourseTester(['Every dog chases a boy', 'He runs'], rc)
    >>> dt.readings()
    
    s0 readings:
    
    s0-r0: ([],[(([x],[dog(x)]) -> ([z3],[boy(z3), chases(x,z3)]))])
    s0-r1: ([z4],[boy(z4), (([x],[dog(x)]) -> ([],[chases(x,z4)]))])
    
    s1 readings:
    
    s1-r0: ([x],[PRO(x), runs(x)])
    
    >>> dt.readings(show_thread_readings=True)
    d0: ['s0-r0', 's1-r0'] : INVALID: AnaphoraResolutionException
    d1: ['s0-r1', 's1-r0'] : ([z6,z10],[boy(z6), (([x],[dog(x)]) ->
    ([],[chases(x,z6)])), (z10 = z6), runs(z10)])
    
    >>> dt.readings(show_thread_readings=True, filter=True)
    d1: ['s0-r1', 's1-r0'] : ([z12,z15],[boy(z12), (([x],[dog(x)]) ->
    ([],[chases(x,z12)])), (z17 = z12), runs(z15)])
    

    6 小结

    在这里插入图片描述

    展开全文
  • 面向主题:主题是指使用数据仓库进行决策时所关心的重点方面,每个主题都对应一个相应的分析领域,一个主题通常与多个信息系统相关。数据分层好处如下:ü 清晰的数据结构:每层数据都有各自的作用域职责...

    数据仓库,Data Warehouse,可简写为DW或DWH。是面向主题的、集成的(非简单的数据堆积)、相对稳定的、反应历史变化的数据集合,数仓中的数据是有组织有结构的存储数据集合,用于对管理决策过程的支持。

    14cdac3a96e355a23ef119024b75f16e.png

    面向主题:主题是指使用数据仓库进行决策时所关心的重点方面,每个主题都对应一个相应的分析领域,一个主题通常与多个信息系统相关。

    数据分层好处如下

    ü 清晰的数据结构:每层数据都有各自的作用域和职责,在使用表的时候更方便定位和理解。

    ü 减少重复开发:规范数据分层,开发一层公用的中间层数据,减少重复计算流转数据。

    ü 统一数据出口:通过数据分层,提供统一的数据出口,保证对外输出数据口径一致。

    ü 简化问题:通过数据分层,将复杂的业务简单化,将复杂的业务拆解为多层数据,每层数据负责解决特定的问题。

    7853353d11a6d1243e395050eeefe122.png

    l ODS(Operational Data Store)层 - 操作数据层

    ODS层,操作数据层,也叫贴源层,本层直接存放从业务系统抽取过来的数据,这些数据从结构上和数据上与业务系统保持一致,降低了数据抽取的复杂性,本层数据大多是按照源头业务系统的分类方式而分类的。一般来讲,为了考虑后续可能需要追溯数据问题,因此对于这一层就不建议做过多的数据清洗工作,原封不动地接入原始数据即可。

    l DW(Data Warehouse)层 - 数据仓库层

    数据仓库层是我们在做数据仓库时要核心设计的一层,本层将从 ODS 层中获得的数据按照主题建立各种数据模型,每一个主题对应一个宏观的分析领域,数据仓库层排除对决策无用的数据,提供特定主题的简明视图。DW层又细分为 DWD(Data Warehouse Detail)层、DWM(Data Warehouse Middle)层和DWS(Data Warehouse Service)层。

    n 数据明细层:DWD(Data Warehouse Detail)

    该层一般保持和ODS层一样的数据粒度,并且提供一定的数据质量保证,在ODS的基础上对数据进行加工处理,提供更干净的数据。同时,为了提高数据明细层的易用性,该层会采用一些维度退化手法,当一个维度没有数据仓库需要的任何数据时,就可以退化维度,将维度退化至事实表中,减少事实表和维表的关联。例如:订单id,这种量级很大的维度,没必要用一张维度表来进行存储,而我们一般在进行数据分析时订单id又非常重要,所以我们将订单id冗余在事实表中,这种维度就是退化维度。

    n 数据中间层:DWM(Data Warehouse Middle)

    该层会在DWD层的数据基础上,对数据做轻度的聚合操作,生成一系列的中间表,提升公共指标的复用性,减少重复加工处理数据。简单来说,就是对通用的维度进行聚合操作,算出相应的统计指标,方便复用。

    n 数据服务层:DWS(Data Warehouse Service)

    该层数据表会相对比较少,大多都是宽表(一张表会涵盖比较多的业务内容,表中的字段较多)。按照主题划分,如订单、用户等,生成字段比较多的宽表,用于提供后续的业务查询,OLAP分析,数据分发等。

    在实际业务处理中,如果直接从DWD或者ODS计算出宽表的统计指标,会存在计算量太大并且维度太少的问题,因此一般的做法是,在DWM层先计算出多个小的中间表,然后再拼接成一张DWS的宽表。由于宽和窄的界限不易界定,也可以去掉DWM这一层,只留DWS层,将所有的数据在放在DWS也没有问题。

    l DM(Data Mart)层 - 数据集市层

    数据集市层,也可以称为数据应用层,基于DW上的基础数据,整合汇总成分析某一个主题域的报表数据。主要是提供给数据产品和数据分析使用的数据,一般会存放在 ES、PostgreSql、Redis等系统中供线上系统使用,也可能会存在 Hive 或者 Druid 中供数据分析和数据挖掘使用。比如我们经常说的报表数据,一般就放在这里。

    数据库与数据仓库区别

    数据库:传统关系型数据库的主要应用是OLTP(On-Line Transaction Processing),主要是基本的、日常的事务处理,例如银行交易。主要用于业务类系统,主要供基层人员使用,进行一线业务操作。

    数据仓库:数仓系统的主要应用主要是OLAP(On-Line Analytical Processing),支持复杂的分析操作,侧重决策支持,并且提供直观易懂的查询结果。OLAP数据分析的目标是探索并挖掘数据价值,作为企业高层进行决策的参考。

    8540b0e70ee2077492c8d20abb5713f2.png
    展开全文
  • import as from import 区别在python中import或者from…import是用来导入相应的模块。那每一种有什么具体的差别呢?一、import只有import,为最简单的引入对应的包。例如:import pickle #引入 pickle包import os #...

    import as from import 区别

    在python中import或者from…import是用来导入相应的模块。那每一种有什么具体的差别呢?

    一、import

    只有import,为最简单的引入对应的包。例如:

    import pickle #引入 pickle包

    import os #引入 os包

    二、from A import B

    这种方式意味着从A中引入B。相当于:import A, b=A.b。

    from urllib.parse import urlparse

    from sys import argv

    除了这种基本形式,还有另外两种,例如:

    from os import makedirs, unlink, sep #从os包中引入 makedirs.unlink,sep类

    from os import listdir, getcwd #从os包中引入 listdir, getcwd 类

    from os.path import dirname, exists, isdir, splitext #从 os包中的path类中引入 dirmame exists 方法

    from os.path import join #从 os包中的path类中引入 join 方法

    三、import A as B

    这种方式为给引入的包A定义一个别名B,例如:

    import xml.etree.ElementTree as ET #给包xml.etree.ElementTree 定义一个 ET 别名

    原文链接:https://blog.csdn.net/weixin_41454036/article/details/108573221

    展开全文
  • 就是一个路径的解析,根据客户端提交的路径,将请求解析到相应的控制器上; 从 URL 找到处理这个 URL 的类函数。参考文献: 1.理解Web路由 2.Web开发中的”路由”是什么意思? 3.web 开发中的路由是什么意思
  • fastadmin一键 crud 菜单生成

    千次阅读 2018-10-10 21:27:41
    fastadmin的一键 crud 菜单的生成; 一键crud , 意思是为我创建的数据生成...相应的步骤是: 首先 在数据库中创建一个表,假设这个表是 fa_testtwo 然后 进行一键crud的生成操作,具体方法是:  在项目的...
  • /* 对正在设置位所对应的显示缓冲区 元素赋 0,使 LED 灭*/ dispbuf[SetSelect*2+1]=0; } if(IsBeep) P3_1=!P3_1; /* 闹钟模式时,产生峰鸣器响脉冲 */ ...
  • 下面的代码通过显示一个更复杂的搜索案例扩展了先前的答案。我有一个受配置文件严格控制的应用程序。...因为我觉得配置集会随着时间的推移而增长,所以我不想在应用程序中硬编码文件列表和相应的选项(以及它们...
  • ORM英文全写Object relational mapping,也就是英文的表面意思对象关系映射,关系型数据库对象之间的一一映射,如果有个用户表user【id、userName、pwd】、如果建立对象之间的一一映射,那么我们也需要建相应的类...
  • 我国也提出了相应的国家标准。IC卡作为人们日常生活的一个支付手段,同样可以作为电子收费中的储值载体。由于非接触IC更适合车辆环境,所以采用了非接触IC卡以及相应的读卡器。为了适合国标的要求,对其的设计实现也...
  • 第八章 硬盘显卡的访问与控制 8.2 用户程序的结构 处理器对指令数据的获取一律按“段地址:偏移地址“进行,相对应地,一个规范的程序应该包括代码段、数据段、附加段栈段。...但是,相应的
  •  每一行都是一个对象先生成一个空项,无数据,如果是普通的项则生成出对应的表格,如果是编辑项,则不仅生成出相应的表格,而且生成出相应的控件,对应的文本框、下拉列表、单选按钮列表等等。当然如果普通项中有...
  • AIDL的定义 aidl是Android interface definition Language 的英文缩写,... 将服务的aidl放到对应的src目录,工程的gen目录会生成相应的接口类    RemoteViews执行流程: RemoteViews通过Binder传递至System...
  •  HitTest为命中测试的意思。在使用MFC编写程序的时候,在树形视图以及列表视图中通常会涉及到需要获得鼠标当前位置所对应的元素。这种通过光标坐标位置来获得相应元素项的操作我们称之为命中测试。 在树形视图...
  • ====================== 基于Qt的第三方库控件======================libQxt--------http://dev.libqxt.org/libqxt/wiki/Home按照文档中所流露的意思,libQxt实现了一些“Qt本来...对应Qt相应的Module,Qxt有 Qx...
  • View类视图 我们在views中写一些方法的时候,需要根据template的请求方法采用不同的逻辑代码,而每次都要判断方法...意思就是把一个类定义为视图类,在这个类中有一些固定的方法,对应了template相应的请求方法 ...
  • 这一节,重点介绍14个希腊字母和相应的国际音标。汉语、韩语中,送气的p、t、k和不送气的b、d、g是区分意思的2组不同音素。送气音p、t、k 对应国际音标[pʰ]、[tʰ]、[kʰ]、古希腊语中的φ、θ、χ,古拉丁语用ph、...
  • 关于字典管理,其实就是2个表,一个表记录字典和对应表,另一个表记录字典内容。我这里改名为字典选项,其实是一个意思。直接上图: 这里字典选项是分子系统,每个子系统可以有自己单独字典,方便管理。...
  • default-action-ref 标签是 struts.xml 中的标签,意思是默认的动作引用,可以理解为当没有相应的 action 对应是,调用这个 action 引用,如下: 1: default-action-ref name="index" /> 上面这段代码...
  • 意思就是只要子节点中包含children属性就不展示,说明不是最终子节点。 如下图所示。 右侧只展示了最终子节点而没有展示一级二级节点。 1、勾选时候右侧列表会展示勾选最终子节点。 2、点击删除列表中某...
  • 解决这个问题我们可以将相应的.dll 文件放到系统 中。在Qt Creator 的安装目录的qt 文件下的bin 文件夹下(我安装在了D 盘, 所以路径是D:\Qt\2009.04\qt\bin),可以找到所有的相关.dll 文件。在这里 找到mingwm10....
  • 一、思考一对一与一对多的区别: ...就是对一个对象进行操作的时候,会把他相关联的对象也一并进行相应的操作,相关联的对象意思是指 在一对多关系中,班级跟学生,Student的实体类中,存在着Classes对象的...
  • HandlerAdapter字面上...当handlerMapping获取到执行请求的controller时,DispatcherServlte会根据controller对应的controller类型来调用相应的HandlerAdapter来进行处理。 在贴源码之前先说一下HandlerAdapt...
  • ios-OAuth授权SSO授权

    2017-10-25 19:15:33
    SSO其实就是Single Sign On,单点登录的意思,当用户安装了相应的第三方软件并且已经登录了,那么我们在采用SSO登录的时候就不需要用户再去输入用户名密码了 第三方登录主要就是简化了用户登录的流程,通过用户...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 149
精华内容 59
关键字:

对应和相应的意思