Desde el lanzamiento en 2016, Google Assistant se ha convertido rápidamente en una voz familiar en los hogares de las personas. Desde la reproducción de tu canción favorita hasta el control de las luces, el Asistente de Google se encarga de todo a través de interacciones de voz simples. Pero ¿qué hay de manejar conversaciones más complejas? Si has usado el Asistente de Google, probablemente hayas notado que cada solicitud debe comenzar con la frase mágica “Hola, Google” y que la mayoría de las conversaciones con el asistente no van más allá de una sola solicitud.

En este post, te mostraremos cómo puedes habilitar tu Asistente de Google para manejar conversaciones más profundas y más naturales al integrarlo con Rasa Stack. Hay una serie de razones por las que los desarrolladores eligen Rasa Stack para crear asistentes de conversación:

⦁ Es de código abierto, lo que permite la personalización completa del marco y garantiza que tenga la propiedad completa de los datos de su aplicación.

⦁ Utiliza el aprendizaje automático para dirigir el diálogo: aprende los patrones a partir de los datos conversacionales reales. Escala mucho mejor en producción que las reglas predefinidas o las máquinas de estado.

⦁ Puedes ejecutar tu asistente Rasa AI a través de múltiples canales, lo que significa que tu asistente puede ser accesible a través de diferentes plataformas de mensajería y voz.

Al combinar Rasa Stack con las poderosas capacidades de voz a texto de Google Assistant y una interfaz ampliamente utilizada, puedes llevar a tu asistente de AI a un nivel completamente nuevo. La integración de Rasa con interfaces de voz como el Asistente de Google es una función muy solicitada por nuestra Comunidad de Rasa , ¡así que sigue leyendo y aprende cómo realizar la integración tu mismo! Este es un ejemplo de lo que puedes lograr al seguir este tutorial:

Contorno

1. El asistente de Rasa AI.

2. Inicializando la habilidad personalizada de Google Assistant.

3. Creando la acción personalizada de Google Assistant.

4. Creando el Rasa Connector para el Asistente de Google.

5. Poniendo todas las piezas juntas.

Bloques de construcción

Estas son las herramientas y el software que necesitarás para crear un Asistente de Google basado en Rasa:

  • Altavoz inteligente de Google Assistant o una aplicación de Google Assistant: una herramienta para probar la habilidad personalizada de Google Assistant
  • Consola Google Actions: la plataforma para inicializar acciones personalizadas de Google Assistant.
  • Google Actions SDK: un paquete de software diseñado para desarrollar habilidades personalizadas de Google Assistant.
  • Rasa NLU y Rasa Core: pila de software de AI de conversación de código abierto
  • Ngrok : un túnel para exponer una aplicación que se ejecuta localmente al mundo exterior.

Paso 1: El asistente de Rasa AI

El objetivo principal de este tutorial es mostrarte cómo puedes conectar un agente de Rasa a Google Assistant y hacerlo más conversacional. Hay dos opciones de cómo puedes seguir este tutorial: puedes usar tu asistente Rasa personalizado o puedes tomar nuestro asistente de búsqueda de lugares preconstruido llamado Place Finder

y usarlo para hacer la integración.

Si eliges la primera opción, puedes ir al paso dos de este tutorial. Si eliges el segundo, ahora es el mejor momento para capturar el Place Finder mediante la clonación de este repositorio.

El asistente consta de los siguientes archivos:

⦁ data/nlu_data.md es un archivo que contiene los datos de entrenamiento para el modelo Rasa NLU. Estos datos consisten en ejemplos de consultas de usuarios junto con los intents y las entidades correspondientes.

⦁ El archivo config.yml contiene la configuración del canal de capacitación Rasa NLU. Define cómo se analizarán las entradas del usuario, cómo se extraerán las características y qué modelo de aprendizaje automático se usará para entrenar el modelo.

⦁ data/stories.md es un archivo que contiene datos de entrenamiento para el modelo Rasa Core. Estos datos consisten en historias: conversaciones reales entre un usuario y un asistente escritas en ⦁ formato Rasa , donde las entradas del usuario se expresan como intenciones y entidades correspondientes, y las respuestas del asistente se expresan como acciones.

