private async Task <AnalyzeTextResult> AnalyzeNewsAsync(IEnumerable <NewsArticle> news, string userLanguage)
{
var scores = new List <double>();
var topKeyPhrases = new List <KeyPhraseCount>();
// prepare news titles to text string
string[] newsTitleList = news.Select(n => n.Title.Replace(".", ";")).ToArray();
string newsTitles = string.Join(". ", newsTitleList);
var strInfo = new StringInfo(newsTitles);
int lenInTextElements = strInfo.LengthInTextElements;
// check Text Analytics data limits
string languageCode = GetTextAnalyticsLanguageCodeFromLanguage(userLanguage);
bool isLangSupportedForKeyPhrases = IsLanguageSupportedByKeyPhraseAPI(userLanguage);
if (lenInTextElements < TextAnalyticsHelper.MaximumLengthOfTextDocument)
{
Task <DocumentSentiment> sentimentTask = TextAnalyticsHelper.AnalyzeSentimentAsync(newsTitles, languageCode);
Task <KeyPhraseCollection> keyPhrasesTask = isLangSupportedForKeyPhrases ? TextAnalyticsHelper.ExtractKeyPhrasesAsync(newsTitles, languageCode) : Task.FromResult <KeyPhraseCollection>(null);
await Task.WhenAll(sentimentTask, keyPhrasesTask);
var sentimentResult = sentimentTask.Result;
var keyPhrasesResult = keyPhrasesTask.Result;
scores = sentimentResult.Sentences.Select(s => GetSentimentScore(s)).ToList();
var wordGroups = keyPhrasesResult?.GroupBy(phrase => phrase, StringComparer.OrdinalIgnoreCase).OrderByDescending(g => g.Count()).Take(10).OrderBy(g => g.Key).ToList();
topKeyPhrases = wordGroups != null && wordGroups.Any()
? wordGroups.Select(w => new KeyPhraseCount {
KeyPhrase = w.Key, Count = w.Count()
}).ToList()
: new List <KeyPhraseCount>()
{
new KeyPhraseCount {
KeyPhrase = "Not available in this language", Count = 1
}
};
}
else
{
// if the input data is larger than max limit then split the input data into several different requests
var sentimentTaskList = new List <Task <AnalyzeSentimentResultCollection> >();
var keyPhrasesTaskList = new List <Task <ExtractKeyPhrasesResultCollection> >();
int maxDocsPerRequest = Math.Min(TextAnalyticsHelper.MaxDocumentsPerRequestForSentimentAnalysis, TextAnalyticsHelper.MaxDocumentsPerRequestForKeyPhraseExtraction);
int batchSize = Math.Min((int)Math.Ceiling((decimal)TotalNewsCount / maxDocsPerRequest), maxDocsPerRequest);
for (int i = 0; i < TextAnalyticsHelper.MaxRequestsPerSecond; i++)
{
int skip = i * batchSize;
string[] newsTitlesBatch = newsTitleList.Skip(skip).Take(batchSize).ToArray();
if (!newsTitlesBatch.Any())
{
break;
}
sentimentTaskList.Add(TextAnalyticsHelper.AnalyzeSentimentAsync(newsTitlesBatch, languageCode));
if (isLangSupportedForKeyPhrases)
{
keyPhrasesTaskList.Add(TextAnalyticsHelper.ExtractKeyPhrasesAsync(newsTitlesBatch, languageCode));
}
}
var taskList = new List <Task>();
taskList.AddRange(sentimentTaskList);
taskList.AddRange(keyPhrasesTaskList);
await Task.WhenAll(taskList);
foreach (var sentimentTask in sentimentTaskList)
{
AnalyzeSentimentResultCollection sentimentResult = sentimentTask.Result;
scores.AddRange(sentimentResult.SelectMany(d => d.DocumentSentiment.Sentences).Select(s => GetSentimentScore(s)).ToList());
}
var keyPhrasesList = new List <string>();
foreach (var keyPhrasesTask in keyPhrasesTaskList)
{
ExtractKeyPhrasesResultCollection keyPhrasesResult = keyPhrasesTask.Result;
keyPhrasesList.AddRange(keyPhrasesResult.SelectMany(k => k.KeyPhrases));
}
var wordGroups = keyPhrasesList.GroupBy(phrase => phrase, StringComparer.OrdinalIgnoreCase).OrderByDescending(g => g.Count()).Take(10).OrderBy(g => g.Key).ToList();
topKeyPhrases = wordGroups.Any()
? wordGroups.Select(w => new KeyPhraseCount {
KeyPhrase = w.Key, Count = w.Count()
}).ToList()
: new List <KeyPhraseCount>()
{
new KeyPhraseCount {
KeyPhrase = "Not available in this language", Count = 1
}
};
}
return(new AnalyzeTextResult
{
Scores = scores,
TopKeyPhrases = topKeyPhrases
});
}
private async Task AnalyzeTextAsync()
{
try
{
this.progressControl.IsActive = true;
DisplayProcessingUI();
string input = this.inputText.Text;
var detectedLanguageTask = TextAnalyticsHelper.DetectLanguageAsync(input);
var detectedKeyPhrasesTask = TextAnalyticsHelper.ExtractKeyPhrasesAsync(input);
var documentSentimentTask = TextAnalyticsHelper.AnalyzeSentimentAsync(input, sentimentAnalyses: AdditionalSentimentAnalyses.OpinionMining);
var namedEntitiesResponseTask = TextAnalyticsHelper.RecognizeEntitiesAsync(input);
var linkedEntitiesResponseTask = TextAnalyticsHelper.RecognizeLinkedEntitiesAsync(input);
await Task.WhenAll(detectedLanguageTask, detectedKeyPhrasesTask, documentSentimentTask, namedEntitiesResponseTask, linkedEntitiesResponseTask);
var detectedLanguage = detectedLanguageTask.Result;
var detectedKeyPhrases = detectedKeyPhrasesTask.Result;
var documentSentiment = documentSentimentTask.Result;
var namedEntitiesResponse = namedEntitiesResponseTask.Result;
var linkedEntitiesResponse = linkedEntitiesResponseTask.Result;
// detected language and key phrases
this.detectedLangTextBlock.Text = !string.IsNullOrEmpty(detectedLanguage.Name) ? $"{detectedLanguage.Name} (confidence: {(int)(detectedLanguage.ConfidenceScore * 100)}%)" : "Not found";
this.detectedKeyPhrasesTextBlock.Text = detectedKeyPhrases.Any() ? string.Join(", ", detectedKeyPhrases) : "Not found";
// document sentiment
CreateSentimentChart(documentSentiment);
// mined opinions
OpinionMiningCollection.Clear();
var minedOpinions = documentSentiment?.Sentences.SelectMany(s => s.MinedOpinions);
if (minedOpinions != null && minedOpinions.Any())
{
var minedOpinionList = minedOpinions.Select(om => new MinedOpinion()
{
Aspect = om.Aspect.Text,
Opinions = string.Join(", ", om.Opinions.Select(o => $"{o.Text} ({o.Sentiment.ToString("G")})"))
});
OpinionMiningCollection.AddRange(minedOpinionList);
}
// entities
if (namedEntitiesResponse.Any())
{
this.namesEntitiesGridView.ItemsSource = namedEntitiesResponse.Select(x => new { x.Text, Category = $"[{x.Category}]" });
}
else
{
this.namesEntitiesGridView.ItemsSource = new[] { new { Text = "No entities" } };
}
// linked entities
if (linkedEntitiesResponse.Any())
{
this.linkedEntitiesGridView.ItemsSource = linkedEntitiesResponse.Select(x => new { Name = $"{x.Name} ({x.DataSource})", x.Url });
}
else
{
this.linkedEntitiesGridView.ItemsSource = new[] { new { Name = "No linked entities" } };
}
// prepare json result
var jsonResult = new
{
LanguageDetection = detectedLanguage,
KeyPhrases = detectedKeyPhrases,
Sentiment = documentSentiment,
Entities = namedEntitiesResponse,
EntityLinking = linkedEntitiesResponse
};
this.jsonResultTextBlock.Text = JsonConvert.SerializeObject(jsonResult, Formatting.Indented);
}
catch (Exception ex)
{
await Util.GenericApiCallExceptionHandler(ex, "Failure analyzing text");
}
finally
{
this.progressControl.IsActive = false;
}
}
private async void btnName_Click(object sender, EventArgs e)
{
if (btnName.Text == "Start")
{
btnName.Text = "Stop";
recognizer.Recognizing += (s, e) =>
{
//Log($"{e.Result.Text}{Environment.NewLine}");
};
recognizer.Recognized += async(s, e) =>
{
if (e.Result.Reason == ResultReason.RecognizedSpeech)
{
if (!string.IsNullOrEmpty(e.Result.Text))
{
var result = await textAnalyticsHelper.AnalyzeSentitmentAsync(e.Result.Text);
var phrases = await textAnalyticsHelper.ExtractKeyPhrasesAsync(e.Result.Text);
string message = $"{result.Sentences.First().Text}{Environment.NewLine}";
message += $"Happiness:{result.Sentences.First().ConfidenceScores.Positive}{Environment.NewLine}";
message += $"Sadness:{result.Sentences.First().ConfidenceScores.Negative}{Environment.NewLine}";
message += $"Neutral:{result.Sentences.First().ConfidenceScores.Neutral}{Environment.NewLine}";
message += $"Key phrases:{ JsonConvert.SerializeObject( phrases.ToList()) } {Environment.NewLine}";
message += $"------------------------------------------------{Environment.NewLine}";
Log(message);
}
}
else if (e.Result.Reason == ResultReason.NoMatch)
{
Log($"NOMATCH: Speech could not be recognized.{Environment.NewLine}");
}
};
recognizer.Canceled += (s, e) =>
{
Log($"CANCELED: Reason={e.Reason}{Environment.NewLine}");
if (e.Reason == CancellationReason.Error)
{
Log($"CANCELED: ErrorCode={e.ErrorCode}{Environment.NewLine}");
Log($"CANCELED: ErrorDetails={e.ErrorDetails}{Environment.NewLine}");
Log($"CANCELED: Did you update the subscription info?{Environment.NewLine}");
}
stopRecognition.TrySetResult(0);
};
recognizer.SessionStopped += (s, e) =>
{
Log($"Session stopped event.{Environment.NewLine}");
stopRecognition.TrySetResult(0);
};
await recognizer.StartContinuousRecognitionAsync();
await Task.WhenAny(stopRecognition.Task);
}
else
{
btnName.Text = "Start";
await recognizer.StopContinuousRecognitionAsync();
}
}
private async Task AnalyzeTextAsync()
{
try
{
this.progressControl.IsActive = true;
DisplayProcessingUI();
// detect language
string input = this.inputText.Text;
DetectedLanguage detectedLanguage = await TextAnalyticsHelper.DetectLanguageAsync(input);
string languageCode = TextAnalyticsHelper.GetLanguageCode(detectedLanguage);
// check supported languages
bool isOpinionMiningSupported = TextAnalyticsHelper.OpinionMiningSupportedLanguages.Any(l => string.Equals(l, languageCode, StringComparison.OrdinalIgnoreCase));
bool isSentimentSupported = TextAnalyticsHelper.SentimentAnalysisSupportedLanguages.Any(l => string.Equals(l, languageCode, StringComparison.OrdinalIgnoreCase));
bool isKeyPhraseSupported = TextAnalyticsHelper.KeyPhraseExtractionSupportedLanguages.Any(l => string.Equals(l, languageCode, StringComparison.OrdinalIgnoreCase));
bool isNamedEntitySupported = TextAnalyticsHelper.NamedEntitySupportedLanguages.Any(l => string.Equals(l, languageCode, StringComparison.OrdinalIgnoreCase));
bool isEntityLinkingSupported = TextAnalyticsHelper.EntityLinkingSupportedLanguages.Any(l => string.Equals(l, languageCode, StringComparison.OrdinalIgnoreCase));
// sentiment analysis, key phrase extraction, named entity recognition and entity linking
Task <DocumentSentiment> documentSentimentTask = isSentimentSupported ? TextAnalyticsHelper.AnalyzeSentimentAsync(input, languageCode, isOpinionMiningSupported) : Task.FromResult <DocumentSentiment>(null);
Task <KeyPhraseCollection> detectedKeyPhrasesTask = isKeyPhraseSupported ? TextAnalyticsHelper.ExtractKeyPhrasesAsync(input, languageCode) : Task.FromResult <KeyPhraseCollection>(null);
Task <CategorizedEntityCollection> namedEntitiesResponseTask = isNamedEntitySupported ? TextAnalyticsHelper.RecognizeEntitiesAsync(input, languageCode) : Task.FromResult <CategorizedEntityCollection>(null);
Task <LinkedEntityCollection> linkedEntitiesResponseTask = isEntityLinkingSupported ? TextAnalyticsHelper.RecognizeLinkedEntitiesAsync(input, languageCode) : Task.FromResult <LinkedEntityCollection>(null);
await Task.WhenAll(documentSentimentTask, detectedKeyPhrasesTask, namedEntitiesResponseTask, linkedEntitiesResponseTask);
DocumentSentiment documentSentiment = documentSentimentTask.Result;
KeyPhraseCollection detectedKeyPhrases = detectedKeyPhrasesTask.Result;
CategorizedEntityCollection namedEntitiesResponse = namedEntitiesResponseTask.Result;
LinkedEntityCollection linkedEntitiesResponse = linkedEntitiesResponseTask.Result;
// display results
this.detectedLangTextBlock.Text = !string.IsNullOrEmpty(detectedLanguage.Name) ? $"{detectedLanguage.Name} (confidence: {(int)(detectedLanguage.ConfidenceScore * 100)}%)" : NotFound;
this.detectedKeyPhrasesTextBlock.Text = detectedKeyPhrases != null && detectedKeyPhrases.Any()
? string.Join(", ", detectedKeyPhrases)
: isKeyPhraseSupported?NotFound : LanguageNotSupported;
this.namesEntitiesGridView.ItemsSource = namedEntitiesResponse != null && namedEntitiesResponse.Any()
? namedEntitiesResponse.Select(x => new { x.Text, Category = $"[{x.Category}]" })
: new[] { new { Text = isNamedEntitySupported ? "No entities" : LanguageNotSupported, Category = "" } };
this.linkedEntitiesGridView.ItemsSource = linkedEntitiesResponse != null && linkedEntitiesResponse.Any()
? linkedEntitiesResponse.Select(x => new { Name = $"{x.Name} ({x.DataSource})", x.Url })
: new[] {
isEntityLinkingSupported
? new { Name = "No linked entities", Url = new Uri("about:blank") }
: new { Name = LanguageNotSupported, Url = TextAnalyticsHelper.LanguageSupportUri }
};
if (isSentimentSupported)
{
CreateSentimentChart(documentSentiment);
// mined opinions
OpinionMiningCollection.Clear();
var minedOpinions = documentSentiment?.Sentences.SelectMany(s => s.MinedOpinions);
if (minedOpinions != null && minedOpinions.Any())
{
var minedOpinionList = minedOpinions.Select(om => new MinedOpinion()
{
Aspect = om.Aspect.Text,
Opinions = string.Join(", ", om.Opinions.Select(o => $"{o.Text} ({o.Sentiment.ToString("G")})"))
});
OpinionMiningCollection.AddRange(minedOpinionList);
}
}
else
{
this.sentimentTextBlock.Text = LanguageNotSupported;
this.sentimentChart.Visibility = Visibility.Collapsed;
}
// prepare json result
var jsonResult = new
{
LanguageDetection = detectedLanguage,
KeyPhrases = detectedKeyPhrases,
Sentiment = documentSentiment,
Entities = namedEntitiesResponse,
EntityLinking = linkedEntitiesResponse
};
this.jsonResultTextBlock.Text = JsonConvert.SerializeObject(jsonResult, Formatting.Indented);
}
catch (Exception ex)
{
await Util.GenericApiCallExceptionHandler(ex, "Failure analyzing text");
}
finally
{
this.progressControl.IsActive = false;
}
}
