Docstoc

Packed Derivation of Meaning Representations

Document Sample
Packed Derivation of Meaning Representations Powered By Docstoc
					    Packed Computation of
Exact Meaning Representations


              Iddo Lev
      Department of Computer Science
            Stanford University
                                     Outline
         Motivation
         From Syntax to Semantics
         Packed Computation
         Conclusion




April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   2
          Natural Language Understanding

     • How can we improve accuracy?
     • Let’s take it for a moment to the extreme
           – Exact NLU applications




April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   3
                 Example: Logic Puzzles
     Six sculptures—C, D, E, F, G, and H—are to be exhibited in
         rooms 1, 2, and 3 of an art gallery.
         Sculptures C and E may not be exhibited in the same room.
         Sculptures D and G must be exhibited in the same room.
         If sculptures E and F are exhibited in the same room, no
         other sculpture may be exhibited in that room.
         At least one sculpture must be exhibited in each room, and
         no more than three sculptures may be exhibited in any room.

     1. If sculpture D is exhibited in room 3 and sculptures E and F
         are exhibited in room 1, which of the following may be true?
     (A) Sculpture C is exhibited in room 1.
     (B) No more than 2 sculptures are exhibited in room 3.
     (C) Sculptures F and H are exhibited in the same room.
     (D) Three sculptures are exhibited in room 2.
     (E) Sculpture G is exhibited in room 2.
April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   4
                  Example: Logic Puzzles



           If sculptures E and F are exhibited in the same room, no
           other sculpture may be exhibited in that room.


                           exact meaning representation:


           x.[(room(x)  exhibited-in(E,x)  exhibited-in(F,x)) 
               ¬y.sculpture(y)  y  E  y  F  exhibited-in(y,x)]




April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations   5
                                    Example:
     • MSCS Degree Requirements
           – A candidate is required to complete a program of 45
             units. At least 36 of these must be graded units, passed
             with an average 3.0 (B) grade point average (GPA) or
             higher. The 45 units may include no more than 21 units of
             courses from those listed below in Requirements 1 and 2.
             …
           – Has Patrick Davis completed the program?
           – Can/must Patrick Davis take CS287?


     • Similar to logic puzzles:
           – General constraints + specific situation



April 17, 2007     Iddo Lev, Packed Computation of Exact Meaning Representations   6
                                    Exact NLU
     • More examples
           – Word problems
                 • Logic puzzles
                 • Math, physics, chemistry questions
           – Simple regulation texts, controlled language
           – NL interfaces to databases
                 • Like SQL, but looks like NL
     • In these tasks
           – “Almost correct” (“only slightly wrong”) is not good enough
           – Simple approximations won’t do
                 • E.g. syntactic matching between text and questions
                 • Because answer does not appear explicitly in the text
           – Need exact calculation of NL meaning representations
                 • Answer needs to be inferred from the text
                 • Need to carefully combine information/meaning throughout the text

April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations   7
                       Structural Semantics
  • Need to rely on high-quality meaning representations and
    linguistic knowledge
        – In particular, structural semantics
                 • Meaning of functional words
                 • Logical structure of sentences
  • Essential for exact NLU tasks
  • Could also improve precision of other NLP tasks
                 • T: Michael Melvill guided a tiny rocket-ship more than 100 kilometers
                   above the Earth.
                 • H: A rocket-ship was guided more than 80 kilometers above the
                   Earth. Follows
                 • H: A rocket-ship was guided more than 120 kilometers above the
                   Earth. Does not follow
  • Relatively small size of knowledge
                 • Functional:    #functional words  400 #grammar rules  400
                 • Lexical:       #verb frames  45,000             #nouns > 100,000

April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations   8
                              My Dissertation
     • How to map syntactic analysis to meaning representations
     • How to compute all meaning representations efficiently
                                                                               Focus of this talk

     • Linguistic analysis of advanced NL constructions using the
       above framework
           –     anaphora     (interaction with truth conditions)
           –     comparatives
           –     reciprocals    (each other, one another)
           –     same/different
     • How to translate meaning representations to
       inference representations (FOL)



