Rilevamento dell'intent con l'output audio

Le applicazioni spesso hanno bisogno di un bot per rispondere all'utente finale. Dialogflow Le applicazioni spesso hanno bisogno di un bot che risponda all'utente finale. Dialogflow ti consente di utilizzare Cloud Text-to-Speech basato su DeepMind WaveNet per generare risposte vocali dal tuo agente. Questa conversione dalle risposte di testo dell'intent all'audio è chiamata uscita audio, sintesi vocale,

Puoi utilizzare l'audio sia per l'input che per l'output quando rilevi un intent. Questo è comune quando si sviluppano app che comunicano con gli utenti utilizzando un'interfaccia puramente audio.

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

Prima di iniziare

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

Prima di iniziare, completa i seguenti passaggi:

Crea un agente

  1. Vai alla console Dialogflow ES.
  2. Se richiesto, accedi alla console. Per saperne di più, consulta la panoramica della console di Dialogflow.
  3. Nel menu della barra laterale, espandi Agenti di caricamento.
  4. Fai clic su Crea nuovo agente.
  5. Inserisci il nome dell'agente, la lingua predefinita e il fuso orario predefinito.
  6. Inserisci un progetto esistente. Per consentire alla console Dialogflow di creare un progetto, seleziona Crea un nuovo progetto Google.
  7. Fai clic su Crea.

Rilevare l'intenzione

Per rilevare l'intent, chiama il metodo detectIntent sul tipo Sessions.

REST

1. Preparare i contenuti audio

Scarica il file book-a-room.wav di esempio input_audio, che dice "prenota una stanza". Per questo esempio, il file audio deve essere codificato in base64, in modo da poter essere fornito nella richiesta JSON riportata di seguito.

Ecco un esempio per 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, vedi Incorporamento dell'audio codificato in base64 nella documentazione dell'API Cloud Speech.

2. Invia una richiesta di rilevamento dell'intenzione

Chiama il metodo detectIntent sul tipo Sessions e specifica l'audio con codifica base64.

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

  • PROJECT_ID: l'ID del tuo progetto Google Cloud
  • SESSION_ID: un ID sessione
  • BASE64_AUDIO: il contenuto base64 del file di output riportato sopra

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:

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

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

3. Riproduci audio di output

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 per Linux:

base64 -d output_audio.b64 > output_audio.wav

Per esempi su altre piattaforme, consulta Decodifica del contenuto audio codificato in base64 nella documentazione dell'API Text-to-Speech.

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

Java

Per eseguire l'autenticazione in Dialogflow CX, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Dialogflow CX, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 CX, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 saperne di più sui campi di risposta pertinenti, consulta la sezione Risposte di rilevamento dell'intent.

Rilevare le risposte di intent

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

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

Il campo DetectIntentResponse.outputAudio viene compilato con l'audio in base ai valori delle risposte text della piattaforma default trovate nel campo DetectIntentResponse.queryResult.fulfillmentMessages:

  • Se esistono più risposte di testo predefinite, queste vengono concatenate durante la generazione dell'audio.
  • Se non esistono risposte di testo predefinite della piattaforma, il contenuto audio generato è vuoto.

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

Rilevare l'intent da uno stream

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

Impostazioni dell'agente per la sintesi vocale

Puoi controllare vari aspetti della sintesi vocale. Consulta le impostazioni di sintesi vocale dell'agente.

Utilizzare il simulatore di Dialogflow

Puoi interagire con l'agente e ricevere risposte audio utilizzando il simulatore Dialogflow:

  1. Attiva la sintesi vocale automatica seguendo le istruzioni riportate in Impostazioni della voce dell'agente.
  2. Digita o di' "prenota una stanza" nel simulatore.
  3. Visualizza la sezione Audio di output nel simulatore.
Indietro
Rilevamento dell'intent con il flusso di input audio
Avanti
Rilevamento dell'intent con l'analisi del sentiment