Detectar intent con salida de audio

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

Puedes usar audio para la entrada y 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 puramente de audio.

Para obtener una lista de los idiomas admitidos, 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 pasos que se indican a continuación:

• 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 Cargando agentes.
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 la intención, 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, de modo que se pueda proporcionar en la solicitud JSON que se muestra 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 Incorpora 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..."
}

Observa que el valor del campo queryResult.action es room.reservation y el campo outputAudio contiene una cadena de audio 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 para 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 pertinentes, consulta la sección Respuestas de intents de detección.

Respuestas de detección de intent

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

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

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

• Si existen varias respuestas de texto predeterminadas, se concatenan cuando se genera el audio.
• Si no existen respuestas de texto de la plataforma predeterminada, el contenido de audio generado está 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 detectas un intent a partir de una transmisión, envías solicitudes similares al ejemplo que no usa audio de salida: Detecta un intent a partir de una transmisión. Sin embargo, debes proporcionar un campo OutputAudioConfig a la solicitud. Los campos output_audio y output_audio_config se completan 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 voz del agente.

Nota: Las llamadas a la API que proporcionan una 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 con el simulador de Dialogflow:

1. Para habilitar la función de texto a voz automática, sigue las instrucciones que se indican en Configuración de voz del agente.
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.