⦁ domain.yml es un archivo que contiene la configuración del dominio del asistente. Se compone de las siguientes piezas:

⦁ Intenciones y entidades que se definen en los ejemplos de datos de capacitación de Rasa NLU;

⦁ Ranuras que funcionan como marcadores de posición para guardar los detalles que el asistente debe recordar durante la conversación;

⦁ Plantillas que definen las respuestas de texto que un asistente debe devolver cuando se pronostican las expresiones correspondientes

⦁ Acciones que el asistente debe poder predecir y ejecutar.

⦁ Actions.py es un archivo que contiene el código de la acción personalizada donde el asistente realiza una llamada a la API para recuperar los detalles sobre la ubicación actual del usuario y buscar el lugar especificado dentro del radio solicitado por el usuario. El asistente luego usa los detalles devueltos para generar la respuesta y almacena algunos de los detalles recuperados como espacios para que el asistente los use en las últimas etapas de la conversación.

⦁ Endpoints.yml contiene la configuración de webhook de acciones personalizadas.

⦁ Credentials.yml es un archivo para almacenar la clave de la API de Google Places.

Todos estos archivos están listos para su uso, todo lo que tienes que hacer es proporcionar tu clave API de Google Places al archivo credentials.yml y capacitar a los modelos. Entrena al modelo NLU usando el comando que encontrarás a continuación y que se encargará de llamar a la función NLU de Rasa, pasará los datos de entrenamiento y procesará los archivos de configuración de la pipeline, y guardará el modelo dentro del directorio models/current/nlu_model:

python -m rasa_nlu.train -c config.yml — data data/nlu_data.md -o models — fixed_model_name nlu_model — project current — verbose

Una vez que se haya capacitado al modelo NLU, adiestra el modelo Rasa Core utilizando el comando que verás a continuación y que llamará a la función de Rasa Core, pasará los datos de las historias y los archivos de dominio y guardará el modelo entrenado dentro del directorio de models/current/ dialogue:

python -m rasa_core.train -d domain.yml -s data/stories.md -o models/current/dialogue — epochs 200

Al capacitar a los modelos Rasa NLU y Rasa Core, crearás el cerebro de tu asistente de IA. Estos dos modelos serán responsables de comprender lo que dice el usuario y decidir cómo debe responder el asistente. Ahora es el momento de crear el oído y la boca del asistente utilizando el Asistente de Google.

Paso 2: Inicializando la acción personalizada de Google Assistant

La acción personalizada de Google Assistant empaquetará a tu agente Rasa como una habilidad personalizada y te permitirá utilizar el servicio de voz a texto de Google Assistant para habilitar la comunicación de voz con tu asistente. Primero, tienes que inicializar la acción personalizada de Google Assistant. Aquí sabrás como podrás hacerlo:

  1. Ves a la consola de acciones de Google y selecciona ‘Agregar / importar proyecto’.

2. Establece el nombre de tu proyecto y eligue el idioma que deseas que use tu asistente. Haz click en ‘Crear proyecto’.

3. Una vez que se haya creado el proyecto, se te pedirá que ingreses a una página donde puedes elegir la categoría de tu proyecto. Desplázate hasta la parte inferior de la página y eligue la opción ‘Acciones SDK’. Al hacerlo, le dice a tu Asistente de Google que implementará su propia acción personalizada con un sistema personalizado de gestión de diálogos y PNL.

4. Dentro de la ventana que se abrió después de seleccionar Actions SDK, encontrarás la guía Google Actions SDK y una función gactions que usarás más adelante para implementar la acción personalizada. Copia la función proporcionada o toma nota del valor del parámetro — proyecto y haz clic en Aceptar.

5. Ahora puedes elegir una categoría de proyecto u omitir este paso seleccionando “Omitir” en la parte superior de la página.

6. En la página de configuraciones del proyecto, puedes especificar cómo deseas que se invoque tu habilidad personalizada. Puedes hacerlo haciendo click en “Decidir cómo se invoca tu acción” en un panel de “Configuración rápida”.

