Detete a intenção com saída de áudio

As aplicações precisam frequentemente de um bot para responder ao utilizador final. O Dialogflow pode usar o Cloud Text-to-Speech com tecnologia DeepMind WaveNet para gerar respostas de voz do seu agente. Esta conversão de respostas de texto de intenção em áudio é conhecida como saída de áudio, síntese de voz, conversão de texto em voz ou TTS.

Este guia fornece um exemplo que usa áudio para entrada e saída ao detetar uma intenção. Este exemplo de utilização é comum quando desenvolve apps que comunicam com os utilizadores através de uma interface puramente de áudio.

Para ver uma lista de idiomas suportados, consulte a coluna TTS na página Idiomas.

Antes de começar

Esta funcionalidade só se aplica quando usa a API para interações do utilizador final. Se estiver a usar uma integração, pode ignorar este guia.

Antes de ler este guia, deve fazer o seguinte:

1. Leia as noções básicas do Dialogflow.
2. Realize os passos de configuração.

Crie um agente

Se ainda não tiver criado um agente, crie um agora:

1. Aceda à consola do Dialogflow ES.
2. Se lhe for pedido, inicie sessão na consola do Dialogflow. Consulte a vista geral da consola do Dialogflow para mais informações.
3. Clique em Criar agente no menu da barra lateral esquerda. (Se já tiver outros agentes, clique no nome do agente, desloque a página para baixo e clique em Criar novo agente.)
4. Introduza o nome do agente, o idioma predefinido e o fuso horário predefinido.
5. Se já tiver criado um projeto, introduza esse projeto. Se quiser permitir que a consola do Dialogflow crie o projeto, selecione Criar um novo projeto Google.
6. Clique no botão Criar.

Importe o ficheiro de exemplo para o seu agente

Os passos neste guia baseiam-se em pressupostos sobre o seu agente. Por isso, tem de importar um agente preparado para este guia. Quando importa, estes passos usam a opção restaurar, que substitui todas as definições, intenções e entidades do agente.

Para importar o ficheiro, siga estes passos:

1. Transfira o ficheiro room-booking-agent.zip.
2. Aceda à consola do Dialogflow ES.
3. Selecione o seu agente.
4. Clique no botão Definições junto ao nome do agente.
5. Selecione o separador Exportar e importar.
6. Selecione Restaurar do ZIP e siga as instruções para restaurar o ficheiro ZIP que transferiu.

Detetar intenção

Para detetar a intenção, chame o método detectIntent no tipo Sessions.

REST

1. Prepare conteúdo de áudio

Transfira o ficheiro de áudio de entrada de exemplo book-a-room.wav que diz "reservar um quarto". O ficheiro de áudio tem de estar codificado em base64 para este exemplo, para que possa ser fornecido no pedido JSON abaixo. Segue-se 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 ver exemplos noutras plataformas, consulte o artigo Incorporar áudio codificado em Base64 na documentação da API Cloud Speech.

2. Faça um pedido de deteção de intenção

Chame o método detectIntent no tipo Sessions e especifique o áudio codificado em base64.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

• PROJECT_ID: o ID do seu projeto do Google Cloud
• SESSION_ID: um ID da sessão
• BASE64_AUDIO: o conteúdo base64 do ficheiro de saída acima

Método HTTP e URL:

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

Corpo JSON do pedido:

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

Para enviar o seu pedido, expanda uma destas opções:

curl (Linux, macOS ou Cloud Shell)

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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

Deve receber uma resposta JSON semelhante à seguinte:

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

Tenha em atenção que o valor do campo queryResult.action é room.reservation e o campo outputAudio contém uma string de áudio base64 grande.

3. Reproduzir áudio de saída

Copie o texto do campo outputAudio e guarde-o num ficheiro com o nome output_audio.b64. Este ficheiro tem de ser convertido em áudio. Segue-se um exemplo do Linux:

base64 -d output_audio.b64 > output_audio.wav

Para ver exemplos noutras plataformas, consulte o artigo Descodificar conteúdo de áudio codificado em Base64 na documentação da API Text-to-Speech.

Agora, pode reproduzir o ficheiro de áudio output_audio.wav e ouvir que 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 predefinida.

Java

Para se autenticar no Dialogflow, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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 se autenticar no Dialogflow, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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 se autenticar no Dialogflow, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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"')

Consulte a secção Respostas de deteção de intenção para ver uma descrição dos campos de resposta relevantes.

Detete respostas de intenção

A resposta a um pedido de deteção de intenção é do tipo DetectIntentResponse.

O processamento normal de intenções de deteção controla o conteúdo do campo DetectIntentResponse.queryResult.fulfillmentMessages.

O campo DetectIntentResponse.outputAudio é preenchido com áudio com base nos valores das respostas de texto da plataforma predefinida encontradas no campo DetectIntentResponse.queryResult.fulfillmentMessages. Se existirem várias respostas de texto predefinidas, estas são concatenadas quando o áudio é gerado. Se não existirem respostas de texto da plataforma predefinidas, o conteúdo de áudio gerado estará vazio.

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

Detetar a intenção a partir de uma stream

Quando deteta a intenção de uma stream, envia pedidos semelhantes ao exemplo que não usa áudio de saída: Detetar a intenção de uma stream. No entanto, fornece um campo OutputAudioConfig ao pedido. Os campos output_audio e output_audio_config são preenchidos na última resposta de streaming que recebe do servidor da API Dialogflow. Para mais informações, consulte os artigos StreamingDetectIntentRequest e StreamingDetectIntentResponse.

Definições do agente para a voz

Pode controlar vários aspetos da síntese de voz. Consulte as definições de voz do agente.

Nota: as chamadas da API que fornecem uma configuração de áudio de saída substituem todas as definições de conversão de texto em voz existentes aplicadas ao agente.

Use o simulador do Dialogflow

Pode interagir com o agente e receber respostas de áudio através do simulador do Dialogflow:

1. Siga os passos acima para ativar a conversão automática de texto em voz.
2. Escreva ou diga "reservar um quarto" no simulador.
3. Consulte a secção Áudio de saída na parte inferior do simulador.