def _train_graph(
file_importer: TrainingDataImporter,
training_type: TrainingType,
output_path: Text,
fixed_model_name: Text,
model_to_finetune: Optional[Text] = None,
force_full_training: bool = False,
dry_run: bool = False,
**kwargs: Any,
) -> TrainingResult:
if model_to_finetune:
model_to_finetune = rasa.model.get_model_for_finetuning(model_to_finetune)
if not model_to_finetune:
rasa.shared.utils.cli.print_error_and_exit(
f"No model for finetuning found. Please make sure to either "
f"specify a path to a previous model or to have a finetunable "
f"model within the directory '{output_path}'."
)
rasa.shared.utils.common.mark_as_experimental_feature(
"Incremental Training feature"
)
is_finetuning = model_to_finetune is not None
config = file_importer.get_config()
recipe = Recipe.recipe_for_name(config.get("recipe"))
model_configuration = recipe.graph_config_for_recipe(
config, kwargs, training_type=training_type, is_finetuning=is_finetuning
)
rasa.engine.validation.validate(model_configuration)
with tempfile.TemporaryDirectory() as temp_model_dir:
model_storage = _create_model_storage(
is_finetuning, model_to_finetune, Path(temp_model_dir)
)
cache = LocalTrainingCache()
trainer = GraphTrainer(model_storage, cache, DaskGraphRunner)
if dry_run:
fingerprint_status = trainer.fingerprint(
model_configuration.train_schema, file_importer
)
return _dry_run_result(fingerprint_status, force_full_training)
model_name = _determine_model_name(fixed_model_name, training_type)
full_model_path = Path(output_path, model_name)
with telemetry.track_model_training(
file_importer, model_type=training_type.model_type
):
trainer.train(
model_configuration,
file_importer,
full_model_path,
force_retraining=force_full_training,
is_finetuning=is_finetuning,
)
rasa.shared.utils.cli.print_success(
f"Your Rasa model is trained and saved at '{full_model_path}'."
)
return TrainingResult(str(full_model_path), 0)
async def _train_core_with_validated_data(
file_importer: TrainingDataImporter,
output: Text,
train_path: Optional[Text] = None,
fixed_model_name: Optional[Text] = None,
additional_arguments: Optional[Dict] = None,
interpreter: Optional[Interpreter] = None,
model_to_finetune: Optional["Text"] = None,
finetuning_epoch_fraction: float = 1.0,
) -> Optional[Text]:
"""Train Core with validated training and config data."""
import rasa.core.train
with ExitStack() as stack:
if train_path:
# If the train path was provided, do nothing on exit.
_train_path = train_path
else:
# Otherwise, create a temp train path and clean it up on exit.
_train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp()))
# normal (not compare) training
rasa.shared.utils.cli.print_color(
"Training Core model...", color=rasa.shared.utils.io.bcolors.OKBLUE
)
domain, config = await asyncio.gather(
file_importer.get_domain(), file_importer.get_config()
)
if model_to_finetune:
rasa.shared.utils.common.mark_as_experimental_feature(
"Incremental Training feature"
)
model_to_finetune = await _core_model_for_finetuning(
model_to_finetune,
file_importer=file_importer,
finetuning_epoch_fraction=finetuning_epoch_fraction,
)
if not model_to_finetune:
rasa.shared.utils.cli.print_error_and_exit(
f"No Core model for finetuning found. Please make sure to either "
f"specify a path to a previous model or to have a finetunable "
f"model within the directory '{output}'."
)
async with telemetry.track_model_training(
file_importer,
model_type="core",
is_finetuning=model_to_finetune is not None,
):
await rasa.core.train(
domain_file=domain,
training_resource=file_importer,
output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME),
policy_config=config,
additional_arguments=additional_arguments,
interpreter=interpreter,
model_to_finetune=model_to_finetune,
)
rasa.shared.utils.cli.print_color(
"Core model training completed.", color=rasa.shared.utils.io.bcolors.OKBLUE
)
if train_path is None:
# Only Core was trained.
new_fingerprint = await model.model_fingerprint(file_importer)
return model.package_model(
fingerprint=new_fingerprint,
output_directory=output,
train_path=_train_path,
fixed_model_name=fixed_model_name,
model_prefix="core-",
)
return _train_path
