def train_dialogue(domain_file = 'customer_domain.yml',
model_path = './models/dialogue',
training_data_file = 'stories.md'):
'''
This function uses the intent clasifier to build responses to sent messages
input :
domain_file : containing the actions, templates , entities necessary for underdtanding the dialogue.The file
is located in the dialogue system
model_path : directory for saving trained dialogue system
training_data_file : contains the story file. It is training file needed to train rasa core dialogue system
'''
featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(), max_history=5) # define featurizer for learning
# define a bot agent
agent = Agent(domain_file, policies = [MemoizationPolicy(), KerasPolicy(featurizer, epochs=300, batch_size=10)])
# asyncio is needed for concurrent wait during training
loop = asyncio.get_event_loop() # define asyncio
data = loop.run_until_complete( agent.load_data(training_data_file )) # embedded data in asyncio
# let agent train
agent.train(
data, validation=0.2)
# persistent saving of model
agent.persist(model_path)
# return agent
return agent
async def test_infer():
default_domain = Domain.load(DEFAULT_DOMAIN_PATH_WITH_SLOTS)
print("action names: {}".format(default_domain.action_names))
trackers = await training.load_data(DEFAULT_STORIES_FILE,
default_domain,
augmentation_factor=4,
debug_plots=True)
policy = KerasPolicy.load("{}/models/keras".format(prj_dir))
for tracker in trackers:
y_pred = policy.predict_action_probabilities(tracker, default_domain)
index = y_pred.index(max(y_pred))
print(default_domain.action_names[index])
def train_dialogue(domain_file='domain.yml',
model_path='./models/dialogue',
training_data_file='./data/stories.md'):
agent = Agent(domain_file, policies=[MemoizationPolicy(), KerasPolicy()])
agent.train(training_data_file,
max_history=3,
epochs=300,
batch_size=50,
validation_split=0.2,
augmentation_factor=50)
agent.persist(model_path)
return agent
def run_weather_online(interpreter,
domain_file="weather_domain.yml",
training_data_file='data/stories.md'):
agent = Agent(domain_file,
policies=[MemoizationPolicy(), KerasPolicy()],
interpreter=interpreter)
agent.train(training_data_file,
max_history=2,
batch_size=50,
epochs=200,
max_training_samples=300)
return agent
async def test_train_keras_policy():
default_domain = Domain.load(DEFAULT_DOMAIN_PATH_WITH_SLOTS)
trackers = await training.load_data(DEFAULT_STORIES_FILE,
default_domain,
augmentation_factor=0,
debug_plots=False)
policy = KerasPolicy(featurizer=featurizer(), priority=1)
policy.train(trackers, default_domain)
policy.persist("{}/models/keras".format(prj_dir))
def train_dialogue(domain_file='./data/criminal_domain.yml',
model_path='./models/dialogue',
training_data_file='./data/stories.md'):
agent = Agent(domain_file,
policies=[
MemoizationPolicy(),
KerasPolicy(max_history=3, epochs=200, batch_size=50)
])
data = agent.load_data(training_data_file)
agent.train(data)
agent.persist(model_path)
return agent
def train_dialogue(domain_file='domain.yml',
model_path='./models/dialogue',
training_data_file='./data/stories.md'):
fallback = FallbackPolicy(fallback_action_name="utter_unclear",
core_threshold=0.3,
nlu_threshold=0.75)
agent = Agent(domain_file,
policies=[
MemoizationPolicy(max_history=7),
KerasPolicy(current_epoch=100, max_history=7), fallback
])
data = asyncio.run(agent.load_data(training_data_file))
agent.train(data)
# agent.train(
# data,
# epochs=500,
# batch_size=50,
# validation_split=0.2)
agent.persist(model_path)
return agent
async def train_core(domain_file: Text = "domain.yml",
model_directory: Text = "models",
model_name: Text = "core",
training_data_file: Text = "data/stories.md",):
logging.basicConfig(filename=logfile, level=logging.DEBUG)
agent = Agent(
domain_file,
policies=[
MemoizationPolicy(max_history=3),
KerasPolicy(batch_size=100, epochs=400, validation_split=0.2)
]
)
training_data = await agent.load_data(training_data_file)
agent.train(training_data)
# Attention: agent.persist stores the model and all meta data into a folder.
# The folder itself is not zipped.
model_path = os.path.join(model_directory, model_name)
agent.persist(model_path)
async def train_core(domain_file, training_data_file, model_directory):
agent = Agent(domain_file, policies=[MemoizationPolicy(max_history=3), MappingPolicy(), KerasPolicy(epochs=500)])
training_data = await agent.load_data(training_data_file, augmentation_factor=10)
agent.train(training_data)
# Attention: agent.persist stores the model and all meta data into a folder.
# The folder itself is not zipped.
model_path = os.path.join(model_directory, "core")
agent.persist(model_path)
logger.info(f"Model trained. Stored in '{model_path}'.")
return model_path
def create_policy(self, featurizer, priority):
p = KerasPolicy(featurizer, priority, **tf_defaults())
return p
def create_policy(self, featurizer, priority):
p = KerasPolicy(featurizer, priority)
return p
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
import logging
from rasa.core.agent import Agent
from rasa.core.policies.keras_policy import KerasPolicy
from rasa.core.policies.memoization import MemoizationPolicy
if __name__ == 'main':
logging.basicConfig(level='info')
training_data_file = './data/stories.md'
model_path = './models/'
agent = Agent('domain.yml', policies=[MemoizationPolicy(), KerasPolicy()])
agent.train(training_data_file,
augmentation_factor=50,
max_history=5,
epochs=100,
batch_size=10,
validation_split=0.2)
agent.persist(model_path)
# !/usr/bin/python
# -*- coding:utf-8 -*-
from rasa.core.agent import Agent
from rasa.core.interpreter import RasaNLUInterpreter
from rasa.core.policies.keras_policy import KerasPolicy
# agent=Agent(domain=None, policies=None, interpreter=None, generator=None,
# tracker_store=None, lock_store=None, action_endpoint=None,
# fingerprint=None, model_directory=None, model_server=None, remote_storage=None, path_to_model_archive=None)
if __name__ == '__main__':
domain_file = '/home/user/xiaoqq/chat_robot/rasa_learn/configs/domain_slot.yml'
agent = Agent(domain_file, policies=[KerasPolicy(validation_split=0.0, epochs=400)])
training_data_file = '/home/user/xiaoqq/chat_robot/rasa_learn/data/nlu/nlu_slot.md'
training_data = agent.load_data(training_data_file)
model_path = '/home/user/xiaoqq/chat_robot/rasa_learn/data/models'
agent.train(training_data
)
agent.persist(model_path)
# !/usr/bin/python
# -*- coding:utf-8 -*-
from rasa.core.agent import Agent
from rasa.core.policies.keras_policy import KerasPolicy
from rasa.core.policies.memoization import MemoizationPolicy
if __name__ == '__main__':
agent = Agent("/home/user/xiaoqq/chat_robot/rasa_learn/configs/domain.yml",
policies=[MemoizationPolicy(),
KerasPolicy()])
agent.visualize(
"/home/user/xiaoqq/chat_robot/rasa_learn/data/stories/stories.md",
output_file="graph.html",
max_history=2)
