Intent mit Audioausgabe erkennen

Anwendungen benötigen für die Kommunikation mit dem Nutzer oft einen Bot. Dialogflow kann mit Cloud Text-to-Speech von DeepMind WaveNet Sprachantworten für Ihren Agent generieren. Die Umwandlung von Intent-Textantworten in Audiodaten wird als Audioausgabe, Sprachsynthese, Sprachausgabe oder TTS bezeichnet.

In dieser Anleitung wird ein Beispiel aufgezeigt, bei dem im Rahmen der Intent-Erkennung Audiodaten für die Ein- und Ausgabe verwendet werden. Dieser Ansatz wird häufig bei der Entwicklung von Anwendungen genutzt, die über eine reine Audioschnittstelle mit Nutzern kommunizieren.

Eine Liste der unterstützten Sprachen finden Sie auf der Seite Languages (Sprachen) in der Spalte TTS (Sprachausgabe).

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.

Intent erkennen

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

REST UND BEFEHLSZEILE

1. Audioinhalte vorbereiten

Laden Sie die Audiodatei book-a-room.wav mit der Beispieleingabe herunter, die den Sprachbefehl "book a room" (Ein Zimmer buchen) enthält. Die Audiodatei muss für dieses Beispiel base64-codiert sein, damit sie in der folgenden JSON-Anfrage bereitgestellt werden kann. Hier ein Linux-Beispiel:

wget https://cloud.google.com/dialogflow/docs/data/book-a-room.wav
base64 -w 0 book-a-room.wav > book-a-room.b64

Beispiele für andere Plattformen finden Sie in der Dokumentation zur Cloud Speech API unter Base64-codierte Audiodaten einbetten.

2. Anfrage zur Intent-Erkennung erstellen

Rufen Sie die Methode detectIntent für den Typ Sessions auf und geben Sie base64-codierte Audiodaten an.

Ersetzen Sie diese Werte in den folgenden Anweisungen:

  • project-id: ID Ihres GCP-Projekts
  • base64-audio: Der base64-Inhalt aus der vorherigen Ausgabedatei

HTTP-Methode und URL:

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

JSON-Text anfordern:

{
  "queryInput": {
    "audioConfig": {
      "languageCode": "en-US"
    }
  },
  "outputAudioConfig" : {
    "audioEncoding": "OUTPUT_AUDIO_ENCODING_LINEAR_16"
  },
  "inputAudio": "base64-audio"
}

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

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "responseId": "b7405848-2a3a-4e26-b9c6-c4cf9c9a22ee",
  "queryResult": {
    "queryText": "book a room",
    "speechRecognitionConfidence": 0.8616504,
    "action": "room.reservation",
    "parameters": {
      "time": "",
      "date": "",
      "duration": "",
      "guests": "",
      "location": ""
    },
    "fulfillmentText": "I can help with that. Where would you like to reserve a room?",
    "fulfillmentMessages": [
      {
        "text": {
          "text": [
            "I can help with that. Where would you like to reserve a room?"
          ]
        }
      }
    ],
    "intent": {
      "name": "projects/project-id/agent/intents/e8f6a63e-73da-4a1a-8bfc-857183f71228",
      "displayName": "room.reservation"
    },
    "intentDetectionConfidence": 1,
    "diagnosticInfo": {},
    "languageCode": "en-us"
  },
  "outputAudio": "UklGRs6vAgBXQVZFZm10IBAAAAABAAEAwF0AAIC7AA..."
}

Das Feld queryResult.action hat den Wert room.reservation und das Feld outputAudio enthält einen langen base64-Audiostring.

3. Audioausgabe abspielen

Kopieren Sie den Text aus dem Feld outputAudio und speichern Sie ihn in einer Datei mit dem Namen output_audio.b64. Diese Datei muss in Audio konvertiert werden. Hier ein Linux-Beispiel:

base64 -d output_audio.b64 > output_audio.wav

Beispiele für andere Plattformen finden Sie in der Dokumentation zur Text-to-Speech API unter Base64-codierte Audioinhalte decodieren.

