Détecter un intent avec l'analyse des sentiments

L'analyse des sentiments inspecte les entrées de l'utilisateur et identifie l'opinion subjective dominante, en particulier pour déterminer l'attitude d'un utilisateur comme étant positive, négative ou neutre. Lorsque vous effectuez une requête de détection d'intent, vous pouvez spécifier l'utilisation de l'analyse des sentiments. La réponse contiendra ainsi des valeurs d'analyse des sentiments.

L'API Natural Language est utilisée par Dialogflow pour effectuer cette analyse. Pour plus d'informations sur cette API et la documentation sur l'interprétation des résultats de l'analyse des sentiments Dialogflow, consultez les sections suivantes :

Langages acceptés

Pour obtenir la liste des langues acceptées, consultez la colonne Sentiment de la page Langues. Si vous effectuez une requête d'analyse des sentiments pour une langue non acceptée, votre requête de détection d'intent n'échoue pas, mais le champ QueryResult.diagnostic_info contient des informations d'erreur.

Avant de commencer

Cette fonctionnalité n'est disponible que lorsque l'API est utilisée pour les interactions de l'utilisateur final. Si vous utilisez une intégration, vous pouvez ignorer ce guide.

Avant de lire ce guide, procédez comme suit :

  1. Consultez la section Principes de base de Dialogflow.
  2. Effectuez la procédure de configuration.

Créer un agent

Si vous n'avez pas encore créé d'agent, créez-en un maintenant :

  1. Accédez à la console Dialogflow ES.
  2. Si nécessaire, connectez-vous à la console Dialogflow. Consultez la section Présentation de la console Dialogflow pour plus d'informations.
  3. Cliquez sur Créer un agent dans le menu de la barre latérale de gauche. (Si vous avez déjà d'autres agents, cliquez sur le nom de l'un d'eux, faites défiler vers le bas, puis cliquez sur Créer un agent.)
  4. Saisissez le nom de l'agent, la langue par défaut et le fuseau horaire par défaut.
  5. Si vous avez déjà créé un projet, saisissez son nom. Si vous souhaitez autoriser la console Dialogflow à créer le projet, sélectionnez Créer un projet Google.
  6. Cliquez sur le bouton Créer.

Importer le fichier d'exemple dans l'agent

Dans la mesure où les étapes de ce guide sont fondées sur certaines hypothèses concernant votre agent, vous devez importer un agent préparé pour ce guide. Lors de l'importation, ces étapes utilisent l'option de restauration qui écrase l'ensemble des paramètres, des intents et des entités de l'agent.

Pour importer le fichier, procédez comme suit :

  1. Téléchargez le fichier room-booking-agent.zip.
  2. Accédez à la console Dialogflow ES.
  3. Sélectionnez votre agent.
  4. Cliquez sur le bouton des paramètres à côté du nom de l'agent.
  5. Sélectionnez l'onglet Exporter et importer.
  6. Sélectionnez Restaurer depuis un fichier ZIP et suivez les instructions pour restaurer le fichier ZIP que vous avez téléchargé.

Paramètres de l'agent pour l'analyse des sentiments

Vous pouvez déclencher l'analyse des sentiments par requête de détection d'intent ou configurer votre agent pour qu'il renvoie toujours les résultats de l'analyse des sentiments.

Pour activer l'analyse des sentiments pour toutes les requêtes, procédez comme suit :

  1. Accédez à la console Dialogflow ES.
  2. Sélectionnez un agent.
  3. Cliquez sur le bouton des paramètres à côté du nom de l'agent.
  4. Cliquez sur l'onglet Avancé.
  5. Activez l'option Activer l'analyse des sentiments pour la requête actuelle.

Utiliser le simulateur Dialogflow

Vous pouvez interagir avec l'agent et recevoir des résultats d'analyse des sentiments via le simulateur Dialogflow :

  1. Saisissez "Merci de votre aide".

  2. Consultez la section SENTIMENT au bas du simulateur. Un score de sentiment positif doit s'afficher.

  3. Ensuite, saisissez "Cela n'a pas fonctionné" dans le simulateur.

  4. Consultez la section SENTIMENT au bas du simulateur. Un score de sentiment négatif doit s'afficher.

.

Détecter un intent

API REST et ligne de commande

Appelez la méthode detectIntent et renseignez le champ sentimentAnalysisRequestConfig.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • project-id : ID de votre projet GCP

Méthode HTTP et URL :

POST https://dialogflow.googleapis.com/v2/projects/project-id/agent/sessions/123456789:detectIntent

Corps JSON de la requête :

{
  "queryParams": {
    "sentimentAnalysisRequestConfig": {
      "analyzeQueryTextSentiment": true
    }
  },
  "queryInput": {
    "text": {
      "text": "please reserve an amazing meeting room for six people",
      "languageCode": "en-US"
    }
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "responseId": "747ee176-acc5-46be-8d9a-b7ef9c2b9199",
  "queryResult": {
    "queryText": "please reserve an amazing meeting room for six people",
    "action": "room.reservation",
    "parameters": {
      "date": "",
      "duration": "",
      "guests": 6,
      "location": "",
      "time": ""
    },
    "fulfillmentText": "I can help with that. Where would you like to reserve a room?",
    ...
    "sentimentAnalysisResult": {
      "queryTextSentiment": {
        "score": 0.8,
        "magnitude": 0.8
      }
    }
  }
}

Notez que le champ sentimentAnalysisResult contient les valeurs score et magnitude.

Java


import com.google.api.gax.rpc.ApiException;
import com.google.cloud.dialogflow.v2.DetectIntentRequest;
import com.google.cloud.dialogflow.v2.DetectIntentResponse;
import com.google.cloud.dialogflow.v2.QueryInput;
import com.google.cloud.dialogflow.v2.QueryParameters;
import com.google.cloud.dialogflow.v2.QueryResult;
import com.google.cloud.dialogflow.v2.SentimentAnalysisRequestConfig;
import com.google.cloud.dialogflow.v2.SessionName;
import com.google.cloud.dialogflow.v2.SessionsClient;
import com.google.cloud.dialogflow.v2.TextInput;
import com.google.common.collect.Maps;
import java.io.IOException;
import java.util.List;
import java.util.Map;

public class DetectIntentWithSentimentAnalysis {

  public static Map<String, QueryResult> detectIntentSentimentAnalysis(
      String projectId, List<String> texts, String sessionId, String languageCode)
      throws IOException, ApiException {
    Map<String, QueryResult> queryResults = Maps.newHashMap();
    // Instantiates a client
    try (SessionsClient sessionsClient = SessionsClient.create()) {
      // Set the session name using the sessionId (UUID) and projectID (my-project-id)
      SessionName session = SessionName.of(projectId, sessionId);
      System.out.println("Session Path: " + session.toString());

      // Detect intents for each text input
      for (String text : texts) {
        // Set the text (hello) and language code (en-US) for the query
        TextInput.Builder textInput =
            TextInput.newBuilder().setText(text).setLanguageCode(languageCode);

        // Build the query with the TextInput
        QueryInput queryInput = QueryInput.newBuilder().setText(textInput).build();

        //
        SentimentAnalysisRequestConfig sentimentAnalysisRequestConfig =
            SentimentAnalysisRequestConfig.newBuilder().setAnalyzeQueryTextSentiment(true).build();

        QueryParameters queryParameters =
            QueryParameters.newBuilder()
                .setSentimentAnalysisRequestConfig(sentimentAnalysisRequestConfig)
                .build();
        DetectIntentRequest detectIntentRequest =
            DetectIntentRequest.newBuilder()
                .setSession(session.toString())
                .setQueryInput(queryInput)
                .setQueryParams(queryParameters)
                .build();

        // Performs the detect intent request
        DetectIntentResponse response = sessionsClient.detectIntent(detectIntentRequest);

        // Display the query result
        QueryResult queryResult = response.getQueryResult();

        System.out.println("====================");
        System.out.format("Query Text: '%s'\n", queryResult.getQueryText());
        System.out.format(
            "Detected Intent: %s (confidence: %f)\n",
            queryResult.getIntent().getDisplayName(), queryResult.getIntentDetectionConfidence());
        System.out.format("Fulfillment Text: '%s'\n", queryResult.getFulfillmentText());
        System.out.format(
            "Sentiment Score: '%s'\n",
            queryResult.getSentimentAnalysisResult().getQueryTextSentiment().getScore());

        queryResults.put(text, queryResult);
      }
    }
    return queryResults;
  }
}

Node.js

// Imports the Dialogflow client library
const dialogflow = require('@google-cloud/dialogflow').v2;

// Instantiate a DialogFlow client.
const sessionClient = new dialogflow.SessionsClient();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'ID of GCP project associated with your Dialogflow agent';
// const sessionId = `user specific ID of session, e.g. 12345`;
// const query = `phrase(s) to pass to detect, e.g. I'd like to reserve a room for six people`;
// const languageCode = 'BCP-47 language code, e.g. en-US';

// Define session path
const sessionPath = sessionClient.projectAgentSessionPath(
  projectId,
  sessionId
);

async function detectIntentandSentiment() {
  // The text query request.
  const request = {
    session: sessionPath,
    queryInput: {
      text: {
        text: query,
        languageCode: languageCode,
      },
    },
    queryParams: {
      sentimentAnalysisRequestConfig: {
        analyzeQueryTextSentiment: true,
      },
    },
  };

  // Send request and log result
  const responses = await sessionClient.detectIntent(request);
  console.log('Detected intent');
  const result = responses[0].queryResult;
  console.log(`  Query: ${result.queryText}`);
  console.log(`  Response: ${result.fulfillmentText}`);
  if (result.intent) {
    console.log(`  Intent: ${result.intent.displayName}`);
  } else {
    console.log('  No intent matched.');
  }
  if (result.sentimentAnalysisResult) {
    console.log('Detected sentiment');
    console.log(
      `  Score: ${result.sentimentAnalysisResult.queryTextSentiment.score}`
    );
    console.log(
      `  Magnitude: ${result.sentimentAnalysisResult.queryTextSentiment.magnitude}`
    );
  } else {
    console.log('No sentiment Analysis Found');
  }

Python

def detect_intent_with_sentiment_analysis(project_id, session_id, texts,
                                          language_code):
    """Returns the result of detect intent with texts as inputs and analyzes the
    sentiment of the query text.

    Using the same `session_id` between requests allows continuation
    of the conversation."""
    from google.cloud import dialogflow
    session_client = dialogflow.SessionsClient()

    session_path = session_client.session_path(project_id, session_id)
    print('Session path: {}\n'.format(session_path))

    for text in texts:
        text_input = dialogflow.TextInput(
            text=text, language_code=language_code)

        query_input = dialogflow.QueryInput(text=text_input)

        # Enable sentiment analysis
        sentiment_config = dialogflow.SentimentAnalysisRequestConfig(
            analyze_query_text_sentiment=True)

        # Set the query parameters with sentiment analysis
        query_params = dialogflow.QueryParameters(
            sentiment_analysis_request_config=sentiment_config)

        response = session_client.detect_intent(
            request={'session': session_path, 'query_input': query_input, 'query_params': query_params})

        print('=' * 20)
        print('Query text: {}'.format(response.query_result.query_text))
        print('Detected intent: {} (confidence: {})\n'.format(
            response.query_result.intent.display_name,
            response.query_result.intent_detection_confidence))
        print('Fulfillment text: {}\n'.format(
            response.query_result.fulfillment_text))
        # Score between -1.0 (negative sentiment) and 1.0 (positive sentiment).
        print('Query Text Sentiment Score: {}\n'.format(
            response.query_result.sentiment_analysis_result
            .query_text_sentiment.score))
        print('Query Text Sentiment Magnitude: {}\n'.format(
            response.query_result.sentiment_analysis_result
            .query_text_sentiment.magnitude))