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)