public void ExtractKeyPhrasesWithWarnings()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
var client = new TextAnalyticsClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
string document = "Anthony runs his own personal training business so thisisaverylongtokenwhichwillbetruncatedtoshowushowwarningsareemittedintheapi";
KeyPhraseCollection keyPhrases = client.ExtractKeyPhrases(document);
if (keyPhrases.Warnings.Count > 0)
{
Console.WriteLine("**Warnings:**");
foreach (TextAnalyticsWarning warning in keyPhrases.Warnings)
{
Console.WriteLine($" Warning: Code: {warning.WarningCode}, Message: {warning.Message}");
}
}
Console.WriteLine($"Extracted {keyPhrases.Count} key phrases:");
foreach (string keyPhrase in keyPhrases)
{
Console.WriteLine(keyPhrase);
}
}
public async Task ExtractKeyPhrasesAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
var client = new TextAnalyticsClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
string document = @"My cat might need to see a veterinarian. It has been sneezing more than normal, and although my
little sister thinks it is funny, I am worried it has the cold that I got last week.
We are going to call tomorrow and try to schedule an appointment for this week. Hopefully it
will be covered by the cat's insurance.
It might be good to not let it sleep in my room for a while.";
try
{
Response <KeyPhraseCollection> response = await client.ExtractKeyPhrasesAsync(document);
KeyPhraseCollection keyPhrases = response.Value;
Console.WriteLine($"Extracted {keyPhrases.Count} key phrases:");
foreach (string keyPhrase in keyPhrases)
{
Console.WriteLine($" {keyPhrase}");
}
}
catch (RequestFailedException exception)
{
Console.WriteLine($"Error Code: {exception.ErrorCode}");
Console.WriteLine($"Message: {exception.Message}");
}
}
public async Task ExtractKeyPhrasesWithLanguageTest()
{
TextAnalyticsClient client = GetClient();
string document = singleSpanish;
KeyPhraseCollection keyPhrases = await client.ExtractKeyPhrasesAsync(document, "es");
Assert.AreEqual(2, keyPhrases.Count);
}
public async Task ExtractKeyPhrasesWithLanguageTest()
{
TextAnalyticsClient client = GetClient();
string document = "Mi perro está en el veterinario";
KeyPhraseCollection keyPhrases = await client.ExtractKeyPhrasesAsync(document, "es");
Assert.AreEqual(2, keyPhrases.Count);
}
static void Main(string[] args)
{
const string SUBSCRIPTION_KEY = "PONER_LA_CLAVE_AQUI";
const string ENDPOINT = "PONER_EL_ENDPOINT_AQUI";
const string TEXTO = "El viaje por Francia del verano pasado fue genial. Conocimos muchos sitios" +
"(el que más nos gustó fue la Provenza) y a mucha gente. Lo único malo fue el tiempo," +
" bastante lluvioso (sobre todo en Normandía). Muchas gracias a nuestro guía, Pierre Martin.";
TextAnalyticsClient client = new TextAnalyticsClient(new Uri(ENDPOINT), new AzureKeyCredential(SUBSCRIPTION_KEY));
/////////////////////////
//Análisis de opinión (Text Analytics-Sentiment)
/////////////////////////
Console.WriteLine("---Análisis de opinión---");
//Invocamos el método de la API para el análisis de la opinión
DocumentSentiment opinion = client.AnalyzeSentiment(TEXTO, "es");
//Procesamos el resultado
Console.WriteLine($"Opinión general del documento: {opinion.Sentiment}\n");
foreach (SentenceSentiment oracion in opinion.Sentences)
{
Console.WriteLine($"\tOración: \"{oracion.Text}\"");
Console.WriteLine($"\tOpinión de la oración: {oracion.Sentiment}\n");
}
/////////////////////////
//Frases clave (Text Analytics-Key Phrases)
/////////////////////////
Console.WriteLine("---Frases clave---");
//Invocamos el método de la API para extraer frases clave
KeyPhraseCollection frases = client.ExtractKeyPhrases(TEXTO, "es");
//Procesamos el resultado
foreach (string frase in frases)
{
Console.WriteLine(frase);
}
/////////////////////////
//Entidades con nombre (Text Analytics-Named Entity Recognition)
/////////////////////////
Console.WriteLine("---Entidades con nombre---");
//Invocamos el método de la API para extraer las entidades
CategorizedEntityCollection entidades = client.RecognizeEntities(TEXTO, "es");
//Procesamos el resultado
foreach (CategorizedEntity entidad in entidades)
{
Console.WriteLine($"{entidad.Text} - Categoría:{entidad.Category}, Subcategoría:{entidad.SubCategory}");
}
}
public async Task ExtractKeyPhrasesTest()
{
TextAnalyticsClient client = GetClient();
string document = singleEnglish;
KeyPhraseCollection keyPhrases = await client.ExtractKeyPhrasesAsync(document);
Assert.AreEqual(2, keyPhrases.Count);
Assert.IsTrue(keyPhrases.Contains("cat"));
Assert.IsTrue(keyPhrases.Contains("veterinarian"));
}
public async Task ExtractKeyPhrasesWithWarningTest()
{
TextAnalyticsClient client = GetClient();
string document = "Anthony runs his own personal training business so thisisaverylongtokenwhichwillbetruncatedtoshowushowwarningsareemittedintheapi";
KeyPhraseCollection keyPhrases = await client.ExtractKeyPhrasesAsync(document, "es");
ValidateInDocumenResult(keyPhrases, 1);
Assert.AreEqual(TextAnalyticsWarningCode.LongWordsInDocument, keyPhrases.Warnings.FirstOrDefault().WarningCode.ToString());
}
public async Task ExtractKeyPhrasesWithLanguageTest()
{
TextAnalyticsClient client = GetClient();
string document = SingleSpanish;
KeyPhraseCollection keyPhrases = await client.ExtractKeyPhrasesAsync(document, "es");
ValidateInDocumenResult(keyPhrases, 2);
Assert.IsTrue(keyPhrases.Contains("perro"));
Assert.IsTrue(keyPhrases.Contains("veterinario"));
}
public async Task ExtractKeyPhrasesTest()
{
TextAnalyticsClient client = GetClient();
string document = SingleEnglish;
KeyPhraseCollection keyPhrases = await client.ExtractKeyPhrasesAsync(document);
ValidateInDocumenResult(keyPhrases, 2);
Assert.IsTrue(keyPhrases.Contains("cat"));
Assert.IsTrue(keyPhrases.Contains("veterinarian"));
}
public async Task ExtractKeyPhrasesAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
var client = new TextAnalyticsClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
string document = "My cat might need to see a veterinarian.";
KeyPhraseCollection keyPhrases = await client.ExtractKeyPhrasesAsync(document);
Console.WriteLine($"Extracted {keyPhrases.Count} key phrases:");
foreach (string keyPhrase in keyPhrases)
{
Console.WriteLine(keyPhrase);
}
}
public async Task ExtractKeyPhrasesWithWarningTest()
{
TextAnalyticsClient client = GetClient();
string document = "Anthony runs his own personal training business so thisisaverylongtokenwhichwillbetruncatedtoshowushowwarningsareemittedintheapi";
ExtractKeyPhrasesResultCollection keyPhrasesCollection = await client.ExtractKeyPhrasesBatchAsync(new List <string> {
document
}, "es", new ExtractKeyPhrasesOptions()
{
ModelVersion = "2020-07-01"
});
KeyPhraseCollection keyPhrases = keyPhrasesCollection.FirstOrDefault().KeyPhrases;
ValidateInDocumenResult(keyPhrases, 1);
Assert.AreEqual(TextAnalyticsWarningCode.LongWordsInDocument, keyPhrases.Warnings.FirstOrDefault().WarningCode.ToString());
}
public void ExtractKeyPhrasesWithWarnings()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
var client = new TextAnalyticsClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
string document = @"Anthony runs his own personal training business so
thisisaverylongtokenwhichwillbetruncatedtoshowushowwarningsareemittedintheapi";
try
{
Response <ExtractKeyPhrasesResultCollection> response = client.ExtractKeyPhrasesBatch(new List <string>()
{
document
}, options: new TextAnalyticsRequestOptions()
{
ModelVersion = "2020-07-01"
});
ExtractKeyPhrasesResultCollection keyPhrasesInDocuments = response.Value;
KeyPhraseCollection keyPhrases = keyPhrasesInDocuments.FirstOrDefault().KeyPhrases;
if (keyPhrases.Warnings.Count > 0)
{
Console.WriteLine("**Warnings:**");
foreach (TextAnalyticsWarning warning in keyPhrases.Warnings)
{
Console.WriteLine($" Warning: Code: {warning.WarningCode}, Message: {warning.Message}");
}
}
Console.WriteLine($"Extracted {keyPhrases.Count} key phrases:");
foreach (string keyPhrase in keyPhrases)
{
Console.WriteLine($" {keyPhrase}");
}
}
catch (RequestFailedException exception)
{
Console.WriteLine($"Error Code: {exception.ErrorCode}");
Console.WriteLine($"Message: {exception.Message}");
}
}
public void ExtractKeyPhrases()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
#region Snippet:TextAnalyticsSample3CreateClient
var client = new TextAnalyticsClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#endregion
#region Snippet:ExtractKeyPhrases
string document = "My cat might need to see a veterinarian.";
KeyPhraseCollection keyPhrases = client.ExtractKeyPhrases(document);
Console.WriteLine($"Extracted {keyPhrases.Count} key phrases:");
foreach (string keyPhrase in keyPhrases)
{
Console.WriteLine(keyPhrase);
}
#endregion
}
private void ValidateInDocumenResult(KeyPhraseCollection keyPhrases, int minKeyPhrasesCount = default)
{
Assert.IsNotNull(keyPhrases.Warnings);
Assert.GreaterOrEqual(keyPhrases.Count, minKeyPhrasesCount);
}
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;
}
}
