Detectar intent com análise de sentimento

A análise de sentimento inspeciona a entrada do usuário e identifica a opinião subjetiva predominante, principalmente para determinar a atitude de um usuário como positiva, negativa ou neutra. Ao fazer uma solicitação de detecção de intent, você pode especificar que a análise de sentimento seja executada e a resposta inclua os valores dessa análise.

O Dialogflow usa a API Natural Language para realizar essa análise. Acesse os tópicos abaixo para mais informações sobre essa API e para consultar a documentação sobre como interpretar os resultados da análise de sentimento do Dialogflow:

• Análise de sentimento
• Como interpretar valores da análise de sentimento

Observação: os casos em que a pontuação da análise de sentimento for 0, o campo retornado sentimentAnalysisResult estará vazio. Se preferir valores 0 explícitos na resposta, consulte o $outputDefaultsparâmetro do sistema.

Idiomas compatíveis

Para conferir a lista de idiomas compatíveis, consulte a coluna sentimento na página de idiomas. Se você solicitar uma análise de sentimento para um idioma que não seja compatível, sua solicitação de detecção de intent não falhará, mas o campo QueryResult.diagnostic_info conterá informações de erro.

Antes de começar

Este recurso só é relevante quando se usa a API para interações do usuário final. Se você estiver usando uma integração, ignore este guia.

Faça o seguinte antes de ler este guia:

1. Leia os Conceitos básicos do Dialogflow.
2. Execute as etapas de configuração.

Criar um agente

Se você ainda não criou um agente, crie um agora:

1. Acesse o console do Dialogflow ES.
2. Se solicitado, faça login no Console do Dialogflow. Para mais informações, consulte a Visão geral do Console do Dialogflow.
3. Clique em Criar agente no menu da barra lateral à esquerda. Se você já tiver outros agentes, clique no nome do agente, role até a parte inferior da página e clique em Criar novo agente.
4. Digite o nome do agente, o idioma padrão e o fuso horário padrão.
5. Se você já tiver criado um projeto, insira-o. Se você quiser permitir que o Console do Dialogflow crie o projeto, selecione Criar um novo projeto do Google.
6. Clique no botão Criar.

Importar o arquivo de exemplo para seu agente

As etapas deste guia fazem considerações sobre o agente. Portanto, você precisa importar um agente preparado para este guia. Ao importar, essas etapas usam a opção restaurar, que substitui todas as configurações, intents e entidades do agente.

Para importar o arquivo, siga estas etapas:

1. Faça o download do arquivo room-booking-agent.zip.
2. Acesse o console do Dialogflow ES.
3. Selecione seu agente.
4. Clique no botão de configurações ao lado do nome do agente.
5. Selecione a guia Exportar e importar.
6. Selecione Restaurar do zip e siga as instruções para restaurar o arquivo zip que você baixou.

Configurações do agente para análise de sentimento

É possível acionar a análise de sentimento por solicitação de detecção de intent ou configurar o agente para sempre retornar os resultados da análise.

Observação: mesmo que um agente esteja configurado para usar a análise de sentimento, as solicitações do Actions on Google não receberão os resultados dessa análise.

Para ativar a análise de sentimento em todas as consultas:

1. Acesse o console do Dialogflow ES.
2. Selecione um agente.
3. Clique no botão de configurações ao lado do nome do agente.
4. Selecione a guia Advanced.
5. Selecione a opção Ativar a análise de sentimento para a consulta atual.

Usar o simulador do Dialogflow

Você pode interagir com o agente e receber os resultados da análise de sentimento por meio do simulador do Dialogflow:

1. Digite "Obrigado por me ajudar".

2. Consulte a seção SENTIMENTO na parte inferior do simulador. Ele deve mostrar uma pontuação de sentimento positiva.

3. Em seguida, digite "Não funcionou". no simulador.

4. Consulte a seção SENTIMENTO na parte inferior do simulador. Ele deve mostrar uma pontuação de sentimento negativa.

Observação: quando um sentimento muito negativo é retornado, convém transferir usuários insatisfeitos para agentes ativos ou entender melhor quais intents levam ao sentimento mais positivo do cliente. Um exemplo de um implementação pode ser encontrado no GitHub

Detectar intent

Para detectar a intent, chame o método detectIntent no tipo Sessions.

REST

Chame o método detectIntent e verifique o campo sentimentAnalysisRequestConfig.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• PROJECT_ID: o ID do projeto do Google Cloud
• SESSION_ID: um código da sessão.

Método HTTP e URL:

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/agent/sessions/SESSION_ID:detectIntent

Corpo JSON da solicitação:

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

Para enviar a solicitação, expanda uma destas opções:

curl (Linux, macOS ou Cloud Shell)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: PROJECT_ID" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/agent/sessions/SESSION_ID:detectIntent"

PowerShell (Windows)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "PROJECT_ID" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/agent/sessions/SESSION_ID:detectIntent" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

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

Observe que o campo sentimentAnalysisResult contém os valores score e magnitude.

Java

Para autenticar no Dialogflow, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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.getFulfillmentMessagesCount() > 0
                ? queryResult.getFulfillmentMessages(0).getText()
                : "Triggered Default Fallback Intent");
        System.out.format(
            "Sentiment Score: '%s'\n",
            queryResult.getSentimentAnalysisResult().getQueryTextSentiment().getScore());

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

Node.js

Para autenticar no Dialogflow, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

// 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

Para autenticar no Dialogflow, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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
            )
        )