1 / 21

Context-Free Parsing

Context-Free Parsing. Part 2 Features and Unification. Parsing with features. We need to constrain the rules in CFGs, for example to coerce agreement within and between constituents to pass features around to enforce subcategorisation constraints

georgianorton
Download Presentation

Context-Free Parsing

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Context-Free Parsing Part 2 Features and Unification

  2. Parsing with features • We need to constrain the rules in CFGs, for example • to coerce agreement within and between constituents • to pass features around • to enforce subcategorisation constraints • Features can be easily added to our grammars • And later we’ll see that feature bundles can completely replace constituents

  3. Parsing with features • Rules can stipulate values, or placeholders (variables) for values • Features can be used within the rule, or passed up via the mother nodes • Example: subject-verb agreement S  NP VP [if NP and VP agree in number] number of NP depends on noun and/or determiner number of VP depends on verb S  NP(num=X) VP (num=X) NP (num=X)  det(num=X) n (num=X) VP(num=X)  v(num=X) NP(num=?)

  4. this man n(num=pl) men Declarative nature of features NP (num=X)  det(num=X) n (num=X) The rules can be used in various ways • To build an NP only if det and n agree (bottom-up) • When generating an NP, to choose an n which agrees with the det (if working L-to-R) (top-down) • To show that the num value for an NP comes from its components (percolation) • To ensure that the num value is correctly set when generating an NP (inheritance) • To block ill-formed input this det (num=sg) these det (num=pl) the det (num=?) man n (num=sg) men n (num=pl) NP (num=sg) det(num=sg) n(num=sg)

  5. the man Use of variables NP (num=X)  det(num=X) n (num=X) • Unbound (unassigned) variables (ie variables with a free value): • the can combine with any value for num • Unification means that the num value for the is set to sg this det (num=sg) these det (num=pl) the det (num=?) man n (num=sg) men n (num=pl) NP (num=sg) det(num=?) n(num=sg)

  6. Parsing with features • Features must be compatible • Formalism should allow features to remain unspecified • Feature mismatch can be used to block false analyses, and disambiguate • e.g. they can fish ~ he can fish ~ he cans fish • Formalism may have attribute-value pairs, or rely on argument position e.g. NP(_num,_sem)  det(_num) n (_num,_sem) an = det(sing) the = det(_num) man = n(sing,hum)

  7. Parsing with features VP  v e.g. dance VP v NP e.g. eat VP  v NP NP e.g. give VP  v PP e.g. wait (for) • Using features to impose subcategorization constraints VP(_num)  v(_num,intr) VP(_num)  v(_num,trans) NP VP(_num)  v(_num,ditrans) NP NP VP(_num)  v(_num,prepobj(_case)) PP(_case) PP(_case)  prep(_case) NP dance = v(plur,intr) dances = v(sing,intr) danced = v(_num,intr) waits = v(sing,prepobj(for)) for = prep(for)

  8. S NP VP (_num) (_num) v (sing,intrans) v NP (sing,trans) (_1) det n (_num) (_num) det n (_1) (_1) shot the man those elephants Parsing with features (top-down) S  NP(_num) VP(_num) NP(_num)  det(_num) n(_num) VP(_num)  v(_num,intrans) VP(_num)  v (_num,trans) NP(_1) the man shot those elephants S  NP(_num) VP(_num) NP(_num)  det(_num) n(_num) the = det(_num) man = n(sing) (sing) (sing) _num=sing VP(sing)  v(sing,intrans) shot = v(sing,trans) (sing) (pl) VP(sing)  v(sing,trans) NP(_1) (sing) shot = v(sing,trans) NP(_1)  det(_1) n(_1) (pl) (pl) those = det(pl) elephants = n(pl)

  9. S NP (sing) VP (sing,trans) v (sing,trans) det (_num) n (sing) NP (pl) n (pl) the shot man det (pl) elephants those Parsing with features (bottom-up) S  NP(_num) VP(_num) NP(_num)  det(_num) n(_num) VP(_num)  v(_num,intrans) VP(_num)  v (_num,trans) NP(_1) the man shot those elephants the = det(_num) man = n(sing) shot = v(sing,trans) those = det(pl) elephants = n(pl) NP(_num)  det(_num) n(_num) VP(_num)  v (_num,trans) NP(_1) S  NP(_num) VP(_num) (sing)

  10. ATTR1 VAL1 ATTR2 VAL2 ATTR3 VAL3 NUM SG PERS 3 CAT NP NUMBER SG PERSON 3 CAT NP AGR Feature structures • Instead of attaching features to the symbols, we can parse with symbols made up entirely of attribute-value pairs: “feature structures” • Can be used in the same way as seen previously • Values can be atomic … • … or embedded feature structures …

  11. AGR 1 SUBJ [ AGR 1 ] NUM SG PERS 3 Feature structures • … or they can be coindexed CAT S HEAD

  12. AGR 1 SUBJ [ AGR 1 ] NUM SG PERS 3 Parsing with feature structures • Grammar rules can specify assignments to or equations between feature structures • Expressed as “feature paths” e.g. HEAD.AGR.NUM = SG CAT S HEAD

  13. CAT NP NUMBER ?? PERSON 3 NUMBER SG PERSON 3 CAT NP NUMBER SG PERSON 3 Feature unification • Feature structures can be unified if • They have like-named attributes that have the same value: [NUM SG]  [NUM SG] = [NUM SG] • Like-named attributes that are “open” get the value assigned:  =

  14. NUM SG PERS 3 CAT NP NUMBER SG CAT NP NUMBER SG PERSON 3 CAT NP AGR Feature unification • Complementary features are brought together • Unification is recursive • Coindexed structures are identical (not just copies): assignment to one effects all  = [PERSON 3] CAT NP AGR [NUM SG] CAT NP AGR [PERS 3]  =

  15. VAL INDEF NUM SG Example CAT N AGR _2 SEM _3 CAT NP AGR _1  _2 SEM _3 CAT DET AGR _1  CAT DET AGR  a CAT DET AGR [VAL DEF]  the CAT N LEX “man” AGR [NUM SG] SEM HUM  man

  16. CAT DET AGR [VAL DEF]  the CAT N LEX “man” AGR [NUM SG] SEM HUM  man the man the the man CAT N AGR _2 SEM _3 CAT NP AGR _1  _2 SEM [_3] CAT DET AGR _1  LEX “man” AGR [NUM SG] SEM HUM VAL DEF [VAL DEF] NUM SG HUM

  17. CAT DET AGR  a VAL INDEF AGR NUM SG VAL INDEF NUM SG VAL INDEF NUM SG VAL INDEF NUM SG CAT N LEX “man” AGR [NUM SG] SEM HUM  man a a man a man CAT NP AGR _1  _2 SEM [_3] CAT N AGR _2 SEM _3 CAT DET AGR _1  LEX “man” AGR [NUM SG] SEM HUM [NUM SG] HUM

  18. Types and inheritance • Feature typing allows us to constrain possible values a feature can have • e.g. num = {sing,plur} • Allows grammars to be checked for consistency, and can make parsing easier • We can express general “feature co-occurrence conditions” … • And “feature inheritance rules” • Both these allow us to make the grammar more compact

  19. Co-occurrence conditions and Inheritance rules • General rules (beyond simple unification) which apply automatically, and so do not need to be stated (and repeated) in each rule or lexical entry • Examples: [cat=np]  [num=??, gen=??, case=??] [cat=v,num=sg]  [tns=pres] [attr1=val1]   [attr2=val2]

  20. Inheritance rules • Inheritance rules can be over-ridden e.g. [cat=n]  [gen=??,sem=??] sex={male,female} gen={masc,fem,neut} [cat=n,gen=fem,sem=hum]  [sex=female] uxor [cat=n,gen=fem,sem=hum] agricola [cat=n,gen=fem,sem=hum,sex=male]

  21. Unification in Linguistics • Lexical Functional Grammar • If interested, see PARGRAM project • GPSG, HPSG • Construction Grammar • Categorial Grammar

More Related