Detectar intent com saída de áudio

Muitas vezes, os aplicativos precisam de um bot para responder ao usuário final. O Dialogflow pode usar o Cloud Text-to-Speech com a tecnologia DeepMind WaveNet (em inglês) para gerar respostas de fala do seu agente. Essa conversão de respostas de texto de intent para áudio é conhecida como saída de áudio, síntese de fala, conversão de texto em voz ou TTS.

Neste guia, você verá um exemplo que usa áudio para entrada e saída ao detectar uma intent. Este caso de uso é comum ao desenvolver aplicativos que se comunicam com usuários por meio de uma interface exclusivamente de áudio.

Para uma lista de idiomas compatíveis, consulte a coluna TTS na página "Idiomas".

Antes de começar

Este recurso só é relevante quando se usa a API para interações do usuário final. Se você estiver usando uma integração, ignore este guia.

Faça o seguinte antes de ler este guia:

  1. Leia os Conceitos básicos do Dialogflow.
  2. Execute as etapas de configuração.

Criar um agente

Se você ainda não criou um agente, crie um agora:

  1. Acesse o Console do Dialogflow ES.
  2. Se solicitado, faça login no Console do Dialogflow. Para mais informações, consulte a Visão geral do Console do Dialogflow.
  3. Clique em Criar agente no menu da barra lateral à esquerda. Se você já tiver outros agentes, clique no nome do agente, role até a parte inferior da página e clique em Criar novo agente.
  4. Digite o nome do agente, o idioma padrão e o fuso horário padrão.
  5. Se você já tiver criado um projeto, insira-o. Se você quiser permitir que o Console do Dialogflow crie o projeto, selecione Criar um novo projeto do Google.
  6. Clique no botão Criar.

Importar o arquivo de exemplo para seu agente

As etapas deste guia fazem considerações sobre o agente. Portanto, você precisa importar um agente preparado para este guia. Ao importar, essas etapas usam a opção restaurar, que substitui todas as configurações, intents e entidades do agente.

Para importar o arquivo, siga estas etapas:

  1. Faça o download do arquivo room-booking-agent.zip.
  2. Acesse o Console do Dialogflow ES.
  3. Selecione seu agente.
  4. Clique no botão de configurações ao lado do nome do agente.
  5. Selecione a guia Exportar e importar.
  6. Selecione Restaurar do zip e siga as instruções para restaurar o arquivo zip que você baixou.

Detectar intent

Para detectar a intent, chame o método detectIntent no tipo Sessions.

REST e LINHA DE CMD

1. Preparar o conteúdo de áudio

Faça o download do arquivo de áudio de entrada de amostra book-a-room.wav, que diz "book a room". O arquivo de áudio precisa ser codificado em base64 para este exemplo. Assim, será possível fornecê-lo na solicitação JSON abaixo. Veja a seguir um exemplo do 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 exemplos em outras plataformas, consulte Como incorporar o áudio com codificação Base64 na documentação da API Cloud Speech.

2. Fazer a solicitação de detecção de intent

Chame o método detectIntent no tipo Sessions e especifique o áudio com codificação Base64.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • project-id: código do projeto do GCP
  • base64-audio: conteúdo em base64 do arquivo de saída acima

Método HTTP e URL:

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

Corpo JSON da solicitação:

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

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

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

Observe que o valor do campo queryResult.action é room.reservation, e o campo outputAudio contém uma grande string de áudio base64.

3. Reproduzir o áudio de saída

Copie o texto do campo outputAudio e salve-o em um arquivo chamado output_audio.b64. Esse arquivo precisa ser convertido em áudio. Veja a seguir um exemplo do Linux:

base64 -d output_audio.b64 > output_audio.wav

Para exemplos em outras plataformas, consulte Como decodificar conteúdo de áudio codificado em Base64 na documentação da API Text-to-speech.

Agora é possível reproduzir o arquivo de áudio output_audio.wav e saber se ele corresponde ao texto do campo queryResult.fulfillmentMessages[1].text.text[0] acima. O segundo elemento fulfillmentMessages é escolhido, porque é a resposta de texto para a plataforma padrão.

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

Consulte a seção Detectar respostas de intent para uma descrição dos campos de resposta relevantes.

Detectar respostas de intent

A resposta de uma solicitação de detecção de intent é um tipo DetectIntentResponse.

O processamento normal de detecção de intent controla o conteúdo do campo DetectIntentResponse.queryResult.fulfillmentMessages.

O campo DetectIntentResponse.outputAudio é preenchido com áudio de acordo com os valores das respostas de texto de plataforma padrão encontradas no campo DetectIntentResponse.queryResult.fulfillmentMessages. Se houver várias respostas de texto padrão, elas serão concatenadas ao gerar o áudio. Se não houver respostas de texto de plataforma padrão, o conteúdo do áudio gerado estará vazio.

O campo DetectIntentResponse.outputAudioConfig é preenchido com configurações de áudio usadas para gerar o áudio de saída.

Detectar intents de um stream

Ao detectar intents de um stream, você envia solicitações semelhantes ao exemplo que não usa áudio de saída: Como detectar intents de um stream. No entanto, você fornece um campo OutputAudioConfig para a solicitação. Os campos output_audio e output_audio_config são preenchidos na última resposta de streaming recebida do servidor da API Dialogflow. Para mais informações, consulte StreamingDetectIntentRequest e StreamingDetectIntentResponse.

Configurações de fala do agente

É possível controlar vários aspectos da síntese de fala. Veja as configurações de fala do agente.

Usar o simulador do Dialogflow

Você pode interagir com o agente e receber respostas de áudio por meio do simulador do Dialogflow:

  1. Siga as etapas acima para ativar a conversão automática de texto em voz.
  2. Digite ou diga "book a room" no simulador.
  3. Confira a seção de saída de áudio na parte inferior do simulador.