As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Análise em tempo real usando a API
Os exemplos a seguir demonstram como usar a API Amazon Comprehend para análise em tempo real, usando AWS CLI o, e AWS SDKs o para .NET, Java e Python. Use os exemplos para saber mais sobre a operação síncrona do Amazon Comprehend e como compilar blocos para seus próprios aplicativos.
Os exemplos do .NET nesta seção usam o [AWS SDK para .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/welcome.html). Você pode usar o [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/AWSToolkitVS/latest/UserGuide/welcome.html)para desenvolver AWS aplicativos usando o.NET. Ele inclui modelos úteis e o AWS Explorer para implantar aplicativos e gerenciar serviços. Para uma perspectiva de desenvolvedores do.NET AWS, consulte o [AWS guia para desenvolvedores.NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/welcome.html).
**Topics**
+ [Detectando o idioma dominante](#get-started-api-dominant-language)
+ [Detectando entidades nomeadas](#get-started-api-entities)
+ [Detectando frases-chave](#get-started-api-key-phrases)
+ [Determinando o sentimento](#get-started-api-sentiment)
+ [Análise em tempo real de um sentimento direcionado](#get-started-api-targeted-sentiment)
+ [Detectando a sintaxe](#get-started-api-syntax)
+ [Lote em tempo real APIs](#get-started-batch)
## Detectando o idioma dominante
Para determinar o idioma dominante usado no texto, use a [DetectDominantLanguage](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectDominantLanguage.html)operação. Para detectar o idioma dominante em até 25 documentos em um lote, use a [BatchDetectDominantLanguage](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectDominantLanguage.html)operação. Para obter mais informações, consulte [Lote em tempo real APIs](#get-started-batch).
**Topics**
+ [Usando o AWS Command Line Interface](#get-started-api-dominant-language-cli)
+ [Usando o AWS SDK para Java SDK para Python ou SDK para .NET](#get-started-api-dominant-language-java)
### Usando o AWS Command Line Interface
O exemplo a seguir demonstra como usar a operação `DetectDominantLanguage` com o AWS CLI.
O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws comprehend detect-dominant-language \
--region region \
--text "It is raining today in Seattle."
```
O Amazon Comprehend responde com o seguinte:
```
{
"Languages": [
{
"LanguageCode": "en",
"Score": 0.9793661236763
}
]
}
```
### Usando o AWS SDK para Java SDK para Python ou SDK para .NET
Para exemplos de SDK sobre como determinar o idioma dominante, consulte [Use `DetectDominantLanguage` com um AWS SDK ou CLI](example_comprehend_DetectDominantLanguage_section.md).
## Detectando entidades nomeadas
Para determinar as entidades nomeadas em um documento, use a [DetectEntities](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectEntities.html)operação. Para detectar entidades em até 25 documentos em um lote, use a [BatchDetectEntities](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectEntities.html)operação. Para obter mais informações, consulte [Lote em tempo real APIs](#get-started-batch).
**Topics**
+ [Usando o AWS Command Line Interface](#get-started-api-entities-cli)
+ [Usando o AWS SDK para Java SDK para Python ou SDK para .NET](#get-started-api-entities-java)
### Usando o AWS Command Line Interface
O exemplo a seguir demonstra como usar a operação `DetectEntities` com o AWS CLI. É necessário especificar o idioma e o texto de entrada.
O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws comprehend detect-entities \
--region region \
--language-code "en" \
--text "It is raining today in Seattle."
```
O Amazon Comprehend responde com o seguinte:
```
{
"Entities": [
{
"Text": "today",
"Score": 0.97,
"Type": "DATE",
"BeginOffset": 14,
"EndOffset": 19
},
{
"Text": "Seattle",
"Score": 0.95,
"Type": "LOCATION",
"BeginOffset": 23,
"EndOffset": 30
}
],
"LanguageCode": "en"
}
```
### Usando o AWS SDK para Java SDK para Python ou SDK para .NET
Para exemplos de SDK sobre como determinar o idioma dominante, consulte [Use `DetectEntities` com um AWS SDK ou CLI](example_comprehend_DetectEntities_section.md).
## Detectando frases-chave
Para determinar as frases nominais principais usadas no texto, use a [DetectKeyPhrases](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectKeyPhrases.html)operação. Para detectar as principais frases nominais em até 25 documentos em um lote, use a [BatchDetectKeyPhrases](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectKeyPhrases.html)operação. Para obter mais informações, consulte [Lote em tempo real APIs](#get-started-batch).
**Topics**
+ [Usando o AWS Command Line Interface](#get-started-api-key-phrases-cli)
+ [Usando o AWS SDK para Java SDK para Python ou SDK para .NET](#get-started-api-key-phrases-java)
### Usando o AWS Command Line Interface
O exemplo a seguir demonstra como usar a operação `DetectKeyPhrases` com o AWS CLI. É necessário especificar o idioma e o texto de entrada.
O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws comprehend detect-key-phrases \
--region region \
--language-code "en" \
--text "It is raining today in Seattle."
```
O Amazon Comprehend responde com o seguinte:
```
{
"LanguageCode": "en",
"KeyPhrases": [
{
"Text": "today",
"Score": 0.89,
"BeginOffset": 14,
"EndOffset": 19
},
{
"Text": "Seattle",
"Score": 0.91,
"BeginOffset": 23,
"EndOffset": 30
}
]
}
```
### Usando o AWS SDK para Java SDK para Python ou SDK para .NET
Para exemplos de SDKs que detectam frases-chave, consulte [Use `DetectKeyPhrases` com um AWS SDK ou CLI](example_comprehend_DetectKeyPhrases_section.md).
## Determinando o sentimento
O Amazon Comprehend fornece as seguintes operações de API para analisar sentimentos:
+ [DetectSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectSentiment.html)— Determina o sentimento emocional geral de um documento.
+ [BatchDetectSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectSentiment.html)— Determine o sentimento geral em até 25 documentos em um lote. Para obter mais informações, consulte [Lote em tempo real APIs](#get-started-batch).
+ [StartSentimentDetectionJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_StartSentimentDetectionJob.html)— inicia um trabalho assíncrono de detecção de sentimentos para uma coleção de documentos.
+ [ListSentimentDetectionJobs](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_ListSentimentDetectionJobs.html)— Retorna a lista de trabalhos de detecção de sentimentos que você enviou.
+ [DescribeSentimentDetectionJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DescribeSentimentDetectionJob.html)— Obtém as propriedades (incluindo status) associadas ao trabalho de detecção de sentimentos especificado.
+ [StopSentimentDetectionJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_StopSentimentDetectionJob.html)— Interrompe o trabalho de sentimento em andamento especificado.
**Topics**
+ [Usando o AWS Command Line Interface](#get-started-api-sentiment-cli)
+ [Usando o AWS SDK para Java SDK para Python ou SDK para .NET](#get-started-api-sentiment-java)
### Usando o AWS Command Line Interface
O exemplo a seguir demonstra como usar a operação `DetectSentiment` com o AWS CLI. Este exemplo especifica o idioma do texto de entrada.
O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws comprehend detect-sentiment \
--region region \
--language-code "en" \
--text "It is raining today in Seattle."
```
O Amazon Comprehend responde com o seguinte:
```
{
"SentimentScore": {
"Mixed": 0.014585512690246105,
"Positive": 0.31592071056365967,
"Neutral": 0.5985543131828308,
"Negative": 0.07093945890665054
},
"Sentiment": "NEUTRAL",
"LanguageCode": "en"
}
```
### Usando o AWS SDK para Java SDK para Python ou SDK para .NET
Para exemplos de SDKs que determinam o sentimento do texto de entrada, consulte [Use `DetectSentiment` com um AWS SDK ou CLI](example_comprehend_DetectSentiment_section.md).
## Análise em tempo real de um sentimento direcionado
O Amazon Comprehend fornece as seguintes operações de API para análise de sentimentos direcionados em tempo real:
+ [DetectTargetedSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectTargetedSentiment.html)— Analisa o sentimento das entidades mencionadas em um documento.
+ [BatchDetectTargetedSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectTargetedSentiment.html)— Analisa o sentimento direcionado de até 25 documentos em um lote. Para obter mais informações, consulte [Lote em tempo real APIs](#get-started-batch).
Se o texto que você está analisando não incluir nenhum sentimento direcionado [Tipos de entidade](how-targeted-sentiment.md#how-targeted-sentiment-entities), a API retornará uma matriz de entidades vazia.
### Usando o AWS Command Line Interface
O exemplo a seguir demonstra como usar a operação `DetectTargetedSentiment` com o AWS CLI. Este exemplo especifica o idioma do texto de entrada.
O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws comprehend detect-targeted-sentiment \
--region region \
--language-code "en" \
--text "The burger was cooked perfectly but it was cold. The service was OK."
```
O Amazon Comprehend responde com o seguinte:
```
{
"Entities": [
{
"DescriptiveMentionIndex": [
0
],
"Mentions": [
{
"BeginOffset": 4,
"EndOffset": 10,
"Score": 1,
"GroupScore": 1,
"Text": "burger",
"Type": "OTHER",
"MentionSentiment": {
"Sentiment": "POSITIVE",
"SentimentScore": {
"Mixed": 0.001515,
"Negative": 0.000822,
"Neutral": 0.000243,
"Positive": 0.99742
}
}
},
{
"BeginOffset": 36,
"EndOffset": 38,
"Score": 0.999843,
"GroupScore": 0.999661,
"Text": "it",
"Type": "OTHER",
"MentionSentiment": {
"Sentiment": "NEGATIVE",
"SentimentScore": {
"Mixed": 0,
"Negative": 0.999996,
"Neutral": 0.000004,
"Positive": 0
}
}
}
]
},
{
"DescriptiveMentionIndex": [
0
],
"Mentions": [
{
"BeginOffset": 53,
"EndOffset": 60,
"Score": 1,
"GroupScore": 1,
"Text": "service",
"Type": "ATTRIBUTE",
"MentionSentiment": {
"Sentiment": "NEUTRAL",
"SentimentScore": {
"Mixed": 0.000033,
"Negative": 0.000089,
"Neutral": 0.993325,
"Positive": 0.006553
}
}
}
]
}
]
}
```
## Detectando a sintaxe
Para analisar o texto para extrair as palavras individuais e determinar as partes do discurso para cada palavra, use a [DetectSyntax](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectSyntax.html)operação. Para analisar a sintaxe de até 25 documentos em um lote, use a [BatchDetectSyntax](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectSyntax.html)operação. Para obter mais informações, consulte [Lote em tempo real APIs](#get-started-batch).
**Topics**
+ [Usando AWS Command Line Interface o.](#get-started-api-syntax-cli)
+ [Usando o AWS SDK para Java SDK para Python ou SDK para .NET](#get-started-api-syntax-java)
### Usando AWS Command Line Interface o.
O exemplo a seguir demonstra como usar a operação `DetectSyntax` com o AWS CLI. Este exemplo especifica o idioma do texto de entrada.
O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
```
aws comprehend detect-syntax \
--region region \
--language-code "en" \
--text "It is raining today in Seattle."
```
O Amazon Comprehend responde com o seguinte:
```
{
"SyntaxTokens": [
{
"Text": "It",
"EndOffset": 2,
"BeginOffset": 0,
"PartOfSpeech": {
"Tag": "PRON",
"Score": 0.8389829397201538
},
"TokenId": 1
},
{
"Text": "is",
"EndOffset": 5,
"BeginOffset": 3,
"PartOfSpeech": {
"Tag": "AUX",
"Score": 0.9189288020133972
},
"TokenId": 2
},
{
"Text": "raining",
"EndOffset": 13,
"BeginOffset": 6,
"PartOfSpeech": {
"Tag": "VERB",
"Score": 0.9977611303329468
},
"TokenId": 3
},
{
"Text": "today",
"EndOffset": 19,
"BeginOffset": 14,
"PartOfSpeech": {
"Tag": "NOUN",
"Score": 0.9993606209754944
},
"TokenId": 4
},
{
"Text": "in",
"EndOffset": 22,
"BeginOffset": 20,
"PartOfSpeech": {
"Tag": "ADP",
"Score": 0.9999061822891235
},
"TokenId": 5
},
{
"Text": "Seattle",
"EndOffset": 30,
"BeginOffset": 23,
"PartOfSpeech": {
"Tag": "PROPN",
"Score": 0.9940338730812073
},
"TokenId": 6
},
{
"Text": ".",
"EndOffset": 31,
"BeginOffset": 30,
"PartOfSpeech": {
"Tag": "PUNCT",
"Score": 0.9999997615814209
},
"TokenId": 7
}
]
}
```
### Usando o AWS SDK para Java SDK para Python ou SDK para .NET
Para exemplos de SDKs que detectam a sintaxe do texto de entrada, consulte [Use `DetectSyntax` com um AWS SDK ou CLI](example_comprehend_DetectSyntax_section.md).
## Lote em tempo real APIs
Para enviar lotes de até 25 documentos, você pode usar as operações em lote em tempo real do Amazon Comprehend. Chamar uma operação em lote é idêntico a chamar o único documento APIs para cada documento na solicitação. Usar o lote APIs pode resultar em melhor desempenho para seus aplicativos. Para obter mais informações, consulte [Processamento síncrono de vários documentos](concepts-processing-modes.md#how-batch).
**Topics**
+ [Processamento em lote com o AWS CLI](#batch-cli)
+ [Processamento em lote com o AWS SDK para .NET](#batch-csharp)
### Processamento em lote com o AWS CLI
Esses exemplos mostram como usar operações de API em lote usando o AWS Command Line Interface. Todas as operações, exceto `BatchDetectDominantLanguage`, usam o seguinte arquivo JSON chamado `process.json` como entrada. Para essa operação, a entidade `LanguageCode` não está incluída.
O terceiro documento no arquivo JSON (`"$$$$$$$$"`) causará um erro durante o processamento em lote. Ele é incluído para que as operações incluam um [BatchItemError](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchItemError.html)na resposta.
```
{
"LanguageCode": "en",
"TextList": [
"I have been living in Seattle for almost 4 years",
"It is raining today in Seattle",
"$$$$$$$$"
]
}
```
O exemplo está formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
**Topics**
+ [Detecte o idioma dominante usando um batch (AWS CLI)](#batch-dominant-language)
+ [Detecte entidades usando um batch (AWS CLI)](#batch-entities)
+ [Detecte frases-chave usando um batch (AWS CLI)](#batch-key-phrase)
+ [Detecte sentimentos usando um batch (AWS CLI)](#batch-sentiment)
#### Detecte o idioma dominante usando um batch (AWS CLI)
A [BatchDetectDominantLanguage](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectDominantLanguage.html)operação determina o idioma dominante de cada documento em um lote. Para obter uma lista dos idiomas que o Amazon Comprehend pode detectar, consulte [Idioma dominante](how-languages.md). O AWS CLI comando a seguir chama a `BatchDetectDominantLanguage` operação.
```
aws comprehend batch-detect-dominant-language \
--endpoint endpoint \
--region region \
--cli-input-json file://path to input file/process.json
```
A seguir está a resposta da operação `BatchDetectDominantLanguage`:
```
{
"ResultList": [
{
"Index": 0,
"Languages":[
{
"LanguageCode":"en",
"Score": 0.99
}
]
},
{
"Index": 1
"Languages":[
{
"LanguageCode":"en",
"Score": 0.82
}
]
}
],
"ErrorList": [
{
"Index": 2,
"ErrorCode": "InternalServerException",
"ErrorMessage": "Unexpected Server Error. Please try again."
}
]
}
```
#### Detecte entidades usando um batch (AWS CLI)
Use a [BatchDetectEntities](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectEntities.html)operação para encontrar as entidades presentes em um lote de documentos. Para obter mais informações sobre entidades, consulte [Entidades](how-entities.md). O seguinte comando AWS CLI chama a operação `BatchDetectEntities`.
```
aws comprehend batch-detect-entities \
--endpoint endpoint \
--region region \
--cli-input-json file://path to input file/process.json
```
#### Detecte frases-chave usando um batch (AWS CLI)
A [BatchDetectKeyPhrases](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectKeyPhrases.html)operação retorna as frases nominais principais em um lote de documentos. O AWS CLI comando a seguir chama a `BatchDetectKeyNounPhrases` operação.
```
aws comprehend batch-detect-key-phrases
--endpoint endpoint
--region region
--cli-input-json file://path to input file/process.json
```
#### Detecte sentimentos usando um batch (AWS CLI)
Detecte o sentimento geral de um lote de documentos usando a [BatchDetectSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectSentiment.html)operação. O AWS CLI comando a seguir chama a `BatchDetectSentiment` operação.
```
aws comprehend batch-detect-sentiment \
--endpoint endpoint \
--region region \
--cli-input-json file://path to input file/process.json
```
### Processamento em lote com o AWS SDK para .NET
O exemplo de programa a seguir mostra como usar a [BatchDetectEntities](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectEntities.html)operação com SDK para .NET o. A resposta do servidor contém um [BatchDetectEntitiesItemResult](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectEntitiesItemResult.html)objeto para cada documento que foi processado com sucesso. Se houver um erro no processamento de um documento, haverá um registro na lista de erros na resposta. O exemplo pega cada um dos documentos com um erro e os reenvia.
O exemplo do .NET nesta seção usam o [AWS SDK para .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/welcome.html). Você pode usar o [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/AWSToolkitVS/latest/UserGuide/welcome.html)para desenvolver AWS aplicativos usando o.NET. Ele inclui modelos úteis e o AWS Explorer para implantar aplicativos e gerenciar serviços. Para uma perspectiva de desenvolvedores do.NET AWS, consulte o [AWS guia para desenvolvedores.NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/welcome.html).
```
using System;
using System.Collections.Generic;
using Amazon.Comprehend;
using Amazon.Comprehend.Model;
namespace Comprehend
{
class Program
{
// Helper method for printing properties
static private void PrintEntity(Entity entity)
{
Console.WriteLine(" Text: {0}, Type: {1}, Score: {2}, BeginOffset: {3} EndOffset: {4}",
entity.Text, entity.Type, entity.Score, entity.BeginOffset, entity.EndOffset);
}
static void Main(string[] args)
{
AmazonComprehendClient comprehendClient = new AmazonComprehendClient(Amazon.RegionEndpoint.USWest2);
List textList = new List()
{
{ "I love Seattle" },
{ "Today is Sunday" },
{ "Tomorrow is Monday" },
{ "I love Seattle" }
};
// Call detectEntities API
Console.WriteLine("Calling BatchDetectEntities");
BatchDetectEntitiesRequest batchDetectEntitiesRequest = new BatchDetectEntitiesRequest()
{
TextList = textList,
LanguageCode = "en"
};
BatchDetectEntitiesResponse batchDetectEntitiesResponse = comprehendClient.BatchDetectEntities(batchDetectEntitiesRequest);
foreach (BatchDetectEntitiesItemResult item in batchDetectEntitiesResponse.ResultList)
{
Console.WriteLine("Entities in {0}:", textList[item.Index]);
foreach (Entity entity in item.Entities)
PrintEntity(entity);
}
// check if we need to retry failed requests
if (batchDetectEntitiesResponse.ErrorList.Count != 0)
{
Console.WriteLine("Retrying Failed Requests");
List textToRetry = new List();
foreach(BatchItemError errorItem in batchDetectEntitiesResponse.ErrorList)
textToRetry.Add(textList[errorItem.Index]);
batchDetectEntitiesRequest = new BatchDetectEntitiesRequest()
{
TextList = textToRetry,
LanguageCode = "en"
};
batchDetectEntitiesResponse = comprehendClient.BatchDetectEntities(batchDetectEntitiesRequest);
foreach(BatchDetectEntitiesItemResult item in batchDetectEntitiesResponse.ResultList)
{
Console.WriteLine("Entities in {0}:", textList[item.Index]);
foreach (Entity entity in item.Entities)
PrintEntity(entity);
}
}
Console.WriteLine("End of DetectEntities");
}
}
}
```