public async Task <SentimentBatchResult> RunSentimentAnalysisAsync(CidadaoModel cidadao)
{
var credentials = new ApiKeyServiceClientCredentials(key);
var client = new TextAnalyticsClient(credentials)
{
Endpoint = endpoint
};
// The documents to be analyzed. Add the language of the document. The ID can be any value.
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("1", cidadao.texto, "pt"),
});
var result = await client.SentimentBatchAsync(inputDocuments);
// Printing sentiment results
// Console.WriteLine("===== Sentiment Analysis =====\n");
//foreach (var document in result.Documents)
//{
// // Console.WriteLine($"Document ID: {document.Id} , Sentiment Score: {document.Score:0.00}");
//}
return(result);
}
public async Task RunKeyPhraseExtractionAsync(CidadaoModel cidadao)
{
var credentials = new ApiKeyServiceClientCredentials(key);
var client = new TextAnalyticsClient(credentials)
{
Endpoint = endpoint
};
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("1", "猫は幸せ", "ja"),
new MultiLanguageInput("2", "Fahrt nach Stuttgart und dann zum Hotel zu Fu.", "de"),
new MultiLanguageInput("3", "My cat might need to see a veterinarian.", "en"),
new MultiLanguageInput("4", "A mi me encanta el fútbol!", "es")
});
var kpResults = await client.KeyPhrasesBatchAsync(inputDocuments);
// Printing keyphrases
foreach (var document in kpResults.Documents)
{
foreach (string keyphrase in document.KeyPhrases)
{
}
}
}
public static async Task RunAsync(string endpoint, string key)
{
var credentials = new ApiKeyServiceClientCredentials(key);
var client = new TextAnalyticsClient(credentials)
{
Endpoint = endpoint
};
// The documents to be analyzed. Add the language of the document. The ID can be any value.
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("1", "I had the best day of my life.", "en"),
new MultiLanguageInput("2", "This was a waste of my time. The speaker put me to sleep.", "en"),
new MultiLanguageInput("3", "No tengo dinero ni nada que dar...", "es"),
new MultiLanguageInput("4", "L'hotel veneziano era meraviglioso. È un bellissimo pezzo di architettura.", "it"),
});
var result = await client.SentimentBatchAsync(inputDocuments);
// Printing sentiment results
Console.WriteLine("===== Sentiment Analysis =====\n");
foreach (var document in result.Documents)
{
Console.WriteLine($"Document ID: {document.Id} , Sentiment Score: {document.Score:0.00}");
}
Console.WriteLine();
}
public static async Task RunAsync(string endpoint, string key)
{
var credentials = new ApiKeyServiceClientCredentials(key);
var client = new TextAnalyticsClient(credentials)
{
Endpoint = endpoint
};
// The documents to be submitted for entity recognition. The ID can be any value.
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("en", "1", "Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975, to develop and sell BASIC interpreters for the Altair 8800."),
new MultiLanguageInput("es", "2", "La sede principal de Microsoft se encuentra en la ciudad de Redmond, a 21 kilómetros de Seattle.")
});
var entitiesResult = await client.EntitiesAsync(false, inputDocuments);
// Printing recognized entities
foreach (var document in entitiesResult.Documents)
{
Console.WriteLine($"Document ID: {document.Id} ");
Console.WriteLine("\t Entities:");
foreach (var entity in document.Entities)
{
Console.WriteLine($"\t\tName: {entity.Name},\tType: {entity.Type ?? "N/A"},\tSub-Type: {entity.SubType ?? "N/A"}");
foreach (var match in entity.Matches)
{
Console.WriteLine($"\t\t\tOffset: {match.Offset},\tLength: {match.Length},\tScore: {match.EntityTypeScore:F3}");
}
}
}
}
public async Task RunRecognizeEntitiesAsync(CidadaoModel cidadao)
{
var credentials = new ApiKeyServiceClientCredentials(key);
var client = new TextAnalyticsClient(credentials)
{
Endpoint = endpoint
};
// The documents to be submitted for entity recognition. The ID can be any value.
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("1", cidadao.texto, "pt"),
});
var entitiesResult = await client.EntitiesBatchAsync(inputDocuments);
foreach (var document in entitiesResult.Documents)
{
foreach (var entity in document.Entities)
{
foreach (var match in entity.Matches)
{
// Console.WriteLine($"\t\t\tOffset: {match.Offset},\tLength: {match.Length},\tScore: {match.EntityTypeScore:F3}");
}
}
}
// Console.WriteLine();
}
public async Task RunAsync(string endpoint, string key, string text)
{
var credentials = new ApiKeyServiceClientCredentials(key);
var client = new TextAnalyticsClient(credentials)
{
Endpoint = endpoint
};
// The documents to be submitted for entity recognition. The ID can be any value.
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("en", "1", text)
});
var entitiesResult = await client.EntitiesAsync(false, inputDocuments);
// Printing recognized entities
foreach (var document in entitiesResult.Documents)
{
foreach (var entity in document.Entities)
{
Entity.Add($"{entity.Name}[{entity.Type ?? "N/A"}]");
//Console.WriteLine($"\t\tName: {entity.Name},\tType: {entity.Type ?? "N/A"},\tSub-Type: {entity.SubType ?? "N/A"}");
//foreach (var match in entity.Matches)
//{
// Console.WriteLine($"\t\t\tOffset: {match.Offset},\tLength: {match.Length},\tScore: {match.EntityTypeScore:F3}");
//}
}
}
}
private double?ExtractSentiments(List <string> Queries)
{
// Create a client.
ITextAnalyticsAPI client = new TextAnalyticsAPI(new ApiKeyServiceClientCredentials());
client.AzureRegion = AzureRegions.Westus;
MultiLanguageBatchInput multiLanguageBatchInput = new MultiLanguageBatchInput();
multiLanguageBatchInput.Documents = new List <MultiLanguageInput>();
for (int i = 0; i < Queries.Count; i++)
{
multiLanguageBatchInput.Documents.Add(new MultiLanguageInput("en", i.ToString(), Queries[i]));
}
SentimentBatchResult sentimentBatchResult = client.SentimentAsync(multiLanguageBatchInput).Result;
double?score = 0;
// Printing sentiment results
foreach (var document in sentimentBatchResult.Documents)
{
score += document.Score;
}
return(score / sentimentBatchResult.Documents.Count);
}
internal Sentiment DetectSentiment(string requestBody)
{
var client = GetClient();
var input = new MultiLanguageBatchInput(new List <MultiLanguageInput>()
{
new MultiLanguageInput()
{
Id = "1", Language = "en", Text = requestBody
}
});
var result = client.SentimentAsync(true, input).Result;
foreach (var document in result.Documents)
{
Console.WriteLine($"Document ID: {document.Id} , Sentiment Score: {document.Score:0.00}," +
$" Statistics Character Count: {document.Statistics.CharactersCount}");
}
var sentimentScore = result.Documents[0].Score;
if (sentimentScore <= 0.3)
{
return(Sentiment.Negetive);
}
if (sentimentScore >= 0.7)
{
return(Sentiment.Positive);
}
else
{
return(Sentiment.Neutral);
}
}
private async Task <IEnumerable <AnalysisResult> > GetAnalysisResultsAsync(MultiLanguageBatchInput batchInput)
{
KeyPhraseBatchResult keyPhraseBatchResult = await _textAnalyticsAPI.KeyPhrasesAsync(batchInput);
SentimentBatchResult sentimentBatchResult = await _textAnalyticsAPI.SentimentAsync(batchInput);
foreach (var keyPhrase in keyPhraseBatchResult.Documents)
{
string tweet = batchInput.Documents
.Where(d => d.Id == keyPhrase.Id)
.Select(t => t.Text)
.FirstOrDefault();
var sentiment = sentimentBatchResult.Documents
.Where(s => s.Id == keyPhrase.Id)
.FirstOrDefault();
if (IsSignificant(sentiment.Score) && !keyPhrase.KeyPhrases.Count().Equals(0))
{
AnalysisResult analysisResult = new AnalysisResult
{
KeyPhrases = keyPhrase.KeyPhrases,
Attitude = DeriveAttitude(sentiment.Score),
Tweet = tweet
};
_analysisResults.Add(analysisResult);
}
}
return(_analysisResults);
}
public static async Task <Dictionary <string, double?> > GetSentiment(List <string> textList)
{
var textIdDictionary = new Dictionary <string, string>();
var multiLanguageBatchInput = new MultiLanguageBatchInput(new List <MultiLanguageInput>());
foreach (var text in textList)
{
var textGuidString = Guid.NewGuid().ToString();
textIdDictionary.Add(textGuidString, text);
multiLanguageBatchInput.Documents.Add(new MultiLanguageInput(id: textGuidString, text: text));
}
var sentimentResults = await TextAnalyticsApiClient.SentimentAsync(multiLanguageBatchInput).ConfigureAwait(false);
if (sentimentResults?.Errors?.Any() ?? false)
{
var exceptionList = sentimentResults.Errors.Select(x => new Exception($"Id: {x.Id}, Message: {x.Message}"));
throw new AggregateException(exceptionList);
}
var resultsDictionary = new Dictionary <string, double?>();
foreach (var result in sentimentResults?.Documents)
{
resultsDictionary.Add(textIdDictionary[result.Id], result?.Score);
}
return(resultsDictionary);
}
/// <summary>
/// Adds found key phrases to references list of keyPhrases - the most important ones first.
/// </summary>
/// <param name="keyPhrases"></param>
/// <param name="analyzable"></param>
/// <param name="log"></param>
private static void RunTextAnalysis(ref List <string> keyPhrases, List <MultiLanguageInput> analyzable, TraceWriter log)
{
var batch = new MultiLanguageBatchInput();
batch.Documents = analyzable;
ITextAnalyticsAPI client = new TextAnalyticsAPI();
client.AzureRegion = AzureRegions.Westus;
client.SubscriptionKey = key1;
try
{
var result = client.KeyPhrases(batch);
foreach (var row in result.Documents)
{
foreach (var kp in row.KeyPhrases)
{
keyPhrases.Add(kp);
}
}
}
catch (Exception ex)
{
log.Warning(ex.Message);
}
}
internal ICollection <string> DetectKeyPhrases(string requestBody)
{
var client = GetClient();
var input = new MultiLanguageBatchInput(
new List <MultiLanguageInput>()
{
new MultiLanguageInput()
{
Id = "1",
Language = "en",
Text = requestBody
}
});
var result = client.KeyPhrasesAsync(true, input).Result;
foreach (var document in result.Documents)
{
Console.WriteLine($"Document ID: {document.Id} , " +
$"Number of KeyPhrases: {document.KeyPhrases.Count}," +
$" Statistics Character Count: " +
$"{document.Statistics.CharactersCount}");
}
return(result.Documents[0].KeyPhrases);
}
internal HttpMessage CreateEntitiesRecognitionGeneralRequest(MultiLanguageBatchInput input, string modelVersion, bool?showStats)
{
var message = _pipeline.CreateMessage();
var request = message.Request;
request.Method = RequestMethod.Post;
var uri = new RawRequestUriBuilder();
uri.AppendRaw(endpoint, false);
uri.AppendRaw("/text/analytics/v3.1-preview.1", false);
uri.AppendPath("/entities/recognition/general", false);
if (modelVersion != null)
{
uri.AppendQuery("model-version", modelVersion, true);
}
if (showStats != null)
{
uri.AppendQuery("showStats", showStats.Value, true);
}
request.Uri = uri;
request.Headers.Add("Content-Type", "application/json");
var content = new Utf8JsonRequestContent();
content.JsonWriter.WriteObjectValue(input);
request.Content = content;
return(message);
}
private static async Task RunRecognizeEntities(TextAnalyticsClient client,
MultiLanguageBatchInput docs)
{
var res = await client.EntitiesBatchAsync(docs);
foreach (var document in res.Documents)
{
Console.WriteLine($"Document ID: {document.Id} ");
Console.WriteLine("\tEntities:");
foreach (var entity in document.Entities)
{
Console.WriteLine($"\t\t{entity.Name}");
Console.WriteLine($"\t\tType: {entity.Type ?? "N/A"}");
Console.WriteLine($"\t\tSubType: {entity.SubType ?? "N/A"}");
foreach (var match in entity.Matches)
{
Console.WriteLine($"\t\tScore: {match.EntityTypeScore:F3}");
}
Console.WriteLine($"\t");
}
}
}
public static async Task RunAsync(string endpoint, string key)
{
var credentials = new ApiKeyServiceClientCredentials(key);
var client = new TextAnalyticsClient(credentials)
{
Endpoint = endpoint
};
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("ja", "1", "猫は幸せ"),
new MultiLanguageInput("de", "2", "Fahrt nach Stuttgart und dann zum Hotel zu Fu."),
new MultiLanguageInput("en", "3", "My cat might need to see a veterinarian."),
new MultiLanguageInput("es", "4", "A mi me encanta el fútbol!")
});
var kpResults = await client.KeyPhrasesAsync(false, inputDocuments);
// Printing keyphrases
foreach (var document in kpResults.Documents)
{
Console.WriteLine($"Document ID: {document.Id} ");
Console.WriteLine("\t Key phrases:");
foreach (string keyphrase in document.KeyPhrases)
{
Console.WriteLine($"\t\t{keyphrase}");
}
}
}
public async Task RunAsync(string endpoint, string key, string text)
{
var credentials = new ApiKeyServiceClientCredentials(key);
var client = new TextAnalyticsClient(credentials)
{
Endpoint = endpoint
};
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("en", "1", text)
});
var kpResults = await client.KeyPhrasesAsync(false, inputDocuments);
// Printing keyphrases
foreach (var document in kpResults.Documents)
{
//Console.WriteLine($"Document ID: {document.Id} ");
//Console.WriteLine("\t Key phrases:");
foreach (string keyphrase in document.KeyPhrases)
{
Phrase.Add($"{keyphrase}");
//Console.WriteLine($"\t\t{keyphrase}");
}
}
}
public static async Task <NameValueCollection> EntitiesInContent(TextAnalyticsClient client, string content, string language = "en")
{
var inputDocuments = new MultiLanguageBatchInput
{
Documents = new List <MultiLanguageInput>
{
new MultiLanguageInput(id: "1", text: content, language: "en")
}
};
var result = await client.EntitiesAsync(false, inputDocuments);
if (!result.Documents.Any())
{
return(new NameValueCollection());
}
var document = result.Documents.First();
var entities = System.Web.HttpUtility.ParseQueryString(string.Empty);
foreach (var entity in document.Entities)
{
entities[entity.Type] = entity.Name;
}
return(entities);
}
public async Task <string[]> GetKeyPhrasesAsync(string text)
{
// Build our request model
MultiLanguageBatchInput requestDocument = GetSingleInput(text);
// Get the result
KeyPhraseBatchResult result = await PostKeyPhrasesRequestAsync(requestDocument);
// Return an array of all the key phrases
return(result.Documents.SelectMany(x => x.KeyPhrases).ToArray());
}
private string RunDemo()
{
MultiLanguageBatchInput batchInputs = new MultiLanguageBatchInput()
{
Documents = FetchCommentsFromDB(connectionString)
};
var sentimentPrediction = _client.SentimentBatch(batchInputs);
string analysis = JsonConvert.SerializeObject(sentimentPrediction);
return(analysis);
}
public static async Task <IList <string> > KeyPhraseExtractionExample(TextAnalyticsClient client, string inputText)
{
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("en", "1", inputText),
});
var kpResults = await client.KeyPhrasesAsync(false, inputDocuments);
return(kpResults.Documents[0].KeyPhrases);
}
private static async Task RunSentiment(TextAnalyticsClient client,
MultiLanguageBatchInput docs)
{
var res = await client.SentimentBatchAsync(docs);
foreach (var document in res.Documents)
{
Console.WriteLine($"Document ID: {document.Id}, " +
$"Sentiment Score: {document.Score:0.00}");
}
}
public async Task <double> GetSentimentAsync(string text)
{
// Build our request model
MultiLanguageBatchInput requestDocument = GetSingleInput(text);
// Get the result
SentimentBatchResult result = await PostSentimentRequestAsync(requestDocument);
// Return the single sentiment value
return(result.Documents.Single().Score.Value);
}
private static async Task <double> SentimentAnalysisExample(TextAnalyticsClient client, string text)
{
// The documents to be analyzed. Add the language of the document. The ID can be any value.
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("ja", "1", text),
});
var result = await client.SentimentAsync(false, inputDocuments);
return((double)result.Documents[0].Score);
}
internal ICollection <string> DetectEntities(string requestBody)
{
var client = GetClient();
var language = DetectLanguage(requestBody);
if (language == "(Unknown)")
{
throw new ApplicationException("Language is unknown");
}
var input = new MultiLanguageBatchInput(
new List <MultiLanguageInput>()
{
new MultiLanguageInput()
{
Id = "1",
Language = language,
Text = requestBody
}
});
var result = client.EntitiesAsync(true, input).Result;
List <string> entitiesResult = new List <string>();
foreach (var document in result.Documents)
{
foreach (var entity in document.Entities)
{
entitiesResult.Add(entity.Name);
Console.WriteLine($"Entity Name: {entity.Name}");
if (!string.IsNullOrEmpty(entity.SubType))
{
Console.WriteLine($"Type : {entity.SubType}");
}
if (!string.IsNullOrEmpty(entity.WikipediaUrl))
{
Console.WriteLine($"Type : {entity.WikipediaUrl}");
}
if (!string.IsNullOrEmpty(entity.WikipediaLanguage))
{
Console.WriteLine($"Wikipedia Language : {entity.WikipediaLanguage}");
}
}
}
return(entitiesResult);
}
//Input the text to be analyzed and return its sentiment score.
//The sentiment score will range from 0 to 1, where 0 is negative sentiment and 1 is positive sentiment.
public async Task <double?> GetSentiment(string text)
{
//Create the request object to send to the TextAnalytics API
//The request can contain multiple text inputs which you can use to batch multiple requests into one API call
var request = new MultiLanguageBatchInput(new List <MultiLanguageInput>
{
{ new MultiLanguageInput(id: "1", text: text) }
});
//Get the sentiment results from the TextAnalytics API
var sentimentResult = await _textAnalyticsApiClient.SentimentAsync(null, request);
//Parse the sentiment score
return(sentimentResult?.Documents?.FirstOrDefault()?.Score);
}
public static async Task <double> SentimentAnalysisExample(TextAnalyticsClient client, string inputText)
{
// The documents to be analyzed. Add the language of the document. The ID can be any value.
var inputDocuments = new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput("en", "1", inputText)
});
//...
var result = await client.SentimentAsync(false, inputDocuments);
return(Convert.ToDouble(result.Documents[0].Score));
}
public virtual Response <EntitiesResult> EntitiesRecognitionGeneral(MultiLanguageBatchInput input, string modelVersion = null, bool?showStats = null, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ServiceClient.EntitiesRecognitionGeneral");
scope.Start();
try
{
return(RestClient.EntitiesRecognitionGeneral(input, modelVersion, showStats, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <SentimentResponse> > SentimentAsync(MultiLanguageBatchInput input, string modelVersion = null, bool?showStats = null, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ServiceClient.Sentiment");
scope.Start();
try
{
return(await RestClient.SentimentAsync(input, modelVersion, showStats, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// The API returns a numeric score between 0 and 1.
/// </summary>
/// <remarks>
/// Scores close to 1 indicate positive sentiment, while scores close to 0
/// indicate negative sentiment. A score of 0.5 indicates the lack of sentiment
/// (e.g. a factoid statement). See the <a
/// href="https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview#supported-languages">Text
/// Analytics Documentation</a> for details about the languages that are
/// supported by sentiment analysis.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='showStats'>
/// (optional) if set to true, response will contain input and document level
/// statistics.
/// </param>
/// <param name='inputText'>
/// Input text of one document.
/// </param>
/// <param name='language'>
/// Language code.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static SentimentBatchResult Sentiment(
this ITextAnalyticsClient operations,
string inputText = default,
string language = "en",
bool?showStats = default,
CancellationToken cancellationToken = default)
{
var multiLanguageBatchInput = new MultiLanguageBatchInput(new List <MultiLanguageInput> {
new MultiLanguageInput("1", inputText, language)
});
var _result = operations.SentimentWithHttpMessagesAsync(showStats, multiLanguageBatchInput, null, cancellationToken).ConfigureAwait(false).GetAwaiter().GetResult();
return(_result.Body);
}
// ------------------------------------ Cognitive Services ----------------------------------------//
public static async Task SentimentAnalysisExample(TextAnalyticsClient client)
{
WriteLine("----------------------------Sentiment Analysis------------------------");
// The documents to be analyzed. Add the language of the document (en). The ID can be any value.
const string path = "sample.txt";
List <string> inputLines = ReadAndDisplay(path);
WriteLine("--------- Check to make sure the file was read properly and lines stored in list----------");
for (int i = 0; i < inputLines.Count; i++)
{
WriteLine(inputLines[i]);
}
// Create this list of Input objects to pass in
List <MultiLanguageInput> myInputList = new List <MultiLanguageInput>();
for (int i = 0; i < inputLines.Count; i++)
{
int id = i + 5;
string idStr = id.ToString();
myInputList.Add(
new MultiLanguageInput("en", idStr, inputLines[i]));
}
var inputDocuments = new MultiLanguageBatchInput(myInputList); // inputs (MultiLanguageBatchInput Objects)
var result = await client.SentimentAsync(false, inputDocuments);
// create a list with corresponding scores
// then sort list using the lookup score
List <double> scores = new List <double>();
// Printing sentiment results
foreach (var document in result.Documents)
{
Console.WriteLine($"Document ID: {document.Id} , Sentiment Score: {document.Score:0.00}");
scores.Add((double)document.Score);
}
// Sort out sad
//List<MultiLanguageInput> sadList = new List<MultiLanguageInput>();
// List<MultiLanguageInput> sadList = new List<MultiLanguageInput>();
for (int i = 0; i < scores.Count; i++)
{
if (scores[i] < 0.5)
{
Globals.sadList.Add(myInputList[i]);
}
}
}
