你可以创建一些自定义组件来执行NLU当前没有提供支持的特定任务（例如：情感分析）。下面是rasa.nlu.components.Component类详述和你需要实现的方法。
你可以通过添加模块路径来添加自定义组件到你的管道中。所以如果你有一个模块叫做 sentiment 包含一个 SentimentAnalyzer 类。

image.png

首先是，你需要使用这个架构，它包含了你应该实现的最重要的方法：

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"'

    # Which components are required by this component.
    # Listed components should appear before the component itself in the pipeline.
    @classmethod
    def required_components(cls) -> List[Type[Component]]:
        """Specify which components need to be present in the pipeline."""

        return []

    # Defines the default configuration parameters of a component
    # these values can be overwritten in the pipeline configuration
    # of the model. The component should choose sensible defaults
    # and should be able to create reasonable results with the defaults.
    defaults = {}

    # Defines what language(s) this component can handle.
    # This attribute is designed for instance method: `can_handle_language`.
    # Default value is None which means it can handle all languages.
    # This is an important feature for backwards compatibility of components.
    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:
        """Train this component.

        This is the components chance to train itself provided
        with the training data. The component can rely on
        any context attribute to be present, that gets created
        by a call to :meth:`components.Component.pipeline_init`
        of ANY component and
        on any context attributes created by a call to
        :meth:`components.Component.train`
        of components previous to this one."""
        pass

    def process(self, message: Message, **kwargs: Any) -> None:
        """Process an incoming message.

        This is the components chance to process an incoming
        message. The component can rely on
        any context attribute to be present, that gets created
        by a call to :meth:`components.Component.pipeline_init`
        of ANY component and
        on any context attributes created by a call to
        :meth:`components.Component.process`
        of components previous to this one."""
        pass

    def persist(self, file_name: Text, model_dir: Text) -> Optional[Dict[Text, Any]]:
        """Persist this component to disk for future loading."""

        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":
        """Load this component from file."""

        if cached_component:
            return cached_component
        else:
            return cls(meta)

note:

如果你创建一个自定义的tokenizer，你应该实现rasa.nlu.tokenizers.tokenizer.Tokenizer 的方法。train 和 process 已经实现并且你只需要重写 tokenize 方法。train 和 process 将会自动添加一个特殊的token(CLS) 到token列表的最后，这是管道的下游需要的。

note:

如果你创建一个自定义featurizer，你应该返回一个特征序列。例如，你的featurizer应该返回一个矩阵的尺寸（字符的数量X特征维度）。CLStoken的特征向量应该包含完整消息的特征。

组件：

class rasa.nlu.components.Component(component_config=None):

在管道中一个组件是信息处理单元。

组件按照管道顺序收集。每个组件都被一个接一个地调用。他适用于初始化，训练，持久化和加载组件。如果一个组件在管道中首先出现，那么这个方法将被首先调用。

例如，处理输入的信息，每个组件的 process 方法将会被调用。在处理过程中（以及训练，持久化和初始化）组件会把信息传递给另一个组件。通过给所谓的管道上下文提供属性，将信息传递给其他组件。管道上下文包含一个组件用来完成自己的处理的前一个组件的所有信息。例如，一个特征分析器组件可以提供由管道中的另一个组件用来进行意图分类的功能。

classmethod required_components():

指定需要在管道中提供哪些组件。

Returns:

所需组件的类名列表

Return type

List[Type[Component]]

classmethod required_packages():

指明需要安装哪些python包。

例如：["spacy"]. 更具体的说，这些事可导入的python包名，比如sklearn,而不是依赖关系意义上包，比如scikit-learn

如果没有安装所需的包，在训练期间请求的列表让我们更早的失败

Returns:

必须的包名列表

Return type:

List[str]

 classmethod create(component_config, config):

创建这个组件（在训练开始之前）。

方法可以访问所有配置参数。

Parameters：

• component_config — 组件的配置参数

• config— 方法的配置参数

Returns:

创建的组件

Return type:

Component

provide_context():

在一个新的管道，初始化这个组件

这个函数将在训练开始和使用解释器处理第一条信息之前被调用。组件有机会向上下文添加信息，在训练和信息处理期间这些信息通过管道传递。大多数的组件不需要去实现这个方法。他主要是初始化架构环境，如MITIE和spacy（如：为管道加载单词向量）

return：

更新组件的配置

return type：

Optional[Dict[str, Any]]

train(training_data, config=None, **kwargs):

训练这个组件.

这是组件训练他自己拥有的训练数据。组件依赖出现的任何上下文属性，任何组件都会通过调用rasa.nlu.components.Component.create() 创建，以及通过调用此组件之前的组件的rasa.nlu.components.Component.train（）:
创建的任何上下文属性。
Parameters：

• training_data—rasa.nlu.training_data.training_data.TrainingData

• config—模型的配置参数

Return type：

None

 process(message, **kwargs)

处理传入的消息。

这是处理传入消息的组件。组件依赖出现的任何上下文属性，任何组件都会通过调用rasa.nlu.components.Component.create() 创建，以及通过调用此组件之前的组件的rasa.nlu.components.Component.process() :
创建的任何上下文属性。

Parameters：

message— rasa.nlu.training_data.message.Message 去处理

return type:

None

 persist(file_name, model_dir)

将此组件持久化到磁盘以备将来加载。

Parameters:

• file_name—模型的文件名

• model_dir—模型的存储的路径

returns:

一个可选的字典，包含关于存储模型的任何信息。

return type:

Optional[Dict[str, Any]]

prepare_partial_processing(pipeline, context):

设置管道和上下文用于部分处理。

管道是管道中在此之前并且已经完成培训的组件的列表(因此可以安全地用于处理消息)。

Parameters：

• pipeline—组件列表

• context—处理的上下文

return type:

None

 partially_process(message):

在训练期间允许所有的组件处理信息。

传递的消息将由管道中此消息之前的所有组件处理。

Parameters：

message— rasa.nlu.training_data.message.Message 去处理。

returns:

rasa.nlu.training_data.message.Message 处理。

return type:

Message

 classmethod can_handle_language(language)：

检查组件是否支持特定的语言。

当你需要时这个方法可以被重写（如：动态的决定支持哪种语言）

Parameters:

language— 要检查的语言

Returns:

如果组件可以处理特定的语言，为True，否则为False。

Return type:

bool