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:

• Sentimentanalyse
• Werte der Sentimentanalyse interpretieren

Hinweis: Wenn die Sentimentanalyse eine Punktzahl von 0 ergibt, ist das zurückgegebene Feld sentimentAnalysisResult leer. Falls Sie explizite Nullwerte in der Antwort bevorzugen, sehen Sie sich den Systemparameter $outputDefaults an.

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.

Hinweis

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 mit Folgendem vertraut sein:

1. Grundlagen von Dialogflow
2. Einrichtungsschritte ausführen

Agent erstellen

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

1. Rufen Sie die Dialogflow ES-Konsole auf.
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. Rufen Sie die Dialogflow ES-Konsole auf.
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.

Hinweis: Bei Actions on Google-Anfragen werden keine Ergebnisse der Sentimentanalyse zurückgegeben, auch wenn Sie einen Agent für die Verwendung der Sentimentanalyse konfigurieren.

So aktivieren Sie die Sentimentanalyse für alle Abfragen:

1. Rufen Sie die Dialogflow ES-Konsole auf.
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.

Hinweis: Wenn ein sehr negativer Sentimentwert zurückgegeben wird, können Sie unzufriedene Nutzer an Mitarbeiter des Kundenservice weiterleiten oder den Wert nutzen, um besser zu verstehen, welche Intents zur besten Kundenstimmung führen. Ein Beispiel für eine Handoff-Implementierung finden Sie auf GitHub

.

Intent erkennen

Rufen Sie zur Intent-Erkennung die Methode detectIntent für den Typ Sessions auf.

REST

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

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

• PROJECT_ID: Ihre Google Cloud-Projekt-ID
• SESSION_ID: eine Sitzungs-ID

HTTP-Methode und URL:

POST https://dialogflow.googleapis.com/v2/projects/PROJECT_ID/agent/sessions/SESSION_ID: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:

curl (Linux, macOS oder Cloud Shell)

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud-Befehlszeile angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch bei der gcloud-Befehlszeile anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

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)

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud-Befehlszeile angemeldet haben. Dazu führen Sie gcloud init oder gcloud auth login aus. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

$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

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

Richten Sie zur Authentifizierung bei Dialogflow die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Richten Sie zur Authentifizierung bei Dialogflow die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Richten Sie zur Authentifizierung bei Dialogflow die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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