Intent mit Sentimentanalyse erkennen

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

In Dialogflow wird für diese Analyse die Natural Language API verwendet. Weitere Informationen zur 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 $outputDefaults Systemparameter an.

Unterstützte Sprachen

Eine Liste der unterstützten Sprachen finden Sie in der Spalte Sentiment auf der Sprachen Seite. 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, können Sie diesen Leitfaden überspringen.

Führen Sie zuerst die folgenden Schritte aus:

• Grundlagen von Dialogflow lesen.
• Einrichtungsschritte ausführen

Agent erstellen

1. Rufen Sie die Dialogflow ES-Konsole auf.
2. Melden Sie sich bei der Console an, wenn Sie dazu aufgefordert werden. Weitere Informationen finden Sie unter dem Dialogflow-Konsolenüberblick.
3. Maximieren Sie in der Seitenleiste Agenten laden.
4. Klicken Sie auf Neuen Agenten erstellen.
5. Geben Sie den Namen des Agents, die Standardsprache und die Standardzeitzone ein.
6. Geben Sie ein vorhandenes Projekt ein. Wenn die Dialogflow-Konsole ein Projekt erstellen soll, wählen Sie Neues Google-Projekt erstellen aus.
7. Klicken Sie auf Erstellen.

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. Wählen Sie neben dem Namen des Agents das Symbol für die Einstellungen aus.
4. Klicken Sie auf den Tab Erweitert.
5. Aktivieren Sie Sentimentanalyse für die aktuelle Abfrage aktivieren.

Dialogflow-Simulator verwenden

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

1. Geben Sie „Vielen Dank für Ihre Hilfe“ ein.
2. Sehen Sie sich unten im Simulator den Abschnitt SENTIMENT an. Er zeigt einen positiven Sentimentwert.
3. Geben Sie im Simulator „Es hat überhaupt nicht funktioniert“ ein.
4. Sehen Sie sich unten im Simulator den Abschnitt SENTIMENT an. Er zeigt einen negativen Sentimentwert.

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 schlechtesten Kundenstimmung führen. Ein Beispiel für eine Handoff-Implementierung finden Sie auf GitHub.

Intent erkennen

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

REST

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

Ersetzen Sie folgende Werte in den 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 der Anfrage:

{
  "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 in der gcloud-Befehlszeile angemeldet haben, indem Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt haben, die Sie automatisch in 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 in der gcloud-Befehlszeile angemeldet haben, indem Sie gcloud init oder gcloud auth login ausgeführt haben. 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 eine JSON-Antwort ähnlich wie diese 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 die Standardanmeldedaten für Anwendungen ein, um sich bei Dialogflow CX zu authentifizieren. 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 die Standardanmeldedaten für Anwendungen ein, um sich bei Dialogflow CX zu authentifizieren. 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 die Standardanmeldedaten für Anwendungen ein, um sich bei Dialogflow CX zu authentifizieren. 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
            )
        )