/// <summary>
/// Method to show GetMentionsActivity.
/// </summary>
/// <param name="scrumMembers">Scrum members present in the current scrum.</param>
/// <returns>member ids.</returns>
private Activity GetMentionsActivity(IEnumerable <TeamsChannelAccount> scrumMembers)
{
StringBuilder membersMention = new StringBuilder();
var entities = new List <Entity>();
var mentions = new List <Mention>();
foreach (var member in scrumMembers)
{
membersMention.Append(" ");
var mention = new Mention
{
Mentioned = new ChannelAccount()
{
Id = member.Id,
Name = member.Name,
},
Text = $"<at>{XmlConvert.EncodeName(member.Name)}</at>",
};
mentions.Add(mention);
entities.Add(mention);
membersMention.Append(mention.Text).Append(",").Append(" ");
}
membersMention = membersMention.Insert(0, "CC: ");
var replyActivity = MessageFactory.Text(membersMention.ToString().Trim().TrimEnd(','));
replyActivity.Entities = entities;
return(replyActivity);
}
internal static string GetMessageForUser(Mention userMention)
{
var user = Users[userMention.Text];
var template = @"Hey {0} It looks like you're typing some code. Let me run it for you! 😊";
if (user.CodeSubmissionCount < 3)
{
template = GetMessageTemplate(Level1MessageTemplates);
}
else
{
var split = Random.NextDouble();
if (split > 5)
{
split = Random.NextDouble();
if (user.HasCustomTemplates && split > 7)
{
template = user.GetMessageTemplate();
}
else
{
template = GetMessageTemplate(Level2MessageTemplates);
}
}
else
{
template = GetMessageTemplate(Level1MessageTemplates);
}
}
return(GenerateMessage(userMention, template));
}
public void RemoveRecipientMention_forTeams()
{
var activity = CreateActivity();
activity.Text = "<at>firstName</at> lastName\n";
var expectedStrippedName = "lastName";
var mention = new Mention
{
Mentioned = new ChannelAccount()
{
Id = activity.Recipient.Id,
Name = "firstName",
},
Text = null,
Type = "mention",
};
var lst = new List <Entity>();
var output = JsonConvert.SerializeObject(mention);
var entity = JsonConvert.DeserializeObject <Entity>(output);
lst.Add(entity);
activity.Entities = lst;
var strippedActivityText = activity.RemoveRecipientMention();
Assert.AreEqual(strippedActivityText, expectedStrippedName);
}
public static bool IsPleonasticDebug(Mention m, Tree tree, StringBuilder sbLog)
{
if (!Sharpen.Runtime.EqualsIgnoreCase(m.SpanToString(), "it"))
{
return(false);
}
bool isPleonastic = false;
int patternIdx = -1;
int matchedPattern = -1;
foreach (TregexPattern p in pleonasticPatterns)
{
patternIdx++;
if (CheckPleonastic(m, tree, p))
{
// SieveCoreferenceSystem.logger.fine("RuleBasedCorefMentionFinder: matched pleonastic pattern '" + p + "' for " + tree);
isPleonastic = true;
matchedPattern = patternIdx;
}
}
sbLog.Append("PLEONASTIC IT: mention ID: " + m.mentionID + "\thastwin: " + m.hasTwin + "\tpleonastic it? " + isPleonastic + "\tcorrect? " + (m.hasTwin != isPleonastic) + "\tmatched pattern: " + matchedPattern + "\n");
sbLog.Append(m.contextParseTree.PennString()).Append("\n");
sbLog.Append("PLEONASTIC IT END\n");
return(isPleonastic);
}
public async Task OnTurnAsync(ITurnContext turnContext, NextDelegate next, CancellationToken cancellationToken)
{
if (turnContext.Activity.Conversation.IsGroup == true)
{
turnContext.OnSendActivities(async(ctx, activities, nextSend) =>
{
foreach (var activity in activities)
{
var text = $"<at>{activity.Recipient.Name}</at>";
var mention = new Mention(activity.Recipient, text, "mention");
activity.Text = text + activity.Text;
if (activity.Entities == null)
{
activity.Entities = new List <Entity>();
}
activity.Entities.Add(mention);
}
// run full pipeline
var responses = await nextSend().ConfigureAwait(false);
return(responses);
});
turnContext.Activity.RemoveRecipientMention();
}
await next(cancellationToken);
}
internal async void InitAllList()
{
#pragma warning disable CS4014 // 由于此调用不会等待，因此在调用完成前将继续执行当前方法
GetUnreadCount();
Timeline.Refresh();
if (Settings.IsMergeMentionAndComment)
{
MergeMessage.Refresh();
}
else
{
Mention.Refresh();
Comment.Refresh();
CommentMention.Refresh();
}
Favor.Refresh();
Message.Refresh();
#pragma warning restore CS4014 // 由于此调用不会等待，因此在调用完成前将继续执行当前方法
try
{
(await Core.Api.Friendships.Groups.GetGroups()).Lists.ForEach(item => Groups.Add(item));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Groups)));
}
catch (Exception ex) when(ex is WebException || ex is HttpRequestException || ex is TaskCanceledException || ex is NullReferenceException)
{
}
}
public static LocalEmbed CreateInfoEmbed(this CachedGuild guild)
{
var e = new LocalEmbed()
.WithDefaultColor()
.WithTitle(guild.Name)
.WithThumbnailUrl(guild.GetIconUrl());
if (guild.Description is not null)
{
e.WithDescription(guild.Description);
}
e.AddInlineField("Owner", Mention.User(guild.OwnerId));
e.AddInlineField("Created On", Markdown.Timestamp(guild.CreatedAt()));
e.FillLineWithEmptyFields();
e.AddInlineField("Member Count", guild.MemberCount);
e.AddInlineField("Role Count", guild.Roles.Count);
var channels = guild.GetChannels();
e.AddInlineField("Channel Count", channels.Count);
e.AddInlineField("Text Channel Count", channels.Count(x => x.Value is CachedTextChannel));
e.AddInlineField("Voice Channel Count", channels.Count(x => x.Value is CachedVoiceChannel));
e.AddInlineField("Category Count", channels.Count(x => x.Value is CachedCategoryChannel));
e.AddInlineField("Boost Level", guild.BoostTier);
e.AddInlineField("Emoji Count", guild.Emojis.Count);
e.AddInlineField("Locale", guild.PreferredLocale);
return(e);
}
/// <summary>
/// Method to show GetMentionsActivity.
/// </summary>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="scrumMasterDetails">Scrum master details.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>member ids.</returns>
private async Task <Activity> GetMentionsActivityAsync(ITurnContext turnContext, ScrumMaster scrumMasterDetails, CancellationToken cancellationToken)
{
var members = await this.scrumHelper.GetValidMembersInScrumAsync(turnContext, scrumMasterDetails, cancellationToken);
StringBuilder membersMention = new StringBuilder();
var entities = new List <Entity>();
var mentions = new List <Mention>();
foreach (var member in members)
{
membersMention.Append(" ");
var mention = new Mention
{
Mentioned = new ChannelAccount()
{
Id = member.Id,
Name = member.Name,
},
Text = $"<at>{XmlConvert.EncodeName(member.Name)}</at>",
};
mentions.Add(mention);
entities.Add(mention);
membersMention.Append(mention.Text).Append(",").Append(" ");
}
membersMention = membersMention.Insert(0, "CC: ");
var replyActivity = MessageFactory.Text(membersMention.ToString().Trim().TrimEnd(','));
replyActivity.Entities = entities;
return(replyActivity);
}
/// <summary>Divides a sentence into clauses and sort the antecedents for pronoun matching</summary>
private static IList <Mention> SortMentionsByClause(IList <Mention> l, Mention m1)
{
IList <Mention> sorted = new List <Mention>();
Tree tree = m1.contextParseTree;
Tree current = m1.mentionSubTree;
if (tree == null || current == null)
{
return(l);
}
while (true)
{
current = current.Ancestor(1, tree);
string curLabel = current.Label().Value();
if ("TOP".Equals(curLabel) || curLabel.StartsWith("S") || curLabel.Equals("NP"))
{
// if(current.label().value().startsWith("S")){
foreach (Mention m in l)
{
if (!sorted.Contains(m) && current.Dominates(m.mentionSubTree))
{
sorted.Add(m);
}
}
}
if (current.Ancestor(1, tree) == null)
{
break;
}
}
return(sorted);
}
public static IList <Mention> GetOrderedAntecedents(Mention m, int antecedentSentence, int mPosition, IList <IList <Mention> > orderedMentionsBySentence, Dictionaries dict)
{
IList <Mention> orderedAntecedents = new List <Mention>();
// ordering antecedents
if (antecedentSentence == m.sentNum)
{
// same sentence
Sharpen.Collections.AddAll(orderedAntecedents, orderedMentionsBySentence[m.sentNum].SubList(0, mPosition));
if (dict.relativePronouns.Contains(m.SpanToString()))
{
Java.Util.Collections.Reverse(orderedAntecedents);
}
else
{
orderedAntecedents = SortMentionsByClause(orderedAntecedents, m);
}
}
else
{
// previous sentence
Sharpen.Collections.AddAll(orderedAntecedents, orderedMentionsBySentence[antecedentSentence]);
}
return(orderedAntecedents);
}
public override bool CheckEntityMatch(Document document, CorefCluster mentionCluster, CorefCluster potentialAntecedent, Dictionaries dict, ICollection <Mention> roleSet)
{
bool matched = false;
Mention mainMention = mentionCluster.GetRepresentativeMention();
Mention antMention = potentialAntecedent.GetRepresentativeMention();
// Check if the representative mentions are compatible
if (IsNamedMention(mainMention, dict, roleSet) && IsNamedMention(antMention, dict, roleSet))
{
if (mainMention.originalSpan.Count > minTokens || antMention.originalSpan.Count > minTokens)
{
if (CorefRules.EntityAttributesAgree(mentionCluster, potentialAntecedent, ignoreGender))
{
if (supportedNerTypes.Contains(mainMention.nerString) || supportedNerTypes.Contains(antMention.nerString))
{
matched = mentionMatcher.IsCompatible(mainMention, antMention);
if (matched != null)
{
//Redwood.log("Match '" + mainMention + "' with '" + antMention + "' => " + matched);
if (!matched)
{
document.AddIncompatible(mainMention, antMention);
}
}
else
{
matched = false;
}
}
}
}
}
return(matched);
}
private void AddMention(Mention mention)
{
if (!ReferenceEquals(Mentions.AddOrUpdate(mention.Id, mention, (x, y) => y), mention))
{
return;
}
ConcurrentDictionary <long, long> tagLookup;
if (MentionTagLookup.TryGetValue(mention.Id, out tagLookup))
{
mention.Tags = tagLookup.Select(x => x.Key).ToList();
}
ConcurrentDictionary <long, long> datasourceLookup;
if (MentionDatasourceLookup.TryGetValue(mention.Id, out datasourceLookup))
{
mention.Datasources = datasourceLookup.Select(x => x.Key).ToList();
}
ConcurrentDictionary <long, long> themeLookup;
if (MentionThemeLookup.TryGetValue(mention.Id, out themeLookup))
{
mention.Themes = themeLookup.Select(x => x.Value).ToList();
}
}
protected internal static void ExtractEnumerations(ICoreMap s, IList <Mention> mentions, ICollection <IntPair> mentionSpanSet, ICollection <IntPair> namedEntitySpanSet)
{
IList <CoreLabel> sent = s.Get(typeof(CoreAnnotations.TokensAnnotation));
Tree tree = s.Get(typeof(TreeCoreAnnotations.TreeAnnotation));
SemanticGraph dependency = s.Get(typeof(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation));
TregexPattern tgrepPattern = enumerationsMentionPattern;
TregexMatcher matcher = tgrepPattern.Matcher(tree);
IDictionary <IntPair, Tree> spanToMentionSubTree = Generics.NewHashMap();
while (matcher.Find())
{
matcher.GetMatch();
Tree m1 = matcher.GetNode("m1");
Tree m2 = matcher.GetNode("m2");
IList <Tree> mLeaves = m1.GetLeaves();
int beginIdx = ((CoreLabel)mLeaves[0].Label()).Get(typeof(CoreAnnotations.IndexAnnotation)) - 1;
int endIdx = ((CoreLabel)mLeaves[mLeaves.Count - 1].Label()).Get(typeof(CoreAnnotations.IndexAnnotation));
spanToMentionSubTree[new IntPair(beginIdx, endIdx)] = m1;
mLeaves = m2.GetLeaves();
beginIdx = ((CoreLabel)mLeaves[0].Label()).Get(typeof(CoreAnnotations.IndexAnnotation)) - 1;
endIdx = ((CoreLabel)mLeaves[mLeaves.Count - 1].Label()).Get(typeof(CoreAnnotations.IndexAnnotation));
spanToMentionSubTree[new IntPair(beginIdx, endIdx)] = m2;
}
foreach (IntPair mSpan in spanToMentionSubTree.Keys)
{
if (!mentionSpanSet.Contains(mSpan) && !InsideNE(mSpan, namedEntitySpanSet))
{
int dummyMentionId = -1;
Mention m = new Mention(dummyMentionId, mSpan.Get(0), mSpan.Get(1), dependency, new List <CoreLabel>(sent.SubList(mSpan.Get(0), mSpan.Get(1))), spanToMentionSubTree[mSpan]);
mentions.Add(m);
mentionSpanSet.Add(mSpan);
}
}
}
private static string GetRole(Mention m)
{
if (m.isSubject)
{
return("subject");
}
else
{
if (m.isDirectObject)
{
return("direct-object");
}
else
{
if (m.isIndirectObject)
{
return("indirect-object");
}
else
{
if (m.isPrepositionObject)
{
return("preposition-object");
}
}
}
}
return("unknown");
}
public virtual IList <IList <Mention> > ExtractGoldMentions(CoNLL2011DocumentReader.Document conllDoc)
{
IList <ICoreMap> sentences = conllDoc.GetAnnotation().Get(typeof(CoreAnnotations.SentencesAnnotation));
IList <IList <Mention> > allGoldMentions = new List <IList <Mention> >();
CollectionValuedMap <string, ICoreMap> corefChainMap = conllDoc.GetCorefChainMap();
for (int i = 0; i < sentences.Count; i++)
{
allGoldMentions.Add(new List <Mention>());
}
int maxCorefClusterId = -1;
foreach (string corefIdStr in corefChainMap.Keys)
{
int id = System.Convert.ToInt32(corefIdStr);
if (id > maxCorefClusterId)
{
maxCorefClusterId = id;
}
}
int newMentionID = maxCorefClusterId + 1;
foreach (KeyValuePair <string, ICollection <ICoreMap> > idChainEntry in corefChainMap)
{
int id = System.Convert.ToInt32(idChainEntry.Key);
int clusterMentionCnt = 0;
foreach (ICoreMap m in idChainEntry.Value)
{
clusterMentionCnt++;
Mention mention = new Mention();
mention.goldCorefClusterID = id;
if (clusterMentionCnt == 1)
{
// First mention in cluster
mention.mentionID = id;
mention.originalRef = -1;
}
else
{
mention.mentionID = newMentionID;
mention.originalRef = id;
newMentionID++;
}
if (maxID < mention.mentionID)
{
maxID = mention.mentionID;
}
int sentIndex = m.Get(typeof(CoreAnnotations.SentenceIndexAnnotation));
ICoreMap sent = sentences[sentIndex];
mention.startIndex = m.Get(typeof(CoreAnnotations.TokenBeginAnnotation)) - sent.Get(typeof(CoreAnnotations.TokenBeginAnnotation));
mention.endIndex = m.Get(typeof(CoreAnnotations.TokenEndAnnotation)) - sent.Get(typeof(CoreAnnotations.TokenBeginAnnotation));
// will be set by arrange
mention.originalSpan = m.Get(typeof(CoreAnnotations.TokensAnnotation));
// Mention dependency graph is the enhanced dependency graph of the sentence
mention.dependency = sentences[sentIndex].Get(typeof(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation));
allGoldMentions[sentIndex].Add(mention);
}
}
return(allGoldMentions);
}
/// <summary>initialize positions and corefClusters (put each mention in each CorefCluster)</summary>
private void InitializeCorefCluster()
{
for (int i = 0; i < predictedOrderedMentionsBySentence.Count; i++)
{
for (int j = 0; j < predictedOrderedMentionsBySentence[i].Count; j++)
{
Mention m = predictedOrderedMentionsBySentence[i][j];
if (allPredictedMentions.Contains(m.mentionID))
{
SieveCoreferenceSystem.logger.Warning("WARNING: Already contain mention " + m.mentionID);
Mention m1 = allPredictedMentions[m.mentionID];
SieveCoreferenceSystem.logger.Warning("OLD mention: " + m1.SpanToString() + "[" + m1.startIndex + "," + m1.endIndex + "]");
SieveCoreferenceSystem.logger.Warning("NEW mention: " + m.SpanToString() + "[" + m.startIndex + "," + m.endIndex + "]");
}
// SieveCoreferenceSystem.debugPrintMentions(System.err, "PREDICTED ORDERED", predictedOrderedMentionsBySentence);
// SieveCoreferenceSystem.debugPrintMentions(System.err, "GOLD ORDERED", goldOrderedMentionsBySentence);
System.Diagnostics.Debug.Assert((!allPredictedMentions.Contains(m.mentionID)));
allPredictedMentions[m.mentionID] = m;
IntTuple pos = new IntTuple(2);
pos.Set(0, i);
pos.Set(1, j);
positions[m] = pos;
m.sentNum = i;
System.Diagnostics.Debug.Assert((!corefClusters.Contains(m.mentionID)));
corefClusters[m.mentionID] = new CorefCluster(m.mentionID, Generics.NewHashSet(Java.Util.Collections.SingletonList(m)));
m.corefClusterID = m.mentionID;
IntTuple headPosition = new IntTuple(2);
headPosition.Set(0, i);
headPosition.Set(1, m.headIndex);
mentionheadPositions[headPosition] = m;
}
}
}
/// <summary>Check one mention is the speaker of the other mention</summary>
public static bool IsSpeaker(Mention m, Mention ant, Dictionaries dict)
{
if (!dict.firstPersonPronouns.Contains(ant.SpanToString().ToLower()) || ant.number == Dictionaries.Number.Plural || ant.sentNum != m.sentNum)
{
return(false);
}
int countQuotationMark = 0;
for (int i = System.Math.Min(m.headIndex, ant.headIndex) + 1; i < System.Math.Max(m.headIndex, ant.headIndex); i++)
{
string word = m.sentenceWords[i].Get(typeof(CoreAnnotations.TextAnnotation));
if (word.Equals("``") || word.Equals("''"))
{
countQuotationMark++;
}
}
if (countQuotationMark != 1)
{
return(false);
}
IndexedWord w = m.dependency.GetNodeByWordPattern(m.sentenceWords[m.headIndex].Get(typeof(CoreAnnotations.TextAnnotation)));
if (w == null)
{
return(false);
}
foreach (Pair <GrammaticalRelation, IndexedWord> parent in m.dependency.ParentPairs(w))
{
if (parent.First().GetShortName().Equals("nsubj") && dict.reportVerb.Contains(parent.Second().Get(typeof(CoreAnnotations.LemmaAnnotation))))
{
return(true);
}
}
return(false);
}
public virtual void ExtractNPorPRP(ICoreMap s, IList <Mention> mentions, ICollection <IntPair> mentionSpanSet, ICollection <IntPair> namedEntitySpanSet)
{
IList <CoreLabel> sent = s.Get(typeof(CoreAnnotations.TokensAnnotation));
Tree tree = s.Get(typeof(TreeCoreAnnotations.TreeAnnotation));
tree.IndexLeaves();
SemanticGraph basicDependency = s.Get(typeof(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation));
SemanticGraph enhancedDependency = s.Get(typeof(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation));
if (enhancedDependency == null)
{
enhancedDependency = s.Get(typeof(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation));
}
TregexPattern tgrepPattern = npOrPrpMentionPattern;
TregexMatcher matcher = tgrepPattern.Matcher(tree);
while (matcher.Find())
{
Tree t = matcher.GetMatch();
IList <Tree> mLeaves = t.GetLeaves();
int beginIdx = ((CoreLabel)mLeaves[0].Label()).Get(typeof(CoreAnnotations.IndexAnnotation)) - 1;
int endIdx = ((CoreLabel)mLeaves[mLeaves.Count - 1].Label()).Get(typeof(CoreAnnotations.IndexAnnotation));
//if (",".equals(sent.get(endIdx-1).word())) { endIdx--; } // try not to have span that ends with ,
IntPair mSpan = new IntPair(beginIdx, endIdx);
if (!mentionSpanSet.Contains(mSpan) && (lang == Locale.Chinese || !InsideNE(mSpan, namedEntitySpanSet)))
{
// if(!mentionSpanSet.contains(mSpan) && (!insideNE(mSpan, namedEntitySpanSet) || t.value().startsWith("PRP")) ) {
int dummyMentionId = -1;
Mention m = new Mention(dummyMentionId, beginIdx, endIdx, sent, basicDependency, enhancedDependency, new List <CoreLabel>(sent.SubList(beginIdx, endIdx)), t);
mentions.Add(m);
mentionSpanSet.Add(mSpan);
}
}
}
/// <inheritdoc/>
public override ValueTask <TypeParserResult <TChannel> > ParseAsync(Parameter parameter, string value, DiscordGuildCommandContext context)
{
if (!context.Bot.CacheProvider.TryGetChannels(context.GuildId, out var cache))
{
throw new InvalidOperationException($"The {GetType().Name} requires the channel cache.");
}
// Wraps the cache in a pattern-matching wrapper dictionary.
var channels = new ReadOnlyOfTypeDictionary <Snowflake, CachedGuildChannel, TChannel>(cache);
TChannel channel;
if (Snowflake.TryParse(value, out var id) || Mention.TryParseChannel(value, out id))
{
// The value is a mention or an id.
channel = channels.GetValueOrDefault(id);
}
else
{
// The value is possibly a name.
channel = channels.Values.FirstOrDefault(x => x.Name == value);
}
if (channel != null)
{
return(Success(channel));
}
return(Failure($"No {ChannelString} found matching the input."));
}
private async Task <List <Entity> > GetPeopleToMention(ITurnContext turnContext, CancellationToken cancellationToken)
{
IEnumerable <TeamsChannelAccount> members = await TeamsInfo.GetMembersAsync(turnContext, cancellationToken);
List <Entity> entities = new List <Entity>();
foreach (TeamsChannelAccount member in members)
{
foreach (string upn in dataFromRequest.Mentions)
{
if (String.Compare(member.UserPrincipalName, upn, true) == 0)
{
// Construct a ChannelAccount Object.
ChannelAccount mentionedUser = new ChannelAccount(member.Id, member.Name, member.Role, member.AadObjectId);
// Construct a Mention object.
var mentionObject = new Mention
{
Mentioned = mentionedUser,
Text = $"<at>{XmlConvert.EncodeName(member.Name)}</at>",
};
entities.Add(mentionObject);
}
}
}
return(entities);
}
/// <summary>Skip this mention? (search pruning)</summary>
public virtual bool SkipThisMention(Document document, Mention m1, CorefCluster c, Dictionaries dict)
{
bool skip = false;
// only do for the first mention in its cluster
// if(!flags.USE_EXACTSTRINGMATCH && !flags.USE_ROLEAPPOSITION && !flags.USE_PREDICATENOMINATIVES
if (!flags.UseRoleapposition && !flags.UsePredicatenominatives && !flags.UseAcronym && !flags.UseApposition && !flags.UseRelativepronoun && !c.GetFirstMention().Equals(m1))
{
// CHINESE CHANGE
return(true);
}
if (m1.appositions == null && m1.predicateNominatives == null && (m1.LowercaseNormalizedSpanString().StartsWith("a ") || m1.LowercaseNormalizedSpanString().StartsWith("an ")) && !flags.UseExactstringmatch)
{
skip = true;
}
// A noun phrase starting with an indefinite article - unlikely to have an antecedent (e.g. "A commission" was set up to .... )
if (dict.indefinitePronouns.Contains(m1.LowercaseNormalizedSpanString()))
{
skip = true;
}
// An indefinite pronoun - unlikely to have an antecedent (e.g. "Some" say that... )
foreach (string indef in dict.indefinitePronouns)
{
if (m1.LowercaseNormalizedSpanString().StartsWith(indef + " "))
{
skip = true;
// A noun phrase starting with an indefinite adjective - unlikely to have an antecedent (e.g. "Another opinion" on the topic is...)
break;
}
}
return(skip);
}
/// <inheritdoc/>
public override ValueTask <TypeParserResult <IRole> > ParseAsync(Parameter parameter, string value, DiscordGuildCommandContext context)
{
if (!context.Bot.CacheProvider.TryGetRoles(context.GuildId, out var roleCache))
{
throw new InvalidOperationException($"The {GetType().Name} requires the role cache.");
}
IRole role;
if (Snowflake.TryParse(value, out var id) || Mention.TryParseRole(value, out id))
{
// The value is a mention or id.
role = roleCache.GetValueOrDefault(id);
}
else
{
// The value is possibly a name.
role = roleCache.Values.FirstOrDefault(x => x.Name == value);
}
if (role != null)
{
return(Success(role));
}
return(Failure("No role found matching the input."));
}
public virtual bool IsIncompatible(Mention m1, Mention m2)
{
int mid1 = System.Math.Min(m1.mentionID, m2.mentionID);
int mid2 = System.Math.Max(m1.mentionID, m2.mentionID);
return(incompatibles.Contains(mid1, mid2));
}
public void MentionInitsWithNoArgs()
{
var mention = new Mention();
Assert.NotNull(mention);
Assert.IsType <Mention>(mention);
}
protected internal static void ExtractNPorPRP(ICoreMap s, IList <Mention> mentions, ICollection <IntPair> mentionSpanSet, ICollection <IntPair> namedEntitySpanSet)
{
IList <CoreLabel> sent = s.Get(typeof(CoreAnnotations.TokensAnnotation));
Tree tree = s.Get(typeof(TreeCoreAnnotations.TreeAnnotation));
tree.IndexLeaves();
SemanticGraph dependency = s.Get(typeof(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation));
TregexPattern tgrepPattern = npOrPrpMentionPattern;
TregexMatcher matcher = tgrepPattern.Matcher(tree);
while (matcher.Find())
{
Tree t = matcher.GetMatch();
IList <Tree> mLeaves = t.GetLeaves();
int beginIdx = ((CoreLabel)mLeaves[0].Label()).Get(typeof(CoreAnnotations.IndexAnnotation)) - 1;
int endIdx = ((CoreLabel)mLeaves[mLeaves.Count - 1].Label()).Get(typeof(CoreAnnotations.IndexAnnotation));
if (",".Equals(sent[endIdx - 1].Word()))
{
endIdx--;
}
// try not to have span that ends with ,
IntPair mSpan = new IntPair(beginIdx, endIdx);
if (!mentionSpanSet.Contains(mSpan) && !InsideNE(mSpan, namedEntitySpanSet))
{
int dummyMentionId = -1;
Mention m = new Mention(dummyMentionId, beginIdx, endIdx, dependency, new List <CoreLabel>(sent.SubList(beginIdx, endIdx)), t);
mentions.Add(m);
mentionSpanSet.Add(mSpan);
}
}
}
//Find Twitter IDs in twitter messages
private void FindTwitterIDs(String message)
{
var regex = new Regex(@"@\w+");
var matches = regex.Matches(message);
bool idExists;
foreach (var match in matches)
{
idExists = false;
Mention t = new Mention(match.ToString(), 1);
foreach (Mention tweet in MentionsList)
{
if (tweet.Id.Trim().Equals(t.Id.Trim()))
{
tweet.Count++;
idExists = true;
break;
}
}
if (!idExists)
{
MentionsList.Add(t);
}
}
}
public override bool CanResolve(Mention.MentionContext mention)
{
string firstToken = mention.FirstTokenText.ToLower();
string firstTokenTag = mention.FirstToken.SyntacticType;
bool canResolve = mention.HeadTokenTag == "NN" && !IsDefiniteArticle(firstToken, firstTokenTag);
return canResolve;
}
/// <exception cref="System.Exception"/>
public override void FindCoreferentAntecedent(Mention m, int mIdx, Document document, Dictionaries dict, Properties props, StringBuilder sbLog)
{
for (int distance = 0; distance <= m.sentNum; distance++)
{
IList <Mention> candidates = document.predictedMentions[m.sentNum - distance];
foreach (Mention candidate in candidates)
{
if (!MatchedMentionType(candidate, aTypeStr) || !MatchedMentionType(m, mTypeStr))
{
continue;
}
// if(!options.mType.contains(m.mentionType) || !options.aType.contains(candidate.mentionType)) continue;
if (candidate == m)
{
continue;
}
if (distance == 0 && m.AppearEarlierThan(candidate))
{
continue;
}
// ignore cataphora
if (Edu.Stanford.Nlp.Coref.Hybrid.Sieve.Sieve.IsReallyCoref(document, m.mentionID, candidate.mentionID))
{
if (m.mentionType == Dictionaries.MentionType.List)
{
log.Info("LIST MATCHING MENTION : " + m.SpanToString() + "\tANT: " + candidate.SpanToString());
}
Edu.Stanford.Nlp.Coref.Hybrid.Sieve.Sieve.Merge(document, m.mentionID, candidate.mentionID);
return;
}
}
}
}
static async Task SendMessageInTeamChannelWithMention(ConnectorClient connectorClient, string teamInternalId, string teamsChannelId, string recipientUserPrincipalName, string message)
{
var teamMembers = await connectorClient.Conversations.GetConversationMembersAsync(teamInternalId, default);
var userToMention = teamMembers
.Select(channelAccount => JObject.FromObject(channelAccount).ToObject <TeamsChannelAccount>())
.First(user => user.UserPrincipalName == recipientUserPrincipalName);
var mention = new Mention
{
Mentioned = userToMention,
Text = $"<at>{userToMention.Name}</at>",
};
var msgActivity = MessageFactory.Text($"{mention.Text} - {message}");
msgActivity.Entities = new List <Entity> {
mention
};
var conversationParameters = new ConversationParameters
{
IsGroup = true,
ChannelData = new TeamsChannelData
{
Channel = new ChannelInfo(teamsChannelId),
},
Activity = msgActivity
};
await connectorClient.Conversations.CreateConversationAsync(conversationParameters);
}
/// <summary>Skip this mention? (search pruning)</summary>
public virtual bool SkipThisMention(Document document, Mention m1, CorefCluster c, Dictionaries dict)
{
bool skip = false;
// only do for the first mention in its cluster
if (!flags.UseExactstringmatch && !flags.UseRoleapposition && !flags.UsePredicatenominatives && !flags.UseAcronym && !flags.UseApposition && !flags.UseRelativepronoun && !c.GetFirstMention().Equals(m1))
{
return(true);
}
SieveCoreferenceSystem.logger.Finest("DOING COREF FOR:\t" + m1.SpanToString());
if (m1.appositions == null && m1.predicateNominatives == null && (m1.LowercaseNormalizedSpanString().StartsWith("a ") || m1.LowercaseNormalizedSpanString().StartsWith("an ")) && !flags.UseExactstringmatch)
{
skip = true;
}
// A noun phrase starting with an indefinite article - unlikely to have an antecedent (e.g. "A commission" was set up to .... )
if (dict.indefinitePronouns.Contains(m1.LowercaseNormalizedSpanString()))
{
skip = true;
}
// An indefinite pronoun - unlikely to have an antecedent (e.g. "Some" say that... )
foreach (string indef in dict.indefinitePronouns)
{
if (m1.LowercaseNormalizedSpanString().StartsWith(indef + " "))
{
skip = true;
// A noun phrase starting with an indefinite adjective - unlikely to have an antecedent (e.g. "Another opinion" on the topic is...)
break;
}
}
if (skip)
{
SieveCoreferenceSystem.logger.Finest("MENTION SKIPPED:\t" + m1.SpanToString() + "(" + m1.sentNum + ")" + "\toriginalRef: " + m1.originalRef + " in discourse " + m1.headWord.Get(typeof(CoreAnnotations.UtteranceAnnotation)));
}
return(skip);
}
public static bool RelaxedStringMatch(Mention m1, Mention m2)
{
ICollection <string> propers = GetPropers(m1);
propers.RetainAll(GetPropers(m2));
return(!propers.IsEmpty());
}
/// <summary>
/// Creates a new entity based on the specified mention and its specified gender and number properties.
/// </summary>
/// <param name="mention">
/// The first mention of this entity.
/// </param>
/// <param name="gender">
/// The gender of this entity.
/// </param>
/// <param name="genderProbability">
/// The probability that the specified gender is correct.
/// </param>
/// <param name="number">
/// The number for this entity.
/// </param>
/// <param name="numberProbability">
/// The probability that the specified number is correct.
/// </param>
public DiscourseEntity(Mention.MentionContext mention, Similarity.GenderEnum gender, double genderProbability, Similarity.NumberEnum number, double numberProbability)
: base(mention)
{
mGender = gender;
mGenderProbability = genderProbability;
mNumber = number;
mNumberProbability = numberProbability;
}
public override bool CanResolve(Mention.MentionContext mention)
{
string firstToken = mention.FirstTokenText.ToLower();
string firstTokenTag = mention.FirstToken.SyntacticType;
bool canResolve = mention.HeadTokenTag == PartsOfSpeech.NounSingularOrMass
&& !IsDefiniteArticle(firstToken, firstTokenTag);
return canResolve;
}
public virtual double GetNonReferentialProbability(Mention.MentionContext mention)
{
List<string> features = GetFeatures(mention);
double probability = mModel.Evaluate(features.ToArray())[mNonReferentialIndex];
if (mDebugOn)
{
System.Console.Error.WriteLine(this + " " + mention.ToText() + " -> null " + probability + " " + string.Join(",", features.ToArray()));
}
return probability;
}
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 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));
}
}
public virtual void AddEvent(Mention.MentionContext context)
{
List<string> features = GetFeatures(context);
if (context.Id == -1)
{
mEvents.Add(new SharpEntropy.TrainingEvent(MaximumEntropyResolver.Same, features.ToArray()));
}
else
{
mEvents.Add(new SharpEntropy.TrainingEvent(MaximumEntropyResolver.Diff, features.ToArray()));
}
}
private void Initialize(Mention.IHeadFinder headFinder)
{
Mention.IParse head = headFinder.GetLastHead(Parse);
List<Mention.IParse> tokenList = head.Tokens;
this.HeadTokenIndex = headFinder.GetHeadIndex(head);
Mention.IParse headToken = headFinder.GetHeadToken(head);
_tokens = tokenList.ToArray();
this.HeadTokenTag = headToken.SyntacticType;
this.HeadTokenText = headToken.ToString();
if (PartsOfSpeech.IsNoun(this.HeadTokenTag) && !PartsOfSpeech.IsProperNoun(this.HeadTokenTag))
{
this.Synsets = GetSynsetSet(this);
}
else
{
this.Synsets = new Util.HashSet<string>();
}
}
/// <summary>
/// Returns the string of "_" delimited tokens for the specified mention.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <returns>
/// the string of "_" delimited tokens for the specified mention.
/// </returns>
protected internal virtual string GetFeatureString(Mention.MentionContext mention)
{
System.Text.StringBuilder output = new System.Text.StringBuilder();
object[] mentionTokens = mention.Tokens;
output.Append(mentionTokens[0].ToString());
for (int currentToken = 1; currentToken < mentionTokens.Length; currentToken++)
{
output.Append("_").Append(mentionTokens[currentToken].ToString());
}
return output.ToString();
}
/// <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;
}
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);
}
}
/// <summary>
/// Returns a string for the specified mention with punctuation, honorifics, designators, and determiners removed.
/// </summary>
/// <param name="mention">
/// The mention to be stripped.
/// </param>
/// <returns>
/// a normalized string representation of the specified mention.
/// </returns>
protected internal virtual string StripNounPhrase(Mention.MentionContext mention)
{
int start = mention.NonDescriptorStart; //start after descriptors
Mention.IParse[] mentionTokens = mention.TokenParses;
int end = mention.HeadTokenIndex + 1;
if (start == end)
{
//System.err.println("StripNounPhrase: return null 1");
return null;
}
//strip determiners
if (mentionTokens[start].SyntacticType == "DT")
{
start++;
}
if (start == end)
{
//System.err.println("StripNounPhrase: return null 2");
return null;
}
//get to first NNP
string type;
for (int index = start; index < end; index++)
{
type = mentionTokens[start].SyntacticType;
if (type.StartsWith("NNP"))
{
break;
}
start++;
}
if (start == end)
{
//System.err.println("StripNounPhrase: return null 3");
return null;
}
if (start + 1 != end)
{
// don't do this on head words, to keep "U.S."
//strip off honorifics in begining
if (Linker.HonorificsPattern.IsMatch(mentionTokens[start].ToString()))
{
start++;
}
if (start == end)
{
//System.err.println("StripNounPhrase: return null 4");
return null;
}
//strip off and honorifics on the end
if (Linker.DesignatorsPattern.IsMatch(mentionTokens[mentionTokens.Length - 1].ToString()))
{
end--;
}
}
if (start == end)
{
//System.err.println("StripNounPhrase: return null 5");
return null;
}
System.Text.StringBuilder strip = new System.Text.StringBuilder();
for (int i = start; i < end; i++)
{
strip.Append(mentionTokens[i].ToString()).Append(" ");
}
return strip.ToString().Trim();
}
/// <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;
}
/// <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;
}
private string ExcludedDeterminerMentionString(Mention.MentionContext entityContext)
{
System.Text.StringBuilder output = new System.Text.StringBuilder();
bool first = true;
Mention.IParse[] mentionTokenParses = entityContext.TokenParses;
for (int tokenIndex = 0; tokenIndex < mentionTokenParses.Length; tokenIndex++)
{
Mention.IParse token = mentionTokenParses[tokenIndex];
string tag = token.SyntacticType;
if (tag != "DT")
{
if (!first)
{
output.Append(" ");
}
output.Append(token.ToString());
first = false;
}
}
return output.ToString();
}
/// <summary>
/// Returns the text of the head word for the specified mention.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <returns>
/// The text of the head word for the specified mention.
/// </returns>
protected internal virtual string GetHeadString(Mention.MentionContext mention)
{
return mention.HeadTokenText.ToLower();
}
private string ExcludedTheMentionString(Mention.MentionContext entityContext)
{
System.Text.StringBuilder output = new System.Text.StringBuilder();
bool first = true;
object[] mentionTokens = entityContext.Tokens;
for (int tokenIndex = 0; tokenIndex < mentionTokens.Length; tokenIndex++)
{
string token = mentionTokens[tokenIndex].ToString();
if (token != "the" && token != "The" && token != "THE")
{
if (!first)
{
output.Append(" ");
}
output.Append(token);
first = false;
}
}
return output.ToString();
}
private string ExcludedHonorificMentionString(Mention.MentionContext entityContext)
{
System.Text.StringBuilder output = new System.Text.StringBuilder();
bool first = true;
object[] mentionTokens = entityContext.Tokens;
for (int tokenIndex = 0; tokenIndex < mentionTokens.Length; tokenIndex++)
{
string token = mentionTokens[tokenIndex].ToString();
if (!(Linker.HonorificsPattern.Match(token).Value == token))
{
if (!first)
{
output.Append(" ");
}
output.Append(token);
first = false;
}
}
return output.ToString();
}
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;
}
public abstract DiscourseEntity Resolve(Mention.MentionContext expression, DiscourseModel discourseModel);
public abstract bool CanResolve(Mention.MentionContext mention);
/// <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;
}
private string GetExactMatchFeature(Mention.MentionContext entityContext, Mention.MentionContext compareContext)
{
//System.err.println("getExactMatchFeature: ec="+mentionString(ec)+" mc="+mentionString(xec));
if (MentionString(entityContext).Equals(MentionString(compareContext)))
{
return "exactMatch";
}
else if (ExcludedHonorificMentionString(entityContext).Equals(ExcludedHonorificMentionString(compareContext)))
{
return "exactMatchNoHonor";
}
else if (ExcludedTheMentionString(entityContext).Equals(ExcludedTheMentionString(compareContext)))
{
return "exactMatchNoThe";
}
else if (ExcludedDeterminerMentionString(entityContext).Equals(ExcludedDeterminerMentionString(compareContext)))
{
return "exactMatchNoDT";
}
return null;
}
/// <summary>
/// Returns the head parse for the specified mention.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <returns>
/// the head parse for the specified mention.
/// </returns>
protected internal virtual Mention.IParse GetHead(Mention.MentionContext mention)
{
return mention.HeadTokenParse;
}
/// <summary>
/// Returns the index for the head word for the specified mention.
/// </summary>
/// <param name="mention">
/// The mention.
/// </param>
/// <returns>
/// the index for the head word for the specified mention.
/// </returns>
protected internal virtual int GetHeadIndex(Mention.MentionContext mention)
{
Mention.IParse[] mentionTokens = mention.TokenParses;
for (int currentToken = mentionTokens.Length - 1; currentToken >= 0; currentToken--)
{
Mention.IParse token = mentionTokens[currentToken];
if (token.SyntacticType != "POS" && token.SyntacticType != "," && token.SyntacticType != ".")
{
return currentToken;
}
}
return mentionTokens.Length - 1;
}
/// <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;
}
private Util.Set<string> ConstructModifierSet(Mention.IParse[] tokens, int headIndex)
{
Util.Set<string> modifierSet = new Util.HashSet<string>();
for (int tokenIndex = 0; tokenIndex < headIndex; tokenIndex++)
{
Mention.IParse token = tokens[tokenIndex];
modifierSet.Add(token.ToString().ToLower());
}
return modifierSet;
}
/// <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;
}
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;
}
*/
}
