def train_bot():
logging.basicConfig(level='INFO')
training_data_file = './data/stories'
model_path = './models/dialogue'
fallback = FallbackPolicy(fallback_action_name="utter_not_understood",
core_threshold=0.3,
nlu_threshold=0.6)
featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(),
max_history=5)
agent = Agent('./data/domain.yml',
policies=[
MemoizationPolicy(max_history=5),
KerasPolicy(featurizer), fallback
])
training_data = agent.load_data(training_data_file)
agent.train(training_data,
augmentation_factor=50,
epochs=500,
batch_size=10,
validation_split=0.2)
agent.persist(model_path)
def run_eventbot_online(input_channel,
interpreter,
domain_file="./data/domain.yml",
training_data_file='./data/stories'):
try:
KnowledgeGraph()
except ServiceUnavailable:
print('Neo4j connection failed. Program stopped.')
return
fallback = FallbackPolicy(fallback_action_name="utter_not_understood",
core_threshold=0.3,
nlu_threshold=0.6)
agent = Agent(domain_file,
policies=[MemoizationPolicy(),
KerasPolicy(), fallback],
interpreter=interpreter)
data = agent.load_data(training_data_file)
agent.train_online(data,
input_channel=input_channel,
max_history=2,
batch_size=50,
epochs=200,
max_training_samples=300)
return agent
def train_dialogue(project='Lambton'):
domain_file = '../Chatbots/projects/' + project + '/domain.yml'
training_data_file = "../Chatbots/projects/" + project + "/stories/stories.md"
model_path = "../Chatbots/projects/" + project + "/models/dialogue"
fallback = FallbackPolicy(fallback_action_name="utter_fallback",
core_threshold=0.5,
nlu_threshold=0.5) #0.3
#agent = Agent(domain_file, policies=[MemoizationPolicy(max_history=3), KerasPolicy(), fallback])
#agent = Agent(domain_file, policies=[MemoizationPolicy(max_history=5), KerasPolicy(), fallback])
agent = Agent(domain_file,
policies=[
AugmentedMemoizationPolicy(max_history=7),
SklearnPolicy(), fallback
])
training_data = agent.load_data(training_data_file)
# *** FASTER ***
# agent.train(
# training_data,
# #max_training_samples=500,
# epochs=300,
# batch_size=33,
# validation_split=0.2
# )
# *** Precise ***
agent.train(training_data,
augmentation_factor=50,
epochs=500,
batch_size=10,
validation_split=0.2)
agent.persist(model_path)
return agent
def train_dialogue_model(domain_file,
stories_file,
output_path,
interpreter=None,
endpoints=AvailableEndpoints(),
dump_stories=False,
policy_config=None,
exclusion_percentage=None,
kwargs=None):
if not kwargs:
kwargs = {}
policies = config.load(policy_config)
agent = Agent(domain_file,
generator=endpoints.nlg,
action_endpoint=endpoints.action,
interpreter=interpreter,
policies=policies)
data_load_args, kwargs = utils.extract_args(
kwargs, {
"use_story_concatenation", "unique_last_num_states",
"augmentation_factor", "remove_duplicates", "debug_plots"
})
training_data = agent.load_data(stories_file,
exclusion_percentage=exclusion_percentage,
**data_load_args)
agent.train(training_data, **kwargs)
agent.persist(output_path, dump_stories)
return agent
def train_dialogue(domain_file='chat_domain.yml',
model_path='./models/dialogue',
training_data_file='./data/stories.md'):
print(training_data_file)
#fall back policy initialized
fallback = FallbackPolicy(fallback_action_name="action_default_fallback",
core_threshold=0.3,
nlu_threshold=0.3)
agent = Agent(domain_file,
policies=[
MemoizationPolicy(),
KerasPolicy(max_history=3, epochs=600, batch_size=50),
fallback
])
# import training data
data = agent.load_data(training_data_file)
# generating diagram of story
agent.visualize("data/stories.md", output_file="graph.html", max_history=3)
# start training
agent.train(data)
agent.persist(model_path)
return agent
def run_bot_online(interpreter,
domain_file="domain.yml",
training_data_file='data/stories.md'):
'''
This function trains the bot in an interactive manner
:param interpreter: NLU Interpreter
:param domain_file: Domain file
:param training_data_file: Chat story board file
:return: Agent
'''
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
agent = Agent(domain_file,
policies=[
MemoizationPolicy(max_history=3),
KerasPolicy(max_history=5, epochs=300, batch_size=50)
],
interpreter=interpreter,
action_endpoint=action_endpoint)
data = agent.load_data(training_data_file)
agent.train(data)
interactive.run_interactive_learning(agent, training_data_file)
return agent
def train_dialogue_model(domain_file,
stories_file,
output_path,
use_online_learning=False,
nlu_model_path=None,
max_history=None,
kwargs=None):
if not kwargs:
kwargs = {}
agent = Agent(
domain_file,
policies=[MemoizationPolicy(max_history=max_history),
KerasPolicy()])
data_load_args, kwargs = utils.extract_args(
kwargs, {
"use_story_concatenation", "unique_last_num_states",
"augmentation_factor", "remove_duplicates", "debug_plots"
})
training_data = agent.load_data(stories_file, **data_load_args)
if use_online_learning:
if nlu_model_path:
agent.interpreter = RasaNLUInterpreter(nlu_model_path)
else:
agent.interpreter = RegexInterpreter()
agent.train_online(training_data,
input_channel=ConsoleInputChannel(),
model_path=output_path,
**kwargs)
else:
agent.train(training_data, **kwargs)
agent.persist(output_path)
def train_dialog(dialog_training_data_file,
domain_file,
path_to_model='models/dialogue'):
logging.basicConfig(level='INFO')
logging.info(dialog_training_data_file)
# Action to be called if the confidence of intent / action is below the threshold
fallback = FallbackPolicy(
fallback_action_name="action_default_fallback",
core_threshold=0.3, # Define the threshold that you need to capture
nlu_threshold=0.3)
# Configuring the endpoint webhook
core_endpoint_config = EndpointConfig(url='http://localhost:5055/webhook')
# Configuring the agent
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=2), fallback],
interpreter=RasaNLUInterpreter('models/nlu/default/chat'),
action_endpoint=core_endpoint_config)
# Load the stories for training the dialog
training_data = agent.load_data(dialog_training_data_file)
# Start training the dialog
agent.train(training_data)
# Save the training data
agent.persist(path_to_model)
# Run interactive learning
# interactive.run_interactive_learning(agent, dialog_training_data_file, skip_visualization=True)
return agent
def initChatBot():
print("STEP 1:Training the NLU Model")
#Training the NLU MODEL:
# loading the nlu training samples
training_data = load_data("NLU_Train.json")
# trainer to create the pipeline
trainer = Trainer(config.load("NLU_model_Config.yml"))
# training the model
interpreter = trainer.train(training_data)
# storeing it for future
model_directory = trainer.persist("./models/nlu",
fixed_model_name="current")
print("Done")
print("STEP 2: Training the CORE model")
fallback = FallbackPolicy(fallback_action_name="utter_default",
core_threshold=0.2,
nlu_threshold=0.1)
agent = Agent(domain='restaurant_domain.yml',
policies=[
MemoizationPolicy(),
KerasPolicy(validation_split=0.0, epochs=200), fallback
])
training_data = agent.load_data('Core_Stories.md')
agent.train(training_data)
agent.persist('models/dialogue')
print("Done")
return model_directory
def train_dialog(dialog_training_data_file, domain_file, path_to_model='./models/dialogue'):
"""Train a rasa-core model and save it in a local path.
Parameters:
----------
dialogue_model_path: str
Path, where the model should be stored
dialog_training_data_file: str
Path to the story files on which it will train
domain_file: str
Path to the file which describes the domain
"""
# initialize the agent
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=2), KerasPolicy(), fallback])
# load data from stories
training_data = agent.load_data(dialog_training_data_file)
# train a new model
agent.train(
training_data,
augmentation_factor=5,
epochs=2,
batch_size=10,
validation_split=0.2)
# save the model to a local path
agent.persist(path_to_model)
def train_dlg():
rasa_core.policies.MemoizationPolicy.ENABLE_FEATURE_STRING_COMPRESSION = False
print("=> Importing tensorflow...")
import tensorflow as tf
tf.logging.set_verbosity(tf.logging.ERROR)
print("=> Importing rasa...")
from rasa_core.agent import Agent
from rasa_core.policies.memoization import MemoizationPolicy
from rasa_core.policies.keras_policy import KerasPolicy
"""
fallback = FallbackPolicy(fallback_action_name="utter_default",core_threshold=0.1,nlu_threshold=0.1)
"""
agent = Agent(botpath.DOMAIN_FILE,
policies=[MemoizationPolicy(max_history=3),
KerasPolicy()])
print("Training dialogue %s" % botpath.STORY_FILE)
training_data = agent.load_data(botpath.STORY_FILE)
agent.train(training_data,
epochs=200,
batch_size=50,
max_training_samples=300)
print("=> Saving Result to %s..." % botpath.DIALOGUE_PATH)
shutil.rmtree(botpath.DIALOGUE_PATH, ignore_errors=True)
agent.persist(botpath.DIALOGUE_PATH)
def train_bot():
training_data_file = './data/stories'
model_path = './models/dialogue'
domain_file = './data/domain.yml'
# core_threshold: min confidence needed to accept an action predicted by Rasa Core
# nlu_threshold: min confidence needed to accept an intent predicted by the interpreter (NLU)
fallback = FallbackPolicy(fallback_action_name="action_not_understood",
core_threshold=0.5,
nlu_threshold=0.35)
featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(),
max_history=3)
agent = Agent(domain=domain_file,
policies=[
MemoizationPolicy(max_history=2),
KerasPolicy(featurizer), fallback
])
training_data = agent.load_data(training_data_file)
agent.train(training_data,
augmentation_factor=50,
epochs=400,
batch_size=50,
validation_split=0.2)
agent.persist(model_path)
def run_bot_cli(input_channel, interpreter,
domain_file="./data/student_info_domain.yml",
training_data_file='./data/stories.md'):
# Featureizer Generation
featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(), max_history=5)
# Not really sure what is happening here
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=5),
KerasPolicy(featurizer)],
interpreter=interpreter)
# This is where our training data file is loaded in for training
training_data = agent.load_data(training_data_file)
# Training data is the training data object created in the above line
# input_channel - How the trainer recieves its input
# batch_size - How many times the model is updated per pass
# epochs - Number of training passes
# validation_split - Fraction of the training data to be used as validation data
# augmentation_factor - How many of the dialogue stories are randomly glued together
# the more stories you have the higher the augmentation factor you want
agent.train_online(training_data,
input_channel=input_channel,
batch_size=35,
epochs=400,
max_training_samples=200,
validation_split = 0.2,
augmentation_factor = 20)
return agent
class CoreServer(): def __init__(self): self.agent = None self.config = Settings.Settings().getConfig() logger = logging.getLogger(__name__) def train_dialogue(self, domain_file, model_path, training_data_file): fallback = FallbackPolicy(fallback_action_name="utter_default",core_threshold=0.2, nlu_threshold=0.5) featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(), max_history=10) self.agent = Agent(domain_file , policies=[MemoizationPolicy(max_history=10), KerasPolicy(epochs = 90, batch_size = 20, validation_split = 0.1), fallback]) data = self.agent.load_data(training_data_file) self.agent.train(data) self.agent.persist(model_path) def run_dialogue(self, core_model_path, nlu_model_path, serve_forever=True): interpreter = RasaNLUInterpreter(nlu_model_path) action_endpoint = EndpointConfig(url="http://localhost:5055/webhook") self.agent = Agent.load(core_model_path, interpreter=interpreter, action_endpoint=action_endpoint) #rasa_core.run.serve_application(self.agent ,channel='cmdline') def build_core(self): if self.agent is None: self.train_dialogue(self.config['domain_file_path'], self.config['core_model_path'], self.config['training_core_data_path']) self.run_dialogue(self.config['core_model_path'], self.config['default_nlu_model_path']) return self.agent
def train_core(domain_file="robot/config/domain.yml",
model_path="robot/models/dialogue",
training_data_file="robot/config/stories.md"):
from rasa_core.featurizers import (MaxHistoryTrackerFeaturizer,
BinarySingleStateFeaturizer)
# fallback = FallbackPolicy(fallback_action_name="action_default_fallback",
# core_threshold=0.9,
# nlu_threshold=0.9)
fallback = FallbackPolicy(fallback_action_name="action_default_custom",
core_threshold=0.8,
nlu_threshold=0.8)
agent = Agent(
domain_file,
policies=[
MemoizationPolicy(max_history=5),
KerasPolicy(
MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(),
max_history=5)), fallback
])
training_data = agent.load_data(training_data_file)
# 训练agent的策略policy
agent.train(training_data, epochs=500)
agent.persist(model_path)
return agent
def train(domain_file: Text,
stories_file: Text,
output_path: Text,
interpreter: Optional[NaturalLanguageInterpreter] = None,
endpoints: AvailableEndpoints = AvailableEndpoints(),
dump_stories: bool = False,
policy_config: Text = None,
exclusion_percentage: int = None,
kwargs: Optional[Dict] = None):
from rasa_core.agent import Agent
if not kwargs:
kwargs = {}
policies = config.load(policy_config)
agent = Agent(domain_file,
generator=endpoints.nlg,
action_endpoint=endpoints.action,
interpreter=interpreter,
policies=policies)
data_load_args, kwargs = utils.extract_args(
kwargs, {
"use_story_concatenation", "unique_last_num_states",
"augmentation_factor", "remove_duplicates", "debug_plots"
})
training_data = agent.load_data(stories_file,
exclusion_percentage=exclusion_percentage,
**data_load_args)
agent.train(training_data, **kwargs)
agent.persist(output_path, dump_stories)
return agent
def train_core(domain_file, model_path, training_data_file, policy_config):
logging.basicConfig(filename=logfile, level=logging.DEBUG)
agent = Agent(domain_file, policies=config.load(policy_config))
training_data = agent.load_data(training_data_file)
agent.train(training_data)
agent.persist(model_path)
return agent
def train_dialogue_model(domain_file,
stories_file,
output_path,
interpreter=None,
endpoints=AvailableEndpoints(),
max_history=None,
dump_flattened_stories=False,
policy_config=None,
kwargs=None):
if not kwargs:
kwargs = {}
fallback_args, kwargs = utils.extract_args(
kwargs, {"nlu_threshold", "core_threshold", "fallback_action_name"})
policies = config.load(policy_config, fallback_args, max_history)
agent = Agent(domain_file,
generator=endpoints.nlg,
action_endpoint=endpoints.action,
interpreter=interpreter,
policies=policies)
data_load_args, kwargs = utils.extract_args(
kwargs, {
"use_story_concatenation", "unique_last_num_states",
"augmentation_factor", "remove_duplicates", "debug_plots"
})
training_data = agent.load_data(stories_file, **data_load_args)
agent.train(training_data, **kwargs)
agent.persist(output_path, dump_flattened_stories)
return agent
def run_weather_online(input_channel, interpreter,domain_file="weather_domain.yml",training_data_file='data/stories.md'):
policies2 = policy_config.load("config.yml")
agent = Agent("weather_domain.yml", policies=policies2)
data = asyncio.run(agent.load_data(training_data_file))
agent.train(data)
return agent
def train(max_training_samples=3, serve_forever=True):
story = 'stories.md'
from rasa_core.interpreter import RasaNLUInterpreter
interpreter = RasaNLUInterpreter(nlu_model_path)
#domain配置文件
default_domain = TemplateDomain.load("./domain.yml")
if os.path.exists(agent_model_path):
agent = Agent.load(agent_model_path,
interpreter=interpreter,
tracker_store=InMemoryTrackerStore(default_domain))
else:
agent = Agent(domain_conf_path,
policies=[MemoizationPolicy(),
KerasPolicy()],
interpreter=interpreter,
tracker_store=InMemoryTrackerStore(default_domain))
#for debug: print(interpreter.parse(u"你好"))
logger.info("开始训练...")
training_data = agent.load_data(story)
agent.train(training_data, epochs=50)
return agent
def test_agent_train(tmpdir, default_domain):
training_data_file = 'examples/moodbot/data/stories.md'
agent = Agent("examples/moodbot/domain.yml",
policies=[AugmentedMemoizationPolicy()])
training_data = agent.load_data(training_data_file)
agent.train(training_data)
agent.persist(tmpdir.strpath)
loaded = Agent.load(tmpdir.strpath)
# test domain
assert [a.name() for a in loaded.domain.actions] == \
[a.name() for a in agent.domain.actions]
assert loaded.domain.intents == agent.domain.intents
assert loaded.domain.entities == agent.domain.entities
assert loaded.domain.templates == agent.domain.templates
assert [s.name for s in loaded.domain.slots] == \
[s.name for s in agent.domain.slots]
# test policies
assert type(loaded.policy_ensemble) is type(
agent.policy_ensemble) # nopep8
assert [type(p) for p in loaded.policy_ensemble.policies] == \
[type(p) for p in agent.policy_ensemble.policies]
def train_dialogue(domain_file, model_path, training_folder):
MemoizationPolicy.USE_NLU_CONFIDENCE_AS_SCORE = True
#keras_1 = KerasPolicy(
# MaxHistoryTrackerFeaturizer(
# BinarySingleStateFeaturizer(),
# max_history=MAX_HISTORY
# )
# )
keras_2 = KerasPolicy(
FullDialogueTrackerFeaturizer(LabelTokenizerSingleStateFeaturizer()))
#agent = Agent(domain_file, policies=[
# keras_2,
# MemoizationPolicy(max_history=MAX_HISTORY),
# CustomFallbackPolicy(
# fallback_action_name=FALLBACK_ACTION_NAME,
# nlu_threshold=NLU_THRESHOLD,
# core_threshold=CORE_THRESHOLD)])
agent = Agent(domain_file,
policies=[
keras_2,
MemoizationPolicy(max_history=MAX_HISTORY),
FallbackPolicy(nlu_threshold=NLU_THRESHOLD,
core_threshold=CORE_THRESHOLD)
])
training_data = agent.load_data(training_folder, augmentation_factor=20)
agent.train(training_data,
epochs=TRAINING_EPOCHS,
batch_size=BATCH_SIZE,
validation_split=VALIDATION_SPLIT)
agent.persist(model_path)
def train_dialogue_model(domain_file,
stories_file,
output_path,
use_online_learning=False,
nlu_model_path=None,
kwargs=None):
if not kwargs:
kwargs = {}
agent = Agent(domain_file, policies=[MemoizationPolicy(), KerasPolicy()])
training_data = agent.load_data(stories_file)
if use_online_learning:
if nlu_model_path:
agent.interpreter = RasaNLUInterpreter(nlu_model_path)
else:
agent.interpreter = RegexInterpreter()
agent.train_online(training_data,
input_channel=ConsoleInputChannel(),
model_path=output_path,
**kwargs)
else:
agent.train(training_data, **kwargs)
agent.persist(output_path)
def train_dialogue(domain_file = 'restaurant_domain.yml', model_path = './models/dialogue', training_data_file = './data/stories.md'): featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(), max_history=5) agent = Agent(domain_file, policies = [MemoizationPolicy(max_history = 5), KerasPolicy(featurizer)]) data = agent.load_data(training_data_file, augmentation_factor = 50) agent.train(data, epochs = 500, batch_size = 30, validation_split = 0.2) # 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'):
action_endpoint = EndpointConfig(url="http://localhost:5000/webhook")
fallback = FallbackPolicy(fallback_action_name="action_default_fallback",
core_threshold=0.8,
nlu_threshold=0.8)
agent = Agent('./weather_domain.yml',
policies=[
MemoizationPolicy(max_history=2, ),
KerasPolicy(epochs=500,
batch_size=50,
validation_split=0.2), fallback
],
interpreter=interpreter,
action_endpoint=action_endpoint)
data_ = agent.load_data(training_data_file, augmentation_factor=50)
agent.train(data_)
interactive.run_interactive_learning(agent,
training_data_file,
skip_visualization=True)
# agent.handle_channels(input_channel)
return agent
def run_bot(interpreter,
domain_file="domain.yml",
training_data_file='./data/stories.md'):
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=2),
KerasPolicy()],
interpreter=interpreter,
action_endpoint=action_endpoint)
data = agent.load_data(training_data_file)
"""
agent.train(data,
batch_size=50,
epochs=200,
max_training_samples=300)
online.serve_agent(agent)
online.ser
"""
agent.persist('./models/dialogue')
return agent
def train_dialogue(domain_file="hainan_domain.yml",
model_path="models/dialogue",
training_data_file="data/story.md"):
#agent = Agent(domain_file,
#policies=[MemoizationPolicy(), MobilePolicy()])
'''
featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(), max_history=2)
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=2),
KerasPolicy(featurizer)])
'''
agent = Agent(domain_file, policies=[MemoizationPolicy(), KerasPolicy()])
training_data = agent.load_data(training_data_file)
agent.train(
training_data,
epochs=200,
batch_size=16,
augmentation_factor=50,
#validation_split=0.2
)
agent.persist(model_path)
return agent
def default_agent(default_domain):
agent = Agent(default_domain,
policies=[MemoizationPolicy()],
interpreter=RegexInterpreter(),
tracker_store=InMemoryTrackerStore(default_domain))
training_data = agent.load_data(DEFAULT_STORIES_FILE)
agent.train(training_data)
return agent
def default_agent(default_domain):
agent = Agent(default_domain,
policies=[MemoizationPolicy()],
interpreter=RegexInterpreter(),
tracker_store=InMemoryTrackerStore(default_domain))
training_data = agent.load_data(DEFAULT_STORIES_FILE)
agent.train(training_data)
return agent
def train_dialogue(domain_file = 'weather_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():
agent = Agent('domain.yml', policies=[MemoizationPolicy(), KerasPolicy()])
training_data = agent.load_data('stories.md')
agent.train(
training_data)
agent.persist('models/dialogue')
return agent
def train_dialogue(domain_file, model_path, training_folder):
agent = Agent(domain_file, policies=[
MemoizationPolicy(max_history=6),
KerasPolicy(MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(),
max_history=6)),
FallbackPolicy(nlu_threshold=0.8, core_threshold=0.3)])
training_data = agent.load_data(training_folder)
agent.train(training_data, epochs=100)
agent.persist(model_path)
def default_processor(default_domain, default_nlg):
agent = Agent(default_domain,
SimplePolicyEnsemble([AugmentedMemoizationPolicy()]),
interpreter=RegexInterpreter())
training_data = agent.load_data(DEFAULT_STORIES_FILE)
agent.train(training_data)
tracker_store = InMemoryTrackerStore(default_domain)
return MessageProcessor(agent.interpreter,
agent.policy_ensemble,
default_domain,
tracker_store,
default_nlg)
def run_concertbot_online(input_channel, interpreter,
domain_file="concert_domain.yml",
training_data_file='data/stories.md'):
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=2), KerasPolicy()],
interpreter=interpreter)
training_data = agent.load_data(training_data_file)
agent.train_online(training_data,
input_channel=input_channel,
batch_size=50,
epochs=200,
max_training_samples=300)
return agent
def run_ivrbot_online(input_channel=ConsoleInputChannel(),
interpreter=RasaNLUInterpreter("projects/ivr_nlu/demo"),
domain_file="mobile_domain.yml",
training_data_file="data/mobile_story.md"):
agent = Agent(domain_file,
policies=[MemoizationPolicy(), KerasPolicy()],
interpreter=interpreter)
training_data = agent.load_data(training_data_file)
agent.train_online(training_data,
input_channel=input_channel,
batch_size=16,
epochs=200,
max_training_samples=300)
return agent
def train_dialogue_model(domain_file, stories_file, output_path,
nlu_model_path=None,
endpoints=None,
max_history=None,
dump_flattened_stories=False,
kwargs=None):
if not kwargs:
kwargs = {}
action_endpoint = utils.read_endpoint_config(endpoints, "action_endpoint")
fallback_args, kwargs = utils.extract_args(kwargs,
{"nlu_threshold",
"core_threshold",
"fallback_action_name"})
policies = [
FallbackPolicy(
fallback_args.get("nlu_threshold",
DEFAULT_NLU_FALLBACK_THRESHOLD),
fallback_args.get("core_threshold",
DEFAULT_CORE_FALLBACK_THRESHOLD),
fallback_args.get("fallback_action_name",
DEFAULT_FALLBACK_ACTION)),
MemoizationPolicy(
max_history=max_history),
KerasPolicy(
MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(),
max_history=max_history))]
agent = Agent(domain_file,
action_endpoint=action_endpoint,
interpreter=nlu_model_path,
policies=policies)
data_load_args, kwargs = utils.extract_args(kwargs,
{"use_story_concatenation",
"unique_last_num_states",
"augmentation_factor",
"remove_duplicates",
"debug_plots"})
training_data = agent.load_data(stories_file, **data_load_args)
agent.train(training_data, **kwargs)
agent.persist(output_path, dump_flattened_stories)
return agent
def train_dialogue(domain_file="mobile_domain.yml",
model_path="projects/dialogue",
training_data_file="data/mobile_story.md"):
agent = Agent(domain_file,
policies=[MemoizationPolicy(), KerasPolicy()])
training_data = agent.load_data(training_data_file)
agent.train(
training_data,
epochs=200,
batch_size=16,
augmentation_factor=50,
validation_split=0.2
)
agent.persist(model_path)
return agent
def train_dialogue(domain_file="domain.yml",
model_path="models/dialogue",
training_data_file="data/stories.md"):
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=3),
CustomPolicy()])
training_data = agent.load_data(training_data_file)
agent.train(
training_data,
epochs=400,
batch_size=100,
validation_split=0.2
)
agent.persist(model_path)
return agent
def train_dialogue(domain_file="mobile_domain.yml",
model_path="models/dialogue",
training_data_file="data/mobile_edit_story.md"):
fallback = FallbackPolicy(
fallback_action_name="action_default_fallback",
nlu_threshold=0.5,
core_threshold=0.3
)
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=5),
MobilePolicy(), fallback])
training_data = agent.load_data(training_data_file)
agent.train(
training_data,
epochs=500,
batch_size=16,
validation_split=0.2
)
agent.persist(model_path)
return agent
def test_agent_train(tmpdir, default_domain):
training_data_file = 'examples/moodbot/data/stories.md'
agent = Agent("examples/moodbot/domain.yml",
policies=[AugmentedMemoizationPolicy()])
training_data = agent.load_data(training_data_file)
agent.train(training_data)
agent.persist(tmpdir.strpath)
loaded = Agent.load(tmpdir.strpath)
# test domain
assert loaded.domain.action_names == agent.domain.action_names
assert loaded.domain.intents == agent.domain.intents
assert loaded.domain.entities == agent.domain.entities
assert loaded.domain.templates == agent.domain.templates
assert [s.name for s in loaded.domain.slots] == \
[s.name for s in agent.domain.slots]
# test policies
assert type(loaded.policy_ensemble) is type(
agent.policy_ensemble) # nopep8
assert [type(p) for p in loaded.policy_ensemble.policies] == \
[type(p) for p in agent.policy_ensemble.policies]
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from rasa_core import utils
from rasa_core.agent import Agent
from rasa_core.policies.keras_policy import KerasPolicy
from rasa_core.policies.memoization import MemoizationPolicy
if __name__ == '__main__':
utils.configure_colored_logging(loglevel="INFO")
training_data_file = 'data/stories.md'
model_path = 'models/dialogue'
agent = Agent("concert_domain.yml",
policies=[MemoizationPolicy(), KerasPolicy()])
training_data = agent.load_data(training_data_file)
agent.train(
training_data,
augmentation_factor=50,
max_history=2,
epochs=500,
batch_size=10,
validation_split=0.2
)
agent.persist(model_path)
