def graph_config_for_recipe(
self,
config: Dict,
cli_parameters: Dict[Text, Any],
training_type: TrainingType = TrainingType.BOTH,
is_finetuning: bool = False,
) -> GraphModelConfiguration:
"""Converts the default config to graphs (see interface for full docstring)."""
mark_as_experimental_feature("graph recipe")
if cli_parameters or is_finetuning:
raise_warning(
"Unlike the Default Recipe, Graph Recipe does not utilize CLI "
"parameters or finetuning and these configurations will be ignored. "
"Add configuration to the recipe itself if you want them to be used.",
docs=DOCS_URL_GRAPH_RECIPE,
)
nlu_target, core_target = self.get_targets(config, training_type)
return GraphModelConfiguration(
train_schema=GraphSchema.from_dict(config.get("train_schema")),
predict_schema=GraphSchema.from_dict(config.get("predict_schema")),
training_type=training_type,
language=config.get("language"),
core_target=core_target,
nlu_target=nlu_target,
)
def test_generate_graphs(
config_path: Text,
expected_train_schema_path: Text,
expected_predict_schema_path: Text,
training_type: TrainingType,
):
expected_schema_as_dict = rasa.shared.utils.io.read_yaml_file(
expected_train_schema_path)
expected_train_schema = GraphSchema.from_dict(expected_schema_as_dict)
expected_schema_as_dict = rasa.shared.utils.io.read_yaml_file(
expected_predict_schema_path)
expected_predict_schema = GraphSchema.from_dict(expected_schema_as_dict)
config = rasa.shared.utils.io.read_yaml_file(config_path)
recipe = Recipe.recipe_for_name(GraphV1Recipe.name)
model_config = recipe.graph_config_for_recipe(config, {},
training_type=training_type)
assert model_config.train_schema == expected_train_schema
assert model_config.predict_schema == expected_predict_schema
if training_type == TrainingType.NLU:
core_target = None
else:
core_target = config.get("core_target", "select_prediction")
assert model_config.core_target == core_target
assert model_config.nlu_target == config.get("nlu_target",
"run_RegexMessageHandler")
rasa.engine.validation.validate(model_config)
def test_invalid_module_error_when_deserializing_schemas(tmp_path: Path):
graph_schema = GraphSchema(
{
"train": SchemaNode(
needs={},
uses=PersistableTestComponent,
fn="train",
constructor_name="create",
config={"some_config": 123455, "some more config": [{"nested": "hi"}]},
)
}
)
serialized = graph_schema.as_dict()
# Pretend module is for some reason invalid
serialized["nodes"]["train"]["uses"] = "invalid.class"
# Dump it to make sure it's actually serializable
file_path = tmp_path / "my_graph.yml"
rasa.shared.utils.io.write_yaml(serialized, file_path)
serialized_graph_schema_from_file = rasa.shared.utils.io.read_yaml_file(file_path)
with pytest.raises(GraphSchemaException):
_ = GraphSchema.from_dict(serialized_graph_schema_from_file)
def test_serialize_graph_schema(tmp_path: Path):
graph_schema = GraphSchema(
{
"train": SchemaNode(
needs={},
uses=PersistableTestComponent,
fn="train",
constructor_name="create",
config={"some_config": 123455, "some more config": [{"nested": "hi"}]},
),
"load": SchemaNode(
needs={"resource": "train"},
uses=PersistableTestComponent,
fn="run_inference",
constructor_name="load",
config={},
is_target=True,
resource=Resource("test resource"),
),
}
)
serialized = graph_schema.as_dict()
# Dump it to make sure it's actually serializable
file_path = tmp_path / "my_graph.yml"
rasa.shared.utils.io.write_yaml(serialized, file_path)
serialized_graph_schema_from_file = rasa.shared.utils.io.read_yaml_file(file_path)
graph_schema_from_file = GraphSchema.from_dict(serialized_graph_schema_from_file)
assert graph_schema_from_file == graph_schema
def test_epoch_fraction_cli_param_unspecified():
# TODO: enhance testing of cli instead of imitating expected parsed input
expected_schema_as_dict = rasa.shared.utils.io.read_yaml_file(
"data/graph_schemas/default_config_finetune_epoch_fraction_schema.yml")
expected_train_schema = GraphSchema.from_dict(expected_schema_as_dict)
# modify the expected schema
for schema_node in expected_train_schema.nodes.values():
if "finetuning_epoch_fraction" in schema_node.config:
schema_node.config["finetuning_epoch_fraction"] = 1.0
if "epochs" in schema_node.config:
schema_node.config["epochs"] *= 2
config = rasa.shared.utils.io.read_yaml_file(
"rasa/engine/recipes/config_files/default_config.yml")
recipe = Recipe.recipe_for_name(DefaultV1Recipe.name)
model_config = recipe.graph_config_for_recipe(
config, {"finetuning_epoch_fraction": None}, is_finetuning=True)
train_schema = model_config.train_schema
for node_name, node in expected_train_schema.nodes.items():
assert train_schema.nodes[node_name] == node
assert train_schema == expected_train_schema
def from_dict(cls, serialized: Dict[Text, Any]) -> ModelMetadata:
"""Loads `ModelMetadata` which has been serialized using `metadata.as_dict()`.
Args:
serialized: Serialized `ModelMetadata` (e.g. read from disk).
Returns:
Instantiated `ModelMetadata`.
"""
return ModelMetadata(
trained_at=datetime.fromisoformat(serialized["trained_at"]),
rasa_open_source_version=serialized["rasa_open_source_version"],
model_id=serialized["model_id"],
domain=Domain.from_dict(serialized["domain"]),
train_schema=GraphSchema.from_dict(serialized["train_schema"]),
predict_schema=GraphSchema.from_dict(serialized["predict_schema"]),
)
def test_generate_graphs(
config_path: Text,
expected_train_schema_path: Text,
expected_predict_schema_path: Text,
training_type: TrainingType,
is_finetuning: bool,
):
expected_schema_as_dict = rasa.shared.utils.io.read_yaml_file(
expected_train_schema_path)
expected_train_schema = GraphSchema.from_dict(expected_schema_as_dict)
expected_schema_as_dict = rasa.shared.utils.io.read_yaml_file(
expected_predict_schema_path)
expected_predict_schema = GraphSchema.from_dict(expected_schema_as_dict)
config = rasa.shared.utils.io.read_yaml_file(config_path)
recipe = Recipe.recipe_for_name(DefaultV1Recipe.name)
model_config = recipe.graph_config_for_recipe(config, {},
training_type=training_type,
is_finetuning=is_finetuning)
train_schema = model_config.train_schema
for node_name, node in expected_train_schema.nodes.items():
assert train_schema.nodes[node_name] == node
assert train_schema == expected_train_schema
default_v1_validator = DefaultV1RecipeValidator(train_schema)
importer = RasaFileImporter()
# does not raise
default_v1_validator.validate(importer)
predict_schema = model_config.predict_schema
for node_name, node in expected_predict_schema.nodes.items():
assert predict_schema.nodes[node_name] == node
assert predict_schema == expected_predict_schema
rasa.engine.validation.validate(model_config)
def test_num_threads_interpolation():
expected_schema_as_dict = rasa.shared.utils.io.read_yaml_file(
"data/graph_schemas/config_pretrained_embeddings_mitie_train_schema.yml"
)
expected_train_schema = GraphSchema.from_dict(expected_schema_as_dict)
expected_schema_as_dict = rasa.shared.utils.io.read_yaml_file(
"data/graph_schemas/config_pretrained_embeddings_mitie_predict_schema.yml"
)
expected_predict_schema = GraphSchema.from_dict(expected_schema_as_dict)
for node_name, node in expected_train_schema.nodes.items():
if issubclass(
node.uses,
(
SklearnIntentClassifier,
MitieEntityExtractor,
MitieIntentClassifier,
),
) and node_name.startswith("train_"):
node.config["num_threads"] = 20
config = rasa.shared.utils.io.read_yaml_file(
"data/test_config/config_pretrained_embeddings_mitie.yml")
recipe = Recipe.recipe_for_name(DefaultV1Recipe.name)
model_config = recipe.graph_config_for_recipe(config, {"num_threads": 20})
train_schema = model_config.train_schema
for node_name, node in expected_train_schema.nodes.items():
assert train_schema.nodes[node_name] == node
assert train_schema == expected_train_schema
predict_schema = model_config.predict_schema
for node_name, node in expected_predict_schema.nodes.items():
assert predict_schema.nodes[node_name] == node
assert predict_schema == expected_predict_schema
def from_dict(cls, serialized: Dict[Text, Any]) -> ModelMetadata:
"""Loads `ModelMetadata` which has been serialized using `metadata.as_dict()`.
Args:
serialized: Serialized `ModelMetadata` (e.g. read from disk).
Returns:
Instantiated `ModelMetadata`.
"""
from rasa.engine.graph import GraphSchema
return ModelMetadata(
trained_at=datetime.fromisoformat(serialized["trained_at"]),
rasa_open_source_version=serialized["rasa_open_source_version"],
model_id=serialized["model_id"],
domain=Domain.from_dict(serialized["domain"]),
train_schema=GraphSchema.from_dict(serialized["train_schema"]),
predict_schema=GraphSchema.from_dict(serialized["predict_schema"]),
training_type=TrainingType(serialized["training_type"]),
project_fingerprint=serialized["project_fingerprint"],
core_target=serialized["core_target"],
nlu_target=serialized["nlu_target"],
language=serialized["language"],
)
def test_epoch_fraction_cli_param():
expected_schema_as_dict = rasa.shared.utils.io.read_yaml_file(
"data/graph_schemas/default_config_finetune_epoch_fraction_schema.yml")
expected_train_schema = GraphSchema.from_dict(expected_schema_as_dict)
config = rasa.shared.utils.io.read_yaml_file(
"rasa/shared/importers/default_config.yml")
recipe = Recipe.recipe_for_name(DefaultV1Recipe.name)
model_config = recipe.graph_config_for_recipe(
config, {"finetuning_epoch_fraction": 0.5}, is_finetuning=True)
train_schema = model_config.train_schema
for node_name, node in expected_train_schema.nodes.items():
assert train_schema.nodes[node_name] == node
assert train_schema == expected_train_schema
