Cette page a été traduite par l'API Cloud Translation.

Analyser les sentiments d'entités

L'analyse des sentiments d'entités combine l'analyse des entités et l'analyse des sentiments pour tenter de déterminer le sentiment (positif ou négatif) exprimé à propos des entités d'un texte. Le sentiment de l'entité est représenté par un score numérique et des valeurs de magnitude, et il est déterminé pour chaque mention d'une entité. Ces scores sont ensuite agrégés pour former un score et une magnitude de sentiment globaux pour une entité. Pour plus d'informations sur l'interprétation des valeurs de sentiment score et magnitude incluses dans l'analyse, consultez la section Interpréter les valeurs d'analyse des sentiments.

Les exemples suivants montrent comment interroger la méthode analyzeEntitySentiment. Vous devez envoyer une demande distincte pour chaque document.

Analyser les sentiments d'entités

Voici un exemple d'analyse des sentiments d'entités sous forme de chaîne :

Protocole

Pour analyser les sentiments d'entités dans un document, envoyez une requête POST à la méthode REST documents:analyzeEntitySentiment et fournissez le corps de requête approprié comme illustré dans l'exemple suivant.

L'exemple utilise la commande gcloud auth application-default print-access-token pour obtenir un jeton d'accès pour un compte de service configuré pour le projet à l'aide de gcloud CLI de Google Cloud Platform. Pour obtenir des instructions d'installation de la gcloud CLI et configurer un projet avec un compte de service, consultez le guide de démarrage rapide.

curl -X POST \
     -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
     -H "Content-Type: application/json; charset=utf-8" \
     --data "{
  'document':{
    'type':'PLAIN_TEXT',
    'content':'I love R&B music. Marvin Gaye is the best.
               \'What\'s Going On\' is one of my favorite songs.
               It was so sad when Marvin Gaye died.'
  },
  'encodingType':'UTF8'
}" "https://language.googleapis.com/v1/documents:analyzeEntitySentiment"

gcloud

Reportez-vous à la commande analyze-entity-sentiment pour obtenir tous les détails.

Pour effectuer une analyse des sentiments d'entités, utilisez gcloud CLI et utilisez l'option --content pour identifier le contenu à analyser :

gcloud ml language analyze-entity-sentiment \
  --content="I love R&B music. Marvin Gaye is the best. 'What's Going On' is one of my favorite songs. It was so sad when Marvin Gaye died."

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Natural Language, consultez la page Bibliothèques clientes Natural Language. Pour en savoir plus, consultez la documentation de référence de l'API Natural Language Go.

Pour vous authentifier auprès de Natural Language, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


func analyzeEntitySentiment(ctx context.Context, client *language.Client, text string) (*languagepb.AnalyzeEntitySentimentResponse, error) {
	return client.AnalyzeEntitySentiment(ctx, &languagepb.AnalyzeEntitySentimentRequest{
		Document: &languagepb.Document{
			Source: &languagepb.Document_Content{
				Content: text,
			},
			Type: languagepb.Document_PLAIN_TEXT,
		},
	})
}

Java

// Instantiate the Language client com.google.cloud.language.v1.LanguageServiceClient
try (com.google.cloud.language.v1.LanguageServiceClient language =
    com.google.cloud.language.v1.LanguageServiceClient.create()) {
  com.google.cloud.language.v1.Document doc =
      com.google.cloud.language.v1.Document.newBuilder().setContent(text)
          .setType(com.google.cloud.language.v1.Document.Type.PLAIN_TEXT).build();
  AnalyzeEntitySentimentRequest request =
      AnalyzeEntitySentimentRequest.newBuilder()
          .setDocument(doc)
          .setEncodingType(com.google.cloud.language.v1.EncodingType.UTF16)
          .build();
  // Detect entity sentiments in the given string
  AnalyzeEntitySentimentResponse response = language.analyzeEntitySentiment(request);
  // Print the response
  for (com.google.cloud.language.v1.Entity entity : response.getEntitiesList()) {
    System.out.printf("Entity: %s\n", entity.getName());
    System.out.printf("Salience: %.3f\n", entity.getSalience());
    System.out.printf("Sentiment : %s\n", entity.getSentiment());
    for (com.google.cloud.language.v1.EntityMention mention : entity.getMentionsList()) {
      System.out.printf("Begin offset: %d\n", mention.getText().getBeginOffset());
      System.out.printf("Content: %s\n", mention.getText().getContent());
      System.out.printf("Magnitude: %.3f\n", mention.getSentiment().getMagnitude());
      System.out.printf("Sentiment score : %.3f\n", mention.getSentiment().getScore());
      System.out.printf("Type: %s\n\n", mention.getType());
    }
  }
}

Node.js

// Imports the Google Cloud client library
const language = require('@google-cloud/language');

// Creates a client
const client = new language.LanguageServiceClient();

/**
 * TODO(developer): Uncomment the following line to run this code.
 */
// const text = 'Your text to analyze, e.g. Hello, world!';

// Prepares a document, representing the provided text
const document = {
  content: text,
  type: 'PLAIN_TEXT',
};

// Detects sentiment of entities in the document
const [result] = await client.analyzeEntitySentiment({document});
const entities = result.entities;

console.log('Entities and sentiments:');
entities.forEach(entity => {
  console.log(`  Name: ${entity.name}`);
  console.log(`  Type: ${entity.type}`);
  console.log(`  Score: ${entity.sentiment.score}`);
  console.log(`  Magnitude: ${entity.sentiment.magnitude}`);
});

Python

from google.cloud import language_v1


def sample_analyze_entity_sentiment(text_content):
    """
    Analyzing Entity Sentiment in a String

    Args:
      text_content The text content to analyze
    """

    client = language_v1.LanguageServiceClient()

    # text_content = 'Grapes are good. Bananas are bad.'

    # Available types: PLAIN_TEXT, HTML
    type_ = language_v1.types.Document.Type.PLAIN_TEXT

    # Optional. If not specified, the language is automatically detected.
    # For list of supported languages:
    # https://cloud.google.com/natural-language/docs/languages
    language = "en"
    document = {"content": text_content, "type_": type_, "language": language}

    # Available values: NONE, UTF8, UTF16, UTF32
    encoding_type = language_v1.EncodingType.UTF8

    response = client.analyze_entity_sentiment(
        request={"document": document, "encoding_type": encoding_type}
    )
    # Loop through entitites returned from the API
    for entity in response.entities:
        print(f"Representative name for the entity: {entity.name}")
        # Get entity type, e.g. PERSON, LOCATION, ADDRESS, NUMBER, et al
        print(f"Entity type: {language_v1.Entity.Type(entity.type_).name}")
        # Get the salience score associated with the entity in the [0, 1.0] range
        print(f"Salience score: {entity.salience}")
        # Get the aggregate sentiment expressed for this entity in the provided document.
        sentiment = entity.sentiment
        print(f"Entity sentiment score: {sentiment.score}")
        print(f"Entity sentiment magnitude: {sentiment.magnitude}")
        # Loop over the metadata associated with entity. For many known entities,
        # the metadata is a Wikipedia URL (wikipedia_url) and Knowledge Graph MID (mid).
        # Some entity types may have additional metadata, e.g. ADDRESS entities
        # may have metadata for the address street_name, postal_code, et al.
        for metadata_name, metadata_value in entity.metadata.items():
            print(f"{metadata_name} = {metadata_value}")

        # Loop over the mentions of this entity in the input document.
        # The API currently supports proper noun mentions.
        for mention in entity.mentions:
            print(f"Mention text: {mention.text.content}")
            # Get the mention type, e.g. PROPER for proper noun
            print(
                "Mention type: {}".format(
                    language_v1.EntityMention.Type(mention.type_).name
                )
            )

    # Get the language of the text, which will be the same as
    # the language specified in the request or, if not specified,
    # the automatically-detected language.
    print(f"Language of the text: {response.language}")

Langues supplémentaires

C# : Veuillez suivre les Instructions de configuration de C# sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur Natural Language pour .NET.

PHP : Veuillez suivre les Instructions de configuration pour PHP sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur Natural Language pour PHP.

Ruby : Veuillez suivre les instructions de configuration de Ruby sur la page des bibliothèques clientes, puis consultez la documentation de référence sur Natural Language pour Ruby.

Analyser les sentiments d'entités depuis Cloud Storage

Voici un exemple d'analyse des sentiments d'entités dans un fichier texte stocké sur Cloud Storage :