7. Aquí puedes seleccionar el Nombre para mostrar: el nombre que el Asistente de Google busca para comenzar tu habilidad personalizada. Por ejemplo, si estableces el nombre para mostrar en ‘Localizador de lugares’, para comenzar esta habilidad personalizada tendrá que decir algo como ‘Hola Google, hable con un Localizador de lugares’. También puedes elegir la voz que deseas que use tu asistente de Google y una vez que estés satisfecho con las configuraciones, selecciona ‘Guardar’.

En esta etapa, has inicializado la acción personalizada de Google Assistant. Ahora es el momento de definir cómo debe comportarse el Asistente de Google cuando el usuario invoca esta acción y qué debe hacer cuando el usuario comienza a usar la habilidad.

Paso 3: Crear una acción personalizada de Google Assistant

Dado que la fuente abierta Rasa Stack se encargará de la comprensión del lenguaje natural y la gestión del diálogo, la acción personalizada de Google Assistant será responsable de solo dos cosas: comprender que un usuario invocó la acción personalizada y pasar todas las entradas del usuario a Rasa después de invocar la habilidad. Para lograr esto, tendrá que definir los intentos para estos dos comportamientos y cumplimientos: cosas que el Asistente de Google tendrá que hacer una vez que estos intentos coincidan después de realizar la voz a texto en las entradas de voz del usuario. Aquí está cómo hacerlo:

  1. Descarga la CLI de Google gactions y colócala en el directorio de tu proyecto.
  2. Dentro de ese directorio, inicializas el archivo de configuración de acción personalizada de Google Assistant ejecutando el siguiente comando:

gactions init

3. Abre el archivo actions.json que se inicializó después de ejecutar el comando anterior. Este archivo tiene la configuración básica de la acción de invocación de habilidad personalizada. Se compone de tres partes principales:

⦁ nombre — define el tipo de intento

 intención — corresponde a lo que se trata la acción

⦁ cumplimiento: un webhook al que el Asistente de Google debe enviar la solicitud una vez que coincida la intención correspondiente.

Todas las habilidades personalizadas de Google Assistant necesitan una acción de invocación, por lo que todo lo que tienes que hacer es proporcionar los detalles necesarios a la configuración anterior:

{    "actions": [      {        "description": "Default Welcome Intent",        "name": "MAIN",        "fulfillment": {          "conversationName": "<INSERT YOUR CONVERSATION NAME HERE>"        },        "intent": {          "name": "actions.intent.MAIN",          "trigger": {            "queryPatterns": [              "talk to <INSERT YOUR NAME HERE>"            ]          }        }      }    ],    "conversations": {      "<INSERT YOUR CONVERSATION NAME HERE>": {        "name": "<INSERT YOUR CONVERSATION NAME HERE>",        "url": "<INSERT YOUR FULLFILLMENT URL HERE>"      }    },    "locale": "en"  }

⦁ conversationName que funcionará como un conector entre la intención y un cumplimiento correspondiente. Para la acción de invocación de habilidad, un nombre de conversación podría ser algo así como “bienvenido”

⦁ queryPatterns: una frase de ejemplo que un usuario podría decir. Para la acción de invocación de habilidad, un patrón de consulta podría ser algo así como ‘Talk to Place Finder’.

Una vez que se configura la acción de invocación, todo lo que tienes que agregar es otra acción que pasará todas las entradas del usuario a la Pila Rasa después de invocar la habilidad personalizada. Para esto, tendrás que definir una nueva intención con el nombre ‘TEXTO’ que capturará todas las entradas del usuario después de que se realice el servicio de voz a texto y pasarlo a Rasa Stack utilizando el webhook que definirás en el próximo paso. A continuación se muestra la configuración completa de la acción personalizada de Google Assistant:

{     "actions": [        {          "description": "Default Welcome Intent",          "name": "MAIN",          "fulfillment": {            "conversationName": "welcome"          },          "intent": {            "name": "actions.intent.MAIN",            "trigger": {              "queryPatterns":["talk to Place Finder"]            }          }        },  	  {          "description": "Rasa Intent",          "name": "TEXT",          "fulfillment": {            "conversationName": "rasa_intent"          },          "intent": {            "name": "actions.intent.TEXT",            "trigger": {              "queryPatterns":[]            }          }        }],      "conversations": {        "welcome": {          "name": "welcome",          "url": "...",          "fulfillmentApiVersion": 2      },        "rasa_intent": {          "name": "rasa_intent",          "url": "...",          "fulfillmentApiVersion": 2      }    }  }

Para pasar las entradas de los usuarios a Rasa, el Asistente de Google necesita un URL de webhook que se utilizará para establecer la conexión entre los dos. En el siguiente paso, escribirás un conector personalizado para conectar Rasa a Google Assistant.

Paso 4: Creando un Rasa Connector para el Asistente de Google

De manera predeterminada, Rasa viene con un montón de conectores precompilados para las plataformas de mensajería más populares, pero como el conector de Google Assistant aún no está incluido, ¡aprenderás cómo crear uno! Aquí están los pasos de cómo hacerlo:

1. En el directorio de tu proyecto, crea un nuevo archivo llamado ‘ga_connector.py’. En este archivo, escribirás el código.

2. Abre el archivo ga_connector.py y comienza importando las bibliotecas necesarias que incluyen:

⦁ future(por la cordura del código).

⦁ logging(para la depuración)

⦁ flask(para crear el webhook)

⦁ Algunas clases de Rasa Core (para crear el conector personalizado)

⦁ json

import logging  import json  from sanic import Blueprint, response  from sanic.request import Request  from typing import Text, Optional, List, Dict, Any    from rasa.core.channels.channel import UserMessage, OutputChannel  from rasa.core.channels.channel import InputChannel  from rasa.core.channels.channel import CollectingOutputChannel    logger = logging.getLogger(__name__)

3. Crea una clase llamada GoogleAssistant que hereda la clase InputChannel del núcleo rasa. Esta clase constará de dos funciones: nombre y plano:

class GoogleAssistant(InputChannel):      @classmethod    def name(cls):      def blueprint(self, on_new_message):

4. La función de nombre definirá tu prefijo de URL de webhook. Llámalo google_assistant:

@classmethod  def name(cls)    return ‘google_assistant’

5. Ahora vamos a completar la función de plano. Esta función definirá el webhook que Google Assistant usará para pasar las entradas del usuario a Rasa Core, recopilar las respuestas y enviarlas de vuelta a Google Assistant. Comienza por inicializar el nombre de webhook:

def blueprint(self, on_new_message):  	google_webhook = Blueprint('google_webhook', __name__)
A continuación, debes definir las rutas de tu webhook. Debes incluir al menos dos rutas: ruta de salud para el punto final ‘/’ y una ruta de recepción para el punto final ‘/ webhook’. A continuación, se muestra la implementación de una ruta de salud: recibirás las solicitudes GET enviadas por el Asistente de Google y devolverás un mensaje de 200 OK confirmando que la conexión funciona bien.La ruta receive recibirá solicitudes POST de Google Assistant y pasará la carga útil recibida al agente Rasa. El siguiente bloque de código contiene la implementación de esta ruta, esto es lo que hace:

@google_webhook.route("/", methods=['GET'])  async def health(request):          return response.json({"status": "ok"})

⦁ Una vez que se recibe la solicitud POST, el conector toma la carga útil de la solicitud.

⦁ La carga útil contiene los detalles sobre la entrada del usuario enviada por el Asistente de Google. Estos detalles incluyen la identificación del usuario, la intención (es una solicitud de inicio o un mensaje regular) y el mensaje real en un formato de texto. Todos estos detalles se extraen de la carga útil y se asignan a las variables correspondientes.

⦁ Si la intención es una solicitud de lanzamiento de habilidad, el Asistente responderá con un mensaje introductorio “Bienvenido a la habilidad Asistente de Google potenciada por Rasa. Puedes empezar diciendo hola “.

