Análisis en tiempo real mediante la API - Amazon Comprehend
Detectar el idioma dominanteDetectar entidades con nombreDetección de frases claveDeterminación de la opiniónAnálisis en tiempo real de la opinión específicaDetección de la sintaxisAPI por lotes en tiempo real

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Análisis en tiempo real mediante la API

Los siguientes ejemplos muestran cómo utilizar la API Amazon Comprehend para el análisis en tiempo real mediante el uso de la AWS CLI, y de los SDK de AWS para.NET, Java y Python. Utilice los ejemplos para conocer las operaciones sincrónicas de Amazon Comprehend y como bloques de construcción para sus propias aplicaciones.

En los ejemplos de .NET de esta sección, se utiliza AWS SDK for .NET. Puede utilizar AWS Toolkit for Visual Studio para desarrollar aplicaciones de AWS usando .NET. Incluye plantillas útiles, así como AWS Explorer, para la implementación de aplicaciones y la administración de servicios. Para conocer la perspectiva de un desarrollador para .NET de AWS, consulte la AWSGuía para desarrolladores de .NET.

Detectar el idioma dominante

Para determinar el idioma dominante utilizado en el texto, utilice la DetectDominantLanguageoperación. Para detectar el idioma dominante en un máximo de 25 documentos de un lote, utilice la BatchDetectDominantLanguageoperación. Para obtener más información, consulte API por lotes en tiempo real.

Mediante AWS Command Line Interface

El siguiente ejemplo muestra el uso de la operación DetectDominantLanguage en la AWS CLI.

El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).

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

Amazon Comprehend responde con lo siguiente:

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

Uso de AWS SDK for Java, SDK para Python, o AWS SDK for .NET

Para ver ejemplos del SDK sobre cómo determinar el idioma dominante, consulte DetectDominantLanguageÚselo con una AWS SDK o CLI.

Detectar entidades con nombre

Para determinar las entidades nombradas en un documento, utilice la DetectEntitiesoperación. Para detectar entidades en un máximo de 25 documentos de un lote, utilice la BatchDetectEntitiesoperación. Para obtener más información, consulte API por lotes en tiempo real.

Mediante AWS Command Line Interface

El siguiente ejemplo muestra el uso de la operación DetectEntities mediante la AWS CLI. Debe especificar el idioma del archivo de entrada.

El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).

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

Amazon Comprehend responde con lo siguiente:

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

Uso de AWS SDK for Java, SDK para Python, o AWS SDK for .NET

Para ver ejemplos del SDK sobre cómo determinar el idioma dominante, consulte DetectEntitiesÚselo con una AWS SDK o CLI.

Detección de frases clave

Para determinar las frases nominales clave utilizadas en el texto, utilice la DetectKeyPhrasesoperación. Para detectar las frases nominales clave en un máximo de 25 documentos de un lote, utilice la BatchDetectKeyPhrasesoperación. Para obtener más información, consulte API por lotes en tiempo real.

Mediante AWS Command Line Interface

El siguiente ejemplo muestra el uso de la operación DetectKeyPhrases en la AWS CLI. Debe especificar el idioma del archivo de entrada.

El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).

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

Amazon Comprehend responde con lo siguiente:

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

Uso de AWS SDK for Java, SDK para Python, o AWS SDK for .NET

Para ver ejemplos de SDK que detectan frases clave, consulte DetectKeyPhrasesÚselo con una AWS SDK o CLI.

Determinación de la opinión

Amazon Comprehend ofrece las siguientes operaciones de API para analizar las opiniones:

Utilización del AWS Command Line Interface

El siguiente ejemplo muestra el uso de la operación DetectSentiment en AWS CLI. En este ejemplo se especifica el idioma del texto de entrada.

El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).

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

Amazon Comprehend responde con lo siguiente:

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

Uso de AWS SDK for Java, SDK para Python, o AWS SDK for .NET

Para ver ejemplos del SDK que determinan la opinión del texto introducido, consulte DetectSentimentÚselo con una AWS SDK o CLI.

Análisis en tiempo real de la opinión específica

Amazon Comprehend proporciona las siguientes operaciones de API para el análisis específico de las opiniones en tiempo real:

Si el texto que está analizando no incluye ninguna opinión específica Tipos de entidad, la API devuelve una matriz de entidades vacía.

