Curso Rasa, entrenamiento Rasa, entrevista Rasa, nuevo mapeo global de ranuras de palabras de Rasa en la serie de combate Rasa 3 métodos principales

En Rasa 3.0, Rasa ha habilitado "Asignación global de ranuras" para un mejor control sobre la información conversacional en los chatbots.

Las máquinas tragamonedas almacenan información durante una conversación, como el nombre de usuario, el número de cuenta y si reservar un vuelo o un tren. El mapeo de ranuras es el proceso de recopilar y preparar esta información para que la política de diálogo pueda usarla para elegir la siguiente acción o insertarla en la plantilla de respuesta del bot. En Rasa 3.0, hemos habilitado "Mapeo de ranuras global", que brinda un mejor control sobre la información.

En esta publicación de blog, le mostraremos tres nuevas formas de usar el mapeo global de tragamonedas en el asistente de Rasa para resolver problemas comunes y desbloquear nuevas funciones.

Decida qué debe hacer su bot en función de la información externa

Supongamos que queremos que el robot se comporte de manera diferente según la hora del día. Por ejemplo, si el usuario solicita chatear con un humano y el horario es fuera del horario de oficina, el bot debe indicar el horario de oficina y seguir intentando resolver el problema del usuario. Pero si es durante el horario de oficina, el bot debe pasar la conversación a un operador humano.

Este es un ejemplo de una decisión de alto nivel, por lo que queremos usar espacios de palabras características que influyan en la política. Por lo tanto, definimos una ranura de palabra office_open, usamos la ranura para que sea True cuando la oficina está abierta y False en caso contrario.

slots:
  office_open:
    type: bool
    influence_conversation: true
    mappings:
    - type: custom
      action: action_set_office_open

El valor de la ranura se establece en action_set_office_open, debemos definirlo en el servidor de acciones

class ActionSetOfficeOpen(Action):


    def name(self) -> Text:
        return "action_set_office_open"


    def run(
        self,
        dispatcher: CollectingDispatcher,
        tracker: Tracker,
        domain: Dict[Text, Any]
    ) -> List[Dict[Text, Any]]:
        office_open = random.choice([True, False]) # just for debugging
        return [
            SlotSet("office_open", office_open)
        ]

Este código ahora se ejecutará después de cada mensaje de usuario, manteniendo office_open actualizado, el nombre "acción" puede ser confuso, esta no es una acción predicha por la política, es solo un fragmento de código que se ejecuta al final de la canalización de NLU .

Con el espacio de palabras office_open, ahora podemos definir el comportamiento del robot en dos reglas breves***:

- rule: Deal with request_human at office hours
  steps:
  - intent: request_human
  - slot_was_set:
    - office_open: true
  - action: utter_handover_to_human  # Just an example for the demo


- rule: Deal with request_human outside office hours
  steps:
  - intent: request_human
  - slot_was_set:
    - office_open: false
  - action: utter_office_hours

Esto no fue posible hasta que introdujimos el mapeo global de ranuras en Rasa. Tiene que entrenar la política para realizar una acción personalizada que rellene la ubicación office_open, o tiene que manejar la decisión en una acción personalizada que pase el horario de trabajo al humano o imprima el horario de oficina.

Las reglas se escriben de la misma manera que las historias, pero generalmente solo representan fragmentos de diálogo. Cada vez que el bot encuentra un cuadro de diálogo que coincide con una regla, RulePolicy ejecuta la siguiente acción definida por la regla.

Use un espacio de palabras ficticias para llenar múltiples espacios de palabras al mismo tiempo

El formato YAML habitual para un mapa de ranuras indica que todas las ranuras se llenan de forma independiente y hay una asignación para cada ranura (operación de llenado de ranuras personalizadas). Sin embargo, para la mayoría de las aplicaciones, donde los valores de las ranuras son interdependientes, es mejor declarar una función que realice todas las asignaciones.

Para hacer esto, defina una ranura ficticia con un mapeo personalizado

slots:
  dummy:
    type: any
    influence_conversation: false
    mappings:
    - type: custom
      action: global_slot_mapping

Y llene todas las ranuras de la función global_slot_mapping usando una acción personalizada escrita para este propósito.
Ejemplo: Establecer una política condicionada a una puntuación baja para una entidad extraída
Con el espacio de palabra office_open, dejamos que el robot reaccione a la información externa (hora del día). Pero dado que la acción de asignación de ranuras tiene acceso al historial de conversaciones (objeto de seguimiento), también podemos establecer ranuras de palabras en función de las propiedades de la conversación, incluida la información que normalmente no se incluye en la política, como las puntuaciones de confianza de extracción de entidades.

