edu.nyu.jet.refres

Class Resolve

java.lang.Object

edu.nyu.jet.refres.Resolve

Direct Known Subclasses:

PerfectAce

public class Resolve
extends Object

contains static procedures for reference resolution within a document.

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	ACE determines range of mentions which participate in reference resolution.
static boolean	linkAppositesAndPredComps set to true if apposites and predicate complements should be linked coreferentially.
static boolean	nameTypeMatch set to true if a pair of names can be linked only if they have been assigned the same named entity type.
static SentenceSet	sentenceSet the set of sentences in the document
static boolean	trace true to produce trace messages for the reference resolution process
static boolean	useMaxEnt true to use the Max Ent resolver

Constructor Summary

Constructors

Constructor and Description
Resolve()

Method Summary

Methods

Modifier and Type	Method and Description
static String	concat(String[] s) append strings in 's', separated by blanks
static boolean	equalArray(Object[] first, Object[] second)
static Vector<Annotation>	gatherClauses(Document doc, Span span) returns the set of all clauses (constituents of category s, rn-wh, or rn-vingo) within Span span of Document doc.
static Vector<Annotation>	gatherMentions(Document doc, Span span) returns the set of all mentions -- constituents which are subject to reference resolution.
static HashMap<Annotation,Annotation>	gatherSyntacticCoref(Document doc, Vector<Annotation> mentions, Vector<Annotation> clauses) gatherSyntacticCoref looks for particular syntactic patterns in the text which indicate coreference, and returns a Map with one entry for each such syntactic coreference, linking the anaphor to the antecedent.
static Annotation	getHeadC(Annotation ann) returns the head constituent associated with constituent 'ann'.
static String[]	getHeadTokens(Document doc, Annotation constit)
static String[]	getNameTokens(Document doc, Annotation constit) returns the name associated with a noun phrase, as an array of token strings, or null if the np does not have a name.
static Annotation	getNgHead(Annotation ng)
static boolean	in(Object o, Object[] array)
static boolean	intersect(Object[] setA, Object[] setB)
static int	isAbbreviation(String[] name, String abbrev) returns true if 'abbrev' is an acronym-style abbreviation for 'name' -- i.e., an acronym with periods, such as U.S.A.
static int	isAcronym(String[] name, String acronym) returns true if 'acronym' is a possible acronym for 'name', such as 'USA' for 'United States of America'.
static boolean	isName(Annotation constit) returns true if 'consit' is a name.
static void	markMentions(Vector mentions) for all constituents on mentions, set the feature mention to true.
static int	matchFullName(String[] mentionName, String mentionHead, String[] entityName, String entityHead) returns true if 'mentionName' is a possible reference to 'entityName'.
static boolean	matchPronoun(Document doc, Annotation anaphor, String mentionHead, Annotation ent) return true if pronoun 'mentionHead' is a possible anaphor for entity 'ent' (this also includes possessive pronouns of category 'det', and headless noun phrases of category 'np').
static boolean	nameNomCoref(Document doc, String det, String mentionHead, Annotation mention, Annotation entity) return true if a common noun phrase headed by 'mentionHead' is a possible anaphoric reference to the (named) entity 'entity'.
static boolean	nomInName(Document doc, Annotation mention, Annotation entity)
static String[]	normalizeGazName(String[] name, boolean notNP, boolean trace) returns a standardized country name, using the gazetteer.
static String	normalizeName(String name) replaces whitespace between tokens with a single blank.
static void	readGenderDict(String dataPath, Properties config) if property NameGender.fileName is specified in config, reads the name gender dictionary from the specified file.
static void	references(Document doc, Span span) Resolve.references resolves the mentions (noun groups) in span of Document doc.
static void	references(Document doc, Span span, Vector<Annotation> mentions, Vector<Annotation> clauses)
static void	updateEvents(Document doc, Span span, Map mentionToEntity) updates events based on reference resolution.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

sentenceSet

public static SentenceSet sentenceSet

the set of sentences in the document

linkAppositesAndPredComps

public static boolean linkAppositesAndPredComps

set to true if apposites and predicate complements should be linked coreferentially.

nameTypeMatch

public static boolean nameTypeMatch

set to true if a pair of names can be linked only if they have been assigned the same named entity type.

trace

public static boolean trace

true to produce trace messages for the reference resolution process

useMaxEnt

public static boolean useMaxEnt

true to use the Max Ent resolver

ACE

public static boolean ACE

determines range of mentions which participate in reference resolution. If false, only noun phrases and possessive pronouns are resolved; if true (for ACE evaluations), a wider range of mentions are included.

Constructor Detail

Resolve

public Resolve()

Method Detail

references

public static void references(Document doc,
              Span span)

Resolve.references resolves the mentions (noun groups) in span of Document doc. It generates entity annotations, corresponding to one or more mentions in the document which are coreferential. In addition, for every event annotation in span, it generates an r-event annotation in which each feature pointing to a mention is replaced by the entity to which that mention has been resolved.

