Erkennen der dominanten Sprache Erkennen benannter Entitäten Erkennen von Schlüsselphrasen Bestimmen der Stimmung Echtzeitanalyse für gezielte Stimmung Erkennen der Syntax Batch-APIs in Echtzeit

Echtzeitanalyse mit der API

Die folgenden Beispiele zeigen, wie Sie die Amazon Comprehend API für Echtzeitanalysen verwenden, indem Sie die AWS CLIund die AWS SDKs für .NET, Java und Python verwenden. Verwenden Sie die Beispiele, um mehr über die synchronen Operationen von Amazon Comprehend und als Bausteine für Ihre eigenen Anwendungen zu erfahren.

Die .NET-Beispiele in diesem Abschnitt verwenden das AWS SDK for .NET. Sie können die verwendenAWS Toolkit for Visual Studio, um AWS Anwendungen mit .NET zu entwickeln. Es enthält hilfreiche Vorlagen und den AWS Explorer für die Bereitstellung von Anwendungen und die Verwaltung von -Services. Eine .NET-Entwicklerperspektive von AWSfinden Sie im AWS Handbuch für .NET-Entwickler.

Erkennen der dominanten Sprache

Um die dominante Sprache zu ermitteln, die im Text verwendet wird, verwenden Sie die -DetectDominantLanguageOperation. Um die dominante Sprache in bis zu 25 Dokumenten in einem Batch zu erkennen, verwenden Sie die -BatchDetectDominantLanguageOperation. Weitere Informationen finden Sie unter Batch-APIs in Echtzeit.

Themen

Verwendung der AWS Command Line Interface
Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

Verwendung der AWS Command Line Interface

Das folgende Beispiel zeigt die Verwendung der -DetectDominantLanguageOperation mit der AWS CLI.

Das Beispiel ist für Unix, Linux und macOS formatiert. Ersetzen Sie unter Windows den umgekehrten Schrägstrich (\), das Unix-Fortsetzungszeichen, am Ende jeder Zeile durch ein Caret-Zeichen oder Zirkumflex (^).


aws comprehend detect-dominant-language \
    --region region \
    --text "It is raining today in Seattle."

Amazon Comprehend antwortet wie folgt:


{
    "Languages": [
        {
            "LanguageCode": "en",
            "Score": 0.9793661236763
        }
    ]
}

Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

SDK-Beispiele zur Bestimmung der dominanten Sprache finden Sie unter Verwenden Sie es DetectDominantLanguage mit einem AWS SDK oder CLI.

Erkennen benannter Entitäten

Um die benannten Entitäten in einem Dokument zu ermitteln, verwenden Sie die -DetectEntitiesOperation. Um Entitäten in bis zu 25 Dokumenten in einem Batch zu erkennen, verwenden Sie die -BatchDetectEntitiesOperation. Weitere Informationen finden Sie unter Batch-APIs in Echtzeit.

Themen

Verwendung der AWS Command Line Interface
Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

Verwendung der AWS Command Line Interface

Das folgende Beispiel zeigt die Verwendung der -DetectEntitiesOperation unter Verwendung der AWS CLI. Sie müssen die Sprache des Eingabetexts angeben.


aws comprehend detect-entities \
    --region region \
    --language-code "en" \
    --text "It is raining today in Seattle."

Amazon Comprehend antwortet wie folgt:


{
    "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"
}

Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

SDK-Beispiele zur Bestimmung der dominanten Sprache finden Sie unter Verwenden Sie es DetectEntities mit einem AWS SDK oder CLI.

Erkennen von Schlüsselphrasen

Um die im Text verwendeten Schlüsselnamenphrasen zu ermitteln, verwenden Sie die -DetectKeyPhrasesOperation. Um die Schlüsselnamenphrasen in bis zu 25 Dokumenten in einem Batch zu erkennen, verwenden Sie die -BatchDetectKeyPhrasesOperation. Weitere Informationen finden Sie unter Batch-APIs in Echtzeit.

Themen

Verwendung der AWS Command Line Interface
Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

Verwendung der AWS Command Line Interface

Das folgende Beispiel zeigt die Verwendung der -DetectKeyPhrasesOperation mit der AWS CLI. Sie müssen die Sprache des Eingabetexts angeben.


aws comprehend detect-key-phrases \
    --region region \
    --language-code "en" \
    --text "It is raining today in Seattle."

Amazon Comprehend antwortet wie folgt:


{
    "LanguageCode": "en",
    "KeyPhrases": [
        {
            "Text": "today",
            "Score": 0.89,
            "BeginOffset": 14,
            "EndOffset": 19
        },
        {
            "Text": "Seattle",
            "Score": 0.91,
            "BeginOffset": 23,
            "EndOffset": 30
        }
    ]
}

Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

SDK-Beispiele, die Schlüsselphrasen erkennen, finden Sie unter Verwenden Sie es DetectKeyPhrases mit einem AWS SDK oder CLI.

Bestimmen der Stimmung

Amazon Comprehend bietet die folgenden API-Operationen zum Analysieren der Stimmung:

DetectSentiment – Bestimmt die gesamte neuronale Stimmung eines Dokuments.
BatchDetectSentiment – Ermitteln Sie die Gesamtstimmung in bis zu 25 Dokumenten in einem Batch. Weitere Informationen finden Sie unter Batch-APIs in Echtzeit.
StartSentimentDetectionJob – Startet einen asynchronen Stimmungserkennungsauftrag für eine Sammlung von Dokumenten.
ListSentimentDetectionJobs – Gibt die Liste der von Ihnen übermittelten Aufträge zur Stimmungserkennung zurück.
DescribeSentimentDetectionJob – Ruft die Eigenschaften (einschließlich Status) ab, die dem angegebenen Stimmungserkennungsauftrag zugeordnet sind.
StopSentimentDetectionJob – Bricht den angegebenen Stimmungsauftrag in Bearbeitung ab.

Themen

Verwenden des AWS Command Line Interface
Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

Verwenden des AWS Command Line Interface

Das folgende Beispiel zeigt die Verwendung der -DetectSentimentOperation mit der AWS CLI. In diesem Beispiel wird die Sprache des Eingabetexts angegeben.


aws comprehend detect-sentiment \
    --region region \
    --language-code "en" \
    --text "It is raining today in Seattle."

Amazon Comprehend antwortet wie folgt:


{
    "SentimentScore": {
        "Mixed": 0.014585512690246105,
        "Positive": 0.31592071056365967,
        "Neutral": 0.5985543131828308,
        "Negative": 0.07093945890665054
    },
    "Sentiment": "NEUTRAL",
    "LanguageCode": "en"
}

Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

SDK-Beispiele, die die Stimmung des Eingabetexts bestimmen, finden Sie unter Verwenden Sie es DetectSentiment mit einem AWS SDK oder CLI.

Echtzeitanalyse für gezielte Stimmung

Amazon Comprehend bietet die folgenden API-Operationen für gezielte Stimmungs-Echtzeitanalysen:

DetectTargetedSentiment – Analysiert die Stimmung der in einem Dokument erwähnten Entitäten.
BatchDetectTargetedSentiment – Analysiert die gezielte Stimmung für bis zu 25 Dokumente in einem Batch. Weitere Informationen finden Sie unter Batch-APIs in Echtzeit.

Wenn der analysierte Text keine gezielte Stimmung enthältEntitätstypen, gibt die API ein leeres Entitäts-Array zurück.

Verwenden des AWS Command Line Interface

Das folgende Beispiel zeigt die Verwendung der -DetectTargetedSentimentOperation mit der AWS CLI. In diesem Beispiel wird die Sprache des Eingabetexts angegeben.


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 antwortet wie folgt:


{
"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
            }
          }
        }
      ]
    }
  ]
}

Erkennen der Syntax

Um Text zu analysieren, um die einzelnen Wörter zu extrahieren und die Sprachteile für jedes Wort zu bestimmen, verwenden Sie die -DetectSyntaxOperation. Um die Syntax von bis zu 25 Dokumenten in einem Batch zu analysieren, verwenden Sie die -BatchDetectSyntaxOperation. Weitere Informationen finden Sie unter Batch-APIs in Echtzeit.

Themen

Verwenden der AWS Command Line Interface.
Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

Verwenden der AWS Command Line Interface.

Das folgende Beispiel zeigt die Verwendung der -DetectSyntaxOperation mit der AWS CLI. In diesem Beispiel wird die Sprache des Eingabetexts angegeben.


aws comprehend detect-syntax \
   --region region \
   --language-code "en" \
   --text "It is raining today in Seattle."

Amazon Comprehend antwortet wie folgt:


{
    "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
        }
    ]
}

Verwenden von AWS SDK for Java, SDK für Python oder AWS SDK for .NET

SDK-Beispiele, die die Syntax von Eingabetext erkennen, finden Sie unter Verwenden Sie es DetectSyntax mit einem AWS SDK oder CLI.

Batch-APIs in Echtzeit

Um Batches mit bis zu 25 Dokumenten zu senden, können Sie die Amazon Comprehend-Echtzeit-Batchoperationen verwenden. Das Aufrufen eines Batchvorgangs ist identisch mit dem Aufrufen der einzelnen Dokument-APIs für jedes Dokument in der Anforderung. Die Verwendung der Batch-APIs kann zu einer besseren Leistung für Ihre Anwendungen führen. Weitere Informationen finden Sie unter Synchrone Verarbeitung mehrerer Dokumente.

Themen

Batchverarbeitung mit der AWS CLI
Batchverarbeitung mit der AWS SDK for .NET

Batchverarbeitung mit der AWS CLI

Diese Beispiele zeigen, wie Sie die Batch-API-Operationen mithilfe der verwendenAWS Command Line Interface. Alle Operationen außer BatchDetectDominantLanguage verwenden die folgende JSON-Datei namens process.json als Eingabe. Für diesen Vorgang ist die LanguageCode Entität nicht enthalten.

Das dritte Dokument in der JSON-Datei ("$$$$$$$$") verursacht während der Batchverarbeitung einen Fehler. Sie ist enthalten, sodass die Operationen eine BatchItemError in der Antwort enthalten.


{
   "LanguageCode": "en",
   "TextList": [
      "I have been living in Seattle for almost 4 years",
      "It is raining today in Seattle",
      "$$$$$$$$"
   ]
}

Die Beispiele sind für Unix, Linux und macOS formatiert. Ersetzen Sie unter Windows den umgekehrten Schrägstrich (\), das Unix-Fortsetzungszeichen, am Ende jeder Zeile durch ein Caret-Zeichen oder Zirkumflex (^).

Themen

Erkennen der dominanten Sprache mithilfe eines Batches (AWS CLI)
Entitäten mithilfe eines Batches erkennen (AWS CLI)
Erkennen von Schlüsselphrasen mithilfe eines Batches (AWS CLI)
Erkennen der Stimmung mithilfe eines Batches (AWS CLI)

Erkennen der dominanten Sprache mithilfe eines Batches (AWS CLI)

Die -BatchDetectDominantLanguageOperation bestimmt die dominante Sprache jedes Dokuments in einem Batch. Eine Liste der Sprachen, die Amazon Comprehend erkennen kann, finden Sie unter Dominante Sprache. Der folgende AWS CLI Befehl ruft die -BatchDetectDominantLanguageOperation auf.


aws comprehend batch-detect-dominant-language \
    --endpoint endpoint \
    --region region \
    --cli-input-json file://path to input file/process.json

Im Folgenden finden Sie die Antwort des -BatchDetectDominantLanguageVorgangs:


{
    "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."
      }
    ]
}

Entitäten mithilfe eines Batches erkennen (AWS CLI)

Verwenden Sie die -BatchDetectEntitiesOperation, um die Entitäten zu finden, die in einem Stapel von Dokumenten vorhanden sind. Weitere Informationen über Entitys finden Sie unter Entitäten. Der folgende AWS CLI Befehl ruft die -BatchDetectEntitiesOperation auf.


aws comprehend batch-detect-entities \
    --endpoint endpoint \
    --region region \
    --cli-input-json file://path to input file/process.json

Erkennen von Schlüsselphrasen mithilfe eines Batches (AWS CLI)

Die BatchDetectKeyPhrases Operation gibt die Schlüsselnamenphrasen in einem Stapel von Dokumenten zurück. Der folgende AWS CLI Befehl ruft die -BatchDetectKeyNounPhrasesOperation auf.


aws comprehend batch-detect-key-phrases
    --endpoint endpoint
    --region region
    --cli-input-json file://path to input file/process.json

Erkennen der Stimmung mithilfe eines Batches (AWS CLI)

Erkennen Sie die Gesamtstimmung eines Dokumentenstapels mithilfe der -BatchDetectSentimentOperation. Der folgende AWS CLI Befehl ruft die -BatchDetectSentimentOperation auf.


aws comprehend batch-detect-sentiment \
    --endpoint endpoint \
    --region region \
    --cli-input-json file://path to input file/process.json

Batchverarbeitung mit der AWS SDK for .NET

Das folgende Beispielprogramm zeigt, wie Sie die -BatchDetectEntitiesOperation mit dem verwendenAWS SDK for .NET. Die Antwort vom Server enthält ein BatchDetectEntitiesItemResult Objekt für jedes Dokument, das erfolgreich verarbeitet wurde. Wenn bei der Verarbeitung eines Dokuments ein Fehler auftritt, befindet sich in der Fehlerliste in der Antwort ein Datensatz. Das Beispiel ruft jedes der Dokumente mit einem Fehler ab und sendet sie erneut.

Das .NET-Beispiel in diesem Abschnitt verwendet die AWS SDK for .NET. Sie können die verwendenAWS Toolkit for Visual Studio, um AWS Anwendungen mit .NET zu entwickeln. Es enthält hilfreiche Vorlagen und den AWS Explorer für die Bereitstellung von Anwendungen und die Verwaltung von -Services. Eine .NET-Entwicklerperspektive von AWSfinden Sie im AWS Handbuch für .NET-Entwickler.


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<String> textList = new List<String>()
            {
                { "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<String> textToRetry = new List<String>();
                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");
        }
    }
}

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Mit SDKs arbeiten AWS

Asynchrone Analyseaufträge (API)