Supongamos que agregamos un formulario a nuestro bot donde el bot solicita el tipo de elemento y la última ubicación conocida cuando el usuario perdió el elemento. Los espacios y formularios ahora se definen en el campo como

slots:
  dummy:
    type: any
    mappings:
    - type: custom
      action: global_slot_mapping
  # Featurized slots for policies
  office_open:
    type: bool
    influence_conversation: true
    mappings:
    - type: custom
  low_entity_score:
    type: bool
    influence_conversation: true
    initial_value: false
    mappings:
    - type: custom
  # Unfeaturized slots for forms
  lost_item_type:
    type: text
    influence_conversation: false
    mappings:
    - type: custom
  last_known_item_location:
    type: text
    influence_conversation: false
    mappings:
    - type: custom
  # Unfeaturized slots for NLG
  unclear_entity_value:
    type: text
    influence_conversation: false
    mappings:
    - type: custom


forms:
  main_form:
    required_slots:
      - lost_item_type
      - last_known_item_location

Verá que solo el espacio de palabra ficticia tiene una operación de mapa de espacio de palabra. Esta acción ahora es responsable de todo el proceso de mapeo:

class GlobalSlotMapping(Action):


    def name(self) -> Text:
        return "global_slot_mapping"


    def run(
        self,
        dispatcher: CollectingDispatcher,
        tracker: Tracker,
        domain: Dict[Text, Any]
    ) -> List[Dict[Text, Any]]:
        new_slot_values: Dict[Text, Any] = dict()


        # Office hours
        new_slot_values["office_open"] = random.choice([True, False])


        # Entity mapping and low entity score handling
        low_entity_score: bool = False
        for entity_type, value, score in get_entity_data(tracker.latest_message):
            print(f"{
      
      entity_type}: {
      
      value} ({
      
      score})")
            if score < 0.98:
                low_entity_score = True
                new_slot_values["unclear_entity_value"] = value
            else:
                if entity_type == "item":
                    new_slot_values["lost_item_type"] = value
                elif entity_type == "location":
                    new_slot_values["last_known_item_location"] = value
        new_slot_values["low_entity_score"] = low_entity_score


        return [
            SlotSet(name, value)
            for name, value in new_slot_values.items()
        ]

Ahora podemos definir una regla para manejar puntajes de extracción bajos:

- rule: Handle low entity score in main form
  condition:
  - active_loop: main_form
  steps:
  - intent: inform
  - slot_was_set:
    - low_entity_score: true
  - action: utter_entity_unclear
  - action: main_form
  - active_loop: main_form

Nuestro bot puede tener las siguientes conversaciones:

Your input ->  hi                                                                                                                                                                                      
Hello! How can I help you?
I am Lost & Found Bot and can help you find things.
Your input ->  i lost my umbrella                                                                                                                                                                      
Where did you last see your item?
Your input ->  on the tran                                                                                                                                                                             
I'm not sure what you mean by 'tran'.
Where did you last see your item?
Your input ->  i mean, on the train                                                                                                                                                                    
You are looking for 'umbrella', last seen at 'train'

Tenga en cuenta que las puntuaciones de confianza de los extractores de entidades no son necesariamente fiables. Puede suceder fácilmente que las entidades se extraigan incorrectamente y aún tengan puntajes muy altos. Volver a entrenar a su modelo también puede cambiar drásticamente el puntaje de confianza.

Genere respuestas usando espacios de palabras

Acabamos de ver cómo definir un mapa de ranuras de palabras global para influir en las decisiones de política a través de ranuras de palabras características. Alternativamente, podemos omitir la estrategia en el gráfico de flujo de información y solo afectar la generación de respuestas a través de espacios de palabras no caracterizados.

Dada una plantilla de respuesta ( utter_* ), los espacios de palabras pueden afectar la respuesta del bot de dos maneras: para condiciones de respuesta o como variables.

Ejemplo: manejo de preguntas duplicadas

Si los usuarios hacen la misma pregunta una y otra vez, es posible que desee que su bot dé una respuesta más detallada. Por ejemplo, si el usuario sigue preguntando sobre las capacidades del bot y el bot responde con utter_abilities, no querrá que el bot siempre diga exactamente lo mismo. Pero tampoco desea elegir aleatoriamente entre plantillas receptivas. Usando el mapa de ranura global, puede hacer esto haciendo un seguimiento de la frecuencia con la que se ejecuta el bot utter_abilities, colocando esta información en la ranura num_utter_abilities y definiendo esta plantilla de respuesta para condicionar esa ranura.

