# 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.10.8/api/custom-nlu-components/#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.10.8/nlu/choosing-a-pipeline/#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
89
90
91
92
93
94
``` | ```
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 = {}
supported_language_list = None
not_supported_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 the 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\_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. 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. **classmethod**`required_components`() Specify which components need to be present in the pipeline. Returns The list of class names of required components. Returns `List`[`Type`[ `Component`]] **classmethod**`required_packages`() Specify which python packages need to be installed. Returns The list of required package names. Returns `List`[`str`] **classmethod**`create`( _component\_config_, _config_) Creates this component (e.g. before a training is started). Returns The created component. Return type [`Component`] `provide_context`() Initialize this component for a new pipeline. Returns The updated component configuration. Return type `Optional`[`Dict`[`str`, `Any`]] `train`( _training\_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\_name_, _model\_dir_) Persist this component to disk for future loading. 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. 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.