Utilización del AWS Command Line Interface

El siguiente ejemplo muestra el uso de la operación DetectTargetedSentiment en AWS CLI. En este ejemplo se especifica el idioma del texto de entrada.

El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).

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 responde con lo siguiente:

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

Detección de la sintaxis

Para analizar el texto a fin de extraer las palabras individuales y determinar las partes del discurso de cada palabra, utilice la DetectSyntaxoperación. Para analizar la sintaxis de hasta 25 documentos en un lote, utilice la BatchDetectSyntaxoperación. Para obtener más información, consulte API por lotes en tiempo real.

Mediante AWS Command Line Interface.

El siguiente ejemplo muestra el uso de la operación DetectSyntax en la AWS CLI. En este ejemplo se especifica el idioma del texto de entrada.

El ejemplo está formateado para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^). 

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

Amazon Comprehend responde con lo siguiente:

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

Uso de AWS SDK for Java, SDK para Python, o AWS SDK for .NET

Para ver ejemplos del SDK que detectan la sintaxis del texto introducido, consulte DetectSyntaxÚselo con una AWS SDK o CLI.

API por lotes en tiempo real

Para enviar lotes de hasta 25 documentos, puede utilizar las operaciones por lotes en tiempo real de Amazon Comprehend. Llamar a una operación por lotes es idéntico a llamar a las API de un solo documento para cada documento de la solicitud. El uso de las API por lotes puede mejorar el rendimiento de sus aplicaciones. Para obtener más información, consulte Procesamiento sincrónico de varios documentos.

Procesamiento por lotes con la AWS CLI

En estos ejemplos se muestra cómo usar las operaciones de la API por lotes con AWS Command Line Interface. Todas las operaciones, excepto BatchDetectDominantLanguage utilizan el siguiente archivo JSON process.json denominado como entrada. Para esa operación, la entidad LanguageCode no está incluida.

El tercer documento del archivo JSON ("$$$$$$$$") provocará un error durante el procesamiento por lotes. Se incluye para que las operaciones incluyan un elemento BatchItemErroren la respuesta.

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

Los ejemplos están preparados para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).

Detecta el idioma dominante mediante un lote (AWS CLI)

La BatchDetectDominantLanguageoperación determina el idioma dominante de cada documento de un lote. Para obtener una lista de los idiomas que Amazon Comprehend puede detectar, consulte Idioma predominante. El siguiente comando AWS CLI llama a la operación BatchDetectDominantLanguage.

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

La siguiente es la respuesta de la operación 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 mediante un lote (AWS CLI)

Utilice la BatchDetectEntitiesoperación para buscar las entidades presentes en un lote de documentos. Para obtener más información sobre entidades, consulte Entidades. El siguiente comando AWS CLI llama a la operación BatchDetectEntities.

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

Detecte frases clave mediante un lote (AWS CLI)

La BatchDetectKeyPhrasesoperación devuelve las frases nominales clave de un lote de documentos. El siguiente comando AWS CLI llama a la operación BatchDetectKeyNounPhrases.

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

Detecte la opinión mediante un lote (AWS CLI)

Detecte el sentimiento general de un lote de documentos mediante la BatchDetectSentimentoperación. El siguiente comando AWS CLI llama a la operación BatchDetectSentiment.

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

Procesamiento por lotes con la AWS SDK for .NET

El siguiente programa de ejemplo muestra cómo utilizar la BatchDetectEntitiesoperación conAWS SDK for .NET. La respuesta del servidor contiene un BatchDetectEntitiesItemResultobjeto para cada documento que se haya procesado correctamente. Si se produce un error al procesar un documento, habrá un registro en la lista de errores de la respuesta. El ejemplo obtiene cada uno de los documentos con un error y los vuelve a enviar.

En los ejemplos de .NET de esta sección se utiliza AWS SDK for .NET. Puede utilizar AWS Toolkit for Visual Studio para desarrollar aplicaciones de AWS usando .NET. Incluye plantillas útiles, así como AWS Explorer, para la implementación de aplicaciones y la administración de servicios. Para conocer la perspectiva de un desarrollador para .NET de AWS, consulte la AWSGuía para desarrolladores de .NET. 

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");
        }
    }
}