references

public static void references(Document doc,
              Span span,
              Vector<Annotation> mentions,
              Vector<Annotation> clauses)

gatherMentions

public static Vector<Annotation> gatherMentions(Document doc,
                                Span span)

returns the set of all mentions -- constituents which are subject to reference resolution. This includes all noun phrases, possessive pronouns, and (for ACE) names. To avoid duplication, we exclude NPs which are the head constituent of other NPs (so that, for example, if we have "the man in the chair" as a mention, we exclude "the man" as a separate mention.

gatherClauses

public static Vector<Annotation> gatherClauses(Document doc,
                               Span span)

returns the set of all clauses (constituents of category s, rn-wh, or rn-vingo) within Span span of Document doc.

markMentions

public static void markMentions(Vector mentions)

for all constituents on mentions, set the feature mention to true.

gatherSyntacticCoref

public static HashMap<Annotation,Annotation> gatherSyntacticCoref(Document doc,
                                                  Vector<Annotation> mentions,
                                                  Vector<Annotation> clauses)

gatherSyntacticCoref looks for particular syntactic patterns in the text which indicate coreference, and returns a Map with one entry for each such syntactic coreference, linking the anaphor to the antecedent.

updateEvents

public static void updateEvents(Document doc,
                Span span,
                Map mentionToEntity)

updates events based on reference resolution. For each constituent of type event, creates a constituent of type r-event, replacing each mention argument with the corresponding entity.

readGenderDict

public static void readGenderDict(String dataPath,
                  Properties config)

if property NameGender.fileName is specified in config, reads the name gender dictionary from the specified file. Each line of the dictionary should have a name (lower case), one or more blanks, and 'M' (for male names) or 'F' (for female names).

normalizeGazName

public static String[] normalizeGazName(String[] name,
                        boolean notNP,
                        boolean trace)

returns a standardized country name, using the gazetteer. If 'name' is a variant country name or a country adjective ('French'), returns the standard country name.

getNgHead

public static Annotation getNgHead(Annotation ng)

nameNomCoref

public static boolean nameNomCoref(Document doc,
                   String det,
                   String mentionHead,
                   Annotation mention,
                   Annotation entity)

return true if a common noun phrase headed by 'mentionHead' is a possible anaphoric reference to the (named) entity 'entity'. Three cases are allowed:
1. if the head is one of the words in the name of the entity ("the Security Council" ... "the council")
2. if the head is one of the words in the first mention of the entity ("President Abe Lincoln" ... "the president")
3. if the head is the name of a country or nationality, and the head is "country", "nation", or "government"

nomInName

public static boolean nomInName(Document doc,
                Annotation mention,
                Annotation entity)

matchFullName

public static int matchFullName(String[] mentionName,
                String mentionHead,
                String[] entityName,
                String entityHead)

returns true if 'mentionName' is a possible reference to 'entityName'. The test succeeds if the tokens in 'mentionName' are a subset of those in 'entityName', occurring in the same order as they do in 'entityName'. Comparisons are done ignoring case because a name may appear in all caps in the dateline (BAGHDAD vs. Baghdad) and may be capitalized differently at the beginning of a sentence (Sergio de Mello vs. De Mello).

isAcronym

public static int isAcronym(String[] name,
            String acronym)

returns true if 'acronym' is a possible acronym for 'name', such as 'USA' for 'United States of America'. The test succeeds if the letters of 'acronym' are a subset of the initial letters of the tokens of 'name', appearing in the same order as in 'name'. The acronym must be at least 2 letters long.

isAbbreviation

public static int isAbbreviation(String[] name,
                 String abbrev)

returns true if 'abbrev' is an acronym-style abbreviation for 'name' -- i.e., an acronym with periods, such as U.S.A. for 'United States of America'.

matchPronoun

public static boolean matchPronoun(Document doc,
                   Annotation anaphor,
                   String mentionHead,
                   Annotation ent)

return true if pronoun 'mentionHead' is a possible anaphor for entity 'ent' (this also includes possessive pronouns of category 'det', and headless noun phrases of category 'np').

normalizeName

public static String normalizeName(String name)

replaces whitespace between tokens with a single blank.

concat

public static String concat(String[] s)

append strings in 's', separated by blanks

isName

public static boolean isName(Annotation constit)

returns true if 'consit' is a name.

getHeadC

public static Annotation getHeadC(Annotation ann)

returns the head constituent associated with constituent 'ann'.

getNameTokens

public static String[] getNameTokens(Document doc,
                     Annotation constit)

returns the name associated with a noun phrase, as an array of token strings, or null if the np does not have a name.

getHeadTokens

public static String[] getHeadTokens(Document doc,
                     Annotation constit)

in

public static boolean in(Object o,
         Object[] array)

intersect

public static boolean intersect(Object[] setA,
                Object[] setB)

equalArray

public static boolean equalArray(Object[] first,
                 Object[] second)