April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations           9
          Structural Semantics Challenges

     • When analyzing one sentence:
           – (1) Bills 2 and 6 are paid on the same day as each other.
     • it might seem enough to use:
           – x.day(x)paid-on(bill2,x)paid-on(bill6,x)
     • But this is not enough when we consider other sentences:
           – (2) John, Mary, and Frank like each other.
           – each_other({john,mary,frank}, xy.like(x,y))
     • Goal
           – Uniformity: one analysis of “each other” for both (1) and (2).
                 • Should interact correctly with “the same” in (1).
           – Solution should also be consistent with “different”, “similar”:
              • Men and women have a different sense of humor (than each other).




April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations   10
                                     Outline
      Motivation
     
      From Syntax to Semantics
      Packed Computation
      Conclusion




April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   11
                 From Syntax to Semantics
     • How do we get from one parse tree to a semantic
       representation?
           – Classic Method (Montague): one-to-one correspondence:
             assign a lambda-term to each syntactic node

                                               S     x. [dog(x)  bark(x)]


 λR. x. [dog(x)  R(x)]      NP

                                                                 VP
                                                                  |
                  Det                  Noun                       V
                every                   dog                    barks
        λP.λR. x. [P(x)  R(x)]      λy.dog(y)              λz. bark(z)

April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations   12
         Problem 1: Floating Operators
                 S

         NP                VP


                     V      NP           PP


                                              NP


     Frank introduced Rachel to Patrick.

         introduce-to(frank, rachel, patrick)




April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations   13
         Problem 1: Floating Operators
                 S

         NP                VP


                     V      NP           PP
                                                NP
                                                            N’
                                                                    RC
                                              Det                              VP
                                                       N                  VP         NP
     Frank introduced Rachel to every person who visited me that summer.

         every(λx.person(x)visit(x,me),
               λx.introduce-to(frank, rachel, x))

         every(P,Q) x. [P(x)  Q(x)]

April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations        14
         Problem 1: Floating Operators


                  S                                                       S
           NP           VP                                       NP              VP
                 N’                                                     N’
           Adj    N                                         Adj      N
        A brave sailor walked by.                     An occasional sailor walked by.

        a(λx.[sailor(x)brave(x)],                    occasionally(a(λx.sailor(x),
          λx.walk-by(x))                                             λx.walk-by(x)))




April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations     15
      Problem 2: More Than One Meaning

      “In this country, a woman gives birth every 15 minutes.
       Our job is to find that woman, and stop her.”
                                                                        -- Groucho Marx


       every 15 minutes                 a woman
           a woman                         every 15 minutes
              gives birth                      gives birth



       You may not smoke.                    All these books are not interesting.
       You may not succeed.                  All that glitters is not gold.




April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations            16
                            Glue Semantics

• Glue Semantics:
  A flexible framework for mapping syntax to semantics
      – Pieces of syntax correspond to pieces of semantics
      – Pieces of semantics combine with each other according to
        constraints
            • Like jigsaw puzzle, but possibly with more than one solution
      – Not a simple one-to-one mapping

• References
      – Dalrymple et al. Semantics and Syntax in Lexical Functional Grammar. 1999
        Mary Dalrymple. Lexical Functional Grammar. 2001
        Asudeh, Crouch, Dalrymple. The syntax-semantics interface. 2002




April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations   17
                               Glue Semantics
                                                                               (simplified example)
                          S
                 NP                 VP
                                         NP
                 Name         V          Name               statements
                 John         saw        Mary
                                                           mary
                                                           xy.see(x,y)
                                                           john




