Get ML components ready for incremental training

rasa/core/policies/policy.py

@@ -113,11 +113,13 @@ def __init__(
         self,
         featurizer: Optional[TrackerFeaturizer] = None,
         priority: int = DEFAULT_POLICY_PRIORITY,
+        should_finetune: bool = False,
         **kwargs: Any,
     ) -> None:
         """Constructs a new Policy object."""
         self.__featurizer = self._create_featurizer(featurizer)
         self.priority = priority
+        self.finetune_mode = should_finetune
 
     @property
     def featurizer(self):

rasa/core/policies/ted_policy.py

@@ -217,13 +217,16 @@ def __init__(
         max_history: Optional[int] = None,
         model: Optional[RasaModel] = None,
         zero_state_features: Optional[Dict[Text, List["Features"]]] = None,
+        should_finetune: bool = False,
         **kwargs: Any,
     ) -> None:
         """Declare instance variables with default values."""
         if not featurizer:
             featurizer = self._standard_featurizer(max_history)
 
-        super().__init__(featurizer, priority, **kwargs)
+        super().__init__(
+            featurizer, priority, should_finetune=should_finetune, **kwargs
+        )
         if isinstance(featurizer, FullDialogueTrackerFeaturizer):
             self.is_full_dialogue_featurizer_used = True
         else:
@@ -349,12 +352,16 @@ def train(
         # keep one example for persisting and loading
         self.data_example = model_data.first_data_example()
 
-        self.model = TED(
-            model_data.get_signature(),
-            self.config,
-            isinstance(self.featurizer, MaxHistoryTrackerFeaturizer),
-            self._label_data,
-        )
+        if not self.finetune_mode:
+            # This means the model wasn't loaded from a
+            # previously trained model and hence needs
+            # to be instantiated.
+            self.model = TED(
+                model_data.get_signature(),
+                self.config,
+                isinstance(self.featurizer, MaxHistoryTrackerFeaturizer),
+                self._label_data,
+            )
 
         self.model.fit(
             model_data,
@@ -436,7 +443,13 @@ def persist(self, path: Union[Text, Path]) -> None:
         )
 
     @classmethod
-    def load(cls, path: Union[Text, Path], **kwargs: Any) -> "TEDPolicy":
+    def load(
+        cls,
+        path: Union[Text, Path],
+        should_finetune: bool = False,
+        epoch_override: int = defaults[EPOCHS],
+        **kwargs: Any,
+    ) -> "TEDPolicy":
         """Loads a policy from the storage.
 
         **Needs to load its featurizer**
@@ -476,6 +489,8 @@ def load(cls, path: Union[Text, Path], **kwargs: Any) -> "TEDPolicy":
         )
         meta = train_utils.update_similarity_type(meta)
 
+        meta[EPOCHS] = epoch_override
+
         model = TED.load(
             str(tf_model_file),
             model_data_example,
@@ -485,30 +500,30 @@ def load(cls, path: Union[Text, Path], **kwargs: Any) -> "TEDPolicy":
                 featurizer, MaxHistoryTrackerFeaturizer
             ),
             label_data=label_data,
+            finetune_mode=should_finetune,
         )
 
-        # build the graph for prediction
-        predict_data_example = RasaModelData(
-            label_key=LABEL_KEY,
-            label_sub_key=LABEL_SUB_KEY,
-            data={
-                feature_name: features
-                for feature_name, features in model_data_example.items()
-                if feature_name
-                in STATE_LEVEL_FEATURES + FEATURES_TO_ENCODE + [DIALOGUE]
-            },
-        )
-        model.build_for_predict(predict_data_example)
+        if not should_finetune:
+            # build the graph for prediction
 
-        meta["should_finetune"] = kwargs.get("should_finetune", False)
-        if "epoch_override" in kwargs:
-            meta[EPOCHS] = kwargs["epoch_override"]
+            features_to_select = STATE_LEVEL_FEATURES + FEATURES_TO_ENCODE + [DIALOGUE]
+            predict_data_example = RasaModelData(
+                label_key=LABEL_KEY,
+                label_sub_key=LABEL_SUB_KEY,
+                data={
+                    feature_name: features
+                    for feature_name, features in model_data_example.items()
+                    if feature_name in features_to_select
+                },
+            )
+            model.build_for_predict(predict_data_example)
 
         return cls(
             featurizer=featurizer,
             priority=priority,
             model=model,
             zero_state_features=zero_state_features,
+            should_finetune=should_finetune,
             **meta,
         )
 

rasa/nlu/classifiers/diet_classifier.py

@@ -308,9 +308,9 @@ def __init__(
         index_label_id_mapping: Optional[Dict[int, Text]] = None,
         entity_tag_specs: Optional[List[EntityTagSpec]] = None,
         model: Optional[RasaModel] = None,
+        finetune_mode: bool = False,
     ) -> None:
         """Declare instance variables with default values."""
-
         if component_config is not None and EPOCHS not in component_config:
             rasa.shared.utils.io.raise_warning(
                 f"Please configure the number of '{EPOCHS}' in your configuration file."
@@ -333,6 +333,17 @@ def __init__(
 
         self.split_entities_config = self.init_split_entities()
 
+        self.finetune_mode = finetune_mode
+
+        if not self.model and self.finetune_mode:
+            raise rasa.shared.exceptions.InvalidParameterException(
+                f"{self.__class__.__name__} was instantiated "
+                f"with `model=None` and `finetune_mode=True`. "
+                f"This is not a valid combination as the component "
+                f"needs an already instantiated and trained model "
+                f"to continue training in finetune mode."
+            )
+
     @property
     def label_key(self) -> Optional[Text]:
         """Return key if intent classification is activated."""
@@ -766,7 +777,9 @@ def train(
         # keep one example for persisting and loading
         self._data_example = model_data.first_data_example()
 
-        self.model = self._instantiate_model_class(model_data)
+        if not self.finetune_mode:
+            # No pre-trained model to load from. Create a new instance of the model.
+            self.model = self._instantiate_model_class(model_data)
 
         self.model.fit(
             model_data,
@@ -956,10 +969,10 @@ def load(
         model_dir: Text = None,
         model_metadata: Metadata = None,
         cached_component: Optional["DIETClassifier"] = None,
+        should_finetune: bool = False,
         **kwargs: Any,
     ) -> "DIETClassifier":
         """Loads the trained model from the provided directory."""
-
         if not model_dir or not meta.get("file"):
             logger.debug(
                 f"Failed to load model for '{cls.__name__}'. "
@@ -979,14 +992,20 @@ def load(
         meta = train_utils.update_similarity_type(meta)
 
         model = cls._load_model(
-            entity_tag_specs, label_data, meta, data_example, model_dir
+            entity_tag_specs,
+            label_data,
+            meta,
+            data_example,
+            model_dir,
+            finetune_mode=should_finetune,
         )
 
         return cls(
             component_config=meta,
             index_label_id_mapping=index_label_id_mapping,
             entity_tag_specs=entity_tag_specs,
             model=model,
+            finetune_mode=should_finetune,
         )
 
     @classmethod
@@ -1039,6 +1058,7 @@ def _load_model(
         meta: Dict[Text, Any],
         data_example: Dict[Text, Dict[Text, List[np.ndarray]]],
         model_dir: Text,
+        finetune_mode: bool = False,
     ) -> "RasaModel":
         file_name = meta.get("file")
         tf_model_file = os.path.join(model_dir, file_name + ".tf_model")
@@ -1051,20 +1071,27 @@ def _load_model(
         )
 
         model = cls._load_model_class(
-            tf_model_file, model_data_example, label_data, entity_tag_specs, meta
+            tf_model_file,
+            model_data_example,
+            label_data,
+            entity_tag_specs,
+            meta,
+            finetune_mode=finetune_mode,
         )
 
-        # build the graph for prediction
-        predict_data_example = RasaModelData(
-            label_key=label_key,
-            data={
-                feature_name: features
-                for feature_name, features in model_data_example.items()
-                if TEXT in feature_name
-            },
-        )
+        if not finetune_mode:
+
+            # build the graph for prediction
+            predict_data_example = RasaModelData(
+                label_key=label_key,
+                data={
+                    feature_name: features
+                    for feature_name, features in model_data_example.items()
+                    if TEXT in feature_name
+                },
+            )
 
-        model.build_for_predict(predict_data_example)
+            model.build_for_predict(predict_data_example)
 
         return model
 
@@ -1076,6 +1103,7 @@ def _load_model_class(
         label_data: RasaModelData,
         entity_tag_specs: List[EntityTagSpec],
         meta: Dict[Text, Any],
+        finetune_mode: bool,
     ) -> "RasaModel":
 
         return cls.model_class().load(
@@ -1085,6 +1113,7 @@ def _load_model_class(
             label_data=label_data,
             entity_tag_specs=entity_tag_specs,
             config=copy.deepcopy(meta),
+            finetune_mode=finetune_mode,
         )
 
     def _instantiate_model_class(self, model_data: RasaModelData) -> "RasaModel":

rasa/nlu/constants.py

@@ -78,3 +78,5 @@
 FEATURIZER_CLASS_ALIAS = "alias"
 
 NO_LENGTH_RESTRICTION = -1
+MIN_ADDITIONAL_REGEX_PATTERNS = 10
+MIN_ADDITIONAL_CVF_VOCABULARY = 1000