def get_local_model(model_path: Text = DEFAULT_MODELS_PATH) -> Text:
"""Returns verified path to local model archive.
Args:
model_path: Path to the zipped model. If it's a directory, the latest
trained model is returned.
Returns:
Path to the zipped model. If it's a directory, the latest
trained model is returned.
Raises:
ModelNotFound Exception: When no model could be found at the provided path.
"""
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}'.")
if os.path.isdir(model_path):
model_path = get_latest_model(model_path)
if not model_path:
raise ModelNotFound(
f"Could not find any Rasa model files in '{model_path}'."
)
elif not model_path.endswith(".tar.gz"):
raise ModelNotFound(f"Path '{model_path}' does not point to a Rasa model file.")
return model_path
def get_model(model_path: Text = DEFAULT_MODELS_PATH) -> TempDirectoryPath:
"""Get a model and unpack it. Raises a `ModelNotFound` exception if
no model could be found at the provided path.
Args:
model_path: Path to the zipped model. If it's a directory, the latest
trained model is returned.
Returns:
Path to the unpacked model.
"""
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}'.")
if os.path.isdir(model_path):
model_path = get_latest_model(model_path)
if not model_path:
raise ModelNotFound(
f"Could not find any Rasa model files in '{model_path}'.")
elif not model_path.endswith(".tar.gz"):
raise ModelNotFound(
f"Path '{model_path}' does not point to a Rasa model file.")
try:
model_relative_path = os.path.relpath(model_path)
except ValueError:
model_relative_path = model_path
logger.info(f"Loading model {model_relative_path}...")
return unpack_model(model_path)
def _load_model(
model_path: Union[Text,
Path]) -> Tuple[Text, ModelMetadata, GraphRunner]:
"""Unpacks a model from a given path using the graph model loader."""
try:
if os.path.isfile(model_path):
model_tar = model_path
else:
model_tar = get_latest_model(model_path)
if not model_tar:
raise ModelNotFound(
f"No model found at path '{model_path}'.")
except TypeError:
raise ModelNotFound(f"Model {model_path} can not be loaded.")
logger.info(f"Loading model {model_tar}...")
with tempfile.TemporaryDirectory() as temporary_directory:
try:
metadata, runner = loader.load_predict_graph_runner(
Path(temporary_directory),
Path(model_tar),
LocalModelStorage,
DaskGraphRunner,
)
return os.path.basename(model_tar), metadata, runner
except tarfile.ReadError:
raise ModelNotFound(f"Model {model_path} can not be loaded.")
def get_model(model_path: Text = DEFAULT_MODELS_PATH) -> TempDirectoryPath:
"""Gets a model and unpacks it. Raises a `ModelNotFound` exception if
no model could be found at the provided path.
Args:
model_path: Path to the zipped model. If it's a directory, the latest
trained model is returned.
Returns:
Path to the unpacked model.
"""
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))
if os.path.isdir(model_path):
model_path = get_latest_model(model_path)
if not model_path:
raise ModelNotFound(
"Could not find any Rasa model files in '{}'.".format(
model_path))
elif not model_path.endswith(".tar.gz"):
raise ModelNotFound(
"Path '{}' does not point to a Rasa model file.".format(
model_path))
return unpack_model(model_path)
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,
)
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_model_subdirectories(
unpacked_model_path: Text,
) -> Tuple[Optional[Text], Optional[Text]]:
"""Return paths for Core and NLU model directories, if they exist.
If neither directories exist, a `ModelNotFound` exception is raised.
Args:
unpacked_model_path: Path to unpacked Rasa model.
Returns:
Tuple (path to Core subdirectory if it exists or `None` otherwise,
path to NLU subdirectory if it exists or `None` otherwise).
"""
core_path = os.path.join(unpacked_model_path, DEFAULT_CORE_SUBDIRECTORY_NAME)
nlu_path = os.path.join(unpacked_model_path, DEFAULT_NLU_SUBDIRECTORY_NAME)
if not os.path.isdir(core_path):
core_path = None
if not os.path.isdir(nlu_path):
nlu_path = None
if not core_path and not nlu_path:
raise ModelNotFound(
"No NLU or Core data for unpacked model at: '{}'.".format(
unpacked_model_path
)
)
return core_path, nlu_path
def get_model_subdirectories(
unpacked_model_path: Text) -> Tuple[Text, Dict[Text, Text]]:
"""Returns paths for Core and NLU model directories, if they exist.
If neither directories exist, a `ModelNotFound` exception is raised.
Args:
unpacked_model_path: Path to unpacked Rasa model.
Returns:
Tuple (path to Core subdirectory if it exists or `None` otherwise,
path to NLU subdirectory if it exists or `None` otherwise).
"""
core_path = os.path.join(unpacked_model_path, "core")
# bf mod
# nlu_path = os.path.join(unpacked_model_path, "nlu")
nlu_models = list(
filter(lambda d: d.startswith("nlu"), os.listdir(unpacked_model_path)))
nlu_paths = {}
try:
for model in nlu_models:
lang = model.split("-")[1]
nlu_paths[lang] = os.path.join(unpacked_model_path, model)
except Exception:
nlu_paths = {}
if not os.path.isdir(core_path):
core_path = None
if not core_path and not len(nlu_paths):
raise ModelNotFound(
"No NLU or Core data for unpacked model at: '{}'.".format(
unpacked_model_path))
return core_path, nlu_paths
def get_model_subdirectories(
unpacked_model_path: Text,
) -> Tuple[Optional[Text], Optional[Text]]:
"""Return paths for Core and NLU model directories, if they exist.
If neither directories exist, a `ModelNotFound` exception is raised.
Args:
unpacked_model_path: Path to unpacked Rasa model.
Returns:
Tuple (path to Core subdirectory if it exists or `None` otherwise,
path to NLU subdirectory if it exists or `None` otherwise).
"""
core_path = os.path.join(unpacked_model_path, DEFAULT_CORE_SUBDIRECTORY_NAME)
# bf mod
# nlu_path = os.path.join(unpacked_model_path, "nlu")
nlu_models = list(
filter(lambda d: d.startswith("nlu"), os.listdir(unpacked_model_path))
)
models_fingerprint = fingerprint_from_path(unpacked_model_path)
nlu_paths = {
lang: None
for lang in models_fingerprint.get(FINGERPRINT_CONFIG_NLU_KEY, {}).keys()
}
try:
for model in nlu_models:
lang = model.split("-")[1]
nlu_paths[lang] = os.path.join(unpacked_model_path, model)
except Exception:
pass
if not os.path.isdir(core_path):
core_path = None
if not core_path and not len(nlu_paths):
raise ModelNotFound(
"No NLU or Core data for unpacked model at: '{}'.".format(
unpacked_model_path
)
)
return core_path, nlu_paths
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,
)
