Intent mit Sentimentanalyse erkennen

Bei der Sentimentanalyse werden Nutzereingaben überprüft, um die vorherrschende subjektive Meinung zu ermitteln. Dadurch soll insbesondere festgestellt werden, ob Nutzer eine positive, negative oder neutrale Haltung haben. Sie können bei einer Anfrage zur Intent-Erkennung festlegen, dass eine Sentimentanalyse durchgeführt wird. Dann enthält die Antwort Sentimentanalysewerte.

In Dialogflow wird für diese Analyse die Natural Language API verwendet. Weitere Informationen zu dieser API und eine Dokumentation zur Interpretation der Ergebnisse der Dialogflow-Sentimentanalyse finden Sie unter:

Unterstützte Sprachen

Eine Liste der unterstützten Sprachen finden Sie in der Spalte Sentiment auf der Seite Sprachen. Wenn Sie eine Sentimentanalyse für eine nicht unterstützte Sprache anfordern, schlägt Ihre Anfrage zur Intent-Erkennung nicht fehl, das Feld QueryResult.diagnostic_info enthält jedoch Fehlerinformationen.

Vorbereitung

Dieses Feature ist nur verfügbar, wenn die API für Endnutzerinteraktionen verwendet wird. Wenn Sie eine Integration verwenden, können Sie diesen Leitfaden überspringen.

Bevor Sie diese Anleitung lesen, sollten Sie Folgendes tun:

  1. Die Grundlagen von Dialogflow lesen.
  2. Einrichtungsschritte ausführen

Agent erstellen

Wenn Sie noch keinen Agent erstellt haben, erstellen Sie jetzt einen:

  1. Öffnen Sie die Dialogflow-Konsole.
  2. Wenn Sie dazu aufgefordert werden, melden Sie sich in der Dialogflow-Konsole an. Weitere Informationen finden Sie unter Dialogflow-Konsole – Übersicht.
  3. Klicken Sie im linken Seitenleistenmenü auf Create agent (Agent erstellen). Wenn Sie bereits andere Agents haben, klicken Sie auf den Agent-Namen, scrollen Sie nach unten und klicken Sie dann auf Create new agent (Neuen Agent erstellen).
  4. Geben Sie den Namen des Agents, die Standardsprache und die Standardzeitzone ein.
  5. Wenn Sie bereits ein Projekt erstellt haben, geben Sie dieses Projekt ein. Wenn Sie zulassen möchten, dass die Dialogflow-Konsole das Projekt erstellt, wählen Sie Create a new Google project (Neues Google-Projekt erstellen) aus.
  6. Klicken Sie auf Create.

Beispieldatei in Agent importieren

Bei den Schritten in dieser Anleitung werden hinsichtlich des Agents Annahmen getroffen. Daher müssen Sie einen für diese Anleitung vorbereiteten Agent importieren. Beim Import wird für diese Schritte die Wiederherstellungsoption verwendet, die alle Agent-Einstellungen, Intents und Entitäten überschreibt.

So importieren Sie die Datei:

  1. Laden Sie die Datei room-booking-agent.zip herunter.
  2. Öffnen Sie die Dialogflow-Konsole.
  3. Wählen Sie den Agent aus.
  4. Klicken Sie neben dem Namen des Agents auf die Schaltfläche  für die Einstellungen.
  5. Wählen Sie den Tab Export and Import aus.
  6. Wählen Sie Restore From Zip aus und folgen Sie der Anleitung, um die Inhalte der heruntergeladenen ZIP-Datei wiederherzustellen.

Agent-Einstellungen für Sentimentanalyse

Sie können die Sentimentanalyse einzeln für jede Anfrage zur Intent-Erkennung auslösen oder den Agent so konfigurieren, dass immer Sentimentanalyseergebnisse zurückgegeben werden.

So aktivieren Sie die Sentimentanalyse für alle Abfragen:

  1. Öffnen Sie die Dialogflow-Konsole.
  2. Wählen Sie einen Agent aus.
  3. Klicken Sie neben dem Namen des Agents auf die Schaltfläche für die Einstellungen.
  4. Klicken Sie auf den Tab Advanced (Erweitert).
  5. Schalten Sie Sentimentanalyse für die aktuelle Abfrage aktivieren auf "Ein".

Dialogflow-Simulator verwenden

Sie können über den Dialogflow-Simulator mit dem Agent interagieren und Sentimentanalyseergebnisse erhalten:

  1. Geben Sie "Thank you for helping me" (Vielen Dank für Ihre Hilfe) ein.

  2. Sehen Sie sich unten im Simulator den Abschnitt SENTIMENT an. Er sollte einen positiven Sentimentwert anzeigen.

  3. Geben Sie in den Simulator als Nächstes Folgendes ein: "It didn't work at all" (Es hat überhaupt nicht funktioniert).

  4. Sehen Sie sich unten im Simulator den Abschnitt SENTIMENT an. Er sollte einen negativen Sentimentwert anzeigen.

.

Intent erkennen

REST UND BEFEHLSZEILE

Rufen Sie die Methode detectIntent auf und geben Sie das Feld sentimentAnalysisRequestConfig an.

Ersetzen Sie diese Werte in den folgenden Anweisungen:

  • project-id mit der ID Ihres GCP-Projekts

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten in etwa folgende JSON-Antwort erhalten:

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

Das Feld sentimentAnalysisResult enthält die Werte score und 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."""
    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))