La respuesta de utter_abilities podría ser:

responses:
  utter_abilities:
  - text: "I am Lost & Found Bot and can help you find things."
    condition:
      - type: slot
        name: num_utter_abilities
        value: 0
  - text: "I can help you find things that you've lost either on a train or some other place in town."
    condition:
      - type: slot
        name: num_utter_abilities
        value: 1
  - text: "Actually, I'm just a demo, so don't expect me to really find something."
    condition:
      - type: slot
        name: num_utter_abilities
        value: 2
  - text: "I can't do anything beyond what I already mentioned, sorry."

num_utter_abilities mantiene los espacios de palabras actualizados usando el siguiente código en la función de mapeo de espacios de palabras:

class GlobalSlotMapping(Action):


    def name(self) -> Text:
        return "global_slot_mapping"


    def run(
        self,
        dispatcher: CollectingDispatcher,
        tracker: Tracker,
        domain: Dict[Text, Any]
    ) -> List[Dict[Text, Any]]:
        new_slot_values: Dict[Text, Any] = dict()


        # ...


        # Count how often the bot executed `utter_abilities`
        num_utter_abilities = 0
        for event in tracker.applied_events():
            if event_is_action(event, "utter_abilities"):
                num_utter_abilities += 1
        new_slot_values["num_utter_abilities"] = num_utter_abilities


        return [
            SlotSet(name, value)
            for name, value in new_slot_values.items()
        ]

Tenemos que definir algunos nuevos intentos y reglas apropiadas para que su bot responda correctamente:

- rule: Respond to ask_what_can_do
  steps:
  - intent: ask_what_can_do
  - action: utter_abilities
  - intent: tell_me_more     # for this to work, set `restrict_rules: false` for the RulePolicy
  - action: utter_abilities
  - intent: tell_me_more
  - action: utter_abilities

Nuestro bot puede tener las siguientes conversaciones:

Your input ->  hi                                                                                      
Hello! How can I help you?
I am Lost & Found Bot and can help you find things.
Your input ->  what can you do?                                                                        
I can help you find things that you've lost either on a train or some other place in town.
Your input ->  what else?                                                                              
Actually, I'm just a demo, so don't expect me to really find something.
Your input ->  tell me more                                                                            
I can't do anything beyond what I already mentioned, sorry.

Esta es una aplicación muy simple. Pero, en principio, puede usar el mapeo de espacios para ajustar su plantilla de respuesta en función de cualquier información que pueda extraer del historial de conversaciones (o fuentes externas). Por ejemplo, podría agregar un clasificador ligero a su canalización de NLU y adaptar sus respuestas al estilo de escritura del usuario. Pero recuerde configurar las respuestas de su bot solo a las cosas que sabe con certeza sobre sus usuarios.

En conclusión

Como puede ver, el mapeo global de ranuras presenta muchas características nuevas en Rasa Open Source que pueden no ser evidentes de inmediato cuando las conoce por primera vez. Son una característica nueva, flexible y poderosa, y esperamos ver cómo pueden resolver todo tipo de problemas para usted.

Recursos del curso Rasa publicados

Lección 121: Rasa Dialogue Robot Debugging Project Demostración práctica de E-commerce Retail Dialogue Robot Operación Proceso Depuración-1
https://download.csdn.net/download/duan_zhihua/85189436
Proyecto de depuración de robot de diálogo Rasa de Gavin Comercio electrónico real Comercio minorista, banca, seguros y educación Robot de diálogo Lección 121 - Lección 128 Notas de estudio Libro electrónico de obras completas V3.1.0
https://download.csdn.net/download /duan_zhihua/85196359

Introducción a Gavin

El fundador de Xingkong Intelligent Dialogue Robot y autor del método de pensamiento universal de dos líneas de IA, actualmente trabaja en el principal laboratorio de IA en Silicon Valley. Especializado en IA conversacional, trabajó en los principales laboratorios de aprendizaje automático e inteligencia artificial de Silicon Valley en los Estados Unidos.

Gavin gran café WeChat: NLP_Matrix_Space

Teléfono: +1 650-603-1290

Correo electrónico de contacto: [email protected]

Profesor asistente de enseñanza WeChat: Spark_AI_NLP
inserte la descripción de la imagen aquí

Compartir blog de la serie Rasa 3.x