Choosing a Pipeline

Choosing an NLU pipeline allows you to customize your model and finetune it on your dataset.

The Short Answer

If your training data is in English, a good starting point is using pretrained_embeddings_convert pipeline.

language: "en"

pipeline: "pretrained_embeddings_convert"

In case your training data is multi-lingual and is rich with domain specific vocabulary, use the supervised_embeddings pipeline:

language: "en"

pipeline: "supervised_embeddings"

A Longer Answer

The three most important pipelines are supervised_embeddings, pretrained_embeddings_convert and pretrained_embeddings_spacy. The pretrained_embeddings_spacy pipeline uses pre-trained word vectors from either GloVe or fastText, whereas pretrained_embeddings_convert uses a pretrained sentence encoding model ConveRT to extract vector representations of complete user utterance as a whole. On the other hand, the supervised_embeddings pipeline doesn’t use any pre-trained word vectors or sentence vectors, but instead fits these specifically for your dataset.

Note: These recommendations are highly dependent on your dataset and hence approximate. We suggest experimenting with different pipelines to train the best model.

pretrained_embeddings_spacy

The advantage of pretrained_embeddings_spacy pipeline is that if you have a training example like: "I want to buy apples", and Rasa is asked to predict the intent for "get pears", your model already knows that the words "apples" and "pears" are very similar. This is especially useful if you don’t have large enough training data.

pretrained_embeddings_convert

Warning
Since ConveRT model is trained only on an English corpus of conversations, this pipeline should only be used if your training data is in English language.

This pipeline uses ConveRT model to extract vector representation of a sentence and feeds them to EmbeddingIntentClassifier for intent classification. The advantage of using pretrained_embeddings_convert pipeline is that it doesn’t treat each word of the user message independently, but creates a contextual vector representation for the complete sentence. For example, if you have a training example, like: "can I book a car?", and Rasa is asked to predict the intent for "I need a ride from my place", since the contextual vector representation for both examples are already very similar, the intent classified for both is highly likely to be the same. This is also useful if you don’t have large enough training data.

Note
To use pretrained_embeddings_convert pipeline, you should install tensorflow-text==1.15.1 and tensorflow-hub==0.6.0. Otherwise, you can also pip install Rasa with pip install rasa[convert]. Please also note that tensorflow-text is only currently supported on Linux platforms.

supervised_embeddings

The advantage of the supervised_embeddings pipeline is that your word vectors will be customised for your domain. For example, in general English, the word "balance" is closely related to "symmetry", but very different to the word "cash". In a banking domain, "balance" and "cash" are closely related and you’d like your model to capture that. This pipeline doesn’t use a language-specific model, so it will work with any language that you can tokenize (on whitespace or using a custom tokenizer).

You can read more about this topic here.

MITIE

You can also use MITIE as a source of word vectors in your pipeline. The MITIE backend performs well for small datasets, but training can take very long if you have more than a couple of hundred examples. However, we do not recommend that you use it as mitie support is likely to be deprecated in a future release.

Comparing different pipelines for your data

Rasa gives you the tools to compare the performance of both of these pipelines on your data directly, see Comparing NLU Pipelines.

Note: Intent classification is independent of entity extraction. So sometimes NLU will get the intent right but entities wrong, or the other way around. You need to provide enough data for both intents and entities.

Class imbalance

Classification algorithms often do not perform well if there is a large class imbalance, for example if you have a lot of training data for some intents and very little training data for others. To mitigate this problem, rasa’s supervised_embeddings pipeline uses a balanced batching strategy. This algorithm ensures that all classes are represented in every batch, or at least in as many subsequent batches as possible, still mimicking the fact that some classes are more frequent than others. Balanced batching is used by default. In order to turn it off and use a classic batching strategy include batch_strategy: sequence in your config file.

language: "en"

pipeline:
- name: "CountVectorsFeaturizer"
- name: "EmbeddingIntentClassifier"
  batch_strategy: sequence

Multiple Intents

If you want to split intents into multiple labels, e.g., for predicting multiple intents or for modeling hierarchical intent structure, you can only do this with the supervised embeddings pipeline. To do this, use these flags in Whitespace Tokenizer:

• intent_split_symbol: sets the delimiter string to split the intent labels. Default _ Here is a tutorial on how to use multiple intents in Rasa Core and NLU.

Here’s an example configuration:

language: "en"

pipeline:
- name: "WhitespaceTokenizer"
  intent_split_symbol: "_"
- name: "CountVectorsFeaturizer"
- name: "EmbeddingIntentClassifier"

Understanding the Rasa NLU Pipeline

In Rasa NLU, incoming messages are processed by a sequence of components. These components are executed one after another in a so-called processing pipeline. There are components for entity extraction, for intent classification, response selection, pre-processing, and others. If you want to add your own component, for example to run a spell-check or to do sentiment analysis, check out Custom NLU Components.

Each component processes the input and creates an output. The output can be used by any component that comes after this component in the pipeline. There are components which only produce information that is used by other components in the pipeline and there are other components that produce Output attributes which will be returned after the processing has finished. For example, for the sentence "I am looking for Chinese food" the output is:

{
    "text": "I am looking for Chinese food",
    "entities": [
        {"start": 8, "end": 15, "value": "chinese", "entity": "cuisine", "extractor": "CRFEntityExtractor", "confidence": 0.864}
    ],
    "intent": {"confidence": 0.6485910906220309, "name": "restaurant_search"},
    "intent_ranking": [
        {"confidence": 0.6485910906220309, "name": "restaurant_search"},
        {"confidence": 0.1416153159565678, "name": "affirm"}
    ]
}

This is created as a combination of the results of the different components in the pre-configured pipeline pretrained_embeddings_spacy. For example, the entities attribute is created by the CRFEntityExtractor component.

Component Lifecycle

Every component can implement several methods from the Component base class; in a pipeline these different methods will be called in a specific order. Lets assume, we added the following pipeline to our config: `