Training Data Format

These docs are for version 1.x of Rasa Open Source.
Docs for the new version 2.0 can be found here.

Data Formats

You can provide training data as Markdown or as JSON, as a single file or as a directory containing multiple files.
Note that Markdown is usually easier to work with.

Markdown Format

Markdown is the easiest Rasa NLU format for humans to read and write.
Examples are listed using the unordered list syntax, e.g. minus -, asterisk *, or plus +.
Examples are grouped by intent, and entities are annotated as Markdown links, e.g. [entity](entity name).

## intent:check_balance
- what is my balance <!-- no entity -->
- how much do I have on my [savings](source_account) <!-- entity "source_account" has value "savings" -->
- how much do I have on my [savings account](source_account:savings) <!-- synonyms, method 1-->
- Could I pay in [yen](currency)?  <!-- entity matched by lookup table -->

## intent:greet
- hey
- hello

## synonym:savings   <!-- synonyms, method 2 -->
- pink pig

## regex:zipcode
- [0-9]{5}

## lookup:additional_currencies  <!-- specify lookup tables in an external file -->
path/to/currencies.txt

The training data for Rasa NLU is structured into different parts:

• common examples
• synonyms
• regex features and
• lookup tables

While common examples is the only part that is mandatory, including the others will help the NLU model learn the domain with fewer examples and also help it be more confident of its predictions.

Synonyms will map extracted entities to the same name, for example mapping “my savings account” to simply “savings”.
However, this only happens after the entities have been extracted, so you need to provide examples with the synonyms present so that Rasa can learn to pick them up.

Lookup tables may be specified as plain text files containing newline-separated words or phrases.
Upon loading the training data, these files are used to generate case-insensitive regex patterns that are added to the regex features.

JSON Format

The JSON format consists of a top-level object called rasa_nlu_data, with the keys common_examples, entity_synonyms and regex_features.
The most important one is common_examples.

{
    "rasa_nlu_data": {
        "common_examples": [],
        "regex_features" : [],
        "lookup_tables"  : [],
        "entity_synonyms": []
    }
}

The common_examples are used to train your model. You should put all of your training examples in the common_examples array.
Regex features are a tool to help the classifier detect entities or intents and improve the performance.

Improving Intent Classification and Entity Recognition

Common Examples

Common examples have three components: text, intent and entities. The first two are strings while the last one is an array.

• The text is the user message [required]
• The intent is the intent that should be associated with the text [optional]
• The entities are specific parts of the text which need to be identified [optional]

Entities are specified with a start and an end value, which together make a python style range to apply to the string, e.g. in the example below, with text="show me chinese restaurants", then text[8:15] == 'chinese'.
Entities can span multiple words, and in fact the value field does not have to correspond exactly to the substring in your example.
That way you can map synonyms, or misspellings, to the same value.

## intent:restaurant_search
- show me [chinese](cuisine) restaurants

Regular Expression Features

Regular expressions can be used to support the intent classification and entity extraction.
For example, if your entity has a deterministic structure (like a zipcode or an email address), you can use a regular expression to ease detection of that entity.
For the zipcode example it might look like this:

## regex:zipcode
- [0-9]{5}

## regex:greet
- hey[^\s]*

Lookup Tables

The supplied lookup table files must be in a newline-delimited format.
For example, data/test/lookup_tables/plates.txt may contain:

tacos
beef
mapo tofu
burrito
lettuce wrap

And can be loaded as:

## lookup:plates
data/test/lookup_tables/plates.txt

When lookup tables are supplied in training data, the contents are combined into a large, case-insensitive regex pattern that looks for exact matches in the training examples.
These regexes match over multiple tokens, so lettuce wrap would match get me a lettuce wrap ASAP as [0 0 0 1 1 0].

Normalizing Data

Entity Synonyms

If you define entities as having the same value they will be treated as synonyms.
Here is an example of that:

## intent:search
- in the center of [NYC](city:New York City)
- in the centre of [New York City](city)

To use the synonyms defined in your training data, you need to make sure the pipeline contains the EntitySynonymMapper component.
Alternatively, you can add an “entity_synonyms” array to define several synonyms to one entity value.

Generating More Entity Examples

It is sometimes helpful to generate a bunch of entity examples, for example if you have a database of restaurant names.
There are a couple of tools built by the community to help with that.

However, creating synthetic examples usually leads to overfitting, it is a better idea to use Lookup Tables instead if you have a large number of entity values.