April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations              18
                                 Glue Semantics
                                                                                 (simplified example)
                            Sa
                 b NP               VP
                                         NP c
                 Name          V         Name                 statements
                  John        saw        Mary
                                                             mary : c
                                                             xy.see(x,y) : b  c  a
                                                             john : b

                            derivation                                        prover

                   john : b         xy.saw(x,y) : b  c  a
    mary : c         y.saw(john,y) : c  a
             saw(john,mary) : a
    gain: order of combination does not have to follow tree hierarchy
April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations              19
            Problem 1: Floating Operators
                    S                                                            S
          NP                 VP                                         NP                VP

                        λx.[sailor(x)brave(x)]                              λQλR.occasionally[Q(λx.sailor(x),R)]
                        N’                                                           N’

               Adj            N                                               Adj            N
    A         brave        sailor      walked by.               An           occas.         sailor     walked by.
λPλR.a(P,R)               λx.sailor(x) λx.walk-by(x)        λPλR.a(P,R)                   λx.sailor(x) λx.walk-by(x)

      λPλx.[P(x)brave(x)]                                        λPλQλR.occasionally[Q(P,R)]



           a(λx.[sailor(x)brave(x)],                        occasionally[a(λx.sailor(x),
             λx.walk-by(x))                                                 λx.walk-by(x))]


   April 17, 2007            Iddo Lev, Packed Computation of Exact Meaning Representations                   20
                                  Glue Semantics
                        S a                                       Flexible handling of
           b NP               VP                                  floating operators.

                          N’ c
                                                                  λPλR.a(P,R) : c  (b  a)  a
                      Adj         N
      An             occas.      sailor     walked by.            λx.sailor(x) : c

                                                                  λx.walk-by(x) : b  a

                 c       c  (b  a)  a                          λS.occasionally[S] : a  a
     ba              (b  a)  a
                 a                               aa
                                   a

                                          occasionally[a(λx.sailor(x),
                                                         λx.walk-by(x))]

April 17, 2007           Iddo Lev, Packed Computation of Exact Meaning Representations            21
                          Glue Semantics
                                                                           (simplified example)
     Can yield more than one meaning.


     A woman gives birth every 15 minutes.

                         “gives birth”              G:a
                         “a woman”                  A: a  a
                         “every 15 minutes”         E:aa


                    two possible derivations:

   G:a         A: a a                            G:a           E:aa
         A(G) : a          E:aa                         E(S) : a        A:aa
                   E(A(G)) : a                                    A(E(S)) : a


April 17, 2007    Iddo Lev, Packed Computation of Exact Meaning Representations              22
                               Glue Semantics

   • Shared labels constrain how statements combine
         – “Resource Sensitive”:
             Use each statement exactly once
         – Inference rules:
                  Application                        Abstraction

                                                       [x:A]
                 :A      :AB                           ¦
                       ():B                           :B
                                                                                  Linear Logic
                                                     x.:AB
                                                                              (implicative fragment)


   • In Glue Semantics, can impose further constraints
     on combinations.
April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations              23
                                     Outline
      Motivation
     
      From Syntax to Semantics
     
      Packed Computation
      Conclusion




April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   24
                                 Ambiguity
     • Flying planes can be dangerous. Therefore, only
       licensed pilots are allowed to do it.
     • Flying planes can be dangerous. Therefore, some
       people are afraid to ride in them.


     • We cannot always disambiguate the sentence
       just by looking at the sentence itself.
     • We sometimes need to take the larger context
       and information into account.



April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   25
                                                 Ambiguity
                              Alternatives multiply across layers…
                 Morphology




                                                                                              Reasoning
                                                           Semantics
                                        Syntax




                                                                               KR
Text




            … so we can’t keep all the alternatives separately

April 17, 2007                Iddo Lev, Packed Computation of Exact Meaning Representations               26
                                            Early Pruning
     • Select most likely analysis at each level
     • Oops: Strong constraints may reject the so-far-best
             (and only) option

                               Statistics


                                                                     X              X X
             Morphology




                                                                                          Reasoning
                                                       Semantics
                                   Syntax




                                                X




                                                                          KR
