def run(serve_forever=True): agent = Agent.load("models/core", interpreter=RasaNLUInterpreter("models/nlu")) if serve_forever: agent.handle_channel(CmdlineInput()) return agent
def _load_and_set_updated_model(agent: 'Agent', model_directory: Text, fingerprint: Text): """Load the persisted model into memory and set the model on the agent.""" logger.debug("Found new model with fingerprint {}. Loading..." "".format(fingerprint)) stack_model_directory = _get_stack_model_directory(model_directory) if stack_model_directory: from rasa.core.interpreter import RasaNLUInterpreter nlu_model = os.path.join(stack_model_directory, "nlu") core_model = os.path.join(stack_model_directory, "core") interpreter = RasaNLUInterpreter(model_directory=nlu_model) else: interpreter = agent.interpreter core_model = model_directory domain_path = os.path.join(os.path.abspath(core_model), "domain.yml") domain = Domain.load(domain_path) # noinspection PyBroadException try: policy_ensemble = PolicyEnsemble.load(core_model) agent.update_model(domain, policy_ensemble, fingerprint, interpreter) logger.debug("Finished updating agent to new model.") except Exception: logger.exception("Failed to load policy and update agent. " "The previous model will stay loaded instead.")
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 _load_and_set_updated_model(agent: "Agent", model_directory: Text, fingerprint: Text): """Load the persisted model into memory and set the model on the agent.""" logger.debug(f"Found new model with fingerprint {fingerprint}. Loading...") core_path, nlu_path = get_model_subdirectories(model_directory) if nlu_path: from rasa.core.interpreter import RasaNLUInterpreter interpreter = RasaNLUInterpreter(model_directory=nlu_path) else: interpreter = (agent.interpreter if agent.interpreter is not None else RegexInterpreter()) domain = None if core_path: domain_path = os.path.join(os.path.abspath(core_path), DEFAULT_DOMAIN_PATH) domain = Domain.load(domain_path) try: policy_ensemble = None if core_path: policy_ensemble = PolicyEnsemble.load(core_path) agent.update_model(domain, policy_ensemble, fingerprint, interpreter, model_directory) logger.debug("Finished updating agent to new model.") except Exception: logger.exception("Failed to load policy and update agent. " "The previous model will stay loaded instead.")
def run(serve_forever=True): interpreter = RasaNLUInterpreter("models/nlu") agent = Agent.load("models/dialogue", interpreter=interpreter) action_endpoint = EndpointConfig(url="http://localhost:5055/webhook") if serve_forever: agent.handle_channels([CmdlineInput()]) return agent
def run_weather_bot(serve_forever=True): interpreter = RasaNLUInterpreter('./models/nlu/default/weathernlu') agent = Agent.load('./models/dialogue', interpreter=interpreter) if serve_forever: agent.handle_channel(ConsoleInputChannel()) return agent
def run_dialogue(serve_forever=True): interpreter = RasaNLUInterpreter('./models/nlu/chatter') action_endpoint = EndpointConfig(url="http://localhost:5055/webhook") agent = Agent.load('./models/dialogue', interpreter=interpreter, action_endpoint=action_endpoint) rasa.core.run.serve_application(agent, channel='cmdline') return agent
def chat( model_path: Optional[Text] = None, endpoints: Optional[Text] = None, agent: Optional["Agent"] = None, interpreter: Optional[NaturalLanguageInterpreter] = None, ) -> None: """Chat to the bot within a Jupyter notebook. Args: model_path: Path to a combined Rasa model. endpoints: Path to a yaml with the action server is custom actions are defined. agent: Rasa Core agent (used if no Rasa model given). interpreter: Rasa NLU interpreter (used with Rasa Core agent if no Rasa model is given). """ if model_path: from rasa.run import create_agent agent = create_agent(model_path, endpoints) elif agent is not None and interpreter is not None: # HACK: this skips loading the interpreter and directly # sets it afterwards nlu_interpreter = RasaNLUInterpreter( "skip this and use given interpreter", lazy_init=True ) nlu_interpreter.interpreter = interpreter agent.interpreter = interpreter else: print_error( "You either have to define a model path or an agent and an interpreter." ) return print("Your bot is ready to talk! Type your messages here or send '/stop'.") loop = asyncio.get_event_loop() while True: message = input() if message == "/stop": break responses = loop.run_until_complete(agent.handle_text(message)) for response in responses: _display_bot_response(response)
def chat( model_path: Text = None, agent: "Agent" = None, interpreter: NaturalLanguageInterpreter = None, ) -> None: """Chat to the bot within a Jupyter notebook. Args: model_path: Path to a Rasa Stack model. agent: Rasa Core agent (used if no Rasa Stack model given). interpreter: Rasa NLU interpreter (used with Rasa Core agent if no Rasa Stack model is given). """ if model_path: from rasa.run import create_agent unpacked = model.get_model(model_path) agent = create_agent(unpacked) elif agent and interpreter: # HACK: this skips loading the interpreter and directly # sets it afterwards nlu_interpreter = RasaNLUInterpreter( "skip this and use given interpreter", lazy_init=True) nlu_interpreter.interpreter = interpreter agent.interpreter = interpreter else: print_error( "You either have to define a model path or an agent and an interpreter." ) print( "Your bot is ready to talk! Type your messages here or send '/stop'.") loop = asyncio.get_event_loop() while True: message = input() if message == "/stop": break responses = loop.run_until_complete(agent.handle_text(message)) for response in responses: _display_bot_response(response)
def __init__(self, *args, **kwargs): # 创建路径上下文对象 path_context = PathContext() # nlu 模块 interpreter = RasaNLUInterpreter( model_directory=path_context.model_directory, config_file=path_context.config_file_path) super(LSTMAgent).__init__(domain=path_context.domain_path, interpreter=interpreter, model_directory=path_context.model_directory)
def _load_interpreter(agent: "Agent", nlu_path: Optional[Text]) -> NaturalLanguageInterpreter: """Load the NLU interpreter at `nlu_path`. Args: agent: Instance of `Agent` to inspect for an interpreter if `nlu_path` is `None`. nlu_path: NLU model path. Returns: The NLU interpreter. """ if nlu_path: from rasa.core.interpreter import RasaNLUInterpreter return RasaNLUInterpreter(model_directory=nlu_path) return agent.interpreter or RegexInterpreter()
def suggestedMessage(model_save, dialogue_save, text): ''' Function to return suggested message from Bot ''' asyncio.set_event_loop(asyncio.new_event_loop()) loop = asyncio.get_event_loop() # call asyncio #asyncio.set_event_loop(loop) #train_dialogue() interpreter = RasaNLUInterpreter( model_save) # interpreter is the intent classifier agent = Agent.load(dialogue_save, interpreter=interpreter) # load dialogue agent botMessage = loop.run_until_complete(agent.handle_text( text)) # test agent response agent.handle_text(text)# #print(botMessage) # print response loop.close() # close loop return botMessage
async def parse( text: Text, core_model_path: Text, nlu_model_path: Optional[Text] = None ): if nlu_model_path: interpreter = RasaNLUInterpreter(nlu_model_path) else: logger.warning("No NLU model passed, parsing messages using RegexInterpreter.") interpreter = RegexInterpreter() agent = Agent.load(core_model_path, interpreter=interpreter) response = await agent.handle_text(text) logger.info("Text: '{}'".format(text)) logger.info("Response:") logger.info(response) return response
def __init__(self, config, loop): """constructor""" super(RasaServiceLocal, self).__init__(config, loop) self.config = config self.subscribe_to = 'hermod/+/rasa/get_domain,hermod/+/rasa/set_slots' \ + ',hermod/+/dialog/ended,hermod/+/dialog/init,hermod/+/nlu/externalparse,' \ + 'hermod/+/nlu/parse,hermod/+/intent,hermod/+/intent,hermod/+/dialog/started' model_path = get_model( config['services']['RasaServiceLocal'].get('model_path')) endpoint = EndpointConfig( config['services']['RasaServiceLocal'].get('rasa_actions_url')) domain = 'domain.yml' self.tracker_store = InMemoryTrackerStore(domain) regex_interpreter = RegexInterpreter() self.text_interpreter = RasaNLUInterpreter(model_path + '/nlu') self.agent = Agent.load(model_path, action_endpoint=endpoint, tracker_store=self.tracker_store, interpreter=regex_interpreter)
def load_interpreter(model_path): model_path = pathlib.Path(model_path) model_path_val = get_validated_path(str(model_path), "model") model_path = get_model(model_path_val) _, nlu_model = get_model_subdirectories(model_path) return RasaNLUInterpreter(nlu_model)
# from rasa.core.channels import HttpInputChannel from rasa.core.agent import Agent # from rasa.core.interpreter import RegexInterpreter from rasa.core.interpreter import RasaNLUInterpreter from slack import SlackInput # import SLACK_DEV_TOKEN, SLACK_CLIENT_TOKEN, VERIFICATION_TOKEN # load your agent import logging logging.basicConfig(level=logging.DEBUG) nlu_interpreter = RasaNLUInterpreter('./models/nlu') agent = Agent.load('./models/', interpreter=nlu_interpreter) print('------------------') print(agent.is_core_ready()) print('---------------------------') input_channel = SlackInput('', 'random', slack_retry_reason_header='x-slack-retry-reason', slack_retry_number_header='x-slack-retry-num') agent.handle_channels( [input_channel], 5005, "/", ) print('test')
domain = Domain.load('domain.yml') db_conf = config['bluelog'] mongo_tracker = MongoTrackerStore(domain, host=db_conf['host'], db=db_conf['db'], username=db_conf['username'], password=db_conf['password'], auth_source=db_conf['authsource'], collection=config['template']['module']) agent_all = {} try: if os.path.isdir('./models/nlu'): if os.path.isdir('./models/nlu/idn'): nlu_interpreter_idn = RasaNLUInterpreter('./models/nlu/idn/') agent_idn = Agent.load('./models/core/core.tar.gz', interpreter=nlu_interpreter_idn, action_endpoint=action_endpoint, generator=nlg_endpoint, tracker_store=mongo_tracker) agent_all["idn"] = agent_idn else: pass if os.path.isdir('./models/nlu/en'): nlu_interpreter_en = RasaNLUInterpreter('./models/nlu/en/latest') agent_en = Agent.load('./models/core/core.tar.gz', interpreter=nlu_interpreter_en, action_endpoint=action_endpoint, generator=nlg_endpoint, tracker_store=mongo_tracker)
import logging from rasa.core.agent import Agent from rasa.core.interpreter import RegexInterpreter from rasa.core.policies.keras_policy import KerasPolicy from rasa.core.policies.memoization import MemoizationPolicy from rasa.core.interpreter import RasaNLUInterpreter logger = logging.getLogger(__name__) def run_weather_online(interpreter, domain_file="weather_domain.yml", training_data_file='data/stories.md'): agent = Agent(domain_file, policies=[MemoizationPolicy(), KerasPolicy()], interpreter=interpreter) agent.train(training_data_file, max_history=2, batch_size=50, epochs=200, max_training_samples=300) return agent if __name__ == '__main__': logging.basicConfig(level="INFO") nlu_interpreter = RasaNLUInterpreter('./models/nlu/default/weathernlu') run_weather_online(nlu_interpreter)
from rasa.core.agent import Agent from rasa.core.interpreter import RasaNLUInterpreter from ga_connector import GoogleConnector from rasa.utils.endpoints import EndpointConfig action_endpoint = EndpointConfig(url="http://localhost:5055/webhook") nlu_interpreter = RasaNLUInterpreter('./models/current/nlu_model') agent = Agent.load('./models/current/dialogue', interpreter = nlu_interpreter, action_endpoint=action_endpoint) input_channel = GoogleConnector() agent.handle_channels([input_channel], 5004, serve_forever=True)
from rasa.core.channels import HttpInputChannel from rasa.core.agent import Agent from rasa.core.interpreter import RasaNLUInterpreter from rasa_twilio_connector import TwilioInput print("initial") nlu_interpreter = RasaNLUInterpreter('./models/20190720-123019/nlu') agent = Agent.load('./models/20190720-123019/core', interpreter=nlu_interpreter) print("before") input_channel = TwilioInput( 'ACf11ed3930668c68e3ea357bb6543902e', '012d8bd5856136d5fac10fc05514bd1d', #'012d8bd5856136d5fac10fc05514bd', '+13367938385') print(input_channel) agent.handle_channels(HttpInputChannel(5500, input_channel))
# -*- coding: utf-8 -*- """ Created on Thu May 7 11:40:40 2020 @author: hung.td170078 """ from rasa.core.channels.facebook import FacebookInput from rasa.core.agent import Agent from rasa.core.interpreter import RasaNLUInterpreter import os from rasa.core.utils import EndpointConfig # load your trained agent interpreter = RasaNLUInterpreter("models/nlu/") MODEL_PATH = "models/20200521-171510.tar.gz" action_endpoint = EndpointConfig(url="https://lunachatbot-prj2-actions.herokuapp.com/webhook") agent = Agent.load(MODEL_PATH, interpreter=interpreter, action_endpoint=action_endpoint) input_channel = FacebookInput( fb_verify="jackfrost", # you need tell facebook this token, to confirm your URL fb_secret="4ad8cdf285aeef2548b23c130cd6f56c", # your app secret fb_access_token="EAASmSto8E9IBANlkhOp0pcoMXdWJanepzZBBAmQ9ZBsm07CYlwG7qqIgb5ccUvGWGdZCJRS6U72W4j1MctoZBUhACihyuAhEUp5wAxsPBSkiMXADiKHWPA8LPErMz5WywZBWg043qnsBJZBr42HpPdPxcoAnWYJKQfc2DNANgERwZDZD" # token for the page you subscribed to ) # set serve_forever=False if you want to keep the server running s = agent.handle_channels([input_channel], int(os.environ.get('PORT',5004)))
from rasa.model import get_model_subdirectories, get_model from rasa.core.channels.socketio import SocketIOInput from rasa.core.agent import Agent from rasa.core.interpreter import RegexInterpreter from rasa.core.interpreter import RasaNLUInterpreter from rasa.core.utils import EndpointConfig from rasa.core.policies.keras_policy import KerasPolicy from rasa.core.policies.memoization import MemoizationPolicy # load your trained agent model_path = get_model('./models/nlu/') _, nlu_model = get_model_subdirectories(model_path) interpreter = RasaNLUInterpreter(nlu_model) action_endpoint = EndpointConfig(url="http://localhost:5055/webhook") agent = Agent.load('models/core/core-20200417-162634.tar.gz', interpreter=interpreter, action_endpoint=action_endpoint) input_channel = SocketIOInput( # event name for messages sent from the user user_message_evt="user_uttered", # event name for messages sent from the bot bot_message_evt="bot_uttered", # socket.io namespace to use for the messages namespace=None) # set serve_forever=True if you want to keep the server running s = agent.handle_channels([input_channel], 5500, route='/webhooks/',
# PART 3: Start the Bot from rasa.core.agent import Agent from rasa.nlu.model import Trainer, Metadata from rasa.core.interpreter import RasaNLUInterpreter from rasa.utils.endpoints import EndpointConfig nlu_interpreter = RasaNLUInterpreter('./models/nlu/default/chatter') action_endpoint = EndpointConfig("http://localhost:5055/webhook") agent = Agent.load('./models/dialogue', interpreter = nlu_interpreter) # Part 4:Talk to Bot print("start the conversation") print() print("Hi! How can I help you today? ") while True: a=input() if a == 'stop' : break responses = agent.handle_message(a) for response in responses: print(response['text'])
from rasa.core.channels.socketio import SocketIOInput from rasa.core.agent import Agent from rasa.core.interpreter import RasaNLUInterpreter from rasa.utils.endpoints import EndpointConfig #from MyIo import RestInput action_endpoint = EndpointConfig(url="http://localhost:5055/webhook") nlu_interpreter = RasaNLUInterpreter('/data/xingyang/Documents/Hangzhou Dianzi University - Chatbot/capstone-master/models/20190717-114901/nlu') agent = Agent.load('/data/xingyang/Documents/Hangzhou Dianzi University - Chatbot/capstone-master/models/20190717-114901/core', interpreter=nlu_interpreter, action_endpoint=action_endpoint) #input_channel = RestInput() input_channel = SocketIOInput( # event name for messages sent from the user user_message_evt="user_uttered", # event name for messages sent from the bot bot_message_evt="bot_uttered", # socket.io namespace to use for the messages namespace=None ) #s = agent.handle_channels([input_channel],5005, serve_forever=True) agent.handle_channels([input_channel], http_port=5005,route="/webhooks/",cors="*")
def load_interpreter(model_dir, model): path_str = str(pathlib.Path(model_dir) / model) model = get_validated_path(path_str, "model") model_path = get_model(model) _, nlu_model = get_model_subdirectories(model_path) return RasaNLUInterpreter(nlu_model)
from rasa.core.agent import Agent from rasa.core.interpreter import RasaNLUInterpreter import asyncio interpreter = RasaNLUInterpreter("/home/pulkit/bot/chatbot/models/nlu") agent = Agent.load("/home/pulkit/bot/chatbot/models/20200706-002358.tar.gz", interpreter=interpreter) async def inter(str): a = await agent.handle_text(str) # b=await interpreter.parse(str) c = await agent.parse_message_using_nlu_interpreter(str) # return (a,b,c) # return a,c first = a[0]['text'] if not first or first[0] == '1': first = None second = None if not first: users = "100 users" ms = "10 motion" ds = "10 door" ts = "10 temperature" for x in c['entities']: if x['extractor'] == 'CRFEntityExtractor': if x['entity'] == "users": users = x['value'] elif x['entity'] == "ms": ms = x['value'] elif x['entity'] == "ds": ds = x['value']
import IPython from IPython.display import clear_output, HTML, display from rasa.core.agent import Agent from rasa.core.interpreter import RasaNLUInterpreter import time import json interpreter = RasaNLUInterpreter('models/nlu') messages = [ "Hi! you can chat in this window. Type 'stop' to end the conversation." ] agent = Agent.load('models/', interpreter=interpreter) def chatlogs_html(messages): messages_html = "".join(["<p>{}</p>".format(m) for m in messages]) chatbot_html = """<div class="chat-window" {}</div>""".format( messages_html) return chatbot_html while True: clear_output() display(HTML(chatlogs_html(messages))) time.sleep(0.3) a = input() messages.append(a) print(messages) if a == 'stop': break responses = agent.parse_message_using_nlu_interpreter(a)
import os import api import requests from rasa.core.agent import Agent from rasa.core.interpreter import RasaNLUInterpreter import asyncio import speech_recognition as sr import nest_asyncio nest_asyncio.apply() token = "xoxb-101944332577-698195991045-QpfdLEMbpRI3oaSnp8DN6ks3" agent = Agent.load("models/depot", interpreter=RasaNLUInterpreter("models/depot/nlu")) client = api.WebClient(token=token, run_async=True) def sendMsg(msg, channel): event_loop = asyncio.get_event_loop() response = event_loop.run_until_complete( client.chat_postMessage(channel=channel, text=msg)) def response(txt): event_loop = asyncio.get_event_loop() result = event_loop.run_until_complete( agent.handle_text(txt, None, None, "jesenchen")) client.chat_postMessage(channel='#general', text=result[0]["text"]) def downloadFile(url):