# Custom NLU Components You can create a custom component to perform a specific task which NLU doesn’t currently offer (for example, sentiment analysis). Below is the specification of the [`rasa.nlu.components.Component`](https://legacy-docs-v1.rasa.com/1.8.2/api/custom-nlu-components/#rasa.nlu.components.Component "rasa.nlu.components.Component") class with the methods you’ll need to implement. **Note** There is a detailed tutorial on building custom components [here](https://blog.rasa.com/enhancing-rasa-nlu-with-custom-components/). You can add a custom component to your pipeline by adding the module path. So if you have a module called `sentiment` containing a `SentimentAnalyzer` class: ``` pipeline: - name: "sentiment.SentimentAnalyzer" ``` Also be sure to read the section on the [Component Lifecycle](https://legacy-docs-v1.rasa.com/1.8.2/nlu/choosing-a-pipeline/#section-component-lifecycle). To get started, you can use this skeleton that contains the most important methods that you should implement: | | | | --- | --- | | ```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
``` | ```
import typing
from typing import Any, Optional, Text, Dict, List, Type
from rasa.nlu.components import Component
from rasa.nlu.config import RasaNLUModelConfig
from rasa.nlu.training_data import Message, TrainingData
if typing.TYPE_CHECKING:
from rasa.nlu.model import Metadata
class MyComponent(Component):
"""A new component"""
@classmethod
def required_components(cls) -> List[Type[Component]]:
return []
defaults = {}
language_list = None
def __init__(self, component_config: Optional[Dict[Text, Any]] = None) -> None:
super().__init__(component_config)
def train(self, training_data: TrainingData, config: Optional[RasaNLUModelConfig] = None, **kwargs: Any) -> None:
pass
def process(self, message: Message, **kwargs: Any) -> None:
pass
def persist(self, file_name: Text, model_dir: Text) -> Optional[Dict[Text, Any]]:
pass
@classmethod
def load(cls, meta: Dict[Text, Any], model_dir: Optional[Text] = None, model_metadata: Optional["Metadata"] = None, cached_component: Optional["Component"] = None, **kwargs: Any) -> "Component":
if cached_component:
return cached_component
else:
return cls(meta)
``` | **Note** If you create a custom tokenizer you should implement the methods of `rasa.nlu.tokenizers.tokenizer.Tokenizer`. The `train` and `process` methods are already implemented and you simply need to overwrite the `tokenize` method. `train` and `process` will automatically add a special token `__CLS__` to the end of list of tokens, which is needed further down the pipeline. **Note** If you create a custom featurizer you should return a sequence of features. E.g. your featurizer should return a matrix of size (number-of-tokens x feature-dimension). The feature vector of the `__CLS__` token should contain features for the complete message. ## Component _class_`rasa.nlu.components.`**Component**( _component extunderscore config=None_) A component is a message processing unit in a pipeline. Components are collected sequentially in a pipeline. Each component is called one after another. This holds for initialization, training, persisting and loading the components. If a component comes first in a pipeline, its methods will be called first. E.g. to process an incoming message, the `process` method of each component will be called. During the processing (as well as the training, persisting and initialization), components can pass information to other components. The information is passed to other components by providing attributes to the so called pipeline context. The pipeline context contains all the information of the previous components a component can use to do its own processing. For example, a featurizer component can provide features that are used by another component down the pipeline to do intent classification. _classmethod_`required_components()` Specify which components need to be present in the pipeline. Returns The list of class names of required components. Return type `List`[`Type`[ `Component`](https://legacy-docs-v1.rasa.com/1.8.2/api/custom-nlu-components/#rasa.nlu.components.Component "rasa.nlu.components.Component")] _classmethod_`required_packages()` Specify which python packages need to be installed. Returns The list of required package names. Return type `List`[`str`] _classmethod_`create`( _component extunderscore config_, _config_) Creates this component. Returns The created component. Return type [`Component`](https://legacy-docs-v1.rasa.com/1.8.2/api/custom-nlu-components/#rasa.nlu.components.Component "rasa.nlu.components.Component") `provide_context()` Initialize this component for a new pipeline. Returns The updated component configuration. Return type `Optional`[`Dict`[`str`, `Any`] ] `train`( _training extunderscore data_, _config=None_, _**kwargs_) Train this component. Parameters - **training_data** – The `rasa.nlu.training_data.training_data.TrainingData`. Return type `None` `process`( _message_, _**kwargs_) Process an incoming message. Parameters **message** – The `rasa.nlu.training_data.message.Message` to process. Return type `None` `persist`( _file extunderscore name_, _model extunderscore dir_) Persist this component to disk for future loading. Parameters - **file_name** – The file name of the model. - **model_dir** – The directory to store the model to. Returns An optional dictionary with any information about the stored model. Return type `Optional`[`Dict`[`str`, `Any`] ] `prepare_partial_processing`( _pipeline_, _context_) Sets the pipeline and context used for partial processing. Returns `None` `partially_process`( _message_) Allows the component to process messages during training. Parameters **message** – The `rasa.nlu.training_data.message.Message` to process. Returns The processed `rasa.nlu.training_data.message.Message`. Return type `Message` _classmethod_`can_handle_language`( _language_) Check if component supports a specific language. Returns True if component can handle specific language, False otherwise. Return type `bool` 👋 I can help you get started with Rasa and answer your technical questions.