⦁ Si la intención es una entrada de usuario regular, entonces tiene que inicializar el canal de salida (CollectingOutputChannel es una buena opción para devolver las respuestas generadas por Rasa Core) y pasarlo a Rasa junto con la entrada del usuario y la identificación del remitente. Rasa Core hará una predicción de cómo debería responder el asistente y te permitirá recuperar el mensaje de respuesta del canal de salida.

⦁ Finalmente, el mensaje producido se incorpora a una respuesta json que se envía de vuelta a Google Assistant.

@google_webhook.route("/webhook", methods=['POST'])  async def receive(request):      payload = request.json	      intent = payload['inputs'][0]['intent'] 			      text = payload['inputs'][0]['rawInputs'][0]['query']   	      if intent == 'actions.intent.MAIN':	          message = "Hello! Welcome to the Rasa-powered Google Assistant skill. You can start by saying hi."			       else:          out = CollectingOutputChannel()			          await on_new_message(UserMessage(text, out))          responses = [m["text"] for m in out.messages]          message = responses[0]      r = {            "expectUserResponse": 'true',            "expectedInputs": [              {                "possibleIntents": [                  {                    "intent": "actions.intent.TEXT"                   }              ],              "inputPrompt": {                "richInitialPrompt": {                  "items": [                    {                      "simpleResponse": {                        "textToSpeech": message,                        "displayText": message                        }                      }                    ]                  }                }              }            ]          }        return response.json(r)

A continuación se muestra el código completo de la clase de conector Asistente de Google:

import logging  import json  from sanic import Blueprint, response  from sanic.request import Request  from typing import Text, Optional, List, Dict, Any    from rasa.core.channels.channel import UserMessage, OutputChannel  from rasa.core.channels.channel import InputChannel  from rasa.core.channels.channel import CollectingOutputChannel        logger = logging.getLogger(__name__)      		  class GoogleConnector(InputChannel):      """A custom http input channel.        This implementation is the basis for a custom implementation of a chat      frontend. You can customize this to send messages to Rasa Core and      retrieve responses from the agent."""        @classmethod      def name(cls):          return "google_assistant"          def blueprint(self, on_new_message):  	              google_webhook = Blueprint('google_webhook', __name__)            @google_webhook.route("/", methods=['GET'])          async def health(request):              return response.json({"status": "ok"})            @google_webhook.route("/webhook", methods=['POST'])          async def receive(request):              payload = request.json	              intent = payload['inputs'][0]['intent'] 			              text = payload['inputs'][0]['rawInputs'][0]['query']   	              if intent == 'actions.intent.MAIN':	                  message = "Hello! Welcome to the Rasa-powered Google Assistant skill. You can start by saying hi."			               else:                  out = CollectingOutputChannel()			                  await on_new_message(UserMessage(text, out))                  responses = [m["text"] for m in out.messages]                  message = responses[0]              r = {                    "expectUserResponse": 'true',                    "expectedInputs": [                      {                        "possibleIntents": [                          {                            "intent": "actions.intent.TEXT"                          }                      ],                      "inputPrompt": {                        "richInitialPrompt": {                          "items": [                            {                              "simpleResponse": {                                "textToSpeech": message,                                "displayText": message                                }                              }                            ]                          }                        }                      }                    ]                  }                return response.json(r)				            		          return google_webhook

Y eso es. ¡Acabas de escribir un conector personalizado de Google Assistant para Rasa! Ahora es el momento de juntar todas las piezas y probar al asistente.

Paso 5: Poniendo todas las piezas juntas.

Todo lo que queda por hacer es iniciar el servidor Rasa Core, que utilizará el conector personalizado para conectarse a Google Assistant. Puedes hacerlo utilizando el código siguiente que cargará el agente de Rasa Core utilizando el modelo Rasa NLU como intérprete e iniciará el webhook que escuchará las entradas del usuario entrante:

from rasa_core.agent import Agent  from rasa_core.interpreter import RasaNLUInterpreter  from custom import GoogleConnector  from rasa_core.utils import EndpointConfig    action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")  nlu_interpreter = RasaNLUInterpreter('./models/current/nlu_model')  agent = Agent.load('./models/current/dialogue', interpreter = nlu_interpreter, action_endpoint=action_endpoint)    input_channel = GoogleConnector()  agent.handle_channels([input_channel], 5004, serve_forever=True)

Guarda este código dentro de un archivo llamado run_app.py y ejecútalo. Iniciará el servidor en el puerto 5004 y establecerá el webhook de GoogleConnector.

Como tu asistente Rasa se ejecuta localmente y Google Assistant se ejecuta en la nube, necesitarás un servicio de tunelización para exponer a tu asistente local Rasa al mundo exterior. Ngrok es una buena opción para eso, así que inicia ngrok en el mismo puerto en el que se está ejecutando el agente de Rasa: 5004. Ahora puedes conectarlo a Google Assistant pasando la URL de webhook a los cumplimientos de tu acción personalizada de Google Assistant. Para hacer eso, copia la url generada por ngrok (será diferente a la que obtuvimos para el siguiente ejemplo), adjunta el sufijo ‘/webhooks/google_assistant/webhook’, regresa al archivo action.json y proporciona la url a la parte de conversaciones del archivo de configuración:

{     "actions": [        {          "description": "Default Welcome Intent",          "name": "MAIN",          "fulfillment": {            "conversationName": "welcome"          },          "intent": {            "name": "actions.intent.MAIN",            "trigger": {              "queryPatterns":["talk to Place Finder"]            }          }        },  	  {          "description": "Rasa Intent",          "name": "TEXT",          "fulfillment": {            "conversationName": "rasa_intent"          },          "intent": {            "name": "actions.intent.TEXT",            "trigger": {              "queryPatterns":[]            }          }        }],      "conversations": {        "welcome": {          "name": "welcome",          "url": "https://145f1bf4.ngrok.io/webhooks/google_assistant/webhook",          "fulfillmentApiVersion": 2      },        "rasa_intent": {          "name": "rasa_intent",          "url": "https://145f1bf4.ngrok.io/webhooks/google_assistant/webhook",          "fulfillmentApiVersion": 2      }    }  }
Si tu asistente de Rasa incluye acciones personalizadas (al igual que Place Finder), asegúrate de iniciar el servidor de acciones ejecutando el siguiente comando:python -m rasa_core_sdk.endpoint --actions actions

Ahora, todo lo que queda por hacer es implementar tu habilidad personalizada de Google Assistant y habilitar las pruebas. Puedes implementar la habilidad personalizada de Google Assistant ejecutando el siguiente comando. Aquí, PROJECT_ID es un valor del parámetro — proyecto del cual tomó nota en el paso 2 de este tutorial.

gactions update --action_package action.json --project PROJECT_ID

Una vez que se carga la acción, habilita la prueba de la acción ejecutando el siguiente comando:

gactions test --action_package action.json --project PROJECT_ID

Sugerencia: si olvidaste tomar nota de tu ID de proyecto, puedes encontrarla dentro de la configuración de proyectos en la consola de Google Actions:

¡Felicidades! ¡Acabas de crear una habilidad personalizada de Google Assistant con Rasa Stack!

¡Ahora puedes continuar y probarlo en tu altavoz inteligente de Google Home o en tu aplicación Google Assistant (asegúrate de iniciar sesión con la misma cuenta de Google que usaste para desarrollar la habilidad personalizada en la consola de acciones de Google)!

¡Háznos saber cómo lo estás implementando y qué te parece!

Estamos deseando ver lo que puedes construir. Comparte tus proyectos en el Foro de la Comunidad de Rasa y publica cualquier pregunta que tengas sobre la integración de Rasa en el Asistente de Google.

Recursos

Por Justina Petraitytė

Data scientist, desarrollador de inteligencia artificial conversacional y educador con la pasión por crear excelentes aplicaciones y convertir los datos en conocimientos significativos y productos innovadores. Tengo más de 5 años de experiencia en la industria en la implementación de soluciones de aprendizaje automático para diversos problemas comerciales (predicción de retención de usuarios, agrupación en clústeres, motores de recomendación, PNL, IA conversacional), consulta de datos y gestión de datos, análisis de datos, informes y visualización de datos.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *