def copy_models_to_compare(models: List[str]) -> Text:
models_dir = tempfile.mkdtemp()
for i, model in enumerate(models):
if os.path.exists(model) and os.path.isfile(model):
path = os.path.join(models_dir, "model_" + str(i))
unpack_model(model, path)
else:
logger.warning("Ignore '{}' as it is not a valid model file.".format(model))
logger.debug("Unpacked models to compare to '{}'".format(models_dir))
return models_dir
def test_train_core_success(rasa_app, default_stack_config,
default_stories_file, default_domain_path):
domain_file = open(default_domain_path)
config_file = open(default_stack_config)
core_file = open(default_stories_file)
payload = dict(domain=domain_file.read(),
config=config_file.read(),
nlu=core_file.read())
config_file.close()
core_file.close()
_, response = rasa_app.post("/model/train", json=payload)
assert response.status == 200
# save model to temporary file
tempdir = tempfile.mkdtemp()
model_path = os.path.join(tempdir, "model.tar.gz")
with open(model_path, "wb") as f:
f.write(response.body)
# unpack model and ensure fingerprint is present
model_path = unpack_model(model_path)
assert os.path.exists(os.path.join(model_path, "fingerprint.json"))
def test_package_model(trained_rasa_model, parameters):
output_path = tempfile.mkdtemp()
train_path = unpack_model(trained_rasa_model)
model_path = _package_model(
_fingerprint(),
output_path,
train_path,
parameters["model_name"],
parameters["prefix"],
parameters["uncompress"],
)
assert os.path.exists(model_path)
file_name = os.path.basename(model_path)
if parameters["model_name"]:
assert parameters["model_name"] in file_name
if parameters["prefix"]:
assert parameters["prefix"] in file_name
if parameters["uncompress"]:
assert os.path.isdir(model_path)
assert not file_name.endswith(".tar.gz")
else:
assert file_name.endswith(".tar.gz")
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 __init__(self, **kwargs):
model_path = kwargs.get("model", None)
try:
if model_path is not None:
logger.info("Loading model " + model_path)
if os.path.isdir(model_path):
self.interpreter = Interpreter.load(model_path)
elif model_path.endswith(".tar.gz"):
model = unpack_model(model_path)
if os.path.isdir(model + "/nlu"):
self.interpreter = Interpreter.load(model + "/nlu")
else:
self.interpreter = Interpreter.load(model)
self.interpreter.parse("ok")
"""Cleanup tmp files and directories"""
try :
if model is not None:
remove_file_or_dir(model)
tmp_dir = "/tmp/"
for root, dirs, files in os.walk(tmp_dir):
for file in files:
if file.startswith("tmp") and file.endswith(".py"):
remove_file_or_dir(tmp_dir+file)
except Exception as e:
logger.error("Exception when cleanup tmp files and directories.", exc_info=True)
else:
self.interpreter = None
except Exception as e:
logger.error("Error when loading model {0}, exception {1}".format(model_path, e), exc_info=True)
remove_file_or_dir(model_path)
raise
async def _core_model_for_finetuning(
model_to_finetune: Text,
file_importer: TrainingDataImporter,
finetuning_epoch_fraction: float = 1.0,
) -> Optional[Agent]:
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 Core model from {path_to_archive} for finetuning...", )
with model.unpack_model(path_to_archive) as 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, core=True):
rasa.shared.utils.cli.print_error_and_exit(
"Core model can not be finetuned.")
config = await file_importer.get_config()
agent = Agent.load(
unpacked,
new_config=config,
finetuning_epoch_fraction=finetuning_epoch_fraction,
)
# Agent might be empty if no underlying Core model was found.
if agent.domain is not None and agent.policy_ensemble is not None:
return agent
return None
def load_local_model(
model_path: Text,
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,
) -> "Agent":
if os.path.isfile(model_path):
model_archive = model_path
else:
model_archive = get_latest_model(model_path)
if model_archive is None:
rasa.shared.utils.io.raise_warning(
f"Could not load local model in '{model_path}'.")
return Agent()
working_directory = tempfile.mkdtemp()
unpacked_model = unpack_model(model_archive, working_directory)
return Agent.load(
unpacked_model,
interpreter=interpreter,
generator=generator,
tracker_store=tracker_store,
lock_store=lock_store,
action_endpoint=action_endpoint,
model_server=model_server,
remote_storage=remote_storage,
path_to_model_archive=model_archive,
)
def test_stack_training(app,
default_domain_path,
default_stories_file,
default_stack_config,
default_nlu_data):
domain_file = open(default_domain_path)
config_file = open(default_stack_config)
stories_file = open(default_stories_file)
nlu_file = open(default_nlu_data)
payload = dict(
domain=domain_file.read(),
config=config_file.read(),
stories=stories_file.read(),
nlu=nlu_file.read()
)
domain_file.close()
config_file.close()
stories_file.close()
nlu_file.close()
_, response = app.post('/jobs', json=payload)
assert response.status == 200
# save model to temporary file
tempdir = tempfile.mkdtemp()
model_path = os.path.join(tempdir, 'model.tar.gz')
with open(model_path, 'wb') as f:
f.write(response.body)
# unpack model and ensure fingerprint is present
model_path = unpack_model(model_path)
assert os.path.exists(os.path.join(model_path, 'fingerprint.json'))
def test_train_no_domain_exists(
run_in_simple_project: Callable[..., RunResult]) -> None:
os.remove("domain.yml")
run_in_simple_project(
"train",
"-c",
"config.yml",
"--data",
"data",
"--out",
"train_models_no_domain",
"--fixed-model-name",
"nlu-model-only",
)
assert os.path.exists("train_models_no_domain")
files = rasa.shared.utils.io.list_files("train_models_no_domain")
assert len(files) == 1
trained_model_path = "train_models_no_domain/nlu-model-only.tar.gz"
unpacked = model.unpack_model(trained_model_path)
metadata_path = os.path.join(unpacked, "nlu", "metadata.json")
assert os.path.exists(metadata_path)
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
async def test_train_nlu_success(
rasa_app: SanicASGITestClient,
default_stack_config: Text,
default_nlu_data: Text,
default_domain_path: Text,
tmp_path: Path,
):
domain_data = rasa.shared.utils.io.read_yaml_file(default_domain_path)
config_data = rasa.shared.utils.io.read_yaml_file(default_stack_config)
nlu_data = rasa.shared.utils.io.read_yaml_file(default_nlu_data)
# combine all data into our payload
payload = {
key: val for d in [domain_data, config_data, nlu_data] for key, val in d.items()
}
data = StringIO()
rasa.shared.utils.io.write_yaml(payload, data)
_, response = await rasa_app.post(
"/model/train",
data=data.getvalue(),
headers={"Content-type": rasa.server.YAML_CONTENT_TYPE},
)
assert response.status == 200
# save model to temporary file
model_path = str(tmp_path / "model.tar.gz")
with open(model_path, "wb") as f:
f.write(response.body)
# unpack model and ensure fingerprint is present
model_path = unpack_model(model_path)
assert os.path.exists(os.path.join(model_path, "fingerprint.json"))
def test_train_stack_success(
rasa_app,
default_domain_path,
default_stories_file,
default_stack_config,
default_nlu_data,
):
with ExitStack() as stack:
domain_file = stack.enter_context(open(default_domain_path))
config_file = stack.enter_context(open(default_stack_config))
stories_file = stack.enter_context(open(default_stories_file))
nlu_file = stack.enter_context(open(default_nlu_data))
payload = dict(
domain=domain_file.read(),
config=config_file.read(),
stories=stories_file.read(),
nlu=nlu_file.read(),
)
_, response = rasa_app.post("/model/train", json=payload)
assert response.status == 200
assert response.headers["filename"] is not None
# save model to temporary file
tempdir = tempfile.mkdtemp()
model_path = os.path.join(tempdir, "model.tar.gz")
with open(model_path, "wb") as f:
f.write(response.body)
# unpack model and ensure fingerprint is present
model_path = unpack_model(model_path)
assert os.path.exists(os.path.join(model_path, "fingerprint.json"))
def load_local_model(
model_path: Text,
interpreter: Optional[NaturalLanguageInterpreter] = None,
generator: Union[EndpointConfig, "NLG"] = None,
tracker_store: Optional["TrackerStore"] = None,
action_endpoint: Optional[EndpointConfig] = None,
model_server: Optional[EndpointConfig] = None,
remote_storage: Optional[Text] = None,
) -> "Agent":
if os.path.isfile(model_path):
model_archive = model_path
else:
model_archive = get_latest_model(model_path)
if model_archive is None:
logger.warning(
"Could not load local model in '{}'".format(model_path))
return Agent()
working_directory = tempfile.mkdtemp()
unpacked_model = unpack_model(model_archive, working_directory)
return Agent.load(
unpacked_model,
interpreter=interpreter,
generator=generator,
tracker_store=tracker_store,
action_endpoint=action_endpoint,
model_server=model_server,
remote_storage=remote_storage,
)
def test_train_with_retrieval_events_success(rasa_app, default_stack_config):
with ExitStack() as stack:
domain_file = stack.enter_context(
open("data/test_domains/default_retrieval_intents.yml"))
config_file = stack.enter_context(open(default_stack_config))
core_file = stack.enter_context(
open("data/test_stories/stories_retrieval_intents.md"))
responses_file = stack.enter_context(
open("data/test_responses/default.md"))
nlu_file = stack.enter_context(
open("data/test_nlu/default_retrieval_intents.md"))
payload = dict(
domain=domain_file.read(),
config=config_file.read(),
stories=core_file.read(),
responses=responses_file.read(),
nlu=nlu_file.read(),
)
_, response = rasa_app.post("/model/train", json=payload)
assert response.status == 200
# save model to temporary file
tempdir = tempfile.mkdtemp()
model_path = os.path.join(tempdir, "model.tar.gz")
with open(model_path, "wb") as f:
f.write(response.body)
# unpack model and ensure fingerprint is present
model_path = unpack_model(model_path)
assert os.path.exists(os.path.join(model_path, "fingerprint.json"))
def test_train_core_success(
rasa_app: SanicTestClient,
default_stack_config: Text,
default_stories_file: Text,
default_domain_path: Text,
tmp_path: Path,
):
with ExitStack() as stack:
domain_file = stack.enter_context(open(default_domain_path))
config_file = stack.enter_context(open(default_stack_config))
core_file = stack.enter_context(open(default_stories_file))
payload = dict(
domain=domain_file.read(),
config=config_file.read(),
stories=core_file.read(),
)
_, response = rasa_app.post("/model/train", json=payload)
assert response.status == 200
# save model to temporary file
model_path = str(tmp_path / "model.tar.gz")
with open(model_path, "wb") as f:
f.write(response.body)
# unpack model and ensure fingerprint is present
model_path = unpack_model(model_path)
assert os.path.exists(os.path.join(model_path, "fingerprint.json"))
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 _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 assert_trained_model(response_body: bytes, tmp_path: Path) -> None:
# save model to temporary file
model_path = str(tmp_path / "model.tar.gz")
with open(model_path, "wb") as f:
f.write(response_body)
# unpack model and ensure fingerprint is present
model_path = unpack_model(model_path)
assert os.path.exists(os.path.join(model_path, "fingerprint.json"))
def assert_trained_model(response_body: bytes) -> None:
# save model to temporary file
tempdir = tempfile.mkdtemp()
model_path = os.path.join(tempdir, "model.tar.gz")
with open(model_path, "wb") as f:
f.write(response_body)
# unpack model and ensure fingerprint is present
model_path = unpack_model(model_path)
assert os.path.exists(os.path.join(model_path, "fingerprint.json"))
def perform_interactive_learning(args, zipped_model):
from rasa.core.train import do_interactive_learning
if zipped_model:
model_path = model.unpack_model(zipped_model)
args.core, args.nlu = model.get_model_subdirectories(model_path)
stories_directory = data.get_core_directory(args.data)
do_interactive_learning(args, stories_directory)
shutil.rmtree(model_path)
else:
print_warning("No initial zipped trained model found.")
def interactive(args: argparse.Namespace):
from rasa.core.train import do_interactive_learning
args.finetune = False # Don't support finetuning
zipped_model = train.train(args)
model_path = model.unpack_model(zipped_model)
args.core, args.nlu = model.get_model_subdirectories(model_path)
stories_directory = data.get_core_directory(args.data)
do_interactive_learning(args, stories_directory)
shutil.rmtree(model_path)
def run_nlu(args: argparse.Namespace):
import rasa_nlu.server
import tempfile
args.model = get_validated_path(args.path, "path", DEFAULT_MODELS_PATH)
model_archive = get_latest_model(args.model)
working_directory = tempfile.mkdtemp()
unpacked_model = model.unpack_model(model_archive, working_directory)
args.path = os.path.dirname(unpacked_model)
rasa_nlu.server.main(args)
shutil.rmtree(unpacked_model)
def perform_interactive_learning(args, zipped_model):
from rasa.core.train import do_interactive_learning
if zipped_model and os.path.exists(zipped_model):
args.model = zipped_model
with model.unpack_model(zipped_model) as model_path:
args.core, args.nlu = model.get_model_subdirectories(model_path)
stories_directory = data.get_core_directory(args.data)
do_interactive_learning(args, stories_directory)
else:
print_error(
"Interactive learning process cannot be started as no initial model was "
"found. Use 'rasa train' to train a model.")
def perform_interactive_learning(args: argparse.Namespace, zipped_model: Text,
file_importer: TrainingDataImporter) -> None:
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:
utils.print_error_and_exit(
"Can not run interactive learning on an NLU-only model.")
args.endpoints = utils.get_validated_path(args.endpoints, "endpoints",
DEFAULT_ENDPOINTS_PATH, True)
do_interactive_learning(args, file_importer)
def perform_interactive_learning(args, zipped_model):
from rasa.core.train import do_interactive_learning
if zipped_model and os.path.exists(zipped_model):
args.model = zipped_model
model_path = model.unpack_model(zipped_model)
args.core, args.nlu = model.get_model_subdirectories(model_path)
stories_directory = data.get_core_directory(args.data)
do_interactive_learning(args, stories_directory)
shutil.rmtree(model_path)
else:
print_error(
"No initial zipped trained model found. Interactive learning process "
"cannot be started.")
async def test_multi_project_training(trained_async):
example_directory = "data/test_multi_domain"
config_file = os.path.join(example_directory, "config.yml")
domain_file = os.path.join(example_directory, "domain.yml")
files_of_root_project = os.path.join(example_directory, "data")
trained_stack_model_path = await trained_async(
config=config_file,
domain=domain_file,
training_files=files_of_root_project,
force_training=True,
persist_nlu_training_data=True,
)
unpacked = model.unpack_model(trained_stack_model_path)
domain_file = os.path.join(
unpacked, DEFAULT_CORE_SUBDIRECTORY_NAME, DEFAULT_DOMAIN_PATH
)
domain = Domain.load(domain_file)
expected_intents = {
"greet",
"goodbye",
"affirm",
"deny",
"mood_great",
"mood_unhappy",
}
assert all([i in domain.intents for i in expected_intents])
nlu_training_data_file = os.path.join(unpacked, "nlu", "training_data.json")
nlu_training_data = RasaReader().read(nlu_training_data_file)
assert expected_intents == nlu_training_data.intents
expected_actions = [
"utter_greet",
"utter_cheer_up",
"utter_did_that_help",
"utter_happy",
"utter_goodbye",
]
assert all([a in domain.action_names for a in expected_actions])
async def test_update_with_new_domain(trained_rasa_model: Text, tmpdir: Path):
_ = model.unpack_model(trained_rasa_model, tmpdir)
new_domain = Domain.empty()
mocked_importer = Mock()
async def get_domain() -> Domain:
return new_domain
mocked_importer.get_domain = get_domain
await model.update_model_with_new_domain(mocked_importer, tmpdir)
actual = Domain.load(tmpdir / DEFAULT_CORE_SUBDIRECTORY_NAME / DEFAULT_DOMAIN_PATH)
assert actual.is_empty()
async def nlu_model_and_evaluation_files_from_archive(
zipped_model_path: Text, directory: Text) -> Tuple[Text, List[Text]]:
"""Extract NLU model path and intent evaluation files zipped model.
Returns a tuple containing the path to the nlu model and a list
of paths to evaluation files.
"""
# unzip and return NLU evaluation files contained in it
unzipped_path = unpack_model(zipped_model_path, directory)
# cast `unzipped_path` as str for py3.5 compatibility
unzipped_path = str(unzipped_path)
model_path = os.path.join(unzipped_path, "nlu")
nlu_files = await find_nlu_files_in_path(unzipped_path)
return model_path, nlu_files
def load_local_model(dir: Text, component_builder: ComponentBuilder) -> "NLUModel":
if os.path.isfile(dir):
model_archive = dir
else:
model_archive = get_latest_model(dir)
if model_archive is None:
logger.warning("Could not load local model in '{}'".format(dir))
return NLUModel.fallback_model(component_builder)
working_directory = tempfile.mkdtemp()
unpacked_model = model.unpack_model(model_archive, working_directory)
_, nlu_model = model.get_model_subdirectories(unpacked_model)
model_path = nlu_model if os.path.exists(nlu_model) else unpacked_model
name = os.path.basename(model_archive)
interpreter = interpreter_for_model(component_builder, model_path)
return NLUModel(name, interpreter, model_path)
async def test_multi_skill_training():
example_directory = "data/test_multi_domain"
config_file = os.path.join(example_directory, "config.yml")
trained_stack_model_path = await train_async(
config=config_file, domain=None, training_files=None
)
unpacked = model.unpack_model(trained_stack_model_path)
model_fingerprint = model.fingerprint_from_path(unpacked)
assert len(model_fingerprint["messages"]) == 2
assert len(model_fingerprint["stories"]) == 2
domain_file = os.path.join(unpacked, "core", "domain.yml")
domain = Domain.load(domain_file)
expected_intents = [
"greet",
"goodbye",
"affirm",
"deny",
"mood_great",
"mood_unhappy",
]
assert all([i in domain.intents for i in expected_intents])
expected_actions = [
"utter_greet",
"utter_cheer_up",
"utter_did_that_help",
"utter_happy",
"utter_goodbye",
]
assert all([a in domain.action_names for a in expected_actions])
