protected internal override bool IsExcluded(MentionContext mention, DiscourseEntity entity)
{
if (base.IsExcluded(mention, entity))
{
return(true);
}
string mentionGender = null;
foreach (MentionContext entityMention in entity.Mentions)
{
string tag = entityMention.HeadTokenTag;
if (tag != null && PartsOfSpeech.IsPersOrPossPronoun(tag) && Linker.SingularThirdPersonPronounPattern.IsMatch(mention.HeadTokenText))
{
if (mentionGender == null)
{
//lazy initilization
mentionGender = GetPronounGender(mention.HeadTokenText);
}
string entityGender = GetPronounGender(entityMention.HeadTokenText);
if (!entityGender.Equals("u") && !mentionGender.Equals(entityGender))
{
return(true);
}
}
}
return(false);
}
protected internal override bool IsExcluded(MentionContext context, DiscourseEntity discourseEntity)
{
MentionContext currentContext = discourseEntity.LastExtent;
if (context.SentenceNumber != currentContext.SentenceNumber)
{
return(true);
}
//shallow parse appositives
if (currentContext.IndexSpan.End == context.IndexSpan.Start - 2)
{
return(false);
}
//full parse w/o trailing comma
if (currentContext.IndexSpan.End == context.IndexSpan.End)
{
return(false);
}
//full parse w/ trailing comma or period
if (currentContext.IndexSpan.End <= context.IndexSpan.End + 2 && (context.NextToken != null &&
(context.NextToken.ToString() == PartsOfSpeech.Comma || context.NextToken.ToString() == PartsOfSpeech.SentenceFinalPunctuation)))
{
return(false);
}
return(true);
}
/*
* protected double getNonReferentialProbability(MentionContext ec) {
* if (useFixedNonReferentialProbability) {
* if (debugOn) {
* System.err.println(this +".resolve: " + ec.toText() + " -> " + null +" " + fixedNonReferentialProbability);
* System.err.println();
* }
* return fixedNonReferentialProbability;
* }
* List lfeatures = getFeatures(ec, null);
* String[] features = (String[]) lfeatures.toArray(new String[lfeatures.size()]);
*
* if (features == null) {
* System.err.println("features=null in " + this);
* }
* if (model == null) {
* System.err.println("model=null in " + this);
* }
* double[] dist = nrModel.eval(features);
*
* if (dist == null) {
* System.err.println("dist=null in " + this);
* }
* if (debugOn) {
* System.err.println(this +".resolve: " + ec.toText() + " -> " + null +" " + dist[nrSameIndex] + " " + lfeatures);
* System.err.println();
* }
* return (dist[nrSameIndex]);
* }
*/
/// <summary>
/// Returns whether the specified entity satisfies the criteria for being a default referent.
/// This criteria is used to perform sample selection on the training data and to select a single
/// non-referent entity. Typically the criteria is a hueristic for a likely referent.
/// </summary>
/// <param name="discourseEntity">
/// The discourse entity being considered for non-reference.
/// </param>
/// <returns>
/// True if the entity should be used as a default referent, false otherwise.
/// </returns>
protected internal virtual bool defaultReferent(DiscourseEntity discourseEntity)
{
Mention.MentionContext entityContext = discourseEntity.LastExtent;
if (entityContext.NounPhraseSentenceIndex == 0)
{
return(true);
}
return(false);
}
protected internal override List<string> GetFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
List<string> features = base.GetFeatures(mention, entity);
if (entity != null)
{
features.AddRange(GetContextFeatures(mention));
features.AddRange(GetStringMatchFeatures(mention, entity));
}
return features;
}
protected internal virtual string GetMentionCountFeature(DiscourseEntity discourseEntity)
{
if (discourseEntity.MentionCount >= 5)
{
return("mc=5+");
}
else
{
return("mc=" + discourseEntity.MentionCount);
}
}
protected internal override bool IsExcluded(MentionContext mention, DiscourseEntity entity)
{
if (base.IsExcluded(mention, entity))
{
return(true);
}
else
{
MentionContext cec = entity.LastExtent;
return(cec.HeadTokenTag != PartsOfSpeech.NounPlural || base.IsExcluded(mention, entity));
}
}
protected internal override bool IsExcluded(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
if (base.IsExcluded(entityContext, discourseEntity))
{
return true;
}
else
{
Mention.MentionContext currentEntityContext = discourseEntity.LastExtent;
return (!CanResolve(currentEntityContext) || base.IsExcluded(entityContext, discourseEntity));
}
}
//UPGRADE_NOTE: Access modifiers of method 'excluded' were changed to 'public'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1204'"
protected internal override bool IsExcluded(MentionContext mention, DiscourseEntity entity)
{
if (base.IsExcluded(mention, entity))
{
return(true);
}
MentionContext cec = entity.LastExtent;
if (!CanResolve(cec))
{
return(true);
}
if (PartsOfSpeech.IsProperNoun(mention.HeadTokenTag))
{
//mention is a propernoun
if (PartsOfSpeech.IsProperNoun(cec.HeadTokenTag))
{
return(true); // both NNP
}
else
{
if (entity.MentionCount > 1)
{
return(true);
}
return(!CanResolve(cec));
}
}
else if (PartsOfSpeech.IsPersOrPossPronoun(mention.HeadTokenTag))
{
// mention is a speech pronoun
// cec can be either a speech pronoun or a propernoun
if (PartsOfSpeech.IsProperNoun(cec.HeadTokenTag))
{
//exclude antecedents not in the same sentence when they are not pronoun
return(mention.SentenceNumber - cec.SentenceNumber != 0);
}
else if (PartsOfSpeech.IsPersOrPossPronoun(cec.HeadTokenTag))
{
return(false);
}
else
{
Console.Error.WriteLine("Unexpected candidate exluded: " + cec.ToText());
return(true);
}
}
else
{
Console.Error.WriteLine("Unexpected mention exluded: " + mention.ToText());
return(true);
}
}
private MentionContext getProperNounExtent(DiscourseEntity de)
{
foreach (MentionContext xec in de.Mentions)
{
//use first extent which is propername
string xecHeadTag = xec.HeadTokenTag;
if (PartsOfSpeech.IsProperNoun(xecHeadTag) || InitialCaps.IsMatch(xec.HeadTokenText))
{
return(xec);
}
}
return(null);
}
protected internal override bool IsExcluded(MentionContext mention, DiscourseEntity entity)
{
if (base.IsExcluded(mention, entity))
{
return(true);
}
foreach (MentionContext xec in entity.Mentions)
{
if (PartsOfSpeech.IsProperNoun(xec.HeadTokenTag))
{
// || initialCaps.matcher(xec.headToken.ToString()).find()) {
return(false);
}
}
return(true);
}
public virtual DiscourseEntity Retain(Mention.MentionContext mention, DiscourseModel discourseModel)
{
int entityIndex = 0;
if (mention.Id == -1)
{
return(null);
}
for (; entityIndex < discourseModel.EntityCount; entityIndex++)
{
DiscourseEntity currentDiscourseEntity = discourseModel.GetEntity(entityIndex);
Mention.MentionContext candidateExtentContext = currentDiscourseEntity.LastExtent;
if (candidateExtentContext.Id == mention.Id)
{
Distances.Add(entityIndex);
return(currentDiscourseEntity);
}
}
return(null);
}
public virtual DiscourseEntity Retain(Mention.MentionContext mention, DiscourseModel discourseModel)
{
int entityIndex = 0;
if (mention.Id == -1)
{
return(null);
}
for (; entityIndex < discourseModel.EntityCount; entityIndex++)
{
DiscourseEntity currentDiscourseEntity = discourseModel.GetEntity(entityIndex);
Mention.MentionContext candidateExtentContext = currentDiscourseEntity.LastExtent;
if (candidateExtentContext.Id == mention.Id)
{
Distances.Add(entityIndex);
return(currentDiscourseEntity);
}
}
//System.err.println("AbstractResolver.Retain: non-referring entity with id: "+ec.toText()+" id="+ec.id);
return(null);
}
private string GetSemanticCompatibilityFeature(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
if (mSimilarityModel != null)
{
double best = 0;
foreach (Mention.MentionContext checkEntityContext in discourseEntity.Mentions)
{
double sim = mSimilarityModel.AreCompatible(entityContext, checkEntityContext);
if (mDebugOn)
{
System.Console.Error.WriteLine("MaxentResolver.GetSemanticCompatibilityFeature: sem-compat " + sim + " " + entityContext.ToText() + " " + checkEntityContext.ToText());
}
if (sim > best)
{
best = sim;
}
}
if (best > mMinimumSimilarityProbability)
{
return(mSimilarityCompatible);
}
else if (best > (1 - mMinimumSimilarityProbability))
{
return(mSimilarityUnknown);
}
else
{
return(mSimilarityIncompatible);
}
}
else
{
System.Console.Error.WriteLine("MaxentResolver: Uninitialized Semantic Model");
return(mSimilarityUnknown);
}
}
private string GetNumberCompatibilityFeature(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
Similarity.NumberEnum entityNumber = discourseEntity.Number;
if (entityNumber == Similarity.NumberEnum.Unknown || entityContext.GetNumber() == Similarity.NumberEnum.Unknown)
{
return(mNumberUnknown);
}
else if (entityContext.GetNumber() == entityNumber)
{
return(mNumberCompatible);
}
else
{
return(mNumberIncompatible);
}
}
protected internal virtual List<string> getAcronymFeatures(MentionContext mention, DiscourseEntity entity)
{
MentionContext xec = getProperNounExtent(entity);
string ecStrip = StripNounPhrase(mention);
string xecStrip = StripNounPhrase(xec);
if (ecStrip != null && xecStrip != null)
{
if (isAcronym(ecStrip, xecStrip))
{
var features = new List<string>(1) {"knownAcronym"};
return features;
}
}
return new List<string>();
}
private MentionContext getProperNounExtent(DiscourseEntity de)
{
foreach (MentionContext xec in de.Mentions)
{
//use first extent which is propername
string xecHeadTag = xec.HeadTokenTag;
if (PartsOfSpeech.IsProperNoun(xecHeadTag) || InitialCaps.IsMatch(xec.HeadTokenText))
{
return xec;
}
}
return null;
}
/// <summary>
/// Returns string-match features for the the specified mention and entity.</summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of string-match features for the the specified mention and entity.
/// </returns>
protected internal virtual List <string> GetStringMatchFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
var sameHead = false;
var modifersMatch = false;
var titleMatch = false;
var noTheModifiersMatch = false;
var features = new List <string>();
var mentionTokens = mention.TokenParses;
var entityContextModifierSet = ConstructModifierSet(mentionTokens, mention.HeadTokenIndex);
var mentionHeadString = mention.HeadTokenText.ToLower();
Util.Set <string> featureSet = new Util.HashSet <string>();
foreach (var entityMention in entity.Mentions)
{
var exactMatchFeature = GetExactMatchFeature(entityMention, mention);
if (exactMatchFeature != null)
{
featureSet.Add(exactMatchFeature);
}
else if (entityMention.Parse.IsCoordinatedNounPhrase && !mention.Parse.IsCoordinatedNounPhrase)
{
featureSet.Add("cmix");
}
else
{
var mentionStrip = StripNounPhrase(mention);
var entityMentionStrip = StripNounPhrase(entityMention);
if (mentionStrip != null && entityMentionStrip != null)
{
if (IsSubstring(mentionStrip, entityMentionStrip))
{
featureSet.Add("substring");
}
}
}
var entityMentionTokens = entityMention.TokenParses;
var headIndex = entityMention.HeadTokenIndex;
//if (!mention.getHeadTokenTag().equals(entityMention.getHeadTokenTag())) {
// continue;
//} want to match NN NNP
var entityMentionHeadString = entityMention.HeadTokenText.ToLower();
// model lexical similarity
if (mentionHeadString == entityMentionHeadString)
{
sameHead = true;
featureSet.Add("hds=" + mentionHeadString);
if (!modifersMatch || !noTheModifiersMatch)
{
//only check if we haven't already found one which is the same
modifersMatch = true;
noTheModifiersMatch = true;
var entityMentionModifierSet = ConstructModifierSet(entityMentionTokens, headIndex);
foreach (var modifierWord in entityContextModifierSet)
{
if (!entityMentionModifierSet.Contains(modifierWord))
{
modifersMatch = false;
if (modifierWord != "the")
{
noTheModifiersMatch = false;
featureSet.Add("mmw=" + modifierWord);
}
}
}
}
}
var descriptorModifierSet = ConstructModifierSet(entityMentionTokens, entityMention.NonDescriptorStart);
if (descriptorModifierSet.Contains(mentionHeadString))
{
titleMatch = true;
}
}
if (featureSet.Count != 0)
{
features.AddRange(featureSet);
}
if (sameHead)
{
features.Add("sameHead");
if (modifersMatch)
{
features.Add("modsMatch");
}
else if (noTheModifiersMatch)
{
features.Add("nonTheModsMatch");
}
else
{
features.Add("modsMisMatch");
}
}
if (titleMatch)
{
features.Add("titleMatch");
}
return(features);
}
protected internal override bool IsOutOfRange(MentionContext mention, DiscourseEntity entity)
{
MentionContext cec = entity.LastExtent;
return(mention.SentenceNumber - cec.SentenceNumber > NumberSentencesBack);
}
private string GetSemanticCompatibilityFeature(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
if (mSimilarityModel != null)
{
double best = 0;
foreach (Mention.MentionContext checkEntityContext in discourseEntity.Mentions)
{
double sim = mSimilarityModel.AreCompatible(entityContext, checkEntityContext);
if (mDebugOn)
{
System.Console.Error.WriteLine("MaxentResolver.GetSemanticCompatibilityFeature: sem-compat " + sim + " " + entityContext.ToText() + " " + checkEntityContext.ToText());
}
if (sim > best)
{
best = sim;
}
}
if (best > mMinimumSimilarityProbability)
{
return mSimilarityCompatible;
}
else if (best > (1 - mMinimumSimilarityProbability))
{
return mSimilarityUnknown;
}
else
{
return mSimilarityIncompatible;
}
}
else
{
System.Console.Error.WriteLine("MaxentResolver: Uninitialized Semantic Model");
return mSimilarityUnknown;
}
}
protected internal override bool IsExcluded(MentionContext mention, DiscourseEntity entity)
{
if (base.IsExcluded(mention, entity))
{
return true;
}
foreach (MentionContext xec in entity.Mentions)
{
if (xec.HeadTokenTag.StartsWith("NNP"))
{
// || initialCaps.matcher(xec.headToken.toString()).find()) {
//System.err.println("MaxentProperNounResolver.exclude: kept "+xec.toText()+" with "+xec.headTag);
return false;
}
}
return true;
}
private string GetGenderCompatibilityFeature(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
Similarity.GenderEnum entityGender = discourseEntity.Gender;
//System.err.println("getGenderCompatibility: mention="+ec.getGender()+" entity="+eg);
if (entityGender == Similarity.GenderEnum.Unknown || entityContext.GetGender() == Similarity.GenderEnum.Unknown)
{
return mGenderUnknown;
}
else if (entityContext.GetGender() == entityGender)
{
return mGenderCompatible;
}
else
{
return mGenderIncompatible;
}
}
private string GetNumberCompatibilityFeature(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
Similarity.NumberEnum entityNumber = discourseEntity.Number;
if (entityNumber == Similarity.NumberEnum.Unknown || entityContext.GetNumber() == Similarity.NumberEnum.Unknown)
{
return mNumberUnknown;
}
else if (entityContext.GetNumber() == entityNumber)
{
return mNumberCompatible;
}
else
{
return mNumberIncompatible;
}
}
protected internal override bool IsExcluded(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
if (base.IsExcluded(entityContext, discourseEntity))
{
return(true);
}
else
{
Mention.MentionContext currentEntityContext = discourseEntity.LastExtent;
return(!CanResolve(currentEntityContext) || base.IsExcluded(entityContext, discourseEntity));
}
}
/// <summary>
/// Excludes entities which you are not compatible with the entity under consideration. The default
/// implementation excludes entties whose last extent contains the extent under consideration.
/// This prevents posessive pronouns from referring to the noun phrases they modify and other
/// undesirable things.
/// </summary>
/// <param name="mention">
/// The mention which is being considered as referential.
/// </param>
/// <param name="entity">
/// The entity to which the mention is to be resolved.
/// </param>
/// <returns>
/// true if the entity should be excluded, false otherwise.
/// </returns>
protected internal virtual bool IsExcluded(Mention.MentionContext mention, DiscourseEntity entity)
{
Mention.MentionContext context = entity.LastExtent;
return(mention.SentenceNumber == context.SentenceNumber && mention.IndexSpan.End <= context.IndexSpan.End);
}
/// <summary>
/// Determines if the specified entity is too far from the specified mention to be resolved to it.
/// Once an entity has been determined to be out of range subsequent entities are not considered.
/// </summary>
/// <seealso cref="IsExcluded">
/// </seealso>
/// <param name="mention">
/// The mention which is being considered.
/// </param>
/// <param name="entity">
/// The entity to which the mention is to be resolved.
/// </param>
/// <returns>
/// true is the entity is in range of the mention, false otherwise.
/// </returns>
protected internal virtual bool IsOutOfRange(Mention.MentionContext mention, DiscourseEntity entity)
{
return(false);
}
protected internal override bool IsExcluded(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
if (base.IsExcluded(entityContext, discourseEntity))
{
return(true);
}
return(false);
/*
* else {
* if (GEN_INCOMPATIBLE == getGenderCompatibilityFeature(ec,de)) {
* return true;
* }
* else if (NUM_INCOMPATIBLE == getNumberCompatibilityFeature(ec,de)) {
* return true;
* }
* else if (SIM_INCOMPATIBLE == getSemanticCompatibilityFeature(ec,de)) {
* return true;
* }
* return false;
* }
*/
}
/*
protected double getNonReferentialProbability(MentionContext ec) {
if (useFixedNonReferentialProbability) {
if (debugOn) {
System.err.println(this +".resolve: " + ec.toText() + " -> " + null +" " + fixedNonReferentialProbability);
System.err.println();
}
return fixedNonReferentialProbability;
}
List lfeatures = getFeatures(ec, null);
String[] features = (String[]) lfeatures.toArray(new String[lfeatures.size()]);
if (features == null) {
System.err.println("features=null in " + this);
}
if (model == null) {
System.err.println("model=null in " + this);
}
double[] dist = nrModel.eval(features);
if (dist == null) {
System.err.println("dist=null in " + this);
}
if (debugOn) {
System.err.println(this +".resolve: " + ec.toText() + " -> " + null +" " + dist[nrSameIndex] + " " + lfeatures);
System.err.println();
}
return (dist[nrSameIndex]);
}
*/
/// <summary>
/// Returns whether the specified entity satisfies the criteria for being a default referent.
/// This criteria is used to perform sample selection on the training data and to select a single
/// non-referent entity. Typically the criteria is a hueristic for a likely referent.
/// </summary>
/// <param name="discourseEntity">
/// The discourse entity being considered for non-reference.
/// </param>
/// <returns>
/// True if the entity should be used as a default referent, false otherwise.
/// </returns>
protected internal virtual bool defaultReferent(DiscourseEntity discourseEntity)
{
Mention.MentionContext entityContext = discourseEntity.LastExtent;
if (entityContext.NounPhraseSentenceIndex == 0)
{
return true;
}
return false;
}
/// <summary>
/// Returns features indicating whether the specified mention is compatible with the pronouns
/// of the specified entity.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of features indicating whether the specified mention is compatible with the pronouns
/// of the specified entity.
/// </returns>
protected internal virtual List <string> GetPronounMatchFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
bool foundCompatiblePronoun = false;
bool foundIncompatiblePronoun = false;
if (mention.HeadTokenTag.StartsWith("PRP"))
{
Dictionary <string, string> pronounMap = GetPronounFeatureMap(mention.HeadTokenText);
//System.err.println("getPronounMatchFeatures.pronounMap:"+pronounMap);
foreach (Mention.MentionContext candidateMention in entity.Mentions)
{
if (candidateMention.HeadTokenTag.StartsWith("PRP"))
{
if (mention.HeadTokenText.ToUpper() == candidateMention.HeadTokenText.ToUpper())
{
foundCompatiblePronoun = true;
break;
}
else
{
Dictionary <string, string> candidatePronounMap = GetPronounFeatureMap(candidateMention.HeadTokenText);
//System.err.println("getPronounMatchFeatures.candidatePronounMap:"+candidatePronounMap);
bool allKeysMatch = true;
foreach (string key in pronounMap.Keys)
{
if (candidatePronounMap.ContainsKey(key))
{
if (pronounMap[key] != candidatePronounMap[key])
{
foundIncompatiblePronoun = true;
allKeysMatch = false;
}
}
else
{
allKeysMatch = false;
}
}
if (allKeysMatch)
{
foundCompatiblePronoun = true;
}
}
}
}
}
List <string> pronounFeatures = new List <string>();
if (foundCompatiblePronoun)
{
pronounFeatures.Add("compatiblePronoun");
}
if (foundIncompatiblePronoun)
{
pronounFeatures.Add("incompatiblePronoun");
}
return(pronounFeatures);
}
/// <summary>
/// Returns distance features for the specified mention and entity.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of distance features for the specified mention and entity.
/// </returns>
protected internal virtual List<string> GetDistanceFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
List<string> features = new List<string>();
Mention.MentionContext currentEntityContext = entity.LastExtent;
int entityDistance = mention.NounPhraseDocumentIndex - currentEntityContext.NounPhraseDocumentIndex;
int sentenceDistance = mention.SentenceNumber - currentEntityContext.SentenceNumber;
int hobbsEntityDistance;
if (sentenceDistance == 0)
{
hobbsEntityDistance = currentEntityContext.NounPhraseSentenceIndex;
}
else
{
//hobbsEntityDistance = entityDistance - (entities within sentence from mention to end) + (entities within sentence form start to mention)
//hobbsEntityDistance = entityDistance - (cec.maxNounLocation - cec.getNounPhraseSentenceIndex) + cec.getNounPhraseSentenceIndex;
hobbsEntityDistance = entityDistance + (2 * currentEntityContext.NounPhraseSentenceIndex) - currentEntityContext.MaxNounPhraseSentenceIndex;
}
features.Add("hd=" + hobbsEntityDistance);
features.Add("de=" + entityDistance);
features.Add("ds=" + sentenceDistance);
//features.add("ds=" + sdist + pronoun);
//features.add("dn=" + cec.sentenceNumber);
//features.add("ep=" + cec.nounLocation);
return features;
}
protected internal override List <string> GetFeatures(MentionContext mention, DiscourseEntity entity)
{
List <string> features = base.GetFeatures(mention, entity);
if (entity != null)
{
features.AddRange(GetStringMatchFeatures(mention, entity));
features.AddRange(getAcronymFeatures(mention, entity));
}
return(features);
}
/// <summary>
/// Returns a list of features for deciding whether the specified mention refers to the specified discourse entity.
/// </summary>
/// <param name="mention">
/// the mention being considers as possibly referential.
/// </param>
/// <param name="entity">
/// The discourse entity with which the mention is being considered referential.
/// </param>
/// <returns>
/// a list of features used to predict reference between the specified mention and entity.
/// </returns>
protected internal virtual List<string> GetFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
List<string> features = new List<string>();
features.Add(Default);
features.AddRange(GetCompatibilityFeatures(mention, entity));
return features;
}
protected internal override bool IsExcluded(MentionContext mention, DiscourseEntity entity)
{
if (base.IsExcluded(mention, entity))
{
return true;
}
foreach (MentionContext xec in entity.Mentions)
{
if (PartsOfSpeech.IsProperNoun(xec.HeadTokenTag))
{
// || initialCaps.matcher(xec.headToken.ToString()).find()) {
return false;
}
}
return true;
}
protected internal virtual string GetMentionCountFeature(DiscourseEntity discourseEntity)
{
if (discourseEntity.MentionCount >= 5)
{
return ("mc=5+");
}
else
{
return ("mc=" + discourseEntity.MentionCount);
}
}
protected internal override List <string> GetFeatures(MentionContext mention, DiscourseEntity entity)
{
List <string> features = base.GetFeatures(mention, entity);
if (entity != null)
{
//generate pronoun w/ referent features
MentionContext cec = entity.LastExtent;
//string gen = getPronounGender(pronoun);
features.AddRange(GetPronounMatchFeatures(mention, entity));
features.AddRange(GetContextFeatures(cec));
features.AddRange(GetDistanceFeatures(mention, entity));
features.Add(GetMentionCountFeature(entity));
/*
* //lexical features
* Set featureSet = new HashSet();
* for (Iterator ei = entity.getExtents(); ei.hasNext();) {
* MentionContext ec = (MentionContext) ei.next();
* List toks = ec.tokens;
* Parse tok;
* int headIndex = PTBHeadFinder.getInstance().getHeadIndex(toks);
* for (int ti = 0; ti < headIndex; ti++) {
* tok = (Parse) toks.get(ti);
* featureSet.add(gen + "mw=" + tok.ToString().toLowerCase());
* featureSet.add(gen + "mt=" + tok.getSyntacticType());
* }
* tok = (Parse) toks.get(headIndex);
* featureSet.add(gen + "hw=" + tok.ToString().toLowerCase());
* featureSet.add(gen + "ht=" + tok.getSyntacticType());
* //semantic features
* if (ec.neType != null) {
* featureSet.add(gen + "," + ec.neType);
* }
* else {
* for (Iterator si = ec.synsets.iterator(); si.hasNext();) {
* Integer synset = (Integer) si.next();
* featureSet.add(gen + "," + synset);
* }
* }
* }
* Iterator fset = featureSet.iterator();
* while (fset.hasNext()) {
* string f = (string) fset.next();
* features.add(f);
* }
*/
}
return(features);
}
/// <summary>
/// Returns features indicating whether the specified mention is compatible with the pronouns
/// of the specified entity.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of features indicating whether the specified mention is compatible with the pronouns
/// of the specified entity.
/// </returns>
protected internal virtual List<string> GetPronounMatchFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
bool foundCompatiblePronoun = false;
bool foundIncompatiblePronoun = false;
if (mention.HeadTokenTag.StartsWith("PRP"))
{
Dictionary<string, string> pronounMap = GetPronounFeatureMap(mention.HeadTokenText);
//System.err.println("getPronounMatchFeatures.pronounMap:"+pronounMap);
foreach (Mention.MentionContext candidateMention in entity.Mentions)
{
if (candidateMention.HeadTokenTag.StartsWith("PRP"))
{
if (mention.HeadTokenText.ToUpper() == candidateMention.HeadTokenText.ToUpper())
{
foundCompatiblePronoun = true;
break;
}
else
{
Dictionary<string, string> candidatePronounMap = GetPronounFeatureMap(candidateMention.HeadTokenText);
//System.err.println("getPronounMatchFeatures.candidatePronounMap:"+candidatePronounMap);
bool allKeysMatch = true;
foreach (string key in pronounMap.Keys)
{
if (candidatePronounMap.ContainsKey(key))
{
if (pronounMap[key] != candidatePronounMap[key])
{
foundIncompatiblePronoun = true;
allKeysMatch = false;
}
}
else
{
allKeysMatch = false;
}
}
if (allKeysMatch)
{
foundCompatiblePronoun = true;
}
}
}
}
}
List<string> pronounFeatures = new List<string>();
if (foundCompatiblePronoun)
{
pronounFeatures.Add("compatiblePronoun");
}
if (foundIncompatiblePronoun)
{
pronounFeatures.Add("incompatiblePronoun");
}
return pronounFeatures;
}
public override DiscourseEntity Retain(Mention.MentionContext mention, DiscourseModel discourseModel)
{
//System.err.println(this+".retain("+ec+") "+mode);
if (mResolverMode == ResolverMode.Train)
{
DiscourseEntity discourseEntity = null;
bool referentFound = false;
bool hasReferentialCandidate = false;
bool nonReferentFound = false;
for (int entityIndex = 0; entityIndex < GetNumberEntitiesBack(discourseModel); entityIndex++)
{
DiscourseEntity currentDiscourseEntity = discourseModel.GetEntity(entityIndex);
Mention.MentionContext entityMention = currentDiscourseEntity.LastExtent;
if (IsOutOfRange(mention, currentDiscourseEntity))
{
if (mention.Id != -1 && !referentFound)
{
//System.err.println("retain: Referent out of range: "+ec.toText()+" "+ec.parse.getSpan());
}
break;
}
if (IsExcluded(mention, currentDiscourseEntity))
{
if (ShowExclusions)
{
if (mention.Id != -1 && entityMention.Id == mention.Id)
{
System.Console.Error.WriteLine(this + ".retain: Referent excluded: (" + mention.Id + ") " + mention.ToText() + " " + mention.IndexSpan + " -> (" + entityMention.Id + ") " + entityMention.ToText() + " " + entityMention.Span + " " + this);
}
}
}
else
{
hasReferentialCandidate = true;
bool useAsDifferentExample = defaultReferent(currentDiscourseEntity);
//if (!sampleSelection || (mention.getId() != -1 && entityMention.getId() == mention.getId()) || (!nonReferentFound && useAsDifferentExample)) {
List <string> features = GetFeatures(mention, currentDiscourseEntity);
//add Event to Model
if (mDebugOn)
{
System.Console.Error.WriteLine(this + ".retain: " + mention.Id + " " + mention.ToText() + " -> " + entityMention.Id + " " + currentDiscourseEntity);
}
if (mention.Id != -1 && entityMention.Id == mention.Id)
{
referentFound = true;
mEvents.Add(new SharpEntropy.TrainingEvent(Same, features.ToArray()));
discourseEntity = currentDiscourseEntity;
//System.err.println("MaxentResolver.retain: resolved at "+ei);
Distances.Add(entityIndex);
}
else if (!mPairedSampleSelection || (!nonReferentFound && useAsDifferentExample))
{
nonReferentFound = true;
mEvents.Add(new SharpEntropy.TrainingEvent(Diff, features.ToArray()));
}
//}
}
if (mPairedSampleSelection && referentFound && nonReferentFound)
{
break;
}
if (mPreferFirstReferent && referentFound)
{
break;
}
}
// doesn't refer to anything
if (hasReferentialCandidate)
{
mNonReferentialResolver.AddEvent(mention);
}
return(discourseEntity);
}
else
{
return(base.Retain(mention, discourseModel));
}
}
protected internal override List<string> GetFeatures(MentionContext mention, DiscourseEntity entity)
{
//System.err.println("ProperNounResolver.getFeatures: "+mention.toText()+" -> "+entity);
List<string> features = base.GetFeatures(mention, entity);
if (entity != null)
{
features.AddRange(GetStringMatchFeatures(mention, entity));
features.AddRange(getAcronymFeatures(mention, entity));
}
return features;
}
/// <summary>
/// Returns a list of features for deciding whether the specified mention refers to the specified discourse entity.
/// </summary>
/// <param name="mention">
/// the mention being considers as possibly referential.
/// </param>
/// <param name="entity">
/// The discourse entity with which the mention is being considered referential.
/// </param>
/// <returns>
/// a list of features used to predict reference between the specified mention and entity.
/// </returns>
protected internal virtual List <string> GetFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
List <string> features = new List <string>();
features.Add(Default);
features.AddRange(GetCompatibilityFeatures(mention, entity));
return(features);
}
protected internal override bool IsExcluded(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
if (base.IsExcluded(entityContext, discourseEntity))
{
return true;
}
return false;
/*
else {
if (GEN_INCOMPATIBLE == getGenderCompatibilityFeature(ec,de)) {
return true;
}
else if (NUM_INCOMPATIBLE == getNumberCompatibilityFeature(ec,de)) {
return true;
}
else if (SIM_INCOMPATIBLE == getSemanticCompatibilityFeature(ec,de)) {
return true;
}
return false;
}
*/
}
private string GetGenderCompatibilityFeature(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
{
Similarity.GenderEnum entityGender = discourseEntity.Gender;
//System.err.println("getGenderCompatibility: mention="+ec.getGender()+" entity="+eg);
if (entityGender == Similarity.GenderEnum.Unknown || entityContext.GetGender() == Similarity.GenderEnum.Unknown)
{
return(mGenderUnknown);
}
else if (entityContext.GetGender() == entityGender)
{
return(mGenderCompatible);
}
else
{
return(mGenderIncompatible);
}
}
/// <summary>
/// Returns features indicating whether the specified mention and the specified entity are compatible.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of features indicating whether the specified mention and the specified entity are compatible.
/// </returns>
private List<string> GetCompatibilityFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
List<string> compatibilityFeatures = new List<string>();
string semanticCompatibilityFeature = GetSemanticCompatibilityFeature(mention, entity);
compatibilityFeatures.Add(semanticCompatibilityFeature);
string genderCompatibilityFeature = GetGenderCompatibilityFeature(mention, entity);
compatibilityFeatures.Add(genderCompatibilityFeature);
string numberCompatibilityFeature = GetNumberCompatibilityFeature(mention, entity);
compatibilityFeatures.Add(numberCompatibilityFeature);
if (semanticCompatibilityFeature == mSimilarityCompatible && genderCompatibilityFeature == mGenderCompatible && numberCompatibilityFeature == mNumberCompatible)
{
compatibilityFeatures.Add("all.compatible");
}
else if (semanticCompatibilityFeature == mSimilarityIncompatible || genderCompatibilityFeature == mGenderIncompatible || numberCompatibilityFeature == mNumberIncompatible)
{
compatibilityFeatures.Add("some.incompatible");
}
return compatibilityFeatures;
}
/// <summary>
/// Returns features indicating whether the specified mention and the specified entity are compatible.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of features indicating whether the specified mention and the specified entity are compatible.
/// </returns>
private List <string> GetCompatibilityFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
List <string> compatibilityFeatures = new List <string>();
string semanticCompatibilityFeature = GetSemanticCompatibilityFeature(mention, entity);
compatibilityFeatures.Add(semanticCompatibilityFeature);
string genderCompatibilityFeature = GetGenderCompatibilityFeature(mention, entity);
compatibilityFeatures.Add(genderCompatibilityFeature);
string numberCompatibilityFeature = GetNumberCompatibilityFeature(mention, entity);
compatibilityFeatures.Add(numberCompatibilityFeature);
if (semanticCompatibilityFeature == mSimilarityCompatible && genderCompatibilityFeature == mGenderCompatible && numberCompatibilityFeature == mNumberCompatible)
{
compatibilityFeatures.Add("all.compatible");
}
else if (semanticCompatibilityFeature == mSimilarityIncompatible || genderCompatibilityFeature == mGenderIncompatible || numberCompatibilityFeature == mNumberIncompatible)
{
compatibilityFeatures.Add("some.incompatible");
}
return(compatibilityFeatures);
}
/// <summary>
/// Returns features indicating whether the specified mention is compatible with the pronouns
/// of the specified entity.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of features indicating whether the specified mention is compatible with the pronouns
/// of the specified entity.
/// </returns>
protected internal virtual List<string> GetPronounMatchFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
bool foundCompatiblePronoun = false;
bool foundIncompatiblePronoun = false;
if (PartsOfSpeech.IsPersOrPossPronoun(mention.HeadTokenTag))
{
Dictionary<string, string> pronounMap = GetPronounFeatureMap(mention.HeadTokenText);
foreach (Mention.MentionContext candidateMention in entity.Mentions)
{
if (PartsOfSpeech.IsPersOrPossPronoun(candidateMention.HeadTokenTag))
{
if (mention.HeadTokenText.ToUpper() == candidateMention.HeadTokenText.ToUpper())
{
foundCompatiblePronoun = true;
break;
}
else
{
Dictionary<string, string> candidatePronounMap = GetPronounFeatureMap(candidateMention.HeadTokenText);
bool allKeysMatch = true;
foreach (string key in pronounMap.Keys)
{
if (candidatePronounMap.ContainsKey(key))
{
if (pronounMap[key] != candidatePronounMap[key])
{
foundIncompatiblePronoun = true;
allKeysMatch = false;
}
}
else
{
allKeysMatch = false;
}
}
if (allKeysMatch)
{
foundCompatiblePronoun = true;
}
}
}
}
}
var pronounFeatures = new List<string>();
if (foundCompatiblePronoun)
{
pronounFeatures.Add("compatiblePronoun");
}
if (foundIncompatiblePronoun)
{
pronounFeatures.Add("incompatiblePronoun");
}
return pronounFeatures;
}
/// <summary>
/// Returns distance features for the specified mention and entity.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of distance features for the specified mention and entity.
/// </returns>
protected internal virtual List <string> GetDistanceFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
List <string> features = new List <string>();
Mention.MentionContext currentEntityContext = entity.LastExtent;
int entityDistance = mention.NounPhraseDocumentIndex - currentEntityContext.NounPhraseDocumentIndex;
int sentenceDistance = mention.SentenceNumber - currentEntityContext.SentenceNumber;
int hobbsEntityDistance;
if (sentenceDistance == 0)
{
hobbsEntityDistance = currentEntityContext.NounPhraseSentenceIndex;
}
else
{
//hobbsEntityDistance = entityDistance - (entities within sentence from mention to end) + (entities within sentence form start to mention)
//hobbsEntityDistance = entityDistance - (cec.maxNounLocation - cec.getNounPhraseSentenceIndex) + cec.getNounPhraseSentenceIndex;
hobbsEntityDistance = entityDistance + (2 * currentEntityContext.NounPhraseSentenceIndex) - currentEntityContext.MaxNounPhraseSentenceIndex;
}
features.Add("hd=" + hobbsEntityDistance);
features.Add("de=" + entityDistance);
features.Add("ds=" + sentenceDistance);
//features.add("ds=" + sdist + pronoun);
//features.add("dn=" + cec.sentenceNumber);
//features.add("ep=" + cec.nounLocation);
return(features);
}
/// <summary>
/// Excludes entities which you are not compatible with the entity under consideration. The default
/// implementation excludes entties whose last extent contains the extent under consideration.
/// This prevents posessive pronouns from referring to the noun phrases they modify and other
/// undesirable things.
/// </summary>
/// <param name="mention">
/// The mention which is being considered as referential.
/// </param>
/// <param name="entity">
/// The entity to which the mention is to be resolved.
/// </param>
/// <returns>
/// true if the entity should be excluded, false otherwise.
/// </returns>
protected internal virtual bool IsExcluded(Mention.MentionContext mention, DiscourseEntity entity)
{
Mention.MentionContext context = entity.LastExtent;
return mention.SentenceNumber == context.SentenceNumber && mention.IndexSpan.End <= context.IndexSpan.End;
}
/// <summary>
/// Returns string-match features for the the specified mention and entity.</summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of string-match features for the the specified mention and entity.
/// </returns>
protected internal virtual List <string> GetStringMatchFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
bool sameHead = false;
bool modifersMatch = false;
bool titleMatch = false;
bool noTheModifiersMatch = false;
List <string> features = new List <string>();
Mention.IParse[] mentionTokens = mention.TokenParses;
OpenNLP.Tools.Util.Set <string> entityContextModifierSet = ConstructModifierSet(mentionTokens, mention.HeadTokenIndex);
string mentionHeadString = mention.HeadTokenText.ToLower();
Util.Set <string> featureSet = new Util.HashSet <string>();
foreach (Mention.MentionContext entityMention in entity.Mentions)
{
string exactMatchFeature = GetExactMatchFeature(entityMention, mention);
if (exactMatchFeature != null)
{
featureSet.Add(exactMatchFeature);
}
else if (entityMention.Parse.IsCoordinatedNounPhrase && !mention.Parse.IsCoordinatedNounPhrase)
{
featureSet.Add("cmix");
}
else
{
string mentionStrip = StripNounPhrase(mention);
string entityMentionStrip = StripNounPhrase(entityMention);
if (mentionStrip != null && entityMentionStrip != null)
{
if (IsSubstring(mentionStrip, entityMentionStrip))
{
featureSet.Add("substring");
}
}
}
Mention.IParse[] entityMentionTokens = entityMention.TokenParses;
int headIndex = entityMention.HeadTokenIndex;
//if (!mention.getHeadTokenTag().equals(entityMention.getHeadTokenTag())) {
// //System.err.println("skipping "+mention.headTokenText+" with "+xec.headTokenText+" because "+mention.headTokenTag+" != "+xec.headTokenTag);
// continue;
//} want to match NN NNP
string entityMentionHeadString = entityMention.HeadTokenText.ToLower();
// model lexical similarity
if (mentionHeadString == entityMentionHeadString)
{
sameHead = true;
featureSet.Add("hds=" + mentionHeadString);
if (!modifersMatch || !noTheModifiersMatch)
{
//only check if we haven't already found one which is the same
modifersMatch = true;
noTheModifiersMatch = true;
Util.Set <string> entityMentionModifierSet = ConstructModifierSet(entityMentionTokens, headIndex);
foreach (string modifierWord in entityContextModifierSet)
{
if (!entityMentionModifierSet.Contains(modifierWord))
{
modifersMatch = false;
if (modifierWord != "the")
{
noTheModifiersMatch = false;
featureSet.Add("mmw=" + modifierWord);
}
}
}
}
}
Util.Set <string> descriptorModifierSet = ConstructModifierSet(entityMentionTokens, entityMention.NonDescriptorStart);
if (descriptorModifierSet.Contains(mentionHeadString))
{
titleMatch = true;
}
}
if (!(featureSet.Count == 0))
{
features.AddRange(featureSet);
}
if (sameHead)
{
features.Add("sameHead");
if (modifersMatch)
{
features.Add("modsMatch");
}
else if (noTheModifiersMatch)
{
features.Add("nonTheModsMatch");
}
else
{
features.Add("modsMisMatch");
}
}
if (titleMatch)
{
features.Add("titleMatch");
}
return(features);
}
/// <summary>
/// Determines if the specified entity is too far from the specified mention to be resolved to it.
/// Once an entity has been determined to be out of range subsequent entities are not considered.
/// </summary>
/// <seealso cref="IsExcluded">
/// </seealso>
/// <param name="mention">
/// The mention which is being considered.
/// </param>
/// <param name="entity">
/// The entity to which the mention is to be resolved.
/// </param>
/// <returns>
/// true is the entity is in range of the mention, false otherwise.
/// </returns>
protected internal virtual bool IsOutOfRange(Mention.MentionContext mention, DiscourseEntity entity)
{
return false;
}
protected internal virtual List <string> getAcronymFeatures(MentionContext mention, DiscourseEntity entity)
{
MentionContext xec = getProperNounExtent(entity);
string ecStrip = StripNounPhrase(mention);
string xecStrip = StripNounPhrase(xec);
if (ecStrip != null && xecStrip != null)
{
if (isAcronym(ecStrip, xecStrip))
{
var features = new List <string>(1)
{
"knownAcronym"
};
return(features);
}
}
return(new List <string>());
}
/// <summary>
/// Returns features indicating whether the specified mention is compatible with the pronouns
/// of the specified entity.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of features indicating whether the specified mention is compatible with the pronouns
/// of the specified entity.
/// </returns>
protected internal virtual List <string> GetPronounMatchFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
bool foundCompatiblePronoun = false;
bool foundIncompatiblePronoun = false;
if (PartsOfSpeech.IsPersOrPossPronoun(mention.HeadTokenTag))
{
Dictionary <string, string> pronounMap = GetPronounFeatureMap(mention.HeadTokenText);
foreach (Mention.MentionContext candidateMention in entity.Mentions)
{
if (PartsOfSpeech.IsPersOrPossPronoun(candidateMention.HeadTokenTag))
{
if (mention.HeadTokenText.ToUpper() == candidateMention.HeadTokenText.ToUpper())
{
foundCompatiblePronoun = true;
break;
}
else
{
Dictionary <string, string> candidatePronounMap = GetPronounFeatureMap(candidateMention.HeadTokenText);
bool allKeysMatch = true;
foreach (string key in pronounMap.Keys)
{
if (candidatePronounMap.ContainsKey(key))
{
if (pronounMap[key] != candidatePronounMap[key])
{
foundIncompatiblePronoun = true;
allKeysMatch = false;
}
}
else
{
allKeysMatch = false;
}
}
if (allKeysMatch)
{
foundCompatiblePronoun = true;
}
}
}
}
}
var pronounFeatures = new List <string>();
if (foundCompatiblePronoun)
{
pronounFeatures.Add("compatiblePronoun");
}
if (foundIncompatiblePronoun)
{
pronounFeatures.Add("incompatiblePronoun");
}
return(pronounFeatures);
}
/// <summary>
/// Returns string-match features for the the specified mention and entity.</summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// list of string-match features for the the specified mention and entity.
/// </returns>
protected internal virtual List<string> GetStringMatchFeatures(Mention.MentionContext mention, DiscourseEntity entity)
{
bool sameHead = false;
bool modifersMatch = false;
bool titleMatch = false;
bool noTheModifiersMatch = false;
List<string> features = new List<string>();
Mention.IParse[] mentionTokens = mention.TokenParses;
OpenNLP.Tools.Util.Set<string> entityContextModifierSet = ConstructModifierSet(mentionTokens, mention.HeadTokenIndex);
string mentionHeadString = mention.HeadTokenText.ToLower();
Util.Set<string> featureSet = new Util.HashSet<string>();
foreach (Mention.MentionContext entityMention in entity.Mentions)
{
string exactMatchFeature = GetExactMatchFeature(entityMention, mention);
if (exactMatchFeature != null)
{
featureSet.Add(exactMatchFeature);
}
else if (entityMention.Parse.IsCoordinatedNounPhrase && !mention.Parse.IsCoordinatedNounPhrase)
{
featureSet.Add("cmix");
}
else
{
string mentionStrip = StripNounPhrase(mention);
string entityMentionStrip = StripNounPhrase(entityMention);
if (mentionStrip != null && entityMentionStrip != null)
{
if (IsSubstring(mentionStrip, entityMentionStrip))
{
featureSet.Add("substring");
}
}
}
Mention.IParse[] entityMentionTokens = entityMention.TokenParses;
int headIndex = entityMention.HeadTokenIndex;
//if (!mention.getHeadTokenTag().equals(entityMention.getHeadTokenTag())) {
// //System.err.println("skipping "+mention.headTokenText+" with "+xec.headTokenText+" because "+mention.headTokenTag+" != "+xec.headTokenTag);
// continue;
//} want to match NN NNP
string entityMentionHeadString = entityMention.HeadTokenText.ToLower();
// model lexical similarity
if (mentionHeadString == entityMentionHeadString)
{
sameHead = true;
featureSet.Add("hds=" + mentionHeadString);
if (!modifersMatch || !noTheModifiersMatch)
{
//only check if we haven't already found one which is the same
modifersMatch = true;
noTheModifiersMatch = true;
Util.Set<string> entityMentionModifierSet = ConstructModifierSet(entityMentionTokens, headIndex);
foreach (string modifierWord in entityContextModifierSet)
{
if (!entityMentionModifierSet.Contains(modifierWord))
{
modifersMatch = false;
if (modifierWord != "the")
{
noTheModifiersMatch = false;
featureSet.Add("mmw=" + modifierWord);
}
}
}
}
}
Util.Set<string> descriptorModifierSet = ConstructModifierSet(entityMentionTokens, entityMention.NonDescriptorStart);
if (descriptorModifierSet.Contains(mentionHeadString))
{
titleMatch = true;
}
}
if (!(featureSet.Count == 0))
{
features.AddRange(featureSet);
}
if (sameHead)
{
features.Add("sameHead");
if (modifersMatch)
{
features.Add("modsMatch");
}
else if (noTheModifiersMatch)
{
features.Add("nonTheModsMatch");
}
else
{
features.Add("modsMisMatch");
}
}
if (titleMatch)
{
features.Add("titleMatch");
}
return features;
}
public override DiscourseEntity Retain(Mention.MentionContext mention, DiscourseModel discourseModel)
{
if (_resolverMode == ResolverMode.Train)
{
DiscourseEntity discourseEntity = null;
var referentFound = false;
var hasReferentialCandidate = false;
var nonReferentFound = false;
for (var entityIndex = 0; entityIndex < GetNumberEntitiesBack(discourseModel); entityIndex++)
{
var currentDiscourseEntity = discourseModel.GetEntity(entityIndex);
var entityMention = currentDiscourseEntity.LastExtent;
if (IsOutOfRange(mention, currentDiscourseEntity))
{
break;
}
if (IsExcluded(mention, currentDiscourseEntity))
{
if (ShowExclusions)
{
if (mention.Id != -1 && entityMention.Id == mention.Id)
{
Console.Error.WriteLine(this + ".retain: Referent excluded: (" + mention.Id + ") " + mention.ToText() + " " + mention.IndexSpan + " -> (" + entityMention.Id + ") " + entityMention.ToText() + " " + entityMention.Span + " " + this);
}
}
}
else
{
hasReferentialCandidate = true;
var useAsDifferentExample = defaultReferent(currentDiscourseEntity);
//if (!sampleSelection || (mention.getId() != -1 && entityMention.getId() == mention.getId()) || (!nonReferentFound && useAsDifferentExample)) {
var features = GetFeatures(mention, currentDiscourseEntity);
//add Event to Model
if (DebugOn)
{
Console.Error.WriteLine(this + ".retain: " + mention.Id + " " + mention.ToText() + " -> " + entityMention.Id + " " + currentDiscourseEntity);
}
if (mention.Id != -1 && entityMention.Id == mention.Id)
{
referentFound = true;
_events.Add(new SharpEntropy.TrainingEvent(Same, features.ToArray()));
discourseEntity = currentDiscourseEntity;
Distances.Add(entityIndex);
}
else if (!PairedSampleSelection || (!nonReferentFound && useAsDifferentExample))
{
nonReferentFound = true;
_events.Add(new SharpEntropy.TrainingEvent(Diff, features.ToArray()));
}
//}
}
if (PairedSampleSelection && referentFound && nonReferentFound)
{
break;
}
if (PreferFirstReferent && referentFound)
{
break;
}
}
// doesn't refer to anything
if (hasReferentialCandidate)
{
NonReferentialResolver.AddEvent(mention);
}
return(discourseEntity);
}
else
{
return(base.Retain(mention, discourseModel));
}
}
