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/dialogue'
agent = Agent('anime_domain.yml',
policies=[
MemoizationPolicy(),
KerasPolicy(max_history=2,
epochs=500,
batch_size=10,
validation_split=0.2,
augmentation_factor=50)
])
data = agent.load_data(training_data_file)
agent.train(
data #,
#augmentation_factor = 50, #Especifica o numero de stories que o rasa cria para auxiliar no treinamento do modelo
#max_history = 2,#numero de estados que o modelo armazena. Deve aumentar conforme o tamanho do dataset
#epochs = 500,
#batch_size = 10,
#validation_split = 0.2
)
import logging
from rasa_core.agent import Agent
from rasa_core.policies.keras_policy import KerasPolicy
from rasa_core.policies.memoization import MemoizationPolicy
from rasa_core.featurizers import (MaxHistoryTrackerFeaturizer,
BinarySingleStateFeaturizer)
if __name__ == '__main__':
logging.basicConfig(level='INFO')
training_data_file = './data/stories.md'
model_path = './models/dialogue'
featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(),
max_history=5)
agent = Agent(
'foodie_domain.yml',
policies=[MemoizationPolicy(max_history=4),
KerasPolicy(featurizer)])
agent.train(
training_data_file,
augmentation_factor=50,
#max_history = 4,
epochs=500,
batch_size=30,
validation_split=0.2)
agent.persist(model_path)
from __future__ import absolute_import
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
from rasa_core.policies.sklearn_policy import SklearnPolicy
if __name__ == '__main__':
utils.configure_colored_logging(loglevel="DEBUG")
training_data_file = './data/stories.md'
model_path = './models/dialogue'
agent = Agent("horoscope_domain.yml",
policies=[MemoizationPolicy(max_history = 2), KerasPolicy()])
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)
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
from rasa_core.policies.fallback import FallbackPolicy
if __name__ == '__main__':
logging.basicConfig(level='INFO')
training_data_file = './data/stories.md'
model_path = './models/dialogue'
fallback = FallbackPolicy(fallback_action_name="action_default_fallback",
core_threshold=0.9,
nlu_threshold=0.9)
agent = Agent(
'weather_domain.yml',
policies=[MemoizationPolicy(max_history=2),
KerasPolicy(), fallback])
agent.train(training_data_file,
epochs=400,
batch_size=15,
validation_split=0.2)
agent.persist(model_path)
'''
generates dialogue management model, stored in model_path
'''
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 = 'C:/Murali/Testing/hackathon2018/customer_bot-master/data/stories.md'
model_path = 'C:/Murali/Testing/hackathon2018/customer_bot-master/models/dialogue'
agent = Agent('customer_domain.yml', policies = [MemoizationPolicy(), KerasPolicy()])
agent.train(
training_data_file,
epochs = 500,
batch_size = 10,
validation_split = 0.2)
agent.persist(model_path)
def create_policy(self, featurizer):
p = KerasPolicy(featurizer)
return p
from wxpy import *
from rasa_core.agent import Agent
from rasa_core.interpreter import RasaNLUInterpreter
from rasa_core.policies.keras_policy import KerasPolicy
from rasa_core.policies.memoization import MemoizationPolicy
from rasa_core.utils import EndpointConfig
agent = Agent('w_domain.yml',
policies=[
MemoizationPolicy(),
KerasPolicy(max_history=3, epochs=200, batch_size=50)
])
data = agent.load_data('./data/stories.md')
agent.train(data)
interpreter = RasaNLUInterpreter('./models/nlu/default/trainedNlu')
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
agent = Agent.load('./models/dialogue',
interpreter=interpreter,
action_endpoint=action_endpoint)
bot = Bot(console_qr=False, cache_path=True)
@bot.register(bot.friends())
def reply_my_friend(msg):
ans = agent.handle_message(msg.text)
print(ans)
return ans[0]['text']
embed()
def main(logger=None):
''' Main routine to call the entire process flow '''
# Train and persist NLU model --- Process starts
logger.info(f'')
logger.info(f'{"-"*20} Train and persist NLU model starts here {"-"*20}')
logger.info(f'')
filename_p1 = "_".join(__file__.split("_")[:-1])
nlu_config = nlu_config_dump(filename_p1=filename_p1, logger=logger)
nlu_data = nlu_data_dump(filename_p1=filename_p1, logger=logger)
warnings.filterwarnings('ignore')
warnings.simplefilter(action='ignore', category=FutureWarning)
# warnings.simplefilter(action='ignore', category=DP);
training_data = load_data(f'{nlu_data}')
trainer = Trainer(config.load(f'{nlu_config}'))
trainer.train(training_data)
model_directory = trainer.persist(f'{filename_p1}_models/nlu/',
fixed_model_name="current")
logger.info(f'')
logger.info(f'{"-"*20} Train and persist NLU model ends here {"-"*20}')
logger.info(f'')
# Train and persist NLU model --- Process ends
# Dialogue model --- Process starts
logger.info(f'')
logger.info(f'{"-"*20} Dialogue model starts here {"-"*20}')
logger.info(f'')
domain_file = domain_dump(filename_p1=filename_p1, logger=logger)
stories_file = stories_dump(filename_p1=filename_p1, logger=logger)
endpoint_file = endpoint_dump(filename_p1=filename_p1, logger=logger)
subprocess.call('export PYTHONWARNINGS="ignore"', shell=True)
# python3 -m rasa_core_sdk.endpoint --actions 04_Blog_03_ChatBot_Actions.weather
return_code = subprocess.call(
"python3 -m rasa_core_sdk.endpoint --actions 05_Blog_03_ChatBot_Actions.weather &",
shell=True)
logger.info(f'{return_code}')
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=3),
KerasPolicy()])
training_data = agent.load_data(stories_file)
agent.train(training_data, epochs=400, batch_size=100, validation_size=0.2)
agent.persist(f'{filename_p1}_models/dialogue/')
# python3 04.Blog_03_ChatBot_Run.py --core ./models/dialogue --nlu ./models/nlu/default/current --endpoints 04.Blog_03_endpoints.yml
return_code = subprocess.call(
f'python3 05.Blog_03_ChatBot_Run.py --core ./{filename_p1}_models/dialogue --nlu ./{filename_p1}_models/nlu/default/current --endpoints {endpoint_file}',
shell=True)
logger.info(f'')
logger.info(f'{"-"*20} Dialogue model ends here {"-"*20}')
logger.info(f'')
raise ValueError("Cannot construct the model because"
"length of output_shape = {} "
"should be 1 or 2."
"".format(len(output_shape)))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#logger.debug(model.summary())
return model
if __name__ == '__main__':
logging.basicConfig(level='INFO')
training_data_file = './stories.md'
model_path = './models/dialogue'
agent = Agent('hospital_domain.yml', policies=[HospitalPolicy(), KerasPolicy()])
agent.train(
training_data_file,
augmentation_factor=25,
epochs=300,
batch_size=100,
validation_split=0.2)
agent.persist(model_path)
#Training the bot using stories.md
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
from __future__ import print_function
import logging
import asyncio
from rasa_core.agent import Agent
from rasa_core.policies.keras_policy import KerasPolicy
from rasa_core.policies.memoization import MemoizationPolicy
from rasa_core import config as policy_config
if __name__ == '__main__':
logging.basicConfig(level='INFO')
training_data_file = './data/stories.md'
model_path = './models/dialogue'
#policies2 = policy_config.load("policies.yml")
agent = Agent("weather_domain.yml",
policies=[
MemoizationPolicy(),
KerasPolicy(epochs=200,
batch_size=10,
validation_split=0.2)
])
training_data = agent.load_data(training_data_file)
agent.train(training_data)
agent.persist(model_path)
def create_policy(self, featurizer, priority):
p = KerasPolicy(featurizer, priority)
return p
def __init__(
self,
disable_nlu=os.environ.get('rasa_disable_nlu', 'no'),
disable_core=os.environ.get('rasa_disable_core', 'no'),
mqtt_hostname=os.environ.get('mqtt_hostname', 'mosquitto'),
mqtt_port=os.environ.get('mqtt_port', 1883),
nlu_model_path=os.environ.get('rasa_nlu_model_path',
'rasa_config/models/default/current'),
nlu_model_path_slots=os.environ.get(
'rasa_nlu_model_path_slots', 'rasa_config/models/default/slots'),
snips_assistant_path=os.environ.get('rasa_snips_assistant_path',
'models/snips'),
snips_user_id=os.environ.get('rasa_snips_user_id', 'user_Kr5A7b4OD'),
core_model_path=os.environ.get('rasa_core_model_path',
'rasa_config/models/dialogue'),
config_file=os.environ.get('rasa_config_file',
'rasa_config/config.json'),
config_file_slots=os.environ.get('rasa_config_file_slots',
'rasa_config/config-slots.json'),
domain_file=os.environ.get('rasa_domain_file',
'rasa_config/domain.yml'),
nlu_training_file=os.environ.get('rasa_nlu_training_file',
'rasa_config/nlu.md'),
core_training_file=os.environ.get('rasa_core_training_file',
'rasa_config/stories.md'),
lang=os.environ.get('rasa_lang', 'en-GB')):
""" Initialisation.
:param config: a YAML configuration.
:param assistant: the client assistant class, holding the
intent handler and intents registry.
"""
self.thread_handler = ThreadHandler()
self.client = mqtt.Client()
self.client.on_connect = self.on_connect
self.client.on_disconnect = self.on_disconnect
self.client.on_message = self.on_message
self.mqtt_hostname = mqtt_hostname
self.mqtt_port = mqtt_port
self.lang = lang
# RASA config
self.disable_nlu = disable_nlu
self.disable_core = disable_core
self.interpreter = None
self.interpreter_slots = None
self.nlu_model_path = nlu_model_path
self.nlu_model_path_slots = nlu_model_path_slots
self.core_model_path = core_model_path
# to generate stub assistant
self.snips_assistant_path = snips_assistant_path
self.snips_user_id = snips_user_id
self.config_file = config_file
self.config_file_slots = config_file_slots
# RASA training config
self.domain_file = domain_file
self.nlu_training_file = nlu_training_file
self.core_training_file = core_training_file
self.isNluTraining = False
self.isCoreTraining = False
# save modified times on source files
self.nlu_modified = self.getNluModified()
self.nlu_model_modified = self.getNluModelModified()
self.core_modified = self.getCoreModified()
self.core_domain_modified = self.getCoreDomainModified()
self.core_model_modified = self.getCoreModelModified()
self.agent = agent = Agent(
self.domain_file, policies=[MemoizationPolicy(),
KerasPolicy()])
self.agentLoaded = None
self.loadModels(True)
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/dialogue/'
agent = Agent('domain.yml',
policies=[
MemoizationPolicy(max_history=2),
KerasPolicy(epochs=500, batch_size=10)
])
data = agent.load_data(training_data_file)
agent.train(data, augmentation_factor=50, validation_split=0.2)
agent.persist(model_path)
from rasa_core.policies.fallback import FallbackPolicy
import warnings
warnings.filterwarnings('ignore')
if __name__ == '__main__':
logging.basicConfig(level='INFO')
training_data_file = './data/stories.md'
model_path = './models/dialogue'
fallback = FallbackPolicy(fallback_action_name="action_default_fallback",
core_threshold=0.3,
nlu_threshold=0.3)
featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(),
max_history=5)
agent = Agent('restaurant_domain.yml',
policies=[
MemoizationPolicy(max_history=5),
KerasPolicy(featurizer), fallback
])
agent.train(
training_data_file,
augmentation_factor=50,
#max_history = 4,
epochs=500,
batch_size=30,
validation_split=0.2)
agent.persist(model_path)
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
from constants_ import *
from haolib import *
prj_dir = "{}/example/02_Weatherbot/".format(PRJ_DIR)
print(prj_dir)
if __name__ == '__main__':
logging.basicConfig(level='INFO')
training_data_file = './data/stories.md'.format(prj_dir)
model_path = './models/dialogue'.format(prj_dir)
agent = Agent('weather_domain.yml'.format(prj_dir), policies=[MemoizationPolicy(), KerasPolicy()])
agent.train(
training_data_file,
augmentation_factor=50,
max_history=2,
epochs=500,
batch_size=10,
validation_split=0.2)
agent.persist(model_path)
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
import logging
# this is the trainter agent
from rasa_core.agent import Agent
# both imports are the models how to train our model
from rasa_core.policies.keras_policy import KerasPolicy
from rasa_core.policies.memoization import MemoizationPolicy
if __name__ == '__main__':
logging.basicConfig(level='INFO')
# our stories for for the trainging
training_data_file = './data/coco_stories.md'
# path where files should be stored
model_path = './models/dialogue'
# Create a training agent with our domain file and the training models
agent = Agent('coco_domain.yml', policies = [MemoizationPolicy(max_history = 2), KerasPolicy()])
# start training, with 500 epochs (iterations), use a batch size of 10, and split trainting data into 80/20
agent.train(
training_data_file,
epochs = 500,
batch_size = 10,
validation_split = 0.2)
# store results
agent.persist(model_path)
def create_policy(self):
p = KerasPolicy()
return p
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/dialogue'
agent = Agent('weather_domain.yml',
policies=[
MemoizationPolicy(max_history=2),
KerasPolicy(augmentation_factor=50,
epochs=500,
batch_size=10,
validation_split=0.2)
])
data = agent.load_data(training_data_file)
agent.train(data)
# # augmentation_factor = 50, #how many generated story?
# # max_history = 2, #how many state should it remember
# epochs = 500,
# batch_size = 10,
# validation_split = 0.2)
agent.persist(model_path)
training_data_file = './data/stories.md'
model_path = './models/dialogue_element2'
fallback = FallbackPolicy(fallback_action_name="action_default_fallback",
core_threshold=0.5,
nlu_threshold=0.5)
# agent = Agent('./weather_domain.yml',
# policies = [MemoizationPolicy(max_history = 2,),
# KerasPolicy(epochs = 100 ,#),fallback])
# batch_size = 50,
# validation_split = 0.2),fallback])
# agent = Agent('./weather_domain.yml',
# policies = [MemoizationPolicy(max_history = 2,),
# KerasPolicy(epochs = 500,
# batch_size = 50,
# validation_split = 0.2),fallback])
agent = Agent('./weather_domain.yml',
policies=[
MemoizationPolicy(max_history=10, ),
KerasPolicy(epochs=150, batch_size=50, rnn_size=500),
fallback
])
data_ = agent.load_data(training_data_file, augmentation_factor=50)
agent.train(data_)
agent.persist(model_path)
run_weather_bot()
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 = u'./data/stories.md'
model_path = u'./models/dialogue'
agent = Agent(u'weather_domain.yml', policies=[MemoizationPolicy(), KerasPolicy()])
agent.train(
training_data_file,
augmentation_factor=50,
max_history=2,
epochs=500,
batch_size=10,
validation_split=0.2)
agent.persist(model_path)
def visualize():
agent = Agent("weather_domain.yml",
policies=[MemoizationPolicy(),
KerasPolicy()])
agent.visualize("data/stories.md", output_file="graph.png", max_history=2)
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/dialogue'
agent = Agent('mood_domain.yml', policies = [MemoizationPolicy(), KerasPolicy()])
agent.train(
training_data_file,
augmentation_factor = 50,
#max_history = 2,
epochs = 500,
batch_size = 10,
validation_split = 0.2)
agent.persist(model_path)
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import bot
from rasa_core.agent import Agent
from rasa_core.policies.keras_policy import KerasPolicy
from rasa_core.policies.memoization import MemoizationPolicy
agent = Agent("domain.yml",
policies=[MemoizationPolicy(), KerasPolicy()])
agent.visualize("data/1.md",
output_file="graph.png", max_history=2)
from rasa_core.interpreter import RasaNLUInterpreter
from rasa_core.policies.keras_policy import KerasPolicy
from rasa_core.policies.memoization import MemoizationPolicy
from rasa_core.policies import FallbackPolicy
if __name__ == '__main__':
logging.basicConfig(level="INFO")
model_path = './models/dialogue'
# this will catch predictions the model isn't very certain about
# there is a threshold for the NLU predictions as well as the action predictions
fallback = FallbackPolicy(fallback_action_name="utter_unclear", core_threshold=0.3, nlu_threshold=0.3)
interpreter = RasaNLUInterpreter("./models/nlu/default/hotel_nlu")
agent = Agent("hotel_domain.yml", policies=[MemoizationPolicy(), KerasPolicy(), fallback])
# loading our neatly defined training dialogues
training_data = agent.load_data('./data/stories.md')
agent.train(training_data)
agent.persist(model_path)
agent = Agent.load("./models/dialogue", interpreter=interpreter)
# agent.handle.text("hello")
# print("Your bot is ready to talk! Type your message here or send 'stop'")
# while True:
# a = input()
# if a == 'stop':
# break
# responses = agent.handle_text(a)
# for response in responses:
from rasa_core.policies.keras_policy import KerasPolicy
from rasa_core.policies.memoization import MemoizationPolicy
from rasa_core.featurizers import (MaxHistoryTrackerFeaturizer,
BinarySingleStateFeaturizer)
from rasa_core.policies.fallback import FallbackPolicy
import logging
if __name__ == '__main__':
logging.basicConfig(level='INFO')
training_data_file = './data/ankit_stories.md'
model_path = './models/dialogue'
# fallback = FallbackPolicy(fallback_action_name="action_default_fallback", core_threshold=0.001,nlu_threshold=0.001)
featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(),
max_history=100)
agent = Agent(
'./restaurant_domain.yml',
policies=[KerasPolicy(featurizer),
MemoizationPolicy(max_history=100)])
agent.train(training_data_file,
augmentation_factor=50,
epoch=500,
batch_size=10,
validation_split=0.2)
agent.persist(model_path)
def create_policy(self, featurizer):
p = KerasPolicy(featurizer, **tf_defaults())
return p
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
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("domain.yml", policies=[MemoizationPolicy(), KerasPolicy()])
agent.visualize("data/generated_story_v1.md",
output_file="graph.html",
max_history=2)
'--nlu_data',
default=None,
type=str,
help="path of the Rasa NLU training data, "
"used to insert example messages into the graph")
utils.add_logging_option_arguments(parser)
return parser
if __name__ == '__main__':
parser = create_argument_parser()
args = parser.parse_args()
utils.configure_colored_logging(args.loglevel)
agent = Agent(args.domain, policies=[MemoizationPolicy(), KerasPolicy()])
# this is optional, only needed if the `_greet` type of
# messages in the stories should be replaced with actual
# messages (e.g. `hello`)
if args.nlu_data is not None:
from rasa_nlu.converters import load_data
nlu_data = load_data(args.nlu_data)
else:
nlu_data = None
logger.info("Starting to visualize stories...")
agent.visualize(args.stories,
args.output,
args.max_history,
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/dialogue'
agent = Agent('wine_domain.yml',
policies=[MemoizationPolicy(),
KerasPolicy()])
# Invokes the agent class and passes domain file and our machine learning
# policy to be used.
agent.train(training_data_file,
augmentation_factor=50,
max_history=2,
epochs=500,
batch_size=10,
validation_split=0.2)
agent.persist(model_path)
import logging
from rasa_core.agent import Agent
from rasa_core.policies.keras_policy import KerasPolicy
from rasa_core.policies.memoization import MemoizationPolicy
from rasa_core.utils import EndpointConfig
from rasa_core.interpreter import RasaNLUInterpreter
from rasa_core.policies.fallback import FallbackPolicy
if __name__ == '__main__':
logging.basicConfig(level='INFO')
training_data_file = './data/stories.md'
model_path = './models/dialogue'
domain_file = "Sell4BidsBot_domain.yml"
nlu_interpreter = RasaNLUInterpreter('./models/nlu/default/sell4bidsbotnlu')
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
fallback = FallbackPolicy(fallback_action_name="action_default_fallback", core_threshold=0.3, nlu_threshold=0.3)
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=2), KerasPolicy(max_history=3, epochs=3, batch_size=50),fallback],
interpreter=nlu_interpreter,action_endpoint=action_endpoint)
agent.train(agent.load_data(training_data_file))
agent.persist(model_path)
#agent.visualize(training_data_file,output_file="graph1.png", max_history=3)
