def test_get_model_from_directory_with_subdirectories(trained_rasa_model: Text,
tmp_path: Path):
unpacked = get_model(trained_rasa_model)
unpacked_core, unpacked_nlu = get_model_subdirectories(unpacked)
assert unpacked_core
assert unpacked_nlu
with pytest.raises(ModelNotFound):
get_model_subdirectories(str(tmp_path)) # temp path should be empty
def test_get_model_from_directory_with_subdirectories(
trained_rasa_model, tmpdir_factory: TempdirFactory):
unpacked = get_model(trained_rasa_model)
unpacked_core, unpacked_nlu = get_model_subdirectories(unpacked)
assert unpacked_core
assert unpacked_nlu
directory = tmpdir_factory.mktemp("empty_model_dir").strpath
with pytest.raises(ModelNotFound):
get_model_subdirectories(directory)
async def load_agent_on_start(
model_path: Text,
endpoints: AvailableEndpoints,
remote_storage: Optional[Text],
app: Sanic,
loop: AbstractEventLoop,
):
"""Load an agent.
Used to be scheduled on server start
(hence the `app` and `loop` arguments)."""
# noinspection PyBroadException
try:
with model.get_model(model_path) as unpacked_model:
_, nlu_model = model.get_model_subdirectories(unpacked_model)
_interpreter = NaturalLanguageInterpreter.create(endpoints.nlu or nlu_model)
except Exception:
logger.debug(f"Could not load interpreter from '{model_path}'.")
_interpreter = None
_broker = EventBroker.create(endpoints.event_broker)
_tracker_store = TrackerStore.create(endpoints.tracker_store, event_broker=_broker)
_lock_store = LockStore.create(endpoints.lock_store)
model_server = endpoints.model if endpoints and endpoints.model else None
try:
app.agent = await agent.load_agent(
model_path,
model_server=model_server,
remote_storage=remote_storage,
interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
lock_store=_lock_store,
action_endpoint=endpoints.action,
)
except Exception as e:
rasa.shared.utils.io.raise_warning(
f"The model at '{model_path}' could not be loaded. " f"Error: {e}"
)
app.agent = None
if not app.agent:
rasa.shared.utils.io.raise_warning(
"Agent could not be loaded with the provided configuration. "
"Load default agent without any model."
)
app.agent = Agent(
interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=endpoints.action,
model_server=model_server,
remote_storage=remote_storage,
)
logger.info("Rasa server is up and running.")
return app.agent
async def test_core(model: Text,
stories: Text,
endpoints: Optional[Text] = None,
output: Text = DEFAULT_RESULTS_PATH):
_endpoints = core_utils.AvailableEndpoints.read_endpoints(endpoints)
model = cli_utils.get_validated_path(model, "model", DEFAULT_MODELS_PATH)
try:
unpacked_model = get_model(model)
except ModelNotFound:
print_error(
"Unable to test: could not find a model. Use 'rasa train' to train a "
"Rasa model and provide it via the '--model' argument.")
return
core_path, nlu_path = get_model_subdirectories(unpacked_model)
if not core_path:
print_error(
"Unable to test: could not find a Core model. Use 'rasa train' to train a "
"Rasa model and provide it via the '--model' argument.")
_interpreter = RegexInterpreter()
_agent = Agent.load(unpacked_model, interpreter=_interpreter)
return await rasa.core.test(stories, _agent, out_directory=output)
def shell_nlu(args: argparse.Namespace):
from rasa.cli.utils import get_validated_path
from rasa.constants import DEFAULT_MODELS_PATH
from rasa.model import get_model, get_model_subdirectories
import rasa.nlu.run
args.connector = "cmdline"
model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
try:
model_path = get_model(model)
except ModelNotFound:
print_error(
"No model found. Train a model before running the "
"server using `rasa train nlu`."
)
return
_, nlu_model = get_model_subdirectories(model_path)
if not os.path.exists(nlu_model):
print_error(
"No NLU model found. Train a model before running the "
"server using `rasa train nlu`."
)
return
rasa.nlu.run.run_cmdline(nlu_model)
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 test_get_model_from_directory_nlu_only(trained_rasa_model):
unpacked = get_model(trained_rasa_model)
shutil.rmtree(os.path.join(unpacked, DEFAULT_CORE_SUBDIRECTORY_NAME))
unpacked_core, unpacked_nlu = get_model_subdirectories(unpacked)
assert not unpacked_core
assert unpacked_nlu
def _create_data_generator(
resource_name: Text,
agent: "Agent",
max_stories: Optional[int] = None,
use_conversation_test_files: bool = False,
) -> "TrainingDataGenerator":
from rasa.shared.core.generator import TrainingDataGenerator
from rasa.shared.constants import DEFAULT_DOMAIN_PATH
from rasa.model import get_model_subdirectories
core_model = None
if agent.model_directory:
core_model, _ = get_model_subdirectories(agent.model_directory)
if core_model and os.path.exists(
os.path.join(core_model, DEFAULT_DOMAIN_PATH)):
domain_path = os.path.join(core_model, DEFAULT_DOMAIN_PATH)
else:
domain_path = None
test_data_importer = TrainingDataImporter.load_from_dict(
training_data_paths=[resource_name], domain_path=domain_path)
if use_conversation_test_files:
story_graph = test_data_importer.get_conversation_tests()
else:
story_graph = test_data_importer.get_stories()
return TrainingDataGenerator(
story_graph,
agent.domain,
use_story_concatenation=False,
augmentation_factor=0,
tracker_limit=max_stories,
)
async def evaluate_intents(request: Request):
"""Evaluate intents against a Rasa model."""
validate_request_body(
request,
"You must provide some nlu data in the request body in order to "
"evaluate your model.",
)
nlu_data = rasa.utils.io.create_temporary_file(request.body,
mode="w+b")
data_path = os.path.abspath(nlu_data)
if not os.path.exists(app.agent.model_directory):
raise ErrorResponse(409, "Conflict",
"Loaded model file not found.")
model_directory = app.agent.model_directory
_, nlu_model = get_model_subdirectories(model_directory)
try:
evaluation = run_evaluation(data_path, nlu_model)
return response.json(evaluation)
except Exception as e:
logger.debug(traceback.format_exc())
raise ErrorResponse(
500,
"TestingError",
"An unexpected error occurred during evaluation. Error: {}".
format(e),
)
async def load_agent_on_start(
model_path: Text,
endpoints: AvailableEndpoints,
remote_storage: Optional[Text],
app: Sanic,
loop: Text,
):
"""Load an agent.
Used to be scheduled on server start
(hence the `app` and `loop` arguments)."""
from rasa.core import broker
try:
unpacked_model_context = get_model(model_path)
if unpacked_model_context:
with unpacked_model_context as unpacked_model:
_, nlu_model = get_model_subdirectories(unpacked_model)
_interpreter = NaturalLanguageInterpreter.create(
nlu_model, endpoints.nlu
)
else:
raise RuntimeError("No model found at '{}'.".format(model_path))
except Exception:
logger.debug("Could not load interpreter from '{}'.".format(model_path))
_interpreter = None
_broker = broker.from_endpoint_config(endpoints.event_broker)
_tracker_store = TrackerStore.find_tracker_store(
None, endpoints.tracker_store, _broker
)
model_server = endpoints.model if endpoints and endpoints.model else None
app.agent = await load_agent(
model_path,
model_server=model_server,
remote_storage=remote_storage,
interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=endpoints.action,
)
if not app.agent:
logger.warning(
"Agent could not be loaded with the provided configuration. "
"Load default agent without any model."
)
app.agent = Agent(
interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=endpoints.action,
model_server=model_server,
remote_storage=remote_storage,
)
return app.agent
async def load_agent_on_start(
model_path: Text,
endpoints: AvailableEndpoints,
remote_storage: Optional[Text],
app: Sanic,
loop: Text,
):
"""Load an agent.
Used to be scheduled on server start
(hence the `app` and `loop` arguments)."""
import rasa.core.brokers.utils as broker_utils
# noinspection PyBroadException
# bf mod
try:
with model.get_model(model_path) as unpacked_model:
_, nlu_models = model.get_model_subdirectories(unpacked_model)
_interpreters = {}
for lang, nlu_model_path in nlu_models.items():
_interpreters[lang] = NaturalLanguageInterpreter.create(
nlu_model_path, endpoints.nlu)
except Exception:
logger.debug(f"Could not load interpreter from '{model_path}'.")
_interpreters = {}
# /bf mod
_broker = broker_utils.from_endpoint_config(endpoints.event_broker)
_tracker_store = TrackerStore.find_tracker_store(None,
endpoints.tracker_store,
_broker)
_lock_store = LockStore.find_lock_store(endpoints.lock_store)
model_server = endpoints.model if endpoints and endpoints.model else None
app.agent = await agent.load_agent(
model_path,
model_server=model_server,
remote_storage=remote_storage,
interpreters=_interpreters,
generator=endpoints.nlg,
tracker_store=_tracker_store,
lock_store=_lock_store,
action_endpoint=endpoints.action,
)
if not app.agent:
warnings.warn(
"Agent could not be loaded with the provided configuration. "
"Load default agent without any model.")
app.agent = Agent(
interpreters=_interpreters,
generator=endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=endpoints.action,
model_server=model_server,
remote_storage=remote_storage,
)
return app.agent
def perform_interactive_learning(
args: argparse.Namespace, zipped_model: Text, file_importer: TrainingDataImporter
) -> None:
"""Performs interactive learning.
Args:
args: Namespace arguments.
zipped_model: Path to zipped model.
file_importer: File importer which provides the training data and model config.
"""
from rasa.core.train import do_interactive_learning
args.model = zipped_model
with model.unpack_model(zipped_model) as model_path:
args.core, args.nlu = model.get_model_subdirectories(model_path)
if args.core is None:
rasa.shared.utils.cli.print_error_and_exit(
"Can not run interactive learning on an NLU-only model."
)
args.endpoints = rasa.cli.utils.get_validated_path(
args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
)
do_interactive_learning(args, file_importer)
def shell(args: argparse.Namespace) -> None:
from rasa.cli.utils import get_validated_path
from rasa.shared.constants import DEFAULT_MODELS_PATH
from rasa.model import get_model, get_model_subdirectories
args.connector = "cmdline"
model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
try:
model_path = get_model(model)
except ModelNotFound:
print_error(
"No model found. Train a model before running the "
"server using `rasa train`."
)
return
core_model, nlu_model = get_model_subdirectories(model_path)
if not core_model:
import rasa.nlu.run
telemetry.track_shell_started("nlu")
rasa.nlu.run.run_cmdline(nlu_model)
else:
import rasa.cli.run
telemetry.track_shell_started("rasa")
rasa.cli.run.run(args)
async def _nlu_model_for_finetuning(
model_to_finetune: Text,
file_importer: TrainingDataImporter,
finetuning_epoch_fraction: float = 1.0,
called_from_combined_training: bool = False,
) -> Optional[Interpreter]:
path_to_archive = model.get_model_for_finetuning(model_to_finetune)
if not path_to_archive:
return None
rasa.shared.utils.cli.print_info(
f"Loading NLU model from {path_to_archive} for finetuning...", )
with model.unpack_model(path_to_archive) as unpacked:
_, old_nlu = model.get_model_subdirectories(unpacked)
new_fingerprint = await model.model_fingerprint(file_importer)
old_fingerprint = model.fingerprint_from_path(unpacked)
if not model.can_finetune(
old_fingerprint,
new_fingerprint,
nlu=True,
core=called_from_combined_training,
):
rasa.shared.utils.cli.print_error_and_exit(
"NLU model can not be finetuned.")
config = await file_importer.get_config()
model_to_finetune = Interpreter.load(
old_nlu,
new_config=config,
finetuning_epoch_fraction=finetuning_epoch_fraction,
)
if not model_to_finetune:
return None
return model_to_finetune
def shell(args: argparse.Namespace):
from rasa.cli.utils import get_validated_path
from rasa.constants import DEFAULT_MODELS_PATH
from rasa.model import get_model, get_model_subdirectories
args.connector = "cmdline"
model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
model_path = get_model(model)
if not model_path:
print_error(
"No model found. Train a model before running the "
"server using `rasa train`."
)
return
core_model, nlu_model = get_model_subdirectories(model_path)
if not os.path.exists(core_model):
import rasa.nlu.run
rasa.nlu.run.run_cmdline(nlu_model)
else:
import rasa.cli.run
rasa.cli.run.run(args)
def _load_and_set_updated_model(
agent: "Agent", model_directory: Text, fingerprint: Text
) -> None:
"""Load the persisted model into memory and set the model on the agent.
Args:
agent: Instance of `Agent` to update with the new model.
model_directory: Rasa model directory.
fingerprint: Fingerprint of the supplied model at `model_directory`.
"""
logger.debug(f"Found new model with fingerprint {fingerprint}. Loading...")
core_path, nlu_path = get_model_subdirectories(model_directory)
try:
interpreter = _load_interpreter(agent, nlu_path)
domain, policy_ensemble = _load_domain_and_policy_ensemble(core_path)
agent.update_model(
domain, policy_ensemble, fingerprint, interpreter, model_directory
)
logger.debug("Finished updating agent to new model.")
except Exception as e:
logger.exception(
f"Failed to update model. The previous model will stay loaded instead. "
f"Error: {e}"
)
def test_get_model_from_directory_nlu_only(trained_model):
unpacked = get_model(trained_model)
shutil.rmtree(os.path.join(unpacked, "core"))
unpacked_core, unpacked_nlu = get_model_subdirectories(unpacked)
assert not unpacked_core
assert unpacked_nlu
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 test_parse():
# model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
model = get_validated_path(None, "model", DEFAULT_MODELS_PATH)
model_path = get_model(model)
if not model_path:
print_error("No model found. Train a model before running the "
"server using `rasa train nlu`.")
exit(1)
_, nlu_model = get_model_subdirectories(model_path)
if not os.path.exists(nlu_model):
print_error("No NLU model found. Train a model before running the "
"server using `rasa train nlu`.")
exit(1)
# input shell
# rasa.nlu.run.run_cmdline(nlu_model)
print("model_path is {},nlu_model is {}".format(model_path, nlu_model))
print("please input your text to parse")
# message = input().strip()
# message = "这款衣服有货吗"
message = "身高170体重140"
interpreter = Interpreter.load(nlu_model, component_builder)
result = interpreter.parse(message)
print(json.dumps(result, indent=2))
def load(
cls,
model_path: Union[Text, Path],
interpreter: Optional[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.")
if not os.path.exists(model_path):
raise ModelNotFound(f"No file or directory at '{model_path}'.")
if os.path.isfile(model_path):
model_path = get_model(str(model_path))
except ModelNotFound as e:
raise ModelNotFound(
f"You are trying to load a model from '{model_path}', "
f"which is not possible. \n"
f"The model path should be a 'tar.gz' file or a directory "
f"containing the various model files in the sub-directories "
f"'core' and 'nlu'. \n\n"
f"If you want to load training data instead of a model, use "
f"`agent.load_data(...)` instead. {e}"
)
core_model, nlu_model = get_model_subdirectories(model_path)
if not interpreter and nlu_model:
interpreter = rasa.core.interpreter.create_interpreter(nlu_model)
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
domain.compare_with_specification(core_model)
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,
)
async def evaluate_intents(request: Request):
"""Evaluate intents against a Rasa model."""
validate_request_body(
request,
"You must provide some nlu data in the request body in order to "
"evaluate your model.",
)
eval_agent = app.agent
model_path = request.args.get("model", None)
if model_path:
model_server = app.agent.model_server
if model_server is not None:
model_server.url = model_path
eval_agent = await _load_agent(model_path, model_server,
app.agent.remote_storage)
nlu_data = rasa.utils.io.create_temporary_file(request.body,
mode="w+b")
data_path = os.path.abspath(nlu_data)
if not eval_agent.model_directory or not os.path.exists(
eval_agent.model_directory):
raise ErrorResponse(409, "Conflict",
"Loaded model file not found.")
model_directory = eval_agent.model_directory
_, nlu_model = model.get_model_subdirectories(model_directory)
try:
# bf >
language = request.args.get("language", None)
evaluation = run_evaluation(
data_path,
nlu_model.get(language),
errors=True,
output_directory=model_directory,
)
for classifier in evaluation.get("entity_evaluation", {}):
entity_errors_file = os.path.join(model_directory,
f"{classifier}_errors.json")
if os.path.isfile(entity_errors_file):
import json
entity_errors = json.loads(
rasa.utils.io.read_file(entity_errors_file))
evaluation["entity_evaluation"][classifier][
"predictions"] = entity_errors
# </ bf
return response.json(evaluation)
except Exception as e:
logger.debug(traceback.format_exc())
raise ErrorResponse(
500,
"TestingError",
f"An unexpected error occurred during evaluation. Error: {e}",
)
def test_create_interpreter(parameters, trained_nlu_model):
obj = parameters["obj"]
if obj == "trained_nlu_model":
_, obj = get_model_subdirectories(get_model(trained_nlu_model))
interpreter = NaturalLanguageInterpreter.create(obj, parameters["endpoint"])
assert isinstance(interpreter, parameters["type"])
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)
unpacked_model = get_model(model)
if unpacked_model is None:
print_error(
"Unable to test: could not find a model. Use 'rasa train' to train a "
"Rasa model."
)
return
core_path, nlu_path = get_model_subdirectories(unpacked_model)
if not os.path.exists(core_path):
print_error(
"Unable to test: could not find a Core model. Use 'rasa train' to "
"train a model."
)
use_e2e = kwargs["e2e"] if "e2e" in kwargs else False
_interpreter = RegexInterpreter()
if use_e2e:
if os.path.exists(nlu_path):
_interpreter = NaturalLanguageInterpreter.create(nlu_path, _endpoints.nlu)
else:
print_warning(
"No NLU model found. Using default 'RegexInterpreter' for end-to-end "
"evaluation."
)
_agent = Agent.load(unpacked_model, interpreter=_interpreter)
kwargs = minimal_kwargs(kwargs, rasa.core.test, ["stories", "agent"])
loop = asyncio.get_event_loop()
loop.run_until_complete(
rasa.core.test(stories, _agent, out_directory=output, **kwargs)
)
def _interpreter_from_previous_model(
old_model_zip_path: Optional[Text],
) -> Optional[NaturalLanguageInterpreter]:
if not old_model_zip_path:
return None
with model.unpack_model(old_model_zip_path) as unpacked:
_, old_nlu = model.get_model_subdirectories(unpacked)
return rasa.core.interpreter.create_interpreter(old_nlu)
def test_create_interpreter(parameters, trained_nlu_model):
obj = parameters["obj"]
if obj == "trained_nlu_model":
_, obj = get_model_subdirectories(get_model(trained_nlu_model))
interpreter = rasa.core.interpreter.create_interpreter(
parameters["endpoint"] or obj)
assert isinstance(interpreter, parameters["type"])
def test_core(
model: Optional[Text] = None,
stories: Optional[Text] = None,
endpoints: Optional[Text] = None,
output: Text = DEFAULT_RESULTS_PATH,
model_path: Optional[Text] = None,
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)
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)
if os.path.exists(core_path) and os.path.exists(nlu_path):
_interpreter = NaturalLanguageInterpreter.create(nlu_path, _endpoints.nlu)
_agent = Agent.load(core_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:
logger.warning(
"Not able to test. Make sure both models, core and "
"nlu, are available."
)
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 _load_model(self, model_name):
model_path = os.path.join("models", model_name)
tempdir = tempfile.mkdtemp()
unpacked_model = unpack_model(model_path, tempdir)
_, nlu_model = get_model_subdirectories(unpacked_model)
with self.lock:
interpreter = Interpreter.load(nlu_model, self.component_builder)
return interpreter
def load(
cls,
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."""
try:
if not model_path:
raise ModelNotFound("No path specified.")
elif not os.path.exists(model_path):
raise ModelNotFound(
"No file or directory at '{}'.".format(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_model = get_model_subdirectories(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=model_path,
model_server=model_server,
remote_storage=remote_storage,
)
def get_interpreter(model_path):
from rasa.model import get_model, get_model_subdirectories
from rasa.core.interpreter import create_interpreter
try:
with get_model(model_path) as unpacked_model:
_, nlu_model = get_model_subdirectories(unpacked_model)
_interpreter = create_interpreter(nlu_model)
except Exception:
logger.debug(f"Could not load interpreter from '{model_path}'.")
_interpreter = None
return _interpreter
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
import rasa.nlu.run
from rasa.core.utils import AvailableEndpoints
model_path = get_model(model)
if not model_path:
logger.error("No model found. Train a model before running the "
"server using `rasa train`.")
return
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
if os.path.exists(core_path):
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)
# TODO: No core model was found, run only nlu server for now
elif os.path.exists(nlu_path):
rasa.nlu.run.run_cmdline(nlu_path)
shutil.rmtree(model_path)