Ling 388 language and computers
Download
1 / 30

LING 388 Language and Computers - PowerPoint PPT Presentation


  • 47 Views
  • Uploaded on

LING 388 Language and Computers. Lecture 20 11/6 /03 Sandiway FONG. Administrivia. Next Tuesday (11th) Veterans’ Day Today’s Lecture Homework 3 review Help with Homework 4 Next time … We start a brand-new topic known as Shallow Parsing

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' LING 388 Language and Computers' - uta


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Ling 388 language and computers

LING 388Language and Computers

Lecture 20

11/6/03

Sandiway FONG


Administrivia
Administrivia

  • Next Tuesday (11th)

    • Veterans’ Day

  • Today’s Lecture

    • Homework 3 review

    • Help with Homework 4

  • Next time …

    • We start a brand-new topic known as Shallow Parsing

      • We’ll begin with Part-of-speech (POS) tagging, stemming …



Exercise 1 part b encoding the idiom kick the bucket

np

vp

v

john

died

Exercise 1 Part (B): Encoding the idiom kick the bucket

  • Add a DCG rule to encode the idiomatic meaning of John kicked the bucket, i.e.

s

?- s(X,[john,kicked,the,bucket],[])

X = s(np(john),vp(v(died)))

  • Hint: see how the terminal string the ball was encoded in Lecture 10

np --> [the,ball].


Sample dcg
Sample DCG

  • s(s(X,Y)) --> np(X), vp(Y).

  • np(np(X,Y)) --> det(X,Num), common_noun(Y,Num).

  • np(np(X)) --> proper_noun(X).

  • vp(vp(X)) --> intransitive_verb(X).

  • vp(vp(X,Y)) --> transitive_verb(X), np(Y).

  • common_noun(n(man),sg) --> [man].

  • common_noun(n(men),sg) --> [men].

  • proper_noun(john) --> [john].

  • det(det(the),_) --> [the]. det(det(a),sg) --> [a].

  • intransitive_verb(v(ran)) --> [ran].

  • transitive_verb(v(saw)) --> [saw].


Exercise 4 part a implementing every and some
Exercise 4 Part (A): Implementing every and some

  • Want parses:

    • s(forall(X,man(X)),vp(v(likes),np(john))))

    • s(exists(X,men(X)),vp(v(like),np(n(beer))))

  • for

    • Every man likes John

    • Some men like beer


Exercise 4 part a implementing every and some1
Exercise 4 Part (A): Implementing every and some

  • NP rules:

    • np(np(X,Y)) --> quantifier(X,Num), common_noun(Y,Num).

    • quantifier(q(every),sg) --> [every].

    • quantifier(q(some),_) --> [some].

    • common_noun(n(man),sg) --> [man].

    • common_noun(n(men),pl) --> [men].

  • Solution:

    • Write one rule specialized for every and another for some


Exercise 4 part a implementing every and some2
Exercise 4 Part (A): Implementing every and some

  • Case 1: every

    • np(np(X,Y)) --> quantifier(X,Num), common_noun(Y,Num).

    • quantifier(q(every),sg) --> [every].

    • common_noun(n(man),sg) --> [man].

  • Parsing every man will produce the following series of variable bindings:

np(np(X,Y)) --> quantifier(X,Num), common_noun(Y,Num).

quantifier(q(every),sg)

common_noun(n(man),sg)

every

man


Exercise 4 part a implementing every and some3
Exercise 4 Part (A): Implementing every and some

  • Perform a partial substitution; instantiate every:

    • np(np(X,Y)) -->

      • quantifier(q(every),Num),

      • common_noun(n(N),Num).

  • Note:

    • NP rule is now particular to sequences every N

    • I.e. NP rule won’t fire for other NP sequences like:

      • some men

      • the cat

      • John


Exercise 4 part a implementing every and some4
Exercise 4 Part (A): Implementing every and some

  • Substitute forall for np:

    • np(forall(X,Y)) -->

      • quantifier(q(every),Num),

      • common_noun(n(N),Num).

  • Finally, add code in {…} to generate Y from N:

    • np(forall(X,Y)) -->

      • quantifier(q(every),Num),

      • common_noun(n(N),Num),

      • {Y=..[N,X]}.

  • The same implementation strategy works also for some and exists(X,N(X)) …


Key concepts
Key Concepts

  • Use partial variable substitution

    • … to customize a rule

  • We can build f(X) where f cannot be determined statically,

    i.e. at the time we specify the grammar rule

    by …

    • using Prolog built-in univ (=..), and

    • the DCG rule out-call mechanism {…}



  • Logic and negation in prolog
    Logic and Negation in Prolog

    • Filter 1:

      • All variables must be bound by an operator

    • Implementation:

      • \+ (variable(X,F), var(F))

        • variable/2 is an np(x) finder

        • F bound when lx can be found

    • Question:

      • Why are we implementing a positive condition using negation (\+)?


    Logic and negation in prolog1
    Logic and Negation in Prolog

    s

    np

    vp

    np

    lambda

    v

    np

    n

    det

    x

    s

    hissed at

    x

    cat

    the

    np

    vp

    • *The cat that John saw hissed at

    john

    v

    np

    saw

    x


    Logic and negation in prolog2
    Logic and Negation in Prolog

    • Example:

      • All tomatoes are red

    • Define predicates:

      tomato(X)

      red(X)

    • Condition:

      • ?- tomato(X), red(X).

        • holds if there exists some X such that X is a tomato and X is red

        • Doesn’t check all the tomatoes in the box

        • Hence, query does not guarantee that all the tomatoes in the box are red


    Logic and negation in prolog3
    Logic and Negation in Prolog

    • Example:

      • All tomatoes are red

    • Equivalent condition:

      • It cannot be the case that there exists some tomato and that tomato is not red

    • Implementation:

      • ?- \+ ( tomato(X), \+ red(X)).

        • holds if it is not the case that there exists some X such that X is a tomato and X is not red

        • Guarantees that all the tomatoes in the box are red


    Logic and negation in prolog4
    Logic and Negation in Prolog

    • Basic Quantifier Conversion Rules:

      • "x p(x) <=> Ø$x Øp(x)

      • Ø$x p(x) <=> "x Øp(x)

  • Examples:

    • "X tomato(X), red(X)

    • <=> Ø$X tomato(X), \+ red(X)

  • Prolog variables?

    • By default, existentially quantified ($)


  • Logic and negation in prolog5
    Logic and Negation in Prolog

    • Filter 1:

      • All variables must be bound by an operator

    • Conversion:

      • There must not exist a variable that is not bound by an operator

    • Implementation:

      • \+ (variable(X,F), var(F))

        • variable/2 is an np(x) finder

        • F bound when lx can be found


    Implementing the exactly one condition
    Implementing the Exactly One Condition

    • In Exercise 5 …

      • Filter 2:

        • All operators must bind exactly one variable

      • Implementation:

        • filter2(X) :- operator(X).

      • Predicate:

        • operator(X)

          • holds if X contains a lx.Y with less than two variables in Y


    Implementing the exactly one condition1
    Implementing the Exactly One Condition

    • Operator/1 calls predicate lt2vars/2:

      • lt2vars(X,F)

        • holds if there are less than two variables in X

        • F is bound to one if there is one variable in X

      • We’ll need to impose either that:

        • F == one or

        • \+ var(F)

          to the output of lt2vars/2 to implement the condition for exactly one variable


    Implementing the universally quantified condition
    Implementing the Universally Quantified Condition

    • Not done yet …

      • Filter 2:

        • All operators must bind exactly one variable

      • Implementation:

        • filter2(X) :- operator(X).

      • Predicate:

        • operator(X)

          • holds if X contains a lx.Y with less than two variables in Y

          • I.e. if in X $ lx.Y with less than two variables in Y


    Implementing the universally quantified condition1
    Implementing the Universally Quantified Condition

    • Filter 2:

      • All operators must bind exactly one variable

    • So we must convert this to an existentially quantified condition

    • Equivalently:

      • In X, it cannot be the case that operator(X) holds and the number of variables bound is not one


    Overlapping non overlapping clauses
    Overlapping/Non-Overlapping Clauses

    • Question:

      • For tree-walkers, why do we sometimes want overlapping clauses, i.e. have more than one applicable clause, and why sometimes we don’t?

    • Example:

      • operator/1 is overlapping

      • lt2vars/2 is non-overlapping


    Case 1 non overlapping clauses
    Case 1: Non-Overlapping Clauses

    • lt2vars(np(x),F) :-

      • var(F), F = one.

    • lt2vars(X,F) :-

      • X =.. [_,A1,A2],

      • lt2vars(A1,F),

      • lt2vars(A2,F).

    • lt2vars(X,F) :-

      • \+ X = np(x),

      • X =.. [_,A],

      • lt2vars(A,F).

    • lt2vars(X,_) :- atom(X).

    • Unary branching structure:

    np(x)

    matches two clauses

    blocks np(x)

    Want only one match!


    Case 1 non overlapping clauses1

    • lt2vars(np(x),F) :-

      • var(F), F = one.

    • lt2vars(X,F) :-

      • X =.. [_,A1,A2],

      • lt2vars(A1,F),

      • lt2vars(A2,F).

    • lt2vars(X,F) :-

      • \+ X = np(x),

      • X =.. [_,A],

      • lt2vars(A,F).

    • lt2vars(X,_) :- atom(X).

    Case 1: Non-Overlapping Clauses

    np(x)

    • Need to block the lower clause from applying

      • it does not set F, and otherwise

      • ?- lt2vars(X,F), var(F).

      • will succeed when X has, say, three np(x)s

    [Upper clause will reject 3 np(x)s, but lower clause will pass it.]


    Case 2 overlapping clauses
    Case 2: Overlapping Clauses

    • operator(lambda(x,Y)):-

      • lt2vars(Y,_).

    • operator(X) :-

      • X =.. [_,A1,_],

      • operator(A1).

    • operator(X) :-

      • X =.. [_,_,A2],

      • operator(A2).

    • operator(X) :-

      • X =.. [F,A],

      • operator(A).

    • Binary branching structure:

    lambda(x,_)

    matches three clauses

    Want multiple matches!


    Case 2 overlapping clauses1
    Case 2: Overlapping Clauses

    lambda(x,_)

    • operator(lambda(x,Y)):-

      • lt2vars(Y,_).

    • operator(X) :-

      • X =.. [_,A1,_],

      • operator(A1).

    • operator(X) :-

      • X =.. [_,_,A2],

      • operator(A2).

    • operator(X) :-

      • X =.. [F,A],

      • operator(A).

    • operator/1 is a lx finder

    • We want it to be able to find and test all lx structures within a phrase structure

    • ?- operator(X). will succeed once for each lx in X


    Case 2

    s

    vp

    np

    Case 2

    first lx

    np

    v

    mary

    np

    lambda

    hit

    x

    s

    det

    n

    np

    vp

    the

    man

    np

    lambda

    v

    np

    n

    det

    x

    s

    hissed at

    x

    cat

    the

    np

    vp

    • *Mary hit the man that the cat that John saw Mary hissed at

    john

    v

    np

    saw

    mary


    Case 21

    s

    vp

    np

    Case 2

    first lx

    np

    v

    mary

    np

    lambda

    hit

    x

    s

    det

    n

    np

    vp

    the

    man

    np

    lambda

    v

    np

    n

    det

    x

    s

    hissed at

    x

    cat

    the

    np

    vp

    • *Mary hit the man that the cat that John saw Mary hissed at

    john

    v

    np

    saw

    mary


    Key concept
    Key Concept

    • We need to restrict or use overlap as appropriate

      • Because of Prolog’s search strategy

        • i.e. if a clause fails during a query, Prolog will look for another way to succeed


    ad