Wenn Sie jetzt die Audiodatei output_audio.wav wiedergeben, entspricht deren Inhalt dem Text aus dem Feld queryResult.fulfillmentMessages[1].text.text[0] oben. Das zweite fulfillmentMessages-Element wird ausgewählt, da es sich um die Textantwort für die Standardplattform handelt.

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.OutputAudioConfig;
import com.google.cloud.dialogflow.v2.OutputAudioEncoding;
import com.google.cloud.dialogflow.v2.QueryInput;
import com.google.cloud.dialogflow.v2.QueryResult;
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 DetectIntentWithTextToSpeechResponse {

  public static Map<String, QueryResult> detectIntentWithTexttoSpeech(
      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();

        //
        OutputAudioEncoding audioEncoding = OutputAudioEncoding.OUTPUT_AUDIO_ENCODING_LINEAR_16;
        int sampleRateHertz = 16000;
        OutputAudioConfig outputAudioConfig =
            OutputAudioConfig.newBuilder()
                .setAudioEncoding(audioEncoding)
                .setSampleRateHertz(sampleRateHertz)
                .build();

        DetectIntentRequest dr =
            DetectIntentRequest.newBuilder()
                .setQueryInput(queryInput)
                .setOutputAudioConfig(outputAudioConfig)
                .setSession(session.toString())
                .build();

        // Performs the detect intent request
        DetectIntentResponse response = sessionsClient.detectIntent(dr);

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

        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';
// const outputFile = `path for audio output file, e.g. ./resources/myOutput.wav`;

// Define session path
const sessionPath = sessionClient.projectAgentSessionPath(
  projectId,
  sessionId
);
const fs = require('fs');
const util = require('util');

async function detectIntentwithTTSResponse() {
  // The audio query request
  const request = {
    session: sessionPath,
    queryInput: {
      text: {
        text: query,
        languageCode: languageCode,
      },
    },
    outputAudioConfig: {
      audioEncoding: 'OUTPUT_AUDIO_ENCODING_LINEAR_16',
    },
  };
  sessionClient.detectIntent(request).then(responses => {
    console.log('Detected intent:');
    const audioFile = responses[0].outputAudio;
    util.promisify(fs.writeFile)(outputFile, audioFile, 'binary');
    console.log(`Audio content written to file: ${outputFile}`);
  });
}
detectIntentwithTTSResponse();

Python

def detect_intent_with_texttospeech_response(project_id, session_id, texts,
                                             language_code):
    """Returns the result of detect intent with texts as inputs and includes
    the response in an audio format.

    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)

        # Set the query parameters with sentiment analysis
        output_audio_config = dialogflow.types.OutputAudioConfig(
            audio_encoding=dialogflow.enums.OutputAudioEncoding
            .OUTPUT_AUDIO_ENCODING_LINEAR_16)

        response = session_client.detect_intent(
            session=session_path, query_input=query_input,
            output_audio_config=output_audio_config)

        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))
        # The response's audio_content is binary.
        with open('output.wav', 'wb') as out:
            out.write(response.output_audio)
            print('Audio content written to file "output.wav"')

Eine Beschreibung der relevanten Antwortfelder finden Sie im Abschnitt Intent-Antworten erkennen.

Intent-Antworten erkennen

Auf eine Anfrage zur Intent-Erkennung wird als Antwort ein Objekt des Typs DetectIntentResponse zurückgegeben.

Bei der normalen Verarbeitung von Intent-Erkennungen wird der Inhalt des Felds DetectIntentResponse.queryResult.fulfillmentMessages gesteuert.

Das Feld DetectIntentResponse.outputAudio wird mit Audiodaten gefüllt, die auf den Werten der im Feld DetectIntentResponse.queryResult.fulfillmentMessages festgelegten Textantworten der Standardplattform basieren. Mehrere Standardtextantworten werden bei der Audiogenerierung verkettet. Sind keine standardmäßigen Plattformtextantworten vorhanden, ist der generierte Audioinhalt leer.

Das Feld DetectIntentResponse.outputAudioConfig wird mit den Audioeinstellungen gefüllt, die zum Generieren der Audioausgabe verwendet werden.

Intent in Stream erkennen

Wenn Sie einen Intent in einem Stream erkennen, senden Sie Anfragen ähnlich dem Beispiel unter Intent in Stream erkennen, in dem keine Audioausgabe verwendet wird. Geben Sie aber für die Anfrage einen Wert im Feld OutputAudioConfig an. Die Felder output_audio und output_audio_config werden in der letzten Streamingantwort vom Dialogflow API-Server mit Werten versehen. Weitere Informationen finden Sie unter StreamingDetectIntentRequest und StreamingDetectIntentResponse.

Agent-Einstellungen für Sprache

Sie können verschiedene Aspekte der Sprachsynthese steuern. Weitere Informationen finden Sie unter Spracheinstellungen des Agents.

Dialogflow-Simulator verwenden

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

  1. Führen Sie die obigen Schritte aus, um die automatische Sprachausgabe zu aktivieren.
  2. Geben Sie in den Simulator "book a room" (Raum buchen) ein oder sagen Sie die Worte.
  3. Prüfen Sie im Bereich output audio (Audioausgabe) am unteren Rand des Simulators die Ergebnisse.