def test_resolve_intent_response_key_from_label(
predicted_label, train_on_text, resolved_intent_response_key
):
# use data that include some responses
training_data = rasa.shared.nlu.training_data.loading.load_data(
"data/examples/rasa/demo-rasa.yml"
)
training_data_responses = rasa.shared.nlu.training_data.loading.load_data(
"data/examples/rasa/demo-rasa-responses.yml"
)
training_data = training_data.merge(training_data_responses)
response_selector = ResponseSelector(
component_config={"use_text_as_label": train_on_text}
)
response_selector.preprocess_train_data(training_data)
label_intent_response_key = response_selector._resolve_intent_response_key(
{"id": hash(predicted_label), "name": predicted_label}
)
assert resolved_intent_response_key == label_intent_response_key
assert (
response_selector.responses[
util.intent_response_key_to_template_key(label_intent_response_key)
]
== training_data.responses[
util.intent_response_key_to_template_key(resolved_intent_response_key)
]
)
def test_preprocess_selector_multiple_retrieval_intents():
# use some available data
training_data = rasa.shared.nlu.training_data.loading.load_data(
"data/examples/rasa/demo-rasa.yml"
)
training_data_responses = rasa.shared.nlu.training_data.loading.load_data(
"data/examples/rasa/demo-rasa-responses.yml"
)
training_data_extra_intent = TrainingData(
[
Message.build(
text="Is it possible to detect the version?", intent="faq/q1"
),
Message.build(text="How can I get a new virtual env", intent="faq/q2"),
]
)
training_data = training_data.merge(training_data_responses).merge(
training_data_extra_intent
)
response_selector = ResponseSelector()
response_selector.preprocess_train_data(training_data)
assert sorted(response_selector.all_retrieval_intents) == ["chitchat", "faq"]
def inner(config_params: Dict[Text, Any]) -> ResponseSelector:
return ResponseSelector.create(
{**ResponseSelector.get_default_config(), **config_params},
default_model_storage,
default_response_selector_resource,
default_execution_context,
)
def test_ground_truth_for_training(use_text_as_label, label_values):
# use data that include some responses
training_data = load_data("data/examples/rasa/demo-rasa.md")
training_data_responses = load_data(
"data/examples/rasa/demo-rasa-responses.md")
training_data = training_data.merge(training_data_responses)
response_selector = ResponseSelector(
component_config={"use_text_as_label": use_text_as_label})
response_selector.preprocess_train_data(training_data)
assert response_selector.responses == training_data.responses
assert (sorted(list(
response_selector.index_label_id_mapping.values())) == label_values)
def test_sets_integer_transformer_size_when_needed(
config: Dict[Text, Optional[int]],
should_set_default_transformer_size: bool,
):
"""ResponseSelector ensures sensible transformer size when transformer enabled."""
default_transformer_size = 256
with pytest.warns(UserWarning) as records:
selector = ResponseSelector(component_config=config)
warning_str = f"positive size is required when using `{NUM_TRANSFORMER_LAYERS} > 0`"
if should_set_default_transformer_size:
assert len(records) > 0
# check that the specific warning was raised
assert any(warning_str in record.message.args[0] for record in records)
# check that transformer size got set to the new default
assert selector.component_config[
TRANSFORMER_SIZE] == default_transformer_size
else:
# check that the specific warning was not raised
assert not any(warning_str in record.message.args[0]
for record in records)
# check that transformer size was not changed
assert selector.component_config[TRANSFORMER_SIZE] == config.get(
TRANSFORMER_SIZE,
None # None is the default transformer size
)
def test_response_selector_present():
response_selector_component = ResponseSelector()
interpreter_with_response_selector = Interpreter(
[response_selector_component], context=None)
interpreter_without_response_selector = Interpreter([], context=None)
assert is_response_selector_present(interpreter_with_response_selector)
assert not is_response_selector_present(
interpreter_without_response_selector)
def test_warning_when_transformer_and_hidden_layers_enabled(
config: Dict[Text, Union[int, Dict[Text, List[int]]]],
should_raise_warning: bool):
"""ResponseSelector recommends disabling hidden layers if transformer is enabled."""
with pytest.warns(UserWarning) as records:
_ = ResponseSelector(component_config=config)
warning_str = "We recommend to disable the hidden layers when using a transformer"
if should_raise_warning:
assert len(records) > 0
# Check all warnings since there may be multiple other warnings we don't care
# about in this test case.
assert any(warning_str in record.message.args[0] for record in records)
else:
# Check all warnings since there may be multiple other warnings we don't care
# about in this test case.
assert not any(warning_str in record.message.args[0]
for record in records)
assert os.path.exists(
os.path.join(report_folder, "response_selection_successes.json"))
@pytest.mark.parametrize(
"components, expected_extractors",
[
([DIETClassifier({ENTITY_RECOGNITION: False})], set()),
([DIETClassifier({ENTITY_RECOGNITION: True})], {"DIETClassifier"}),
([CRFEntityExtractor()], {"CRFEntityExtractor"}),
(
[SpacyEntityExtractor(),
CRFEntityExtractor()],
{"SpacyEntityExtractor", "CRFEntityExtractor"},
),
([ResponseSelector()], set()),
],
)
def test_get_entity_extractors(components, expected_extractors):
mock_interpreter = Interpreter(components, None)
extractors = get_entity_extractors(mock_interpreter)
assert extractors == expected_extractors
def test_entity_evaluation_report(tmpdir_factory):
class EntityExtractorA(EntityExtractor):
provides = ["entities"]
def __init__(self, component_config=None) -> None:
