Detecta intents con análisis de opiniones

El análisis de opiniones inspecciona las entradas de los usuarios para identificar su parecer subjetivo predominante; especialmente, para clasificar la actitud de un usuario como positiva, negativa o neutral. Cuando se realiza una solicitud de detección de intent, puedes especificar que se realice un análisis de opiniones, en cuyo caso la respuesta incluirá valores del análisis de opiniones.

Dialogflow usa la API de Natural Language para realizar este análisis. Si deseas obtener más información sobre esa API y documentación sobre cómo interpretar los resultados del análisis de opiniones de Dialogflow, consulta los siguientes recursos:

Idiomas admitidos

Para obtener una lista de los idiomas admitidos, consulta la columna Opiniones en la página de idiomas. Si solicitas un análisis de opiniones para un idioma que no es compatible, la solicitud de detección de intent en sí no fallará, pero el campo QueryResult.diagnostic_info contendrá información de error.

Antes de comenzar

Esta función solo se aplica cuando se usa la API para las interacciones del usuario final. Si usas una integración, puedes omitir esta guía.

Debes hacer lo siguiente antes de leer esta guía:

  1. Lee los conceptos básicos de Dialogflow.
  2. Realiza los pasos de configuración.

Crea un agente

En los pasos que se brindan esta guía, damos por sentado determinadas características de tu agente. Por eso, es recomendable que comiences con un agente nuevo. Debes borrar cualquier agente existente en tu proyecto antes de crear uno nuevo. Para borrar un agente existente, haz lo siguiente:

  1. Ve a la Consola de Dialogflow.
  2. Si se te solicita, accede a la consola de Dialogflow. Consulta Descripción general de la consola de Dialogflow para obtener más información.
  3. Selecciona el agente que deseas borrar.
  4. Haz clic en el botón de configuración settings ubicado junto al nombre del agente.
  5. Desplázate hasta la parte inferior de la pestaña de configuración General.
  6. Haz clic en Borrar este agente.
  7. Ingresa BORRAR en el campo de texto.
  8. Haz clic en Borrar.

Para crear un agente, haz lo siguiente:

  1. Ve a la Consola de Dialogflow.
  2. Si se te solicita, accede a la consola de Dialogflow. Consulta Descripción general de la consola de Dialogflow para obtener más información.
  3. Haz clic en Crear agente en el menú de la barra lateral izquierda. Si ya tienes otros agentes, haz clic en el nombre del agente, desplázate hasta la parte inferior y haz clic en Crear agente nuevo.
  4. Ingresa el nombre del agente, y el idioma y la zona horaria predeterminados.
  5. Si ya creaste un proyecto, ingrésalo. Si deseas permitir que la consola de Dialogflow cree el proyecto, selecciona Crear un proyecto de Google nuevo.
  6. Haz clic en el botón Crear.

Importa el archivo de ejemplo al agente

La importación agregará intents y entidades al agente. Si hay intents o entidades con el mismo nombre que los del archivo importado, se reemplazarán los primeros por los segundos.

Para importar el archivo, sigue estos pasos:

  1. Descarga el archivo RoomReservation.zip.
  2. Ve a la Consola de Dialogflow.
  3. Selecciona el agente.
  4. Haz clic en el botón de configuración settings ubicado junto al nombre del agente.
  5. Selecciona la pestaña Importar y exportar.
  6. Selecciona Importar desde ZIP y, luego, importa el archivo ZIP que descargaste.

Configuración del agente para el análisis de opiniones

Puedes activar el análisis de opiniones en solicitudes de detección de intent individuales o configurar tu agente para que siempre muestre resultados de análisis de opiniones.

Si quieres habilitar el análisis de opiniones para todas las consultas, haz lo siguiente:

  1. Ve a la consola de Dialogflow.
  2. Selecciona un agente.
  3. Haz clic en el botón de configuración settings junto al nombre del agente.
  4. Selecciona la pestaña Avanzada.
  5. Activa Habilitar análisis de opiniones para la consulta actual.

Usa el simulador de Dialogflow

Puedes interactuar con el agente y recibir los resultados del análisis de opiniones a través del simulador de Dialogflow:

  1. Escribe “please reserve an amazing meeting room for six people” ("por favor, reserva una sala de reuniones increíble para seis personas") en el simulador.

  2. Consulta la sección OPINIONES en la parte inferior del simulador.

Detecta intents

REST Y LÍNEA DE COMANDOS

Realiza una llamada al método detectIntent y proporciona el campo sentimentAnalysisRequestConfig.

Antes de usar cualquiera de los datos de solicitud que se muestran a continuación, realiza los siguientes reemplazos:

  • project-id: el ID de tu proyecto de GCP

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

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

Ten en cuenta que el campo sentimentAnalysisResult contiene valores score y magnitude.

Java


    /**
     * Returns the result of detect intent with texts as inputs.
     *
     * <p>Using the same `session_id` between requests allows continuation of the conversation.
     *
     * @param projectId    Project/Agent Id.
     * @param texts        The text intents to be detected based on what a user says.
     * @param sessionId    Identifier of the DetectIntent session.
     * @param languageCode Language code of the query.
     * @return The QueryResult for each text in query.
     */
    public static Map<String, QueryResult>  detectIntentSentimentAnalysis(
        String projectId,
        List<String> texts,
        String sessionId,
        String languageCode) throws Exception {
      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
          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('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.sessionPath(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."""
        import dialogflow_v2 as 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.types.TextInput(
                text=text, language_code=language_code)

            query_input = dialogflow.types.QueryInput(text=text_input)

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

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

            response = session_client.detect_intent(
                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))