Rilevamento dell'intent con l'output audio

Spesso le applicazioni hanno bisogno di un bot per comunicare con l'utente finale. Dialogflow può utilizzare Cloud Text-to-Speech fornito da WaveNet di DeepMind per generare risposte vocali dal tuo agente. La conversione dalle risposte testuali per intenzione ad audio è nota come output audio, sintesi vocale, sintesi vocale o TTS.

Questa guida fornisce un esempio che utilizza l'audio sia per l'input che per l'output quando rileva un intent. Questo caso d'uso è comune quando si sviluppano app che comunicano con gli utenti tramite un'interfaccia puramente audio.

Per un elenco delle lingue supportate, vedi la colonna TTS nella pagina Lingue.

Prima di iniziare

Questa funzionalità è applicabile solo se l'API viene utilizzata per le interazioni con gli utenti finali. Se utilizzi un integrazione, puoi saltare questa guida.

Prima di leggere questa guida, devi procedere nel seguente modo:

1. Leggi le 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 Dialogflow.
3. Fai clic su Create Agent (Crea agente) nel menu della barra laterale sinistra. Se hai già altri agenti, fai clic sul nome dell'agente, scorri verso il basso e fai clic su Crea nuovo agente.
4. Inserisci il nome, la lingua e il fuso orario predefiniti dell'agente.
5. Se hai già creato un progetto, inseriscilo. Se vuoi consentire alla console 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 descritti in questa guida fanno delle supposizioni sul tuo agente, quindi devi importare un agente preparato per questa guida. Durante l'importazione, questi passaggi utilizzano l'opzione ripristina, che sovrascrive tutte le impostazioni, gli intent e le entità dell'agente.

Per importare il file:

1. Scarica room-booking-agent.zip .
2. Vai alla console di Dialogflow ES.
3. Seleziona il tuo agente.
4. Fai clic sull' pulsante 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 che hai scaricato.

Rilevamento dell'intento

Per rilevare l'intento, chiama il metodo detectIntent nella Sessions di testo.

REST

1. Preparare i contenuti audio

Scarica il book-a-room.wav file input_audio di esempio, che dice "prenota una stanza". In questo esempio, il file audio deve essere codificato in base64, in modo che possa essere fornito nella richiesta JSON di seguito. Ecco un esempio di Linux:

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

Per esempi su altre piattaforme, consulta Incorporare audio codificato in base64 nella documentazione dell'API Cloud Speech.

2. Effettua una richiesta di rilevamento dell'intento

Chiama il metodo detectIntent sul tipo Sessions e specifica l'audio codificato in base64.

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

• PROJECT_ID: l'ID del tuo progetto Google Cloud
• SESSION_ID: un ID sessione
• BASE64_AUDIO: i contenuti base64 del file di output sopra indicato

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, espandi una di queste opzioni:

curl (Linux, macOS o Cloud Shell)

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud di Google. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

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)

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login di Google. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

$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

Dovresti ricevere una risposta JSON simile alla seguente:

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

Tieni presente che il valore del campo queryResult.action è room.reservation e il campo outputAudio contiene una lunga stringa audio base64.

3. Riproduci l'audio in uscita

Copia il testo dal campo outputAudio e salvalo in un file denominato output_audio.b64. Questo file deve essere convertito in audio. Ecco un esempio di Linux:

base64 -d output_audio.b64 > output_audio.wav

Per esempi su altre piattaforme, vedi Decodifica dei contenuti audio con codifica Base64 nella documentazione dell'API Text-to-Speech.

Ora puoi riprodurre il file audio output_audio.wav e ascolta che corrisponde al testo del campo queryResult.fulfillmentMessages[1].text.text[0] riportato sopra. Viene scelto il secondo elemento fulfillmentMessages, perché è la risposta di testo per la piattaforma predefinita.

Java

Per autenticarti a Dialogflow, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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.getFulfillmentMessagesCount() > 0
                ? queryResult.getFulfillmentMessages(0).getText()
                : "Triggered Default Fallback Intent");

        queryResults.put(text, queryResult);
      }
    }
    return queryResults;
  }
}

Node.js

Per autenticarti a Dialogflow, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Dialogflow, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

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

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

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

Per una descrizione dei campi di risposta pertinenti, consulta la sezione Rileva le risposte all'intent.

Rilevamento delle risposte di intent

La risposta a una richiesta di rilevamento di intent è di tipo DetectIntentResponse.

L'elaborazione normale dell'intent di rilevamento controlla i contenuti del campo DetectIntentResponse.queryResult.fulfillmentMessages.

Il campo DetectIntentResponse.outputAudio viene compilato con l'audio in base ai valori delle risposte di testo della piattaforma predefinita trovate nel campo DetectIntentResponse.queryResult.fulfillmentMessages. Se esistono più risposte di testo predefinite, queste verranno concatenate durante la generazione dell'audio. Se non esistono risposte di testo predefinite della piattaforma, i contenuti audio generati saranno vuoti.

Il campo DetectIntentResponse.outputAudioConfig viene compilato con le impostazioni audio utilizzate per generare l'audio in uscita.

Rilevamento dell'intento da uno stream

Quando rilevi l'intento di uno stream, invii richieste simili all'esempio che non utilizza l'audio di output: Rilevamento dell'intent da uno stream. Tuttavia, fornisci un campo OutputAudioConfig alla richiesta. I campi output_audio e output_audio_config vengono compilati nell'ultima risposta in streaming che ricevi dal server dell'API Dialogflow. Per ulteriori informazioni, vedi StreamingDetectIntentRequest e StreamingDetectIntentResponse.

Impostazioni dell'agente per il parlato

Puoi controllare diversi aspetti della sintesi vocale. Consulta le impostazioni vocali dell'agente.

Nota: le chiamate API che forniscono la configurazione audio in uscita superano tutte le impostazioni di sintesi vocale esistenti applicate all'agente.

Utilizzare il simulatore Dialogflow

Puoi interagire con l'agente e ricevere risposte audio tramite il Simulatore Dialogflow:

1. Segui i passaggi precedenti per attivare la sintesi vocale automatica.
2. Digita o di' "prenota una stanza" nel simulatore.
3. Vedi la sezione Output audio nella parte inferiore del simulatore.