Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Analyse en temps réel à l'aide de l'API
Les exemples suivants montrent comment utiliser l'API Amazon Comprehend pour une analyse en temps réel AWS CLI, en utilisant et AWS SDKs pour .NET, Java et Python. Utilisez les exemples pour en savoir plus sur les opérations synchrones d'Amazon Comprehend et comme éléments de base pour vos propres applications.
Les exemples .NET présentés dans cette section utilisent le kit [AWS SDK pour .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/welcome.html). Vous pouvez utiliser le [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/AWSToolkitVS/latest/UserGuide/welcome.html)pour développer des AWS applications à l'aide de .NET. Il inclut des modèles utiles et l' AWS explorateur pour le déploiement d'applications et la gestion des services. Pour connaître le point de vue des développeurs .NET AWS, consultez le [AWS guide destiné aux développeurs .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/welcome.html).
**Topics**
+ [Détecter la langue dominante](#get-started-api-dominant-language)
+ [Détection des entités nommées](#get-started-api-entities)
+ [Détecter les phrases clés](#get-started-api-key-phrases)
+ [Déterminer le sentiment](#get-started-api-sentiment)
+ [Analyse en temps réel pour un sentiment ciblé](#get-started-api-targeted-sentiment)
+ [Détection de la syntaxe](#get-started-api-syntax)
+ [Lot en temps réel APIs](#get-started-batch)
## Détecter la langue dominante
Pour déterminer la langue dominante utilisée dans le texte, utilisez l'[DetectDominantLanguage](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectDominantLanguage.html)opération. Pour détecter la langue dominante dans un maximum de 25 documents par lot, utilisez l'[BatchDetectDominantLanguage](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectDominantLanguage.html)opération. Pour de plus amples informations, veuillez consulter [Lot en temps réel APIs](#get-started-batch).
**Topics**
+ [À l'aide du AWS Command Line Interface](#get-started-api-dominant-language-cli)
+ [À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET](#get-started-api-dominant-language-java)
### À l'aide du AWS Command Line Interface
L'exemple suivant montre comment utiliser l'`DetectDominantLanguage`opération avec le AWS CLI.
L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws comprehend detect-dominant-language \
--region region \
--text "It is raining today in Seattle."
```
Amazon Comprehend répond comme suit :
```
{
"Languages": [
{
"LanguageCode": "en",
"Score": 0.9793661236763
}
]
}
```
### À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET
Pour des exemples de SDK expliquant comment déterminer la langue dominante, consultez[Utilisation `DetectDominantLanguage` avec un AWS SDK ou une CLI](example_comprehend_DetectDominantLanguage_section.md).
## Détection des entités nommées
Pour déterminer les entités nommées dans un document, utilisez l'[DetectEntities](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectEntities.html)opération. Pour détecter des entités dans un maximum de 25 documents par lot, utilisez l'[BatchDetectEntities](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectEntities.html)opération. Pour de plus amples informations, veuillez consulter [Lot en temps réel APIs](#get-started-batch).
**Topics**
+ [À l'aide du AWS Command Line Interface](#get-started-api-entities-cli)
+ [À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET](#get-started-api-entities-java)
### À l'aide du AWS Command Line Interface
L'exemple suivant illustre l'utilisation de l'`DetectEntities`opération à l'aide du AWS CLI. Vous devez spécifier la langue du texte saisi.
L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws comprehend detect-entities \
--region region \
--language-code "en" \
--text "It is raining today in Seattle."
```
Amazon Comprehend répond comme suit :
```
{
"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"
}
```
### À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET
Pour des exemples de SDK expliquant comment déterminer la langue dominante, consultez[Utilisation `DetectEntities` avec un AWS SDK ou une CLI](example_comprehend_DetectEntities_section.md).
## Détecter les phrases clés
Pour déterminer les phrases nominales clés utilisées dans le texte, utilisez l'[DetectKeyPhrases](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectKeyPhrases.html)opération. Pour détecter les phrases nominales clés dans un maximum de 25 documents par lot, utilisez cette [BatchDetectKeyPhrases](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectKeyPhrases.html)opération. Pour de plus amples informations, veuillez consulter [Lot en temps réel APIs](#get-started-batch).
**Topics**
+ [À l'aide du AWS Command Line Interface](#get-started-api-key-phrases-cli)
+ [À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET](#get-started-api-key-phrases-java)
### À l'aide du AWS Command Line Interface
L'exemple suivant montre comment utiliser l'`DetectKeyPhrases`opération avec le AWS CLI. Vous devez spécifier la langue du texte saisi.
L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws comprehend detect-key-phrases \
--region region \
--language-code "en" \
--text "It is raining today in Seattle."
```
Amazon Comprehend répond comme suit :
```
{
"LanguageCode": "en",
"KeyPhrases": [
{
"Text": "today",
"Score": 0.89,
"BeginOffset": 14,
"EndOffset": 19
},
{
"Text": "Seattle",
"Score": 0.91,
"BeginOffset": 23,
"EndOffset": 30
}
]
}
```
### À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET
Pour des exemples de SDK qui détectent des phrases clés, consultez[Utilisation `DetectKeyPhrases` avec un AWS SDK ou une CLI](example_comprehend_DetectKeyPhrases_section.md).
## Déterminer le sentiment
Amazon Comprehend fournit les opérations d'API suivantes pour analyser les sentiments :
+ [DetectSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectSentiment.html)— Détermine le sentiment émotionnel général d'un document.
+ [BatchDetectSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectSentiment.html)— Déterminez le sentiment général d'un maximum de 25 documents par lot. Pour de plus amples informations, consultez [Lot en temps réel APIs](#get-started-batch).
+ [StartSentimentDetectionJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_StartSentimentDetectionJob.html)— Démarre une tâche de détection des sentiments asynchrone pour un ensemble de documents.
+ [ListSentimentDetectionJobs](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_ListSentimentDetectionJobs.html)— Renvoie la liste des tâches de détection des sentiments que vous avez soumises.
+ [DescribeSentimentDetectionJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DescribeSentimentDetectionJob.html)— Obtient les propriétés (y compris le statut) associées à la tâche de détection des sentiments spécifiée.
+ [StopSentimentDetectionJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_StopSentimentDetectionJob.html)— Arrête la tâche d'évaluation des sentiments en cours spécifiée.
**Topics**
+ [À l'aide du AWS Command Line Interface](#get-started-api-sentiment-cli)
+ [À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET](#get-started-api-sentiment-java)
### À l'aide du AWS Command Line Interface
L'exemple suivant montre comment utiliser l'`DetectSentiment`opération avec le AWS CLI. Cet exemple indique la langue du texte saisi.
L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws comprehend detect-sentiment \
--region region \
--language-code "en" \
--text "It is raining today in Seattle."
```
Amazon Comprehend répond comme suit :
```
{
"SentimentScore": {
"Mixed": 0.014585512690246105,
"Positive": 0.31592071056365967,
"Neutral": 0.5985543131828308,
"Negative": 0.07093945890665054
},
"Sentiment": "NEUTRAL",
"LanguageCode": "en"
}
```
### À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET
Pour des exemples de SDK qui déterminent le sentiment du texte saisi, voir[Utilisation `DetectSentiment` avec un AWS SDK ou une CLI](example_comprehend_DetectSentiment_section.md).
## Analyse en temps réel pour un sentiment ciblé
Amazon Comprehend fournit les opérations d'API suivantes pour une analyse ciblée des sentiments en temps réel :
+ [DetectTargetedSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectTargetedSentiment.html)— Analyse le sentiment des entités mentionnées dans un document.
+ [BatchDetectTargetedSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectTargetedSentiment.html)— Analyse le sentiment ciblé pour un maximum de 25 documents par lot. Pour de plus amples informations, consultez [Lot en temps réel APIs](#get-started-batch).
Si le texte que vous analysez n'inclut aucun sentiment ciblé[Types d’entités](how-targeted-sentiment.md#how-targeted-sentiment-entities), l'API renvoie un tableau d'entités vide.
### À l'aide du AWS Command Line Interface
L'exemple suivant montre comment utiliser l'`DetectTargetedSentiment`opération avec le AWS CLI. Cet exemple indique la langue du texte saisi.
L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws comprehend detect-targeted-sentiment \
--region region \
--language-code "en" \
--text "The burger was cooked perfectly but it was cold. The service was OK."
```
Amazon Comprehend répond comme suit :
```
{
"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
}
}
}
]
}
]
}
```
## Détection de la syntaxe
Pour analyser le texte afin d'extraire les mots individuels et de déterminer les parties du discours pour chaque mot, utilisez l'[DetectSyntax](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DetectSyntax.html)opération. Pour analyser la syntaxe d'un maximum de 25 documents par lot, utilisez l'[BatchDetectSyntax](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectSyntax.html)opération. Pour de plus amples informations, veuillez consulter [Lot en temps réel APIs](#get-started-batch).
**Topics**
+ [En utilisant le AWS Command Line Interface.](#get-started-api-syntax-cli)
+ [À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET](#get-started-api-syntax-java)
### En utilisant le AWS Command Line Interface.
L'exemple suivant montre comment utiliser l'`DetectSyntax`opération avec le AWS CLI. Cet exemple indique la langue du texte saisi.
L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
```
aws comprehend detect-syntax \
--region region \
--language-code "en" \
--text "It is raining today in Seattle."
```
Amazon Comprehend répond comme suit :
```
{
"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
}
]
}
```
### À l'aide du AWS SDK pour Java SDK pour Python, ou SDK pour .NET
Pour des exemples de SDK qui détectent la syntaxe du texte saisi, consultez[Utilisation `DetectSyntax` avec un AWS SDK ou une CLI](example_comprehend_DetectSyntax_section.md).
## Lot en temps réel APIs
Pour envoyer des lots contenant jusqu'à 25 documents, vous pouvez utiliser les opérations par lots en temps réel d'Amazon Comprehend. L'appel d'une opération par lots est identique à l'appel d'un seul document APIs pour chaque document de la demande. L'utilisation du lot APIs peut améliorer les performances de vos applications. Pour de plus amples informations, veuillez consulter [Traitement synchrone de plusieurs documents](concepts-processing-modes.md#how-batch).
**Topics**
+ [Traitement par lots avec AWS CLI](#batch-cli)
+ [Traitement par lots avec AWS SDK pour .NET](#batch-csharp)
### Traitement par lots avec AWS CLI
Ces exemples montrent comment utiliser les opérations d'API par lots à l'aide du AWS Command Line Interface. Toutes les opérations sauf l'`BatchDetectDominantLanguage`utilisation du fichier JSON suivant `process.json` appelé en entrée. Pour cette opération, l'`LanguageCode`entité n'est pas incluse.
Le troisième document du fichier JSON (`"$$$$$$$$"`) provoquera une erreur lors du traitement par lots. Il est inclus afin que les opérations incluent un [BatchItemError](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchItemError.html)dans la réponse.
```
{
"LanguageCode": "en",
"TextList": [
"I have been living in Seattle for almost 4 years",
"It is raining today in Seattle",
"$$$$$$$$"
]
}
```
Les exemples sont formatés pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
**Topics**
+ [Détecter la langue dominante à l'aide d'un batch (AWS CLI)](#batch-dominant-language)
+ [Détecter les entités à l'aide d'un lot (AWS CLI)](#batch-entities)
+ [Détecter les phrases clés à l'aide d'un batch (AWS CLI)](#batch-key-phrase)
+ [Détectez les sentiments à l'aide d'un batch (AWS CLI)](#batch-sentiment)
#### Détecter la langue dominante à l'aide d'un batch (AWS CLI)
L'[BatchDetectDominantLanguage](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectDominantLanguage.html)opération détermine la langue dominante de chaque document d'un lot. Pour obtenir la liste des langues qu'Amazon Comprehend peut détecter, consultez. [Langue dominante](how-languages.md) La AWS CLI commande suivante lance l'`BatchDetectDominantLanguage`opération.
```
aws comprehend batch-detect-dominant-language \
--endpoint endpoint \
--region region \
--cli-input-json file://path to input file/process.json
```
Voici la réponse de l'`BatchDetectDominantLanguage`opération :
```
{
"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."
}
]
}
```
#### Détecter les entités à l'aide d'un lot (AWS CLI)
Utilisez cette [BatchDetectEntities](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectEntities.html)opération pour rechercher les entités présentes dans un lot de documents. Pour plus d'informations sur les entités, consultez [Entités](how-entities.md). La AWS CLI commande suivante lance l'`BatchDetectEntities`opération.
```
aws comprehend batch-detect-entities \
--endpoint endpoint \
--region region \
--cli-input-json file://path to input file/process.json
```
#### Détecter les phrases clés à l'aide d'un batch (AWS CLI)
L'[BatchDetectKeyPhrases](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectKeyPhrases.html)opération renvoie les phrases nominales clés d'un lot de documents. La AWS CLI commande suivante lance l'`BatchDetectKeyNounPhrases`opération.
```
aws comprehend batch-detect-key-phrases
--endpoint endpoint
--region region
--cli-input-json file://path to input file/process.json
```
#### Détectez les sentiments à l'aide d'un batch (AWS CLI)
Détectez l'impression générale d'un lot de documents à l'aide de cette [BatchDetectSentiment](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectSentiment.html)opération. La AWS CLI commande suivante lance l'`BatchDetectSentiment`opération.
```
aws comprehend batch-detect-sentiment \
--endpoint endpoint \
--region region \
--cli-input-json file://path to input file/process.json
```
### Traitement par lots avec AWS SDK pour .NET
L'exemple de programme suivant montre comment utiliser l'[BatchDetectEntities](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectEntities.html)opération avec le SDK pour .NET. La réponse du serveur contient un [BatchDetectEntitiesItemResult](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_BatchDetectEntitiesItemResult.html)objet pour chaque document traité avec succès. En cas d'erreur lors du traitement d'un document, un enregistrement figurera dans la liste des erreurs de la réponse. L'exemple récupère chacun des documents contenant une erreur et les renvoie.
L'exemple .NET présenté dans cette section utilise le [AWS SDK pour .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/welcome.html). Vous pouvez utiliser le [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/AWSToolkitVS/latest/UserGuide/welcome.html)pour développer des AWS applications à l'aide de .NET. Il inclut des modèles utiles et l' AWS explorateur pour le déploiement d'applications et la gestion des services. Pour connaître le point de vue des développeurs .NET AWS, consultez le [AWS guide destiné aux développeurs .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");
}
}
}
```