def serialise(self) -> Tuple[List[Text], List[Text]]:
"""Turn targets and predictions to lists of equal size for sklearn."""
targets = (self.action_targets + self.intent_targets + [
TrainingDataWriter.generate_entity(gold.get("text"), gold)
for gold in self.entity_targets
])
predictions = (self.action_predictions + self.intent_predictions + [
TrainingDataWriter.generate_entity(predicted.get("text"),
predicted)
for predicted in self.entity_predictions
])
# sklearn does not cope with lists of unequal size, nor None values
return pad_lists_to_size(targets, predictions, padding_value="None")
def test_evaluation_store_serialise(entity_predictions, entity_targets):
from rasa.nlu.training_data.formats.readerwriter import TrainingDataWriter
store = EvaluationStore(
entity_predictions=entity_predictions, entity_targets=entity_targets
)
targets, predictions = store.serialise()
assert len(targets) == len(predictions)
i_pred = 0
i_target = 0
for i, prediction in enumerate(predictions):
target = targets[i]
if prediction != "None" and target != "None":
predicted = entity_predictions[i_pred]
assert prediction == TrainingDataWriter.generate_entity(
predicted.get("text"), predicted
)
assert predicted.get("start") == entity_targets[i_target].get("start")
assert predicted.get("end") == entity_targets[i_target].get("end")
if prediction != "None":
i_pred += 1
if target != "None":
i_target += 1
def md_format_message(text, intent, entities) -> Text:
from rasa.nlu.training_data.formats import MarkdownReader
from rasa.nlu.training_data.formats.readerwriter import TrainingDataWriter
message_from_md = MarkdownReader().parse_training_example(text)
deserialised_entities = deserialise_entities(entities)
return TrainingDataWriter.generate_message(
{
"text": message_from_md.text,
"intent": intent,
"entities": deserialised_entities,
}
)
def process_training_examples_by_key(
training_examples: Dict,
key_name: Text,
key_examples: Text,
example_extraction_predicate=lambda x: x,
) -> List[OrderedDict]:
from ruamel.yaml.scalarstring import LiteralScalarString
result = []
for entity_key, examples in training_examples.items():
converted_examples = [
TrainingDataWriter.generate_list_item(
example_extraction_predicate(example).strip(STRIP_SYMBOLS))
for example in examples
]
next_item = OrderedDict()
next_item[key_name] = entity_key
next_item[key_examples] = LiteralScalarString(
"".join(converted_examples))
result.append(next_item)
return result
def md_format_message(text: Text, intent: Optional[Text],
entities: Union[Text, List[Any]]) -> Text:
"""Uses NLU parser information to generate a message with inline entity annotations.
Arguments:
text: text of the message
intent: intent of the message
entities: entities of the message
Return:
Message with entities annotated inline, e.g.
`I am from [Berlin]{"entity": "city"}`.
"""
from rasa.nlu.training_data.formats.readerwriter import TrainingDataWriter
from rasa.nlu.training_data import entities_parser
message_from_md = entities_parser.parse_training_example(text, intent)
deserialised_entities = deserialise_entities(entities)
return TrainingDataWriter.generate_message({
"text":
message_from_md.text,
"entities":
deserialised_entities,
})
def _generate_entity_training_data(entity: Dict[Text, Any]) -> Text:
return TrainingDataWriter.generate_entity(entity.get("text"), entity)