Detectar intent com saída de áudio

Muitas vezes, os aplicativos precisam de um bot para responder ao usuário final. Dialogflow Os aplicativos geralmente precisam de um bot para responder ao usuário final. O Dialogflow permite que você use o Cloud Text-to-Speech, com tecnologia DeepMind WaveNet, para gerar respostas de fala do seu agente. Essa conversão de respostas de texto de intent em áudio é chamada de saída de áudio, síntese de fala,

É possível usar áudio para entrada e saída ao detectar uma intent. Isso é comum ao desenvolver apps que se comunicam com os usuários usando uma interface puramente 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.

Antes de começar, conclua as etapas a seguir:

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

Criar um agente

1. Acesse o console do Dialogflow ES.
2. Faça login no console se solicitado. Para mais informações, consulte a visão geral do console do Dialogflow.
3. No menu da barra lateral, abra Agentes de carregamento.
4. Clique em Criar novo agente.
5. Insira o nome do agente, o idioma padrão e o fuso horário padrão.
6. Insira um projeto atual. Para permitir que o console do Dialogflow crie um projeto, selecione Criar um novo projeto do Google.
7. Clique em Criar.

Detectar intent

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

REST

1. Preparar o conteúdo de áudio

Faça o download do arquivo de amostra input_audio book-a-room.wav, que diz "book a room". O arquivo de áudio precisa ser codificado em base64 para este exemplo, para que possa ser fornecido 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 ver exemplos em outras plataformas, consulte Como incorporar áudio codificado em 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 codificado em Base64.

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

• PROJECT_ID: o ID do projeto do Google Cloud
• SESSION_ID: um código da sessão.
• 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/SESSION_ID: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:

curl (Linux, macOS ou Cloud Shell)

Observação: o comando a seguir pressupõe que você tenha feito login na CLI do gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

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)

Observação: o comando a seguir pressupõe que você tenha feito login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando abaixo:

$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

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

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

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 você pode reproduzir o arquivo de áudio output_audio.wav e ouvir que 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

Para autenticar na Dialogflow CX, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 autenticar na Dialogflow CX, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 autenticar na Dialogflow CX, configure o Application Default Credentials. Para mais informações, consulte Configurar 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"')

Para mais informações sobre os campos de resposta relevantes, consulte a seção Detectar respostas de intent.

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 com base nos valores das respostas de texto da plataforma padrão encontradas no campo DetectIntentResponse.queryResult.fulfillmentMessages:

• Se houver várias respostas de texto padrão, elas serão concatenadas ao gerar áudio.
• Se não houver respostas de texto padrão da plataforma, o conteúdo de áudio gerado ficará 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 intent de um stream, você envia solicitações semelhantes ao exemplo que não usa áudio de saída: Como detectar intent 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 resposta final de streaming que você recebe 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. Consulte as configurações de fala do agente.

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

Usar o simulador do Dialogflow

É possível interagir com o agente e receber respostas em áudio usando o simulador do Dialogflow:

1. Ative a conversão automática de texto em voz seguindo as instruções em Configurações de fala do agente.
2. Digite ou diga "book a room" no simulador.
3. Confira a seção Áudio de saída no simulador.