Desenvolvimento Rouana 1.0

Rasa Core

Organização dos modelos do Rasa Core

Para utilização do Rasa Core com o Rasa NLU. Além de ser necessário treinar um modelo de processamento de texto para o Rasa NLU, é preciso treinar um modelo de diálogo para o Rasa Core. Este modelo é probabilístico, e baseado em um algoritmo de redes neurais baseado em reforço de aprendizado. O objetivo deste modelo é entender o fluxo das ações realizadas pelo usuário e determinar a probabilidade de uma ação ocorrer após outra.

É possível sobreescrever o modelo padrão do Rasa Core para torná-lo mais específico ou mais genérico. No geral não é preciso alterar o modelo padrão de treinamento de diálogos, uma vez que este responde muito bem para a grande maioria dos contextos.

Para sobreescrita do modelo a ser utilizado o Rasa Core utiliza um esquema de políticas que utiliza a ferramenta Keras, como uma interface de configuração do Tensor Flow. Os parâmetros podem ser alterados de acordo com a quantidade de dados e a complexidade da tarefa sendo executada. O código abaixo mostra a definição de uma política customizada utilizando o Keras, caso seja necessário adaptar o uso para um contexto específico.

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

import logging
from rasa_core.policies.keras_policy import KerasPolicy
logger = logging.getLogger(__name__)

class RouanaPolicy(KerasPolicy):
    def model_architecture(self, num_features, num_actions, max_history_len):
        """Build a Keras model and return a compiled model."""
        from keras.layers import LSTM, Activation, Masking, Dense
        from keras.models import Sequential

        n_hidden = 32  # size of hidden layer in LSTM
        # Build Model
        batch_shape = (None, max_history_len, num_features)

        model = Sequential()
        model.add(Masking(-1, batch_input_shape=batch_shape))
        model.add(LSTM(n_hidden, batch_input_shape=batch_shape))
        model.add(Dense(input_dim=n_hidden, output_dim=num_actions))
        model.add(Activation('softmax'))

        model.compile(loss='categorical_crossentropy',
                      optimizer='adam',
                      metrics=['accuracy'])

        logger.debug(model.summary())
        return model

Para treinamento dos modelos de diálogo, o Rasa Core utiliza um padrão de Agentes, que são interfaces para treinamento, carregamento e uso de modelos. Os agentes agem como interfaces e fornecem uma API de acesso simples aos métodos do Rasa Core. Para o treinamento dos modelos de diálogos é possível, setar parâmetros para configuração do Agent.

Os parâmetros de batch estão relacionados à forma como os dados serão divididos para paralelização do treinamento. Se for definida a paralelização dos recursos em mais de um núcleo de um processador, o tamanho do batch determinará que quantidade de dados devem ser paralelizados. e processados em cada núcleo de cada vez.

O modelo de treinamento utilizado pelo Rasa Core é baseado em aprendizado por reforço(Reinforcement Learning), em que o algoritmo passará várias vezes por toda a base de dados, se atualizando e atualizando os resultados de treinamento, com o objetivo de melhorar a precisão. As epochs determinam quantas vezes o algoritmo passará pelo treinamento de toda a base de dados, ou seja, quantas vezes o processo de reforço será realizado. Além disso com o esquema de épocas auxilia o monitoramento e avaliação periódica do treinamento.

As políticas a serem utilizadas também devem ser definidas no método de treinamento do modelo de diálogo.

def train_dialogue(domain_file="rouana_domain.yml",
                   model_path="models/dialogue",
                   training_data_file="data/rouana_stories.md"):
    agent = Agent(domain_file,
                  policies=[MemoizationPolicy(), RouanaPolicy()])

    agent.train(
            training_data_file,
            max_history=3,
            epochs=5000,
            batch_size=100,
            validation_split=0.2
    )

    agent.persist(model_path)
    return agent