def run_interactive_learning(stories: Text = None, finetune: bool = False, skip_visualization: bool = False, server_args: Dict[Text, Any] = None, additional_arguments: Dict[Text, Any] = None): """Start the interactive learning with the model of the agent.""" server_args = server_args or {} if not skip_visualization: p = Process(target=start_visualization, args=("story_graph.dot", )) p.deamon = True p.start() else: p = None app = run.configure_app(enable_api=True) endpoints = AvailableEndpoints.read_endpoints(server_args.get("endpoints")) # before_server_start handlers make sure the agent is loaded before the # interactive learning IO starts if server_args.get("core"): app.register_listener( partial(run.load_agent_on_start, server_args.get("core"), endpoints, server_args.get("nlu")), 'before_server_start') else: app.register_listener( partial(train_agent_on_start, server_args, endpoints, additional_arguments), 'before_server_start') _serve_application(app, stories, finetune, skip_visualization) if not skip_visualization: p.terminate() p.join()
def run(core_dir, nlu_dir, endpoints_file): configs = { 'user': os.getenv('ROCKETCHAT_BOT_USERNAME'), 'password': os.getenv('ROCKETCHAT_BOT_PASSWORD'), 'server_url': os.getenv('ROCKETCHAT_URL'), } input_channel = RocketChatInput(user=configs['user'], password=configs['password'], server_url=configs['server_url']) _endpoints = AvailableEndpoints.read_endpoints(endpoints_file) _interpreter = NaturalLanguageInterpreter.create(nlu_dir, _endpoints.nlu) _tracker_store = ElasticTrackerStore() _agent = load_agent(core_dir, interpreter=_interpreter, tracker_store=_tracker_store, endpoints=_endpoints) http_server = start_server([input_channel], "", "", 5005, _agent) try: http_server.serve_forever() except Exception as exc: logger.exception(exc)
def create_agent(model: Text, endpoints: Text = None) -> 'Agent': from rasa_core.interpreter import RasaNLUInterpreter from rasa_core.tracker_store import TrackerStore from rasa_core import broker from rasa_core.utils import AvailableEndpoints core_path, nlu_path = get_model_subdirectories(model) _endpoints = AvailableEndpoints.read_endpoints(endpoints) _interpreter = None if os.path.exists(nlu_path): _interpreter = RasaNLUInterpreter(model_directory=nlu_path) else: _interpreter = None logging.info("No NLU model found. Running without NLU.") _broker = broker.from_endpoint_config(_endpoints.event_broker) _tracker_store = TrackerStore.find_tracker_store(None, _endpoints.tracker_store, _broker) return Agent.load(core_path, generator=_endpoints.nlg, tracker_store=_tracker_store, action_endpoint=_endpoints.action)
def serve_application(model_directory: Text, nlu_model: Optional[Text] = None, tracker_dump: Optional[Text] = None, port: int = constants.DEFAULT_SERVER_PORT, endpoints: Optional[Text] = None, enable_api: bool = True): from rasa_core import run _endpoints = AvailableEndpoints.read_endpoints(endpoints) nlu = NaturalLanguageInterpreter.create(nlu_model, _endpoints.nlu) input_channels = run.create_http_input_channels("cmdline", None) agent = load_agent(model_directory, interpreter=nlu, endpoints=_endpoints) http_server = run.start_server(input_channels, None, None, port=port, initial_agent=agent, enable_api=enable_api) tracker = load_tracker_from_json(tracker_dump, agent.domain) run.start_cmdline_io(constants.DEFAULT_SERVER_FORMAT.format(port), http_server.stop, sender_id=tracker.sender_id) replay_events(tracker, agent) try: http_server.serve_forever() except Exception as exc: logger.exception(exc)
def run(core_dir, nlu_dir): input_channel = SocketIOInput(user_message_evt="user_uttered", bot_message_evt="bot_uttered", session_persistence=True, namespace=None) _endpoints = AvailableEndpoints.read_endpoints('endpoints.yml') _interpreter = NaturalLanguageInterpreter.create(nlu_dir) elastic_user = os.getenv('ELASTICSEARCH_USER') if elastic_user is None: _tracker_store = ElasticTrackerStore( domain=os.getenv('ELASTICSEARCH_URL', 'elasticsearch:9200')) else: _tracker_store = ElasticTrackerStore( domain=os.getenv('ELASTICSEARCH_URL', 'elasticsearch:9200'), user=os.getenv('ELASTICSEARCH_USER', 'user'), password=os.getenv('ELASTICSEARCH_PASSWORD', 'password'), scheme=os.getenv('ELASTICSEARCH_HTTP_SCHEME', 'http'), scheme_port=os.getenv('ELASTICSEARCH_PORT', '80')) _agent = load_agent(core_dir, interpreter=_interpreter, tracker_store=_tracker_store, endpoints=_endpoints) WEBCHAT_PORT = os.getenv('WEBCHAT_PORT', 3000) http_server = start_server([input_channel], "", "", int(WEBCHAT_PORT), _agent) try: http_server.serve_forever() except Exception as exc: logger.exception(exc)
def run(core_dir, nlu_dir): pika_broker = None if ENABLE_ANALYTICS: pika_broker = PikaProducer(url, username, password, queue=queue) configs = { 'user': os.getenv('ROCKETCHAT_BOT_USERNAME'), 'password': os.getenv('ROCKETCHAT_BOT_PASSWORD'), 'server_url': os.getenv('ROCKETCHAT_URL'), } input_channel = RocketChatInput(user=configs['user'], password=configs['password'], server_url=configs['server_url']) _tracker_store = InMemoryTrackerStore(domain=None, event_broker=pika_broker) _endpoints = AvailableEndpoints.read_endpoints(None) _interpreter = NaturalLanguageInterpreter.create(nlu_dir) _agent = load_agent(core_dir, interpreter=_interpreter, tracker_store=_tracker_store, endpoints=_endpoints) http_server = start_server([input_channel], "", "", 5005, _agent) try: http_server.serve_forever() except Exception as exc: logger.exception(exc)
def run(core_dir, nlu_dir): _endpoints = AvailableEndpoints.read_endpoints('endpoints.yml') _interpreter = NaturalLanguageInterpreter.create(nlu_dir) input_channel = TelegramInput(access_token=os.getenv( 'TELEGRAM_ACCESS_TOKEN', ''), verify=os.getenv('VERIFY', ''), webhook_url=os.getenv('WEBHOOK_URL', '')) elastic_user = os.getenv('ELASTICSEARCH_USER') if elastic_user is None: _tracker_store = ElasticTrackerStore( domain=os.getenv('ELASTICSEARCH_URL', 'elasticsearch:9200')) else: _tracker_store = ElasticTrackerStore( domain=os.getenv('ELASTICSEARCH_URL', 'elasticsearch:9200'), user=os.getenv('ELASTICSEARCH_USER', 'user'), password=os.getenv('ELASTICSEARCH_PASSWORD', 'password'), scheme=os.getenv('ELASTICSEARCH_HTTP_SCHEME', 'http'), scheme_port=os.getenv('ELASTICSEARCH_PORT', '80')) _agent = load_agent(core_dir, interpreter=_interpreter, tracker_store=_tracker_store, endpoints=_endpoints) http_server = _agent.handle_channels([input_channel], 5001, "") try: http_server.serve_forever() except Exception as exc: logger.exception(exc)
def run(): endpoints = AvailableEndpoints.read_endpoints('config/endpoints.yml') interpreter = NaturalLanguageInterpreter.create('models/ticket/nlu_bot',endpoints.nlu) agent = load_agent("models/dialogue", interpreter=interpreter, endpoints=endpoints) serve_application(agent,channel='rest') # serve_application(agent) return agent
def test_formbot_example(): sys.path.append("examples/formbot/") p = "examples/formbot/" stories = os.path.join(p, "data", "stories.md") endpoint = EndpointConfig("https://abc.defg/webhooks/actions") endpoints = AvailableEndpoints(action=endpoint) agent = train(os.path.join(p, "domain.yml"), stories, os.path.join(p, "models", "dialogue"), endpoints=endpoints, policy_config="rasa_core/default_config.yml") response = { 'events': [{ 'event': 'form', 'name': 'restaurant_form', 'timestamp': None }, { 'event': 'slot', 'timestamp': None, 'name': 'requested_slot', 'value': 'cuisine' }], 'responses': [{ 'template': 'utter_ask_cuisine' }] } httpretty.register_uri(httpretty.POST, 'https://abc.defg/webhooks/actions', body=json.dumps(response)) httpretty.enable() responses = agent.handle_text("/request_restaurant") httpretty.disable() assert responses[0]['text'] == 'what cuisine?' response = { "error": "Failed to validate slot cuisine with action restaurant_form", "action_name": "restaurant_form" } httpretty.register_uri(httpretty.POST, 'https://abc.defg/webhooks/actions', status=400, body=json.dumps(response)) httpretty.enable() responses = agent.handle_text("/chitchat") httpretty.disable() assert responses[0]['text'] == 'chitchat'
def _create_agent(model_directory, interpreter): """Creates a Rasa Agent which runs when the server is started""" try: endpoints = AvailableEndpoints.read_endpoints('endpoints.yml') return Agent.load(model_directory, interpreter, action_endpoint=endpoints.action) except Exception as e: logger.warn("Failed to load any agent model. Running " "Rasa Core server with out loaded model now. {}" "".format(e)) return None
async def test_formbot_example(): sys.path.append("examples/formbot/") p = "examples/formbot/" stories = os.path.join(p, "data", "stories.md") endpoint = EndpointConfig("https://example.com/webhooks/actions") endpoints = AvailableEndpoints(action=endpoint) agent = await train(os.path.join(p, "domain.yml"), stories, os.path.join(p, "models", "dialogue"), endpoints=endpoints, policy_config="rasa_core/default_config.yml") response = { 'events': [{ 'event': 'form', 'name': 'restaurant_form', 'timestamp': None }, { 'event': 'slot', 'timestamp': None, 'name': 'requested_slot', 'value': 'cuisine' }], 'responses': [{ 'template': 'utter_ask_cuisine' }] } with aioresponses() as mocked: mocked.post('https://example.com/webhooks/actions', payload=response, repeat=True) responses = await agent.handle_text("/request_restaurant") assert responses[0]['text'] == 'what cuisine?' response = { "error": "Failed to validate slot cuisine with action " "restaurant_form", "action_name": "restaurant_form" } with aioresponses() as mocked: # noinspection PyTypeChecker mocked.post('https://example.com/webhooks/actions', repeat=True, exception=ClientResponseError(400, "", json.dumps(response))) responses = await agent.handle_text("/chitchat") assert responses[0]['text'] == 'chitchat'
def run_online(domain_file="config/domain.yml", stories_file="config/stories.md", output_path="models/dialogue", max_history=3, kwargs={"batch_size": 50, "epochs": 800, "max_training_samples": 300}): interpreter = RasaNLUInterpreter("models/ticket/nlu_bot") agent = train.train_dialogue_model(domain_file=domain_file, interpreter=interpreter, stories_file=stories_file, output_path=output_path, max_history=max_history, endpoints=AvailableEndpoints.read_endpoints("config/endpoints.yml"), kwargs=kwargs) online.run_online_learning(agent)
def load_agent(): p = "examples/formbot/" strpath = os.path.join(p, "models", "dialogue") endpoint = EndpointConfig("http://localhost:5055/webhook") endpoints = AvailableEndpoints(action=endpoint) loaded = Agent.load(strpath, interpreter=RegexInterpreter(), action_endpoint=endpoints.action) # loaded = Agent.load(strpath, interpreter=RegexInterpreter()) responses = loaded.handle_text("/request_restaurant") print(responses[0]) responses = loaded.handle_text("/chitchat") print(responses)
def main(): from rasa_core.agent import Agent from rasa_core.interpreter import NaturalLanguageInterpreter from rasa_core.utils import (AvailableEndpoints, set_default_subparser) import rasa_nlu.utils as nlu_utils import rasa_core.cli from rasa_core import utils loop = asyncio.get_event_loop() # Running as standalone python application arg_parser = create_argument_parser() set_default_subparser(arg_parser, 'default') cmdline_arguments = arg_parser.parse_args() logging.basicConfig(level=cmdline_arguments.loglevel) _endpoints = AvailableEndpoints.read_endpoints(cmdline_arguments.endpoints) if cmdline_arguments.output: nlu_utils.create_dir(cmdline_arguments.output) if not cmdline_arguments.core: raise ValueError("you must provide a core model directory to evaluate " "using -d / --core") if cmdline_arguments.mode == 'default': _interpreter = NaturalLanguageInterpreter.create( cmdline_arguments.nlu, _endpoints.nlu) _agent = Agent.load(cmdline_arguments.core, interpreter=_interpreter) stories = loop.run_until_complete( rasa_core.cli.train.stories_from_cli_args(cmdline_arguments)) loop.run_until_complete( test(stories, _agent, cmdline_arguments.max_stories, cmdline_arguments.output, cmdline_arguments.fail_on_prediction_errors, cmdline_arguments.e2e)) elif cmdline_arguments.mode == 'compare': compare(cmdline_arguments.core, cmdline_arguments.stories, cmdline_arguments.output) story_n_path = os.path.join(cmdline_arguments.core, 'num_stories.json') number_of_stories = utils.read_json_file(story_n_path) plot_curve(cmdline_arguments.output, number_of_stories) logger.info("Finished evaluation")
def run(core_dir, nlu_dir): _endpoints = AvailableEndpoints.read_endpoints('endpoints.yml') _interpreter = NaturalLanguageInterpreter.create(nlu_dir) input_channel = FacebookInput( fb_verify=VERIFY, # you need tell facebook this token, to confirm your URL fb_secret=SECRET, # your app secret fb_access_token=FACEBOOK_ACCESS_TOKEN # token for the page you subscribed to ) _agent = load_agent(core_dir, interpreter=_interpreter, endpoints=_endpoints) _agent.handle_channels([input_channel], 5001, serve_forever=True)
def run_evaluation(file_to_evaluate, fail_on_prediction_errors=False, max_stories=None, use_e2e=False): _endpoints = AvailableEndpoints.read_endpoints(None) _interpreter = NaturalLanguageInterpreter.create(NLU_DIR) _agent = load_agent(CORE_DIR, interpreter=_interpreter, endpoints=_endpoints) completed_trackers = _generate_trackers(file_to_evaluate, _agent, max_stories, use_e2e) story_evaluation, _ = collect_story_predictions(completed_trackers, _agent, fail_on_prediction_errors, use_e2e) _failed_stories = story_evaluation.failed_stories _num_stories = len(completed_trackers) _file_result = FileResult(num_stories=_num_stories, num_failed_stories=len(_failed_stories)) file_message = "EVALUATING STORIES FOR FILE '{}':".format(file_to_evaluate) utils.print_color('\n' + '#' * 80, BOLD_COLOR) utils.print_color(file_message, BOLD_COLOR) files_results[file_to_evaluate] = _file_result if len(_failed_stories) == 0: success_message = "The stories have passed for file '{}'!!" \ .format(file_to_evaluate) utils.print_color('\n' + '=' * len(success_message), BLUE_COLOR) utils.print_color(success_message, BLUE_COLOR) utils.print_color('=' * len(success_message), BLUE_COLOR) else: for failed_story in _failed_stories: process_failed_story(failed_story.export_stories()) story_name = re.search('## (.*)', failed_story.export_stories()).group(1) all_failed_stories.append(file_to_evaluate + ' - ' + story_name) utils.print_color('#' * 80 + '\n', BOLD_COLOR)
def run(core_dir, nlu_dir): _endpoints = AvailableEndpoints.read_endpoints('endpoints.yml') _interpreter = NaturalLanguageInterpreter.create(nlu_dir) input_channel = TelegramInput(access_token=os.getenv( 'TELEGRAM_ACCESS_TOKEN', ''), verify=os.getenv('VERIFY', ''), webhook_url=os.getenv('WEBHOOK_URL', '')) _agent = load_agent(core_dir, interpreter=_interpreter, endpoints=_endpoints) http_server = _agent.handle_channels([input_channel], 5001, "") try: http_server.serve_forever() except Exception as exc: logger.exception(exc)
def run(core_dir, nlu_dir): configs = { 'user': os.getenv('ROCKETCHAT_BOT_USERNAME'), 'password': os.getenv('ROCKETCHAT_BOT_PASSWORD'), 'server_url': os.getenv('ROCKETCHAT_URL'), } input_channel = RocketChatInput( user=configs['user'], password=configs['password'], server_url=configs['server_url'] ) _endpoints = AvailableEndpoints.read_endpoints(None) _interpreter = NaturalLanguageInterpreter.create(nlu_dir) elastic_user = os.getenv('ELASTICSEARCH_USER') if elastic_user is None: _tracker_store = ElasticTrackerStore( domain = os.getenv('ELASTICSEARCH_URL', 'elasticsearch:9200') ) else: _tracker_store = ElasticTrackerStore( domain = os.getenv('ELASTICSEARCH_URL', 'elasticsearch:9200'), user = os.getenv('ELASTICSEARCH_USER', 'user'), password = os.getenv('ELASTICSEARCH_PASSWORD', 'password'), scheme = os.getenv('ELASTICSEARCH_HTTP_SCHEME', 'http'), scheme_port = os.getenv('ELASTICSEARCH_PORT', '80') ) _agent = load_agent(core_dir, interpreter=_interpreter, tracker_store=_tracker_store, endpoints=_endpoints) http_server = start_server([input_channel], "", "", 5005, _agent) try: http_server.serve_forever() except Exception as exc: logger.exception(exc)
def __init__(self): self.config = Config() self.endpoints = AvailableEndpoints.read_endpoints( self.config.RASA_CONFIG_ENDPOINTS_FILE) # self.interpreter = NaturalLanguageInterpreter.create(self.config.RASA_CONFIG_NLU_TRAIN_PACKAGE_NAME, self.endpoints.nlu) self.agent = load_agent( self.config.RASA_CONFIG_CORE_DIALOGUE_PACKAGE_NAME, interpreter=None, endpoints=self.endpoints) self.executor = ActionExecutor() self.executor.register_package( self.config.RASA_CONFIG_ENDPOINTS_ACTION_PACKAGE_NAME) self.message_processor = MessageProcessor( # self.interpreter, None, self.agent.policy_ensemble, self.agent.domain, self.agent.tracker_store, self.agent.nlg, action_endpoint=self.agent.action_endpoint, message_preprocessor=None)
def run(model: Text, endpoints: Text, connector: Text = None, credentials: Text = None, **kwargs: Dict): """Runs a Rasa model. Args: model: Path to model archive. endpoints: Path to endpoints file. connector: Connector which should be use (overwrites `credentials` field). credentials: Path to channel credentials file. **kwargs: Additional arguments which are passed to `rasa_core.run.serve_application`. """ import rasa_core.run from rasa_core.utils import AvailableEndpoints model_path = get_model(model) core_path, nlu_path = get_model_subdirectories(model_path) _endpoints = AvailableEndpoints.read_endpoints(endpoints) if not connector and not credentials: channel = "cmdline" logger.info("No chat connector configured, falling back to the " "command line. Use `rasa configure channel` to connect" "the bot to e.g. facebook messenger.") else: channel = connector kwargs = minimal_kwargs(kwargs, rasa_core.run.serve_application) rasa_core.run.serve_application(core_path, nlu_path, channel=channel, credentials_file=credentials, endpoints=_endpoints, **kwargs) shutil.rmtree(model_path)
def start_core(platform_token): from rasa_core.utils import AvailableEndpoints _endpoints = AvailableEndpoints( # TODO: make endpoints more configurable, esp ports model=EndpointConfig( "http://localhost:5002" "/api/projects/default/models/tags/production", token=platform_token, wait_time_between_pulls=1), event_broker=EndpointConfig(**{"type": "file"}), nlg=EndpointConfig("http://localhost:5002" "/api/nlg", token=platform_token)) from rasa_core import broker _broker = broker.from_endpoint_config(_endpoints.event_broker) from rasa_core.tracker_store import TrackerStore _tracker_store = TrackerStore.find_tracker_store(None, _endpoints.tracker_store, _broker) from rasa_core.run import load_agent _agent = load_agent("models", interpreter=None, tracker_store=_tracker_store, endpoints=_endpoints) from rasa_core.run import serve_application print_success("About to start core") serve_application( _agent, "rasa", 5005, "credentials.yml", "*", None, # TODO: configure auth token True)
def start_core(platform_token): from rasa_core.utils import AvailableEndpoints from rasa_core.run import serve_application from rasa_core.utils import EndpointConfig _endpoints = AvailableEndpoints( # TODO: make endpoints more configurable, esp ports model=EndpointConfig("http://localhost:5002" "/api/projects/default/models/tags/production", token=platform_token, wait_time_between_pulls=1), event_broker=EndpointConfig(**{"type": "file"}), nlg=EndpointConfig("http://localhost:5002" "/api/nlg", token=platform_token)) serve_application("models", nlu_model=None, channel="rasa", credentials_file="credentials.yml", cors="*", auth_token=None, # TODO: configure auth token enable_api=True, endpoints=_endpoints)
def test_formbot_example(): sys.path.append("examples/formbot/") p = "examples/formbot/" stories = os.path.join(p, "data", "stories.md") endpoint = EndpointConfig("http://localhost:5055/webhook") endpoints = AvailableEndpoints(action=endpoint) agent = train_dialogue_model(os.path.join(p, "domain.yml"), stories, os.path.join(p, "models", "dialogue"), endpoints=endpoints, policy_config="rasa_core/default_config.yml") # response = { # 'events': [ # {'event': 'form', 'name': 'restaurant_form', 'timestamp': None}, # {'event': 'slot', 'timestamp': None, # 'name': 'requested_slot', 'value': 'cuisine'} # ], # 'responses': [ # {'template': 'utter_ask_cuisine'} # ] # } print(type(agent.policy_ensemble)) responses = agent.handle_text("/request_restaurant") # assert responses[0]['text'] == 'what cuisine?' print(responses) # response = { # "error": "Failed to validate slot cuisine with action restaurant_form", # "action_name": "restaurant_form" # } responses = agent.handle_text("/chitchat") # assert responses[0]['text'] == 'chitchat' print(responses[0])
if __name__ == '__main__': # Running as standalone python application arg_parser = create_argument_parser() cmdline_args = arg_parser.parse_args() logging.getLogger('werkzeug').setLevel(logging.WARN) logging.getLogger('matplotlib').setLevel(logging.WARN) utils.configure_colored_logging(cmdline_args.loglevel) utils.configure_file_logging(cmdline_args.loglevel, cmdline_args.log_file) logger.info("Rasa process starting") _endpoints = AvailableEndpoints.read_endpoints(cmdline_args.endpoints) _interpreter = NaturalLanguageInterpreter.create(cmdline_args.nlu, _endpoints.nlu) _broker = PikaProducer.from_endpoint_config(_endpoints.event_broker) _tracker_store = TrackerStore.find_tracker_store( None, _endpoints.tracker_store, _broker) _agent = load_agent(cmdline_args.core, interpreter=_interpreter, tracker_store=_tracker_store, endpoints=_endpoints) serve_application(_agent, cmdline_args.connector, cmdline_args.port, cmdline_args.credentials, cmdline_args.cors,
app = Flask(__name__) app.secret_key = '12345' @app.route('/') def hello_world(): return render_template('home.html') get_random_response = lambda intent: random.choice(intent_response_dict[intent] ) # Load Rasa NLU interpreter and Rasa Core agent interpreter = RasaNLUInterpreter("models/livio/nlu") _endpoints = AvailableEndpoints.read_endpoints("endpoints.yml") action_endpoint = _endpoints.action agent = Agent.load("models/livio/dialouge", interpreter=interpreter, action_endpoint=action_endpoint) @app.route('/chat', methods=["POST"]) def chat(): try: user_message = request.form["text"] response = requests.get("http://localhost:5000/parse", params={"q": user_message}) response = response.json() entities = response.get("entities") topresponse = response["intent"]
from robot import app from robot.config.setting import Config logger = logging.getLogger(__name__) robot_api = Blueprint('robot_api', __name__) CORS(app, resources={r"/*": {"origins": "*"}}) cors_origins = None or [] __version__ = '0.11.6' auth_token = None config = Config #初始化jwt参数 # JWTManager(app) endpoints = AvailableEndpoints.read_endpoints( config.RASA_CONFIG_ENDPOINTS_FILE) interpreter = NaturalLanguageInterpreter.create( config.RASA_CONFIG_NLU_TRAIN_PACKAGE_NAME, endpoints.nlu) agent = load_agent(config.RASA_CONFIG_CORE_DIALOGUE_PACKAGE_NAME, interpreter=interpreter, endpoints=endpoints) input_channels = create_http_input_channels('rest', None) rasa_core.channels.channel.register(input_channels, app, agent.handle_message, route="/webhooks/") @robot_api.route("/", methods=['GET', 'OPTIONS']) @cross_origin(origins=cors_origins) def hello():