Detectar intent con salida de audio

Las aplicaciones a menudo necesitan un bot para responder al usuario final. Las aplicaciones de Dialogflow a menudo necesitan un bot para responder al usuario final. Dialogflow te permite usar Cloud Text-to-Speech con tecnología de DeepMind WaveNet para generar respuestas de voz de tu agente. Esta conversión de respuestas de texto de intent a audio se llama salida de audio, síntesis de voz,

Puedes usar audio tanto para la entrada como para la salida cuando detectas un intent. Esto es común cuando se desarrollan apps que se comunican con los usuarios a través de una interfaz solo de audio.

Para obtener una lista de los idiomas compatibles, consulta la columna TTS en la página Idiomas.

Antes de comenzar

Esta función solo es aplicable cuando se usa la API para las interacciones del usuario final. Si usas una integración, puedes omitir esta guía.

Antes de comenzar, completa los siguientes pasos:

• Lee los conceptos básicos de Dialogflow.
• Realiza los pasos de configuración.

Crea un agente

1. Ve a la consola de Dialogflow ES.
2. Accede a la consola si se te solicita. Para obtener más información, consulta la descripción general de la consola de Dialogflow.
3. En el menú de la barra lateral, expande Loading agents.
4. Haz clic en Create new agent.
5. Ingresa el nombre del agente, el idioma predeterminado y la zona horaria predeterminada.
6. Ingresa un proyecto existente. Para permitir que la consola de Dialogflow cree un proyecto, selecciona Crear un proyecto de Google nuevo.
7. Haz clic en Crear.

Detecta intents

Para detectar un intent, llama al método detectIntent en el tipo Sessions.

REST

1. Prepara el contenido de audio

Descarga el archivo input_audio de muestra book-a-room.wav, que dice “book a room”. El archivo de audio debe estar codificado en Base64 para este ejemplo, por lo que se puede proporcionar en la solicitud JSON a continuación.

El siguiente es un ejemplo de 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

Para ver ejemplos en otras plataformas, consulta Cómo incorporar audio codificado en Base64 en la documentación de la API de Cloud Speech.

2. Realiza una solicitud de intent de detección

Llama al método detectIntent en el tipo Sessions y especifica el audio codificado en Base64.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

• PROJECT_ID: El ID del proyecto de Google Cloud.
• SESSION_ID: Es un ID de sesión.
• BASE64_AUDIO: Es el contenido en base64 del archivo de salida anterior.

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a gcloud CLI con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login , o a través del uso de Cloud Shell, que accede de forma automática a gcloud CLI . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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: El siguiente comando supone que accediste a gcloud CLI con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

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

Ten en cuenta que el valor del campo queryResult.action es room.reservation y que el campo outputAudio contiene una cadena de audio en base64 grande.

3. Reproduce el audio de salida

Copia el texto del campo outputAudio y guárdalo en un archivo llamado output_audio.b64. Este archivo necesita convertirse en audio.

El siguiente es un ejemplo de Linux:

base64 -d output_audio.b64 > output_audio.wav

Para ver ejemplos en otras plataformas, consulta Cómo decodificar contenido de audio codificado en Base64 en la documentación de la API de Text-to-Speech.

Ahora puedes reproducir el archivo de audio output_audio.wav y escuchar que coincide con el texto del campo queryResult.fulfillmentMessages[1].text.text[0] anterior. Se elige el segundo elemento fulfillmentMessages porque es la respuesta de texto de la plataforma predeterminada.

Java

Para autenticarte en Dialogflow CX, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Dialogflow CX, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Dialogflow CX, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para obtener más información sobre los campos de respuesta relevantes, consulta la sección Respuestas de detección de intent.

Respuestas de detección de intent

La respuesta para una solicitud de detección de intent es un tipo DetectIntentResponse.

El procesamiento de la detección del intent normal controla el contenido del campo DetectIntentResponse.queryResult.fulfillmentMessages.

El campo DetectIntentResponse.outputAudio se completa con el audio en función de los valores de las respuestas de texto de la plataforma predeterminada que se encuentran en el campo DetectIntentResponse.queryResult.fulfillmentMessages:

• Si existen múltiples respuestas de texto predeterminadas, se concatenarán cuando se genere el audio.
• Si no existen respuestas de texto de la plataforma predeterminada, el contenido de audio generado estará vacío.

El campo DetectIntentResponse.outputAudioConfig se propaga con la configuración de audio usada para generar el audio de salida.

Detecta intents en una transmisión

Cuando se detecta un intent de una transmisión, envías solicitudes similares al ejemplo que no usa audio de salida: Detecta intents en una transmisión de audio. Sin embargo, debes proporcionar un campo OutputAudioConfig a la solicitud. Los campos output_audio y output_audio_config se propagan en la respuesta de transmisión final que obtienes del servidor de la API de Dialogflow. Para obtener más información, consulta StreamingDetectIntentRequest y StreamingDetectIntentResponse.

Configuración del agente para voz

Puedes controlar varios aspectos de la síntesis de voz. Consulta la configuración de agentes.

Nota: Las llamadas a la API que proporcionan configuración de audio de salida anulan todos los parámetros de configuración de texto a voz existentes que se aplican al agente.

Usa el simulador de Dialogflow

Puedes interactuar con el agente y recibir respuestas de audio a través del simulador de Dialogflow:

1. Sigue las instrucciones en Configuración de voz del agente para habilitar el texto a voz automático.
2. Escribe o di "reservar una habitación" ("book a room") en el simulador.
3. Consulta la sección audio de salida en el simulador.