Rilevamento dell'intent con l'analisi del sentiment

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

L'analisi del sentiment esamina l'input utente e identifica l'opinione soggettiva prevalente, soprattutto per determinare l'atteggiamento di un utente come positivo, negativo o neutro. Quando effettui una richiesta di rilevamento del intent, puoi specificare che l'analisi del sentiment deve essere eseguita e la risposta conterrà valori di analisi del sentiment.

L'API Natural Language viene utilizzata da Dialogflow per eseguire questa analisi. Per scoprire di più su tale API e sulla documentazione sull'interpretazione dei risultati dell'analisi del sentiment di Dialogflow:

Lingue supportate

Per un elenco delle lingue supportate, consulta la colonna Opinione nella pagina delle lingue. Se richiedi l'analisi del sentiment per una lingua non supportata, la richiesta di rilevamento dell'intent non avrà esito negativo, ma il campo QueryResult.diagnostic_info contiene informazioni sull'errore.

Prima di iniziare

Questa funzionalità è applicabile solo quando si utilizza l'API per le interazioni degli utenti finali. Se utilizzi un'integrazione, puoi ignorare questa guida.

Prima di leggere questa guida:

  1. Leggi l'articolo Nozioni di base su Dialogflow.
  2. Esegui i passaggi di configurazione.

Crea un agente

Se non hai ancora creato un agente, creane uno ora:

  1. Vai alla console di Dialogflow ES.
  2. Se richiesto, accedi alla console di Dialogflow. Per ulteriori informazioni, consulta la panoramica della console di Dialogflow.
  3. Fai clic su Crea agente nel menu della barra laterale sinistra. Se hai già altri agenti, fai clic sul nome dell'agente, scorri fino in fondo e fai clic su Crea nuovo agente.
  4. Inserisci il nome dell'agente, la lingua predefinita e il fuso orario predefinito.
  5. Se hai già creato un progetto, inseriscilo. Se vuoi consentire alla console di Dialogflow di creare il progetto, seleziona Crea un nuovo progetto Google.
  6. Fai clic su pulsante Crea.

Importa il file di esempio nell'agente

I passaggi di questa guida fanno ipotesi sul tuo agente, quindi devi importare un agente preparato per questa guida. Durante l'importazione, questi passaggi utilizzano l'opzione restore, che sovrascrive tutte le impostazioni, gli intent e le entità dell'agente.

Per importare il file:

  1. Scarica il file room-booking-agent.zip.
  2. Vai alla console di Dialogflow ES.
  3. Seleziona l'agente.
  4. Fai clic sul pulsante delle impostazioni accanto al nome dell'agente.
  5. Seleziona la scheda Esporta e importa.
  6. Seleziona Ripristina da Zip e segui le istruzioni per ripristinare il file ZIP scaricato.

Impostazioni agente per l'analisi del sentiment

Puoi attivare l'analisi del sentiment per la richiesta di intent di rilevamento oppure configurare l'agente in modo che restituisca sempre i risultati dell'analisi del sentiment.

Per attivare l'analisi del sentiment per tutte le query:

  1. Vai alla console di Dialogflow ES.
  2. Seleziona un agente.
  3. Fai clic sul pulsante delle impostazioni accanto al nome dell'agente.
  4. Seleziona la scheda Avanzate.
  5. Attiva l'opzione Attiva analisi del sentiment per la query corrente.

Utilizzare il simulatore Dialogflow

Puoi interagire con l'agente e ricevere i risultati dell'analisi del sentiment tramite il simulatore di Dialogflow:

  1. Digita "Grazie per l'aiuto."

  2. Consulta la sezione SENTIMENT nella parte inferiore del simulatore. Dovrebbe mostrare un punteggio di sentiment positivo.

  3. Quindi, digita "Non ha funzionato affatto" nel simulatore.

  4. Consulta la sezione SENTIMENT nella parte inferiore del simulatore. Dovrebbe mostrare un punteggio di sentiment negativo.

Rileva intent

Per rilevare l'intent, chiama il metodo detectIntent nel tipo Sessions.

REST

Chiama il metodo detectIntent e fornisci il campo sentimentAnalysisRequestConfig.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: il tuo ID progetto GCP
  • SESSION_ID: un ID sessione

Metodo HTTP e URL:

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

Corpo JSON richiesta:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

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

Nota che il campo sentimentAnalysisResult contiene valori score e 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.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

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