Text




                                Locally less likely option
                                but globally correct
April 17, 2007            Iddo Lev, Packed Computation of Exact Meaning Representations               27
                                       Packing
                     The sheep liked the fish.                         More than one sheep?
                                                                       More than one fish?
                           Options multiplied out
                       The sheep-sg liked the fish-sg.
                       The sheep-pl liked the fish-sg.
                       The sheep-sg liked the fish-pl.
                       The sheep-pl liked the fish-pl.

                                 Options packed
                                      sg                sg
                      The sheep          liked the fish
                                      pl                pl

           Packed representation:
               – Encodes all analyses without loss of information
               – Common items represented and computed just once

April 17, 2007     Iddo Lev, Packed Computation of Exact Meaning Representations             28
                                          Packing
  •      Calculate compactly all analyses at each stage
  •      Push ambiguities through the stages
  •      Possibly, filter and keep only N-best at each stage
         in a packed form (not only 1-best)
  •      This approach is being pursued in the XLE system
         at PARC (and Powerset Inc.)
        –        (Maxwell & Kaplan ’89,93,95)




April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations   29
           Packing In Syntax: Chart Parser

   A chart parser for a context-free grammar can compute an
   exponential number of parse trees in O(n3) time by
   representing and computing them compactly.

   Instead of separately:

                                                    we have:




April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   30
                       Packed Structures
  XLE manages natural language ambiguity by packing similar
  structures and managing them under a free-choice space

         C-structure forest                                          Packed F-structure




                                      Choice Space:         true  A1  A2
                                                            A1  A2  false
April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations         31
                               Currently in XLE
      Text                                     semantic rewrite rules

FST

      morph.                                  glue             glue
                                              spec.           prover
parser
                           unpack F-str1              Glue1            MR1    pack
      C-str            F-str
                                               :                :                    MR    KR
                                               :                :
                 C-F                 F-strn           Gluen            MRn

                                                                                          answer



         = packed

         = packed calculation + possibly filter N-best

April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations           32
                                           The Goal
      Text

FST

      morph.

parser
                                                     Glue
      C-str            F-str                                                        MR    KR
                                                  statements
                                   glue                               glue
                 C-F                                                 prover
                                   spec.

                                                                                         answer



         = packed

         = packed calculation + possibly filter N-best

April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations          33
    Goal: Packed Meaning Representation

                      Bill saw the girl with the telescope.
            a:1 e. see(e)  agent(e,bill)                   a:2 e. see(e)  agent(e,bill) 
                    theme(e,the(x.girl(x))                         theme(e, the(x. girl(x) 
                    with(e,the(y.tele(y)))                                         with(x,the(y.tele(y))) )



                          e. see(e)  agent(e,bill)  ●

                                                                      ●●

                            theme(e, the(x. ● ))

                                                    ●●


                               girl(x)                     with(●,the(y.tele(y)))
                                                               x e

                           packed meaning representation
April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations                           34
                        Glue Specification
     Glue specification – connecting syntactic and semantic pieces
                                        NTYPE(f, NAME), PRED(f,     p)  p : f

                                        NTYPE(f, COMMON), PRED(f,     p)  λx.p(x) : fv  fr

            F-Structure


                                                        glue statements

                                                         john : a

                                                         λx.cake(x) : bv  br




        “John ate the cake.”
April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations             35
                           Packed Glue Input
         Packed F-structure

                                                                   NTYPE(f, NAME), PRED(f,   p)  p : f e


                                                                       Glue specification




                                                     {1} e.see(e) : aveart
                                                     {2} P.e.P(e) : (aveart)at
                                                     {3} bill : be
     “Bill saw the girl with the telescope.”
                                                     {4} xPe.P(e)agent(e,x) : be(aveart)(aveart)
                                                     {5} P.the(P) : (gvegrt)ge
                                                     {6} x.girl(x) : gvegrt
 This combines                                       {7} xPe.P(e)theme(e,x) : ge(aveart)(aveart)
 Glue Semantics                                      {8} P.the(P) : (hvehrt)he
 + packing                                           {9} x.tele(x) : hvehrt



                                       
                                                     {10} A1: yPe.P(e)with(e,y) : he(aveart)(aveart)
 at the input level                                  {11} A2: yPx.P(x)with(x,y) : he(gvegrt)(gvegrt)


April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations                   36
            Non-packed Prover (Hepple’96)
                                                           Rule:

            Input:                                             : A | S1           : AB | S2
            f : c c d      q:c        r:c                           () : B | S1  S2
                                                                     provided S1  S2 = 
            Chart:
            meaning   category       span
                f     c c d        {1}
                q     c              {2}                     cannot combine:
                r     c              {3}                     {2}{1,2}  
              f(q)    cd            {1,2}
              f(r)    cd            {1,3}
                                                                complete derivation
             f(q,r)   d              {1,2,3}
Output:                                                         (all indices were used)
             f(r,q)   d              {1,2,3}


 April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations          37
                  Syntactic Ambiguity
      “Time flies like an arrow. Fruit-flies like a banana.”

                                                                         -- Groucho Marx




April 17, 2007    Iddo Lev, Packed Computation of Exact Meaning Representations            38
                 Naive Packed Algorithm
     •
           – A1: [[John]a thinks that [[time]d flies [like [an arrow]c]]b]g
           – A2: [[John]a thinks that [[time flies]f like [an arrow]c]b]g

     • The chart algorithm will discover one history for
       [[time]d flies [like [an arrow]c]]b under A1
     • It may then continue under A1 with “John thinks that”
     • It will later discover a history for
       [[time flies]f like [an arrow]c]b under A2
     • So it will have to redo the work for “John thinks that”
       under A2




April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations   39
                        Non-Packed Prover
    – Forget about meaning terms for now
          • (can reconstruct them after the derivation finishes)
    – Combine histories according to topological order of category graph

                                                    {1}      {2} {3}            {4}
                                                    ab            a            ac     category
                                                                                        graph
  mean.    category    span               {5}
   q       ab         {1}               bcd              b {1,2}      c {2,4}
                                                               {1,3}        {3,4}
   p       a           {2}
                                          {1,2,5}
    r      a           {3}                            cd
                                          {1,3,5}
    s      ac         {4}
    t      bcd       {5}
   u       df         {6}                   t(q(p),s(r))     d          t(q(r),s(p))
                                                  df             {1,2,3,4,5}
                                            {6}
                                                            f {1,2,3,4,5,6}

April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations                40
                            Packed Derivation
     •   (Simplified example)
           – A1: [[John]a thinks that [[time]d flies [like [an arrow]c]]b]g
           – A2: [[John]a thinks that [[time flies]f like [an arrow]c]b]g


                 premises       choice
    john         a          {1} 1
    think        abg      {2}
    anarrow      c          {3}
    time         d          {4} A1
    fly          deb      {5}
    like         ce        {6}
    timeflies    f          {7} A2
    like         fcb      {8}




April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations   41
                            Packed Derivation
     •   (Simplified example)
           – A1: [[John]a thinks that [[time]d flies [like [an arrow]c]]b]g
           – A2: [[John]a thinks that [[time flies]f like [an arrow]c]b]g


                 premises          choice
    john         a          {jn}   1
    think        abg      {th}
    anarrow      c          {ar}
    time         d          {t}    A1
    fly          deb      {f}
    like         ce        {k1}
    timeflies    f          {tf}   A2
    like         fcb      {k2}




April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations   42
                            Packed Derivation
    Imagine how each derivation works separately;
     then figure out how to pack.



                 premises          choice
    john         a          {jn}   1
                                                        {f}     {t}       {k1}        {ar}
    think        abg      {th}
    anarrow      c          {ar}
    time         d          {t}   A1                          {k1,ar}                        {jn}   {th}
    fly          deb      {f}                {t,f}
    like         ce        {k1}                         {t,f,k1,ar}
                                                                                                     {jn,th}
    timeflies    f          {tf} A2
    like         fcb      {lk2}
                                                                      {jn,th,t,f,k1,ar}

                                                                          Category graph
April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations                           43
                            Packed Derivation
    Imagine how each derivation works separately;
     then figure out how to pack.


                                                                                        {tf}           {k2}
                 premises          choice
    john         a          {jn}   1
                                                                             {ar}
    think        abg      {th}                                                                       {tf,k2}

    anarrow      c          {ar}                                                         {tf,k2,ar}
    time         d          {t}   A1                                                    {jn}           {th}
    fly          deb      {f}
    like         ce        {lk1}
                                                                                                        {jn,th}
    timeflies    f          {tf} A2
    like         fcb      {k2}
                                                                                    {jn,th,tf,k2,ar}

                                                                    Category graph
April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations                              44
                            Packed Derivation
    Imagine how each derivation works separately;
     then figure out how to pack.


                                                                                                      {tf}           {k2}
                 premises          choice
    john         a          {j}    1
                                                            {f}      {t}       {k1}        {ar}
    think        abg      {th}                                                                                     {tf,k2}

    anarrow      c          {a}
    time         d          {t}    A1                             {k1,ar}                             {jn}           {th}
    fly          deb      {f}                 {t,f}                                     A2:{tf,k2,ar}
    like         ce        {k1}                        A1:{t, f,k1,ar}
                                                                                                                      {jn,th}
    timeflies    f          {tf}   A2
                                            1:{ar} A1:{t, f,k1} A2:{tf,k2}
    like         fcb      {k2}
                                                                           {jn,th,t,f,k1,ar}      {jn,th,tf,k2,ar}
                                                                      1:{jn,th,ar} A1:{t, f,k1} A2:{tf,k2}

April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations                                            45
                                    Packed Derivation
                                                                         only possible in A1
  history   under A1             under A2          packed span
  h1        {ar}                 {ar}              1:{ar}
  h2        {k1,ar}                                A1:{k1,ar}
  h3        {t,f}                                  A1:{t,f}
  h4        {t,f,k1,ar}                            A1:{t,f,k1,ar}
  h5                             {tf,k2}           A2:{tf,k2}
  h6                             {tf,k2,ar}        A2:{tf,k2,ar}
  h7        {t,f,k1,ar}          {tf,k2,ar}        1:{ar} A1:{t,f,k1} A2:{tf,k2}
  h8        {jn,th}              {jn,th}           1:{jn,th}
  h9        {jn,th,t,f,k1,ar}    {jn,thtf,k2,ar}   1:{jn,th,ar} A1:{t,f,k1} A2:{tf,k2}                                     {tf}       {k2}


      packed common part
                                                                                {f}       {t}       {k1}     {ar}
                                                                                                                                       {tf,k2}


                                                                                            {k1,ar}
                                                                        {t,f}                              A2:{tf,k2,ar}   {jn}
                                                                                                                                            {th}
                                                                                  A1:{t, f,k1,ar}

                                                                                                                                  {jn,th}
                                                                    1:{ar} A1:{t, f,k1} A2:{tf,k2}


                                                                                          1:{jn,th,ar} A1:{t, f,k1} A2:{tf,k2}

April 17, 2007                  Iddo Lev, Packed Computation of Exact Meaning Representations                                                      46
                              Packed Derivation
    • Two histories with categories A and AB can be combined:
          – original algorithm: if their spans are disjoint
          – packed algorithm: can combine them in all contexts in which
                                their spans are disjoint


      original combination:
                 A | S1              AB | S2                   provided S1  S2 = 
                             B|S                                and S = S1  S2


      packed combination:
                                                                provided C1  C2  0
           C1 | A | PS1       C2 | AB | PS2
                                                                and combinable(PS1, PS2, C)
                      C | B | PS                                and PS = union(C, PS1, PS2)


April 17, 2007            Iddo Lev, Packed Computation of Exact Meaning Representations       47
                              Packed Derivation
    • Two histories with categories A and AB can be combined:
          – original algorithm: if their spans are disjoint
          – packed algorithm: can combine them in all contexts in which
                                their spans are disjoint

      packed combination:
                                                              provided C1  C2  0
           C1 | A | PS1       C2 | AB | PS2
                                                              and combinable(PS1, PS2, C)
                      C | B | PS                              and PS = union(C, PS1, PS2)

   combinable:           1:{3,4}          1:{5,6,7}              1:{3,4,5,6,7}
   combinable:           1:{3},A1:{6,7}   1:{4,5},A2:{6,8}       1:{3,4,5,6},A1:{7},A2:{8}
   combinable:           A1:{6},A2:{7}    A1:{6},A2:{8}          A2:{7,8}
   non-combinable:       1:{4},A1:{6}     1:{5,6},A2:{4}          (6 is in A1 in both, 4 is in A2 in both)

                 A1:{4,6}   A2:{4}       A1:{5,6}     A2:{4,5,6}


April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations                        48
                          Packed Derivation
     • Two histories with the same category can be packed:
           – original algorithm: if their spans are identical
           – packed algorithm: if their spans are identical in the shared contexts


           can pack:      1:{3,4,5}        1:{3,4,5}       1:{3,4,5}
           can pack:      A1:{1},A2:{2}    A2:{2},A3:{3}  A1:{1},A2:{2},A3:{3}
           can pack:      A1:{t,f,k1,ar}   A2:{tf,k2,ar}   1:{ar}, A1:{t,f,k1}, A2:{tf,k2}
           cannot pack:   1:{5},A1:{6}     1:{5},A2:{7} ({5,6}{5} in A1 , {5}{5,7} in A2))
                 A1:{5,6}    A2:{5}       A1:{5} A2:{5,7}


                                                                                         {ar}




                                                                                        A2:{tf,k2,ar}
                                                                 A1:{t, f,k1,ar}

                                                          1:{ar} A1:{t, f,k1} A2:{tf,k2}


April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations                      49
                                  Packed Derivation
   Reconstruction of packed meaning representation:
     history   packed span                           meaning
     h1        1:{ar}                                l1 : anarrow
     h2        A1:{k1,ar}                            like(l1)
     h3        A1:{t,f}                              fly(time)
     h4        A1:{t,f,k1,ar}                        fly(time,like(l1))
     h5        A2:{tf,k2}                            like(timeflies)
     h6        A2:{tf,k2,ar}                         like(timeflies,l1)
     h7        1:{ar} A1:{t,f,k1} A2:{tf,k2}         A1:fly(time,like(l1)) A2:like(timeflies,l1)
     h8        1:{jn,th}                             think(john)
     h9        1:{jn,th,ar} A1:{t,f,k1} A2:{tf,k2}




                                                                         think(john, ●)
                                                                        A1                           A2
                                                                      fly(time,like(●))            like(timeflies,●)


                                                                                                   anarrow

       category graph                                             packed meaning representation
April 17, 2007              Iddo Lev, Packed Computation of Exact Meaning Representations                              50
                        Packed Derivation
   • What if the category graph has cycles?
         – Calculate strongly connected components (SCCs) and
           the induced directed-acyclic graph (DAG) (+ topological sort)
         – In each SCC, run basic algorithm to find all possibilities
         – If SCC is simple (X, XX) then optimize:
           use as much material as possible before moving out of the cycle


                                                         {2} {3} {4}
                                   {1}
                                                           XX

                                         X

                                             {1}
                 category graph              {1,2} {1,3} {1,4}
                                             {1,2,3} {1,2,4} {1,3,4}
                                             {1,2,3,4}
April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations   51
                         Packed Derivation

          [girl [with the telescope]]A2



                                                                A2:{wt}
                                       1:{grl}
                                                                  XX

                                                 X

                                                     1:{grl}
                                                     A1:{grl} A2:{grl,wt}
                  category graph
                                                     1:{grl}, A2:{wt}




April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations   52
                                           Packed Derivation
     Category graph                                                                  {1} e.see(e) : aveart
                                                                                     {2} P.e.P(e) : (aveart)at
                             1:{8}                     1:{9}                     {3} bill : be
                                   (hvehrt)he             hvehrt
A2:{11}                                                                            {4} xPe.P(e)agent(e,x) : be(aveart)(aveart)
   he(gvegrt)(gvegrt)                                                            {5} P.the(P) : (gvegrt)ge
                                                       he 1:{8,9}                  {6} x.girl(x) : gvegrt
        A2:{8,9,11}                                                                {7} xPe.P(e)theme(e,x) : ge(aveart)(aveart)
                        (gvegrt)(gvegrt)
                                                                                     {8} P.the(P) : (hvehrt)he
                                                                                     {9} x.tele(x) : hvehrt
                                                                                     {10} A1: yPe.P(e)with(e,y) : he(aveart)(aveart)
(gvegrt)ge       gvegrt                                                           {11} A2: yPx.P(x)with(x,y) : he(gvegrt)(gvegrt)
                             1:{6},A2:{8,9,11}

                                                                                                      A1:{10}
       ge        geaetaet                                  1:{3}               heaetaet
                                          beaetaet             be

            1:{5,6,7},                    1:{3,4}
                                                                               A1:{8,9,10}                                Need to calculate
             A2:{8,9,11}                                                                                                   strongly-connected
                                                                                                                            components before
                                            aetaet                                                             1:{2}
                                                                                                       aetat
                                                                                                                            topological sort.
                                                                            aet
                                                             1:{1,3,4,5,6,7,8,9},
                                                              A1:{10},A2:{11}            at1:{1,2,3,4,5,6,7,8,9},
            packing in a cycle                                                                 A1:{10},A2:{11}


 April 17, 2007                        Iddo Lev, Packed Computation of Exact Meaning Representations                                        53
                                     Outline
      Motivation
     
      From Syntax to Semantics
     
      Packed Computation
     
      Conclusion




April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   54
                              My Dissertation
     • How to map syntactic analysis to meaning representations
     • How to compute all meaning representations efficiently
                                                                               Focus of this talk

     • Linguistic analysis of advanced NL constructions using the
       above framework
           –     anaphora     (interaction with truth conditions)
           –     comparatives
           –     reciprocals    (each other, one another)
           –     same/different
     • How to translate meaning representations to
       inference representations (FOL)



April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations           55
                                   Summary
     • Mapping syntax to exact meaning representations
       using Glue Semantics
           – More powerful than traditional approach
           – Easier for users, more principled than semantic rewrite
             rules
           – Covered advanced NL constructions
     • Computing all meaning representations efficiently
           – Input: packed syntactic analysis
           – Output: packed meaning representation
            Pushing packed ambiguities through the semantics stage




April 17, 2007    Iddo Lev, Packed Computation of Exact Meaning Representations   56
                                Future Work
     • Researchers can use this work as a basis
           – Use this in applications
                 • Logic puzzles, word problems, NLIDB, regulation texts
           – Extend this approach to additional NL constructions
                 • (requires some linguistic research)
           – Extend idea of packing to anaphora/plurality and
             back-end inference stages
                 • Some initial work on packed reasoning at PARC
           – Extend statistical disambiguation to packed semantic
             structures




April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations   57
                                     Thanks
     •   Stanley Peters
     •   Dick Crouch
     •   Chris Manning
     •   Mike Genesereth
     •   Johan van Benthem

     • NLTT group at PARC
     • Ivan Sag
     • Bill MacCartney, Mihaela Enachescu, Powerset Inc.

     • Beth Nowadnick

April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   58

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:5
posted:8/10/2012
language:
pages:58