def load( cls, unpacked_model_path: Text, interpreter: Optional[NaturalLanguageInterpreter] = None, generator: Union[EndpointConfig, NaturalLanguageGenerator] = None, tracker_store: Optional[TrackerStore] = None, action_endpoint: Optional[EndpointConfig] = None, model_server: Optional[EndpointConfig] = None, remote_storage: Optional[Text] = None, ) -> "Agent": """Load a persisted model from the passed path.""" if not os.path.exists(unpacked_model_path) or not os.path.isdir( unpacked_model_path): raise ValueError("You are trying to load a MODEL from " "('{}'), which is not possible. \n" "The persisted path should be a directory " "containing the various model files in the " "sub-directories 'core' and 'nlu'. \n\n" "If you want to load training data instead of " "a model, use `agent.load_data(...)` " "instead.".format(unpacked_model_path)) core_model, nlu_model = get_model_subdirectories(unpacked_model_path) if not interpreter and os.path.exists(nlu_model): interpreter = NaturalLanguageInterpreter.create(nlu_model) domain = None ensemble = None if os.path.exists(core_model): domain = Domain.load(os.path.join(core_model, DEFAULT_DOMAIN_PATH)) ensemble = PolicyEnsemble.load(core_model) if core_model else None # ensures the domain hasn't changed between test and train domain.compare_with_specification(core_model) return cls( domain=domain, policies=ensemble, interpreter=interpreter, generator=generator, tracker_store=tracker_store, action_endpoint=action_endpoint, model_directory=unpacked_model_path, model_server=model_server, remote_storage=remote_storage, )
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: return NaturalLanguageInterpreter.create(nlu_path) return agent.interpreter or RegexInterpreter()
async def train_agent_on_start(args, endpoints, additional_arguments, app, loop): _interpreter = NaturalLanguageInterpreter.create(args.get("nlu"), endpoints.nlu) model_directory = args.get("out", tempfile.mkdtemp(suffix="_core_model")) _agent = await train(args.get("domain"), args.get("stories"), model_directory, _interpreter, endpoints, args.get("dump_stories"), args.get("config")[0], None, additional_arguments) app.agent = _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)) # bf mod core_path, nlu_models = get_model_subdirectories(model_directory) interpreters = {} # If NLU models exist then create interpreters from them if len(nlu_models): for lang, model_path in nlu_models.items(): interpreters[lang] = NaturalLanguageInterpreter.create( os.path.join(model_directory, model_path)) # If no NLU models exist, then associate a RegexInterpreter to the language code found in the fingerprints, # that should correspond to the default language in Botfront. This is to make sure an interpreter is available # when training stories without NLU else: from rasa.model import fingerprint_from_path, FINGERPRINT_CONFIG_NLU_KEY models_fingerprint = fingerprint_from_path(model_directory) if len(models_fingerprint.get(FINGERPRINT_CONFIG_NLU_KEY).keys()): interpreters = { list( models_fingerprint.get(FINGERPRINT_CONFIG_NLU_KEY).keys())[0]: RegexInterpreter() } # /bf mod 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, interpreters, 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 test_core(model: Text, stories: Text, endpoints: Text = None, output: Text = DEFAULT_RESULTS_PATH, model_path: Text = None, **kwargs: Dict): import rasa.core.test import rasa.core.utils as core_utils from rasa_nlu import utils as nlu_utils from rasa.model import get_model from rasa.core.interpreter import NaturalLanguageInterpreter from rasa.core.agent import Agent _endpoints = core_utils.AvailableEndpoints.read_endpoints(endpoints) if output: nlu_utils.create_dir(output) if os.path.isfile(model): model_path = get_model(model) if model_path: # Single model: Normal evaluation loop = asyncio.get_event_loop() model_path = get_model(model) core_path, nlu_path = get_model_subdirectories(model_path) _interpreter = NaturalLanguageInterpreter.create( nlu_path, _endpoints.nlu) _agent = Agent.load(core_path, interpreter=_interpreter) kwargs = minimal_kwargs(kwargs, rasa.core.test) loop.run_until_complete( rasa.core.test(stories, _agent, out_directory=output, **kwargs)) else: from rasa.core.test import compare, plot_curve compare(model, stories, output) story_n_path = os.path.join(model, 'num_stories.json') number_of_stories = core_utils.read_json_file(story_n_path) plot_curve(output, number_of_stories)
def update_model(self, domain: Union[Text, Domain], policy_ensemble: PolicyEnsemble, fingerprint: Optional[Text], interpreter: Optional[NaturalLanguageInterpreter] = None ) -> None: self.domain = domain self.policy_ensemble = policy_ensemble if interpreter: self.interpreter = NaturalLanguageInterpreter.create(interpreter) self._set_fingerprint(fingerprint) # update domain on all instances self.tracker_store.domain = domain if hasattr(self.nlg, "templates"): self.nlg.templates = domain.templates or []
def __init__( self, domain: Union[Text, Domain, None] = None, policies: Union[PolicyEnsemble, List[Policy], None] = None, interpreter: Optional[NaturalLanguageInterpreter] = None, generator: Union[EndpointConfig, NaturalLanguageGenerator, None] = None, tracker_store: Optional[TrackerStore] = None, lock_store: Optional[LockStore] = None, action_endpoint: Optional[EndpointConfig] = None, fingerprint: Optional[Text] = None, model_directory: Optional[Text] = None, model_server: Optional[EndpointConfig] = None, remote_storage: Optional[Text] = None, path_to_model_archive: Optional[Text] = None, ): # Initializing variables with the passed parameters. self.domain = self._create_domain(domain) self.policy_ensemble = self._create_ensemble(policies) if self.domain is not None: self.domain.add_requested_slot() self.domain.add_form_id() self.domain.add_reset_slot() self.domain.add_knowledge_base_slots() self.domain.add_categorical_slot_default_value() PolicyEnsemble.check_domain_ensemble_compatibility( self.policy_ensemble, self.domain ) self.interpreter = NaturalLanguageInterpreter.create(interpreter) self.nlg = NaturalLanguageGenerator.create(generator, self.domain) self.tracker_store = self.create_tracker_store(tracker_store, self.domain) self.lock_store = self._create_lock_store(lock_store) self.action_endpoint = action_endpoint self._set_fingerprint(fingerprint) self.model_directory = model_directory self.model_server = model_server self.remote_storage = remote_storage self.path_to_model_archive = path_to_model_archive
def test_core( model: Optional[Text] = None, stories: Optional[Text] = None, endpoints: Optional[Text] = None, output: Text = DEFAULT_RESULTS_PATH, kwargs: Optional[Dict] = None, ): import rasa.core.test import rasa.core.utils as core_utils from rasa.nlu import utils as nlu_utils from rasa.model import get_model from rasa.core.interpreter import NaturalLanguageInterpreter from rasa.core.agent import Agent _endpoints = core_utils.AvailableEndpoints.read_endpoints(endpoints) if kwargs is None: kwargs = {} if output: nlu_utils.create_dir(output) loop = asyncio.get_event_loop() model_path = get_model(model) core_path, nlu_path = get_model_subdirectories(model_path) if os.path.exists(core_path) and os.path.exists(nlu_path): _interpreter = NaturalLanguageInterpreter.create( nlu_path, _endpoints.nlu) _agent = Agent.load(model_path, interpreter=_interpreter) kwargs = minimal_kwargs(kwargs, rasa.core.test, ["stories", "agent"]) loop.run_until_complete( rasa.core.test(stories, _agent, out_directory=output, **kwargs)) else: print_error( "Not able to test. Make sure both models - core and nlu - are available." )
def update_model( self, domain: Optional[Domain], policy_ensemble: Optional[PolicyEnsemble], fingerprint: Optional[Text], interpreter: Optional[NaturalLanguageInterpreter] = None, model_directory: Optional[Text] = None, ) -> None: self.domain = self._create_domain(domain) self.policy_ensemble = policy_ensemble if interpreter: self.interpreter = NaturalLanguageInterpreter.create(interpreter) self._set_fingerprint(fingerprint) # update domain on all instances self.tracker_store.domain = domain if hasattr(self.nlg, "templates"): self.nlg.templates = domain.templates if domain else {} self.model_directory = model_directory
def __init__( self, domain: Union[Text, Domain, None] = None, policies: Union[PolicyEnsemble, List[Policy], None] = None, interpreter: Optional[NaturalLanguageInterpreter] = None, generator: Union[EndpointConfig, NaturalLanguageGenerator, None] = None, tracker_store: Optional[TrackerStore] = None, action_endpoint: Optional[EndpointConfig] = None, fingerprint: Optional[Text] = None, model_directory: Optional[Text] = None, model_server: Optional[EndpointConfig] = None, remote_storage: Optional[Text] = None, ): # Initializing variables with the passed parameters. self.domain = self._create_domain(domain) if self.domain: self.domain.add_requested_slot() self.policy_ensemble = self._create_ensemble(policies) if not self._is_form_policy_present(): raise InvalidDomain( "You have defined a form action, but haven't added the " "FormPolicy to your policy ensemble.") self.interpreter = NaturalLanguageInterpreter.create(interpreter) self.nlg = NaturalLanguageGenerator.create(generator, self.domain) self.tracker_store = self.create_tracker_store(tracker_store, self.domain) self.action_endpoint = action_endpoint self.conversations_in_processing = {} self._set_fingerprint(fingerprint) self.model_directory = model_directory self.model_server = model_server self.remote_storage = remote_storage
async def load_agent_on_start(core_model, endpoints, nlu_model, app, loop): """Load an agent. Used to be scheduled on server start (hence the `app` and `loop` arguments).""" from rasa.core import broker from rasa.core.agent import Agent _interpreter = NaturalLanguageInterpreter.create(nlu_model, endpoints.nlu) _broker = broker.from_endpoint_config(endpoints.event_broker) _tracker_store = TrackerStore.find_tracker_store(None, endpoints.tracker_store, _broker) if endpoints and endpoints.model: from rasa.core import agent app.agent = Agent( interpreter=_interpreter, generator=endpoints.nlg, tracker_store=_tracker_store, action_endpoint=endpoints.action, ) await agent.load_from_server(app.agent, model_server=endpoints.model) else: app.agent = Agent.load( core_model, interpreter=_interpreter, generator=endpoints.nlg, tracker_store=_tracker_store, action_endpoint=endpoints.action, ) return app.agent
def __init__( self, domain: Union[Text, Domain, None] = None, policies: Union[PolicyEnsemble, List[Policy], None] = None, interpreter: Optional[NaturalLanguageInterpreter] = None, generator: Union[EndpointConfig, NaturalLanguageGenerator, None] = None, tracker_store: Optional[TrackerStore] = None, action_endpoint: Optional[EndpointConfig] = None, fingerprint: Optional[Text] = None, model_directory: Optional[Text] = None, model_server: Optional[EndpointConfig] = None, remote_storage: Optional[Text] = None, ): # Initializing variables with the passed parameters. self.domain = self._create_domain(domain) self.policy_ensemble = self._create_ensemble(policies) if self.domain is not None: self.domain.add_requested_slot() PolicyEnsemble.check_domain_ensemble_compatibility( self.policy_ensemble, self.domain) self.interpreter = NaturalLanguageInterpreter.create(interpreter) self.nlg = NaturalLanguageGenerator.create(generator, self.domain) self.tracker_store = self.create_tracker_store(tracker_store, self.domain) self.action_endpoint = action_endpoint self.conversations_in_processing = {} self._set_fingerprint(fingerprint) self.model_directory = model_directory self.model_server = model_server self.remote_storage = remote_storage
def load( cls, model_path: Text, interpreter: Optional[Dict[Text, NaturalLanguageInterpreter]] = None, generator: Union[EndpointConfig, NaturalLanguageGenerator] = None, tracker_store: Optional[TrackerStore] = None, lock_store: Optional[LockStore] = None, action_endpoint: Optional[EndpointConfig] = None, model_server: Optional[EndpointConfig] = None, remote_storage: Optional[Text] = None, path_to_model_archive: Optional[Text] = None, ) -> "Agent": """Load a persisted model from the passed path.""" try: if not model_path: raise ModelNotFound("No path specified.") elif not os.path.exists(model_path): raise ModelNotFound(f"No file or directory at '{model_path}'.") elif os.path.isfile(model_path): model_path = get_model(model_path) except ModelNotFound: raise ValueError( "You are trying to load a MODEL from '{}', which is not possible. \n" "The model path should be a 'tar.gz' file or a directory " "containing the various model files in the sub-directories 'core' " "and 'nlu'. \n\nIf you want to load training data instead of " "a model, use `agent.load_data(...)` instead.".format(model_path) ) core_model, nlu_models = get_model_subdirectories(model_path) if nlu_models: if not interpreter: interpreter = {} for lang, model_path in nlu_models.items(): interpreter[lang] = NaturalLanguageInterpreter.create(os.path.join(model_path, model_path)) else: from rasa.model import fingerprint_from_path, FINGERPRINT_CONFIG_NLU_KEY fingerprint = fingerprint_from_path(model_path) if len(fingerprint.get(FINGERPRINT_CONFIG_NLU_KEY).keys()): interpreter = {list(fingerprint.get(FINGERPRINT_CONFIG_NLU_KEY).keys())[0]: RegexInterpreter()} domain = None ensemble = None if core_model: domain = Domain.load(os.path.join(core_model, DEFAULT_DOMAIN_PATH)) ensemble = PolicyEnsemble.load(core_model) if core_model else None # ensures the domain hasn't changed between test and train try: domain.compare_with_specification(core_model) except rasa.core.domain.InvalidDomain as e: logger.warning(e.message) domain = None return cls( domain=domain, policies=ensemble, interpreter=interpreter, generator=generator, tracker_store=tracker_store, lock_store=lock_store, action_endpoint=action_endpoint, model_directory=model_path, model_server=model_server, remote_storage=remote_storage, path_to_model_archive=path_to_model_archive, )
# --------------------- # In[37]: from rasa.core.agent import Agent from rasa.core.interpreter import NaturalLanguageInterpreter from rasa.core.utils import EndpointConfig # In[38]: model_directory = os.path.join(model_dir, "current") # In[39]: interpreter = NaturalLanguageInterpreter.create(model_directory) # In[40]: action_endpoint = EndpointConfig(url="http://localhost:5055/webhook") # In[41]: agent_model_path = os.path.join(model_dir, policy_fixed_model_name) agent = Agent.load(agent_model_path, interpreter=interpreter, action_endpoint=action_endpoint) # In[44]: loop = asyncio.get_event_loop()
from rasa.core.channels.socketio import SocketIOInput from rasa.core.agent import Agent from rasa.core.interpreter import NaturalLanguageInterpreter # load your trained agent interpreter = NaturalLanguageInterpreter.create( 'C:/Users/NJJainnew_ex/models/20190805-123059/nlu') agent = Agent.load('C:/Users/NJJain/new_ex/models/20190805-123059', interpreter=interpreter) 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=False if you want to keep the server running s = agent.handle_channels([input_channel], 5005)