def train_nlu():
    from rasa_nlu.training_data.loading import load_data # 新api,会将目录下的所有文件合并
    from rasa_nlu.config import RasaNLUModelConfig#新 API
    from rasa_nlu.model import Trainer
    from rasa_nlu.config import load

    training_data = load_data("nlu_data/train_data")#加载训练数据
    trainer = Trainer(load("pipeline_config.yaml"))#加载pipeline
    trainer.train(training_data)
    model_directory = trainer.persist("models/", project_name="nlu",fixed_nmodel_name="model_ner_reg_all")

#位置rasa_nlu/featurizers/regex_featurizer.py
def features_for_patterns(self, message):
        """Checks which known patterns match the message.

        Given a sentence, returns a vector of {1,0} values indicating which
        regexes did match. Furthermore, if the
        message is tokenized, the function will mark the matching regex on
        the tokens that are part of the match."""

        found = []
        for i, exp in enumerate(self.known_patterns):#遍历全部正则
            match = re.search(exp["pattern"], message.text)
            if match is not None:#当前正则匹配上
                for t in message.get("tokens", []):#若分词token和正则结果有交叉，则设置一个标记
                    if t.offset < match.end() and t.end > match.start():
                        t.set("pattern", i)
                found.append(1.0)#匹配上，增加一个维度，值为1.0
            else:
                found.append(0.0)
        return np.array(found)

class Component(object):
    name = ""#组件名字，
    provides = []#当前组件能够计算出什么
    requires = []#当前组件需要提供什么
    defaults = {}#组件的默认参数，可以被pipeline文件中覆写
    language_list = None#定义组件能处理什么语言，值为None则默认能处理所有语言
    
    def train(self, training_data, cfg, **kwargs):
        """训练组件，如果不需要训练，可以不实现，如正则"""
        pass
    def process(self, message, **kwargs):
        """使用组件进行处理，从message中取想要的数据，计算完成后更新到message中"""
        pass
    def persist(self, model_dir):
        """保存组件模型到本地，如果没有需要保存的东西，可以不实现"""
        pass
    def load(cls,
             model_dir=None,   # type: Optional[Text]
             model_metadata=None,   # type: Optional[Metadata]
             cached_component=None,   # type: Optional[Component]
             **kwargs  # type: **Any
             ):
        """从本地加载保存的东西，若没有保存东西到本地，也不需要实现"""
        pass

def __init__(self,
                 nlu_threshold=0.3,  # type: float
                 core_threshold=0.3,  # type: float
                 fallback_action_name="action_listen"  # type: Text
                 ):
        # type: (...) -> None

        super(FallbackPolicy, self).__init__()

        self.nlu_threshold = nlu_threshold
        self.core_threshold = core_threshold
        self.fallback_action_name = fallback_action_name

class ActionListen(Action):
    """The first action in any turn - bot waits for a user message.
    The bot should stop taking further actions and wait for the user to say
    something."""

    def name(self):
        return ACTION_LISTEN_NAME

    def run(self, dispatcher, tracker, domain):
        return []

class ActionDefaultFallback(Action):
    """Executes the fallback action and goes back to the previous state
     of the dialogue"""
    def name(self):
        return ACTION_DEFAULT_FALLBACK_NAME
    def run(self, dispatcher, tracker, domain):
        from rasa_core.events import UserUtteranceReverted
        dispatcher.utter_template("utter_default", tracker, silent_fail=True)
        return [UserUtteranceReverted()]

dispatcher.utter_message(text)#直接返回text
dispatcher.utter_template(template_name)#调用模板，随机返回该模板中的某一句