rasa-pro 3.14.0a20__py3-none-any.whl → 3.14.0a23__py3-none-any.whl

rasa/model_training.py

@@ -15,6 +15,10 @@ import rasa.shared.utils.common
 import rasa.shared.utils.io
 import rasa.utils.common
 from rasa import telemetry
+from rasa.core.config.configuration import (
+    Configuration,
+    MessageProcessingConfigPath,
+)
 from rasa.core.persistor import StorageType
 from rasa.engine.caching import LocalTrainingCache
 from rasa.engine.recipes.recipe import Recipe
@@ -115,58 +119,32 @@ def get_unresolved_slots(domain: Domain, stories: StoryGraph) -> List[Text]:
     )
 
 
-def _check_unresolved_slots(domain: Domain, stories: StoryGraph) -> None:
-    """Checks if there are any unresolved slots.
-
-    Args:
-        domain: The domain.
-        stories: The story graph.
-
-    Raises:
-        `Sys exit` if there are any unresolved slots.
-
-    Returns:
-        `None` if there are no unresolved slots.
-    """
-    unresolved_slots = get_unresolved_slots(domain, stories)
-    if unresolved_slots:
-        structlogger.error(
-            "model.training.check_unresolved_slots.not_in_domain",
-            slots=unresolved_slots,
-            event_info=(
-                f"Unresolved slots found in stories/rules🚨 \n"
-                f'Tried to set slots "{unresolved_slots}" that are not present in'
-                f"your domain.\n Check whether they need to be added to the domain or "
-                f"whether there is a spelling error."
-            ),
-        )
-        rasa.shared.utils.common.display_research_study_prompt()
-        sys.exit(1)
-
-
 async def train(
     domain: Text,
     config: Text,
     training_files: Optional[Union[Text, List[Text]]],
+    endpoints: Text = rasa.shared.constants.DEFAULT_ENDPOINTS_PATH,
     output: Text = rasa.shared.constants.DEFAULT_MODELS_PATH,
     dry_run: bool = False,
     force_training: bool = False,
-    fixed_model_name: Optional[Text] = None,
+    fixed_model_name: Optional[str] = None,
     persist_nlu_training_data: bool = False,
     core_additional_arguments: Optional[Dict] = None,
     nlu_additional_arguments: Optional[Dict] = None,
-    model_to_finetune: Optional[Text] = None,
+    model_to_finetune: Optional[str] = None,
     finetuning_epoch_fraction: float = 1.0,
     remote_storage: Optional[StorageType] = None,
     file_importer: Optional[TrainingDataImporter] = None,
     keep_local_model_copy: bool = False,
     remote_root_only: bool = False,
+    sub_agents: Optional[str] = None,
 ) -> TrainingResult:
     """Trains a Rasa model (Core and NLU).
 
     Args:
         domain: Path to the domain file.
         config: Path to the config file.
+        endpoints: Path to the endpoints file.
         training_files: List of paths to training data files.
         output: Output directory for the trained model.
         dry_run: If `True` then no training will be done, and the information about
@@ -190,10 +168,17 @@ async def train(
             remote storage is configured.
         remote_root_only: If `True`, the model will be stored in the root of the
             remote model storage.
+        sub_agents: Path to sub-agents directory.
 
     Returns:
         An instance of `TrainingResult`.
     """
+    Configuration.initialise_message_processing(
+        message_processing_config_path=MessageProcessingConfigPath.validate(
+            Path(config)
+        )
+    ).initialise_endpoints(endpoints_path=Path(endpoints))
+
     if not file_importer:
         file_importer = TrainingDataImporter.load_from_config(
             config, domain, training_files, core_additional_arguments
@@ -278,6 +263,35 @@ async def train(
         )
 
 
+def _check_unresolved_slots(domain: Domain, stories: StoryGraph) -> None:
+    """Checks if there are any unresolved slots.
+
+    Args:
+        domain: The domain.
+        stories: The story graph.
+
+    Raises:
+        `Sys exit` if there are any unresolved slots.
+
+    Returns:
+        `None` if there are no unresolved slots.
+    """
+    unresolved_slots = get_unresolved_slots(domain, stories)
+    if unresolved_slots:
+        structlogger.error(
+            "model.training.check_unresolved_slots.not_in_domain",
+            slots=unresolved_slots,
+            event_info=(
+                f"Unresolved slots found in stories/rules🚨 \n"
+                f'Tried to set slots "{unresolved_slots}" that are not present in'
+                f"your domain.\n Check whether they need to be added to the domain or "
+                f"whether there is a spelling error."
+            ),
+        )
+        rasa.shared.utils.common.display_research_study_prompt()
+        sys.exit(1)
+
+
 async def _train_graph(
     file_importer: TrainingDataImporter,
     training_type: TrainingType,
@@ -292,24 +306,19 @@ async def _train_graph(
     **kwargs: Any,
 ) -> TrainingResult:
     if model_to_finetune:
-        model_to_finetune = rasa.model.get_model_for_finetuning(model_to_finetune)
-        if not model_to_finetune:
-            structlogger.error(
-                "model_training.train.finetuning_model_not_found",
-                event_info=(
-                    f"No model for finetuning found. Please make sure to either "
-                    f"specify a path to a previous model or to have a finetunable "
-                    f"model within the directory '{output_path}'."
-                ),
-            )
-            rasa.shared.utils.common.display_research_study_prompt()
-            sys.exit(1)
-
-        rasa.shared.utils.common.mark_as_experimental_feature(
-            "Incremental Training feature"
+        structlogger.error(
+            "model_training.train.incremental_training_not_supported",
+            event_info=(
+                "Incremental training (--finetune) is "
+                "not supported in Rasa 3.14.0 onwards. "
+                "Please retrain your model from scratch "
+                "if you have updated your configuration. "
+            ),
         )
+        rasa.shared.utils.common.display_research_study_prompt()
+        sys.exit(1)
 
-    is_finetuning = model_to_finetune is not None
+    is_finetuning = False  # Incremental training is not supported in Rasa 3.14.0+
 
     config = file_importer.get_config()
     recipe = Recipe.recipe_for_name(config.get(CONFIG_RECIPE_KEY))
@@ -573,6 +582,10 @@ async def train_nlu(
         )
         return None
 
+    Configuration.initialise_message_processing(
+        message_processing_config_path=Path(config),
+    ).initialise_empty_endpoints()
+
     return (
         await _train_graph(
             file_importer,

rasa/nlu/classifiers/diet_classifier.py

@@ -8,7 +8,13 @@ from typing import Any, Dict, List, Optional, Text, Tuple, Type, TypeVar, Union
 
 import numpy as np
 import scipy.sparse
-import tensorflow as tf
+
+from rasa.utils.tensorflow import TENSORFLOW_AVAILABLE
+
+if TENSORFLOW_AVAILABLE:
+    import tensorflow as tf
+else:
+    tf = None
 
 import rasa.nlu.utils.bilou_utils as bilou_utils
 import rasa.shared.utils.io
@@ -16,7 +22,6 @@ from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
-from rasa.exceptions import ModelNotFound
 from rasa.nlu.classifiers import LABEL_RANKING_LENGTH
 from rasa.nlu.classifiers.classifier import IntentClassifier
 from rasa.nlu.constants import DEFAULT_TRANSFORMER_SIZE, TOKENS_NAMES
@@ -38,77 +43,155 @@ from rasa.shared.nlu.constants import (
 )
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils import train_utils
-from rasa.utils.tensorflow import rasa_layers
-from rasa.utils.tensorflow.constants import (
-    AUTO,
-    BALANCED,
-    BATCH_SIZES,
-    BATCH_STRATEGY,
-    BILOU_FLAG,
-    CHECKPOINT_MODEL,
-    CONCAT_DIMENSION,
-    CONNECTION_DENSITY,
-    CONSTRAIN_SIMILARITIES,
-    CROSS_ENTROPY,
-    DENSE_DIMENSION,
-    DENSE_INPUT_DROPOUT,
-    DROP_RATE,
-    DROP_RATE_ATTENTION,
-    DROP_SMALL_LAST_BATCH,
-    EMBEDDING_DIMENSION,
-    ENTITY_RECOGNITION,
-    EPOCHS,
-    EVAL_NUM_EPOCHS,
-    EVAL_NUM_EXAMPLES,
-    FEATURIZERS,
-    HIDDEN_LAYERS_SIZES,
-    IDS,
-    INTENT_CLASSIFICATION,
-    KEY_RELATIVE_ATTENTION,
-    LABEL,
-    LEARNING_RATE,
-    LOSS_TYPE,
-    MASK,
-    MASKED_LM,
-    MAX_NEG_SIM,
-    MAX_POS_SIM,
-    MAX_RELATIVE_POSITION,
-    MODEL_CONFIDENCE,
-    NEGATIVE_MARGIN_SCALE,
-    NUM_HEADS,
-    NUM_NEG,
-    NUM_TRANSFORMER_LAYERS,
-    RANDOM_SEED,
-    RANKING_LENGTH,
-    REGULARIZATION_CONSTANT,
-    RENORMALIZE_CONFIDENCES,
-    RUN_EAGERLY,
-    SCALE_LOSS,
-    SENTENCE,
-    SEQUENCE,
-    SEQUENCE_LENGTH,
-    SHARE_HIDDEN_LAYERS,
-    SIMILARITY_TYPE,
-    SOFTMAX,
-    SPARSE_INPUT_DROPOUT,
-    TENSORBOARD_LOG_DIR,
-    TENSORBOARD_LOG_LEVEL,
-    TRANSFORMER_SIZE,
-    UNIDIRECTIONAL_ENCODER,
-    USE_MAX_NEG_SIM,
-    VALUE_RELATIVE_ATTENTION,
-)
-from rasa.utils.tensorflow.feature_array import (
-    FeatureArray,
-    deserialize_nested_feature_arrays,
-    serialize_nested_feature_arrays,
-)
-from rasa.utils.tensorflow.model_data import (
-    FeatureSignature,
-    RasaModelData,
-)
-from rasa.utils.tensorflow.models import RasaModel, TransformerRasaModel
+
+if TENSORFLOW_AVAILABLE:
+    from rasa.utils.tensorflow import rasa_layers
+else:
+    rasa_layers = None  # type: ignore
+if TENSORFLOW_AVAILABLE:
+    from rasa.utils.tensorflow.constants import (
+        AUTO,
+        BALANCED,
+        BATCH_SIZES,
+        BATCH_STRATEGY,
+        BILOU_FLAG,
+        CHECKPOINT_MODEL,
+        CONCAT_DIMENSION,
+        CONNECTION_DENSITY,
+        CONSTRAIN_SIMILARITIES,
+        CROSS_ENTROPY,
+        DENSE_DIMENSION,
+        DENSE_INPUT_DROPOUT,
+        DROP_RATE,
+        DROP_RATE_ATTENTION,
+        DROP_SMALL_LAST_BATCH,
+        EMBEDDING_DIMENSION,
+        ENTITY_RECOGNITION,
+        EPOCHS,
+        EVAL_NUM_EPOCHS,
+        EVAL_NUM_EXAMPLES,
+        FEATURIZERS,
+        HIDDEN_LAYERS_SIZES,
+        IDS,
+        INTENT_CLASSIFICATION,
+        KEY_RELATIVE_ATTENTION,
+        LABEL,
+        LEARNING_RATE,
+        LOSS_TYPE,
+        MASK,
+        MASKED_LM,
+        MAX_NEG_SIM,
+        MAX_POS_SIM,
+        MAX_RELATIVE_POSITION,
+        MODEL_CONFIDENCE,
+        NEGATIVE_MARGIN_SCALE,
+        NUM_HEADS,
+        NUM_NEG,
+        NUM_TRANSFORMER_LAYERS,
+        RANDOM_SEED,
+        RANKING_LENGTH,
+        REGULARIZATION_CONSTANT,
+        RENORMALIZE_CONFIDENCES,
+        RUN_EAGERLY,
+        SCALE_LOSS,
+        SENTENCE,
+        SEQUENCE,
+        SEQUENCE_LENGTH,
+        SHARE_HIDDEN_LAYERS,
+        SIMILARITY_TYPE,
+        SOFTMAX,
+        SPARSE_INPUT_DROPOUT,
+        TENSORBOARD_LOG_DIR,
+        TENSORBOARD_LOG_LEVEL,
+        TRANSFORMER_SIZE,
+        UNIDIRECTIONAL_ENCODER,
+        USE_MAX_NEG_SIM,
+        VALUE_RELATIVE_ATTENTION,
+    )
+else:
+    # Placeholder values when TensorFlow is not available
+    AUTO = "auto"
+    BALANCED = "balanced"
+    BATCH_SIZES = "batch_sizes"
+    BATCH_STRATEGY = "batch_strategy"
+    BILOU_FLAG = "bilou_flag"
+    CHECKPOINT_MODEL = "checkpoint_model"
+    CONCAT_DIMENSION = "concat_dimension"
+    CONNECTION_DENSITY = "connection_density"
+    CONSTRAIN_SIMILARITIES = "constrain_similarities"
+    CROSS_ENTROPY = "cross_entropy"
+    DENSE_DIMENSION = "dense_dimension"
+    DENSE_INPUT_DROPOUT = "dense_input_dropout"
+    DROP_RATE = "drop_rate"
+    DROP_RATE_ATTENTION = "drop_rate_attention"
+    DROP_SMALL_LAST_BATCH = "drop_small_last_batch"
+    EMBEDDING_DIMENSION = "embedding_dimension"
+    ENTITY_RECOGNITION = "entity_recognition"
+    EPOCHS = "epochs"
+    EVAL_NUM_EPOCHS = "eval_num_epochs"
+    EVAL_NUM_EXAMPLES = "eval_num_examples"
+    FEATURIZERS = "featurizers"
+    HIDDEN_LAYERS_SIZES = "hidden_layers_sizes"
+    IDS = "ids"
+    INTENT_CLASSIFICATION = "intent_classification"
+    KEY_RELATIVE_ATTENTION = "key_relative_attention"
+    LABEL = "label"
+    LEARNING_RATE = "learning_rate"
+    LOSS_TYPE = "loss_type"
+    MASK = "mask"
+    MASKED_LM = "masked_lm"
+    MAX_NEG_SIM = "max_neg_sim"
+    MAX_POS_SIM = "max_pos_sim"
+    MAX_RELATIVE_POSITION = "max_relative_position"
+    MODEL_CONFIDENCE = "model_confidence"
+    NEGATIVE_MARGIN_SCALE = "negative_margin_scale"
+    NUM_HEADS = "num_heads"
+    NUM_NEG = "num_neg"
+    NUM_TRANSFORMER_LAYERS = "num_transformer_layers"
+    RANDOM_SEED = "random_seed"
+    RANKING_LENGTH = "ranking_length"
+    REGULARIZATION_CONSTANT = "regularization_constant"
+    RENORMALIZE_CONFIDENCES = "renormalize_confidences"
+    RUN_EAGERLY = "run_eagerly"
+    SCALE_LOSS = "scale_loss"
+    SENTENCE = "sentence"
+    SEQUENCE = "sequence"
+    SEQUENCE_LENGTH = "sequence_length"
+    SHARE_HIDDEN_LAYERS = "share_hidden_layers"
+    SIMILARITY_TYPE = "similarity_type"
+    SOFTMAX = "softmax"
+    SPARSE_INPUT_DROPOUT = "sparse_input_dropout"
+    TENSORBOARD_LOG_DIR = "tensorboard_log_dir"
+    TENSORBOARD_LOG_LEVEL = "tensorboard_log_level"
+    TRANSFORMER_SIZE = "transformer_size"
+    UNIDIRECTIONAL_ENCODER = "unidirectional_encoder"
+    USE_MAX_NEG_SIM = "use_max_neg_sim"
+    VALUE_RELATIVE_ATTENTION = "value_relative_attention"
+if TENSORFLOW_AVAILABLE:
+    from rasa.utils.tensorflow.feature_array import (
+        FeatureArray,
+        deserialize_nested_feature_arrays,
+        serialize_nested_feature_arrays,
+    )
+else:
+    FeatureArray = None  # type: ignore
+    deserialize_nested_feature_arrays = None  # type: ignore
+    serialize_nested_feature_arrays = None  # type: ignore
+if TENSORFLOW_AVAILABLE:
+    from rasa.utils.tensorflow.model_data import (
+        FeatureSignature,
+        RasaModelData,
+    )
+else:
+    FeatureSignature = None  # type: ignore
+    RasaModelData = None  # type: ignore
+if TENSORFLOW_AVAILABLE:
+    from rasa.utils.tensorflow.models import RasaModel, TransformerRasaModel
+else:
+    RasaModel = None  # type: ignore
+    TransformerRasaModel = None  # type: ignore
 
 logger = logging.getLogger(__name__)
 
@@ -306,6 +389,9 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
         sparse_feature_sizes: Optional[Dict[Text, Dict[Text, List[int]]]] = None,
     ) -> None:
         """Declare instance variables with default values."""
+        raise_deprecation_warning(
+            "DIETClassifier is deprecated and will be removed in a future version."
+        )
         if EPOCHS not in config:
             rasa.shared.utils.io.raise_warning(
                 f"Please configure the number of '{EPOCHS}' in your configuration file."
@@ -906,24 +992,16 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
         # keep one example for persisting and loading
         self._data_example = model_data.first_data_example()
 
-        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.compile(
-                optimizer=tf.keras.optimizers.Adam(
-                    self.component_config[LEARNING_RATE]
-                ),
-                run_eagerly=self.component_config[RUN_EAGERLY],
-            )
-        else:
-            if self.model is None:
-                raise ModelNotFound("Model could not be found. ")
+        # as the keras 2.15 does not allow updating a compiled model anymore,
+        # we cannot support finetune mode anymore
+
+        # Create a new instance of the model.
+        self.model = self._instantiate_model_class(model_data)
+        self.model.compile(
+            optimizer=tf.keras.optimizers.Adam(self.component_config[LEARNING_RATE]),
+            run_eagerly=self.component_config[RUN_EAGERLY],
+        )
 
-            self.model.adjust_for_incremental_training(
-                data_example=self._data_example,
-                new_sparse_feature_sizes=model_data.get_sparse_feature_sizes(),
-                old_sparse_feature_sizes=self._sparse_feature_sizes,
-            )
         self._sparse_feature_sizes = model_data.get_sparse_feature_sizes()
 
         data_generator, validation_data_generator = train_utils.create_data_generators(
@@ -1070,12 +1148,14 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
 
         with self._model_storage.write_to(self._resource) as model_path:
             file_name = self.__class__.__name__
-            tf_model_file = model_path / f"{file_name}.tf_model"
+            tf_model_file = model_path / f"{file_name}.weights.h5"
 
             rasa.shared.utils.io.create_directory_for_file(tf_model_file)
 
             if self.component_config[CHECKPOINT_MODEL] and self.tmp_checkpoint_dir:
-                self.model.load_weights(self.tmp_checkpoint_dir / "checkpoint.tf_model")
+                self.model.load_weights(
+                    self.tmp_checkpoint_dir / "checkpoint.weights.h5"
+                )
                 # Save an empty file to flag that this model has been
                 # produced using checkpointing
                 checkpoint_marker = model_path / f"{file_name}.from_checkpoint.pkl"
@@ -1247,7 +1327,7 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
         finetune_mode: bool = False,
     ) -> "RasaModel":
         file_name = cls.__name__
-        tf_model_file = model_path / f"{file_name}.tf_model"
+        tf_model_file = model_path / f"{file_name}.weights.h5"
 
         label_key = LABEL_KEY if config[INTENT_CLASSIFICATION] else None
         label_sub_key = LABEL_SUB_KEY if config[INTENT_CLASSIFICATION] else None
@@ -1306,7 +1386,7 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
         )
 
 
-class DIET(TransformerRasaModel):
+class DIET(TransformerRasaModel if TENSORFLOW_AVAILABLE else object):  # type: ignore[misc]
     def __init__(
         self,
         data_signature: Dict[Text, Dict[Text, List[FeatureSignature]]],
@@ -1314,6 +1394,8 @@ class DIET(TransformerRasaModel):
         entity_tag_specs: Optional[List[EntityTagSpec]],
         config: Dict[Text, Any],
     ) -> None:
+        if not TENSORFLOW_AVAILABLE:
+            raise RuntimeError("DIET classifier requires TensorFlow to be installed")
         # create entity tag spec before calling super otherwise building the model
         # will fail
         super().__init__("DIET", config, data_signature, label_data)
@@ -1527,7 +1609,7 @@ class DIET(TransformerRasaModel):
         # convert to bag-of-words by summing along the sequence dimension
         x = tf.reduce_sum(x, axis=1)
 
-        return self._tf_layers[f"ffnn.{name}"](x, self._training)
+        return self._tf_layers[f"ffnn.{name}"](x, training=self._training)
 
     def _create_all_labels(self) -> Tuple[tf.Tensor, tf.Tensor]:
         all_label_ids = self.tf_label_data[LABEL_KEY][LABEL_SUB_KEY][0]
@@ -1536,9 +1618,23 @@ class DIET(TransformerRasaModel):
             self.tf_label_data, LABEL
         )
 
+        # Check if SENTENCE features exist, if not use None
+        # This is needed for compatibility with tensorFlow=2.19.1, which
+        # has a transitive dependency on keras=3.11.3, which introduces
+        # stricter data validation
+        sentence_features = None
+        if SENTENCE in self.tf_label_data[LABEL]:
+            sentence_features = self.tf_label_data[LABEL][SENTENCE]
+
+        # Handle missing SEQUENCE features for Keras 3+ compatibility,
+        # which introduces stricter data validation
+        sequence_features = None
+        if SEQUENCE in self.tf_label_data[LABEL]:
+            sequence_features = self.tf_label_data[LABEL][SEQUENCE]
+
         x = self._create_bow(
-            self.tf_label_data[LABEL][SEQUENCE],
-            self.tf_label_data[LABEL][SENTENCE],
+            sequence_features,
+            sentence_features,
             sequence_feature_lengths,
             self.label_name,
         )
@@ -1797,8 +1893,12 @@ class DIET(TransformerRasaModel):
         )
         predictions = {
             DIAGNOSTIC_DATA: {
-                "attention_weights": attention_weights,
-                "text_transformed": text_transformed,
+                "attention_weights": attention_weights.numpy()
+                if hasattr(attention_weights, "numpy")
+                else attention_weights,
+                "text_transformed": text_transformed.numpy()
+                if hasattr(text_transformed, "numpy")
+                else text_transformed,
             }
         }
 

rasa/nlu/classifiers/logistic_regression_classifier.py

@@ -1,5 +1,6 @@
 from typing import Any, Dict, List, Text, Tuple, Type
 
+import skops.io as sio
 import structlog
 from scipy.sparse import csr_matrix, hstack, vstack
 from sklearn.exceptions import NotFittedError
@@ -183,8 +184,6 @@ class LogisticRegressionClassifier(IntentClassifier, GraphComponent):
 
     def persist(self) -> None:
         """Persist this model into the passed directory."""
-        import skops.io as sio
-
         with self._model_storage.write_to(self._resource) as model_dir:
             path = model_dir / f"{self._resource.name}.skops"
             sio.dump(self.clf, path)
@@ -203,8 +202,6 @@ class LogisticRegressionClassifier(IntentClassifier, GraphComponent):
         **kwargs: Any,
     ) -> "LogisticRegressionClassifier":
         """Loads trained component (see parent class for full docstring)."""
-        import skops.io as sio
-
         try:
             with model_storage.read_from(resource) as model_dir:
                 classifier_file = model_dir / f"{resource.name}.skops"

rasa/nlu/classifiers/mitie_intent_classifier.py

@@ -4,6 +4,9 @@ import logging
 import typing
 from typing import Any, Dict, List, Optional, Text, Type
 
+# importing mitie at module level to ensure error is raised if mitie is not installed
+import mitie
+
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource

rasa/nlu/classifiers/sklearn_intent_classifier.py

@@ -6,6 +6,7 @@ import warnings
 from typing import Any, Dict, List, Optional, Text, Tuple, Type
 
 import numpy as np
+import skops.io as sio
 
 import rasa.shared.utils.io
 from rasa.engine.graph import ExecutionContext, GraphComponent
@@ -266,8 +267,6 @@ class SklearnIntentClassifier(GraphComponent, IntentClassifier):
 
     def persist(self) -> None:
         """Persist this model into the passed directory."""
-        import skops.io as sio
-
         with self._model_storage.write_to(self._resource) as model_dir:
             file_name = self.__class__.__name__
             classifier_file_name = model_dir / f"{file_name}_classifier.skops"
@@ -291,7 +290,6 @@ class SklearnIntentClassifier(GraphComponent, IntentClassifier):
         **kwargs: Any,
     ) -> SklearnIntentClassifier:
         """Loads trained component (see parent class for full docstring)."""
-        import skops.io as sio
         from sklearn.preprocessing import LabelEncoder
 
         try:

rasa/nlu/extractors/crf_entity_extractor.py

@@ -10,6 +10,9 @@ from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Type
 
 import numpy as np
 
+# importing sklearn_crfsuite at module level to raise error if not installed
+import sklearn_crfsuite
+
 import rasa.nlu.utils.bilou_utils as bilou_utils
 import rasa.shared.utils.io
 import rasa.utils.train_utils
@@ -20,7 +23,6 @@ from rasa.engine.storage.storage import ModelStorage
 from rasa.nlu.constants import TOKENS_NAMES
 from rasa.nlu.extractors.extractor import EntityExtractorMixin
 from rasa.nlu.test import determine_token_labels
-from rasa.nlu.tokenizers.spacy_tokenizer import POS_TAG_KEY
 from rasa.nlu.tokenizers.tokenizer import Token, Tokenizer
 from rasa.shared.constants import DOCS_URL_COMPONENTS
 from rasa.shared.nlu.constants import (
@@ -37,6 +39,8 @@ from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
 from rasa.utils.tensorflow.constants import BILOU_FLAG, FEATURIZERS
 
+POS_TAG_KEY = "pos"
+
 logger = logging.getLogger(__name__)
 
 if typing.TYPE_CHECKING:
@@ -445,13 +449,11 @@ class CRFEntityExtractor(GraphComponent, EntityExtractorMixin):
     def _load_taggers(
         cls, model_dir: Path, config: Dict[Text, Any]
     ) -> Dict[str, "CRF"]:
-        """
-        Load taggers from model directory that persists trained binary
-        `model.crfsuite` files.
-        """
+        """Load taggers from model directory.
 
+        It persists trained binary `model.crfsuite` files.
+        """
         import pycrfsuite
-        import sklearn_crfsuite
 
         # Get tagger directories
         taggers_base = model_dir / TAGGERS_DIR
@@ -613,8 +615,7 @@ class CRFEntityExtractor(GraphComponent, EntityExtractorMixin):
 
     @staticmethod
     def _pattern_of_token(message: Message, idx: int) -> Dict[Text, bool]:
-        """Get the patterns of the token at the given index extracted by the
-        'RegexFeaturizer'.
+        """Get patterns of token at the given index extracted by 'RegexFeaturizer'.
 
         The 'RegexFeaturizer' adds all patterns listed in the training data to the
         token. The pattern name is mapped to either 'True' (pattern applies to token) or
@@ -728,8 +729,6 @@ class CRFEntityExtractor(GraphComponent, EntityExtractorMixin):
         crf_order: List[str],
     ) -> OrderedDict[str, CRF]:
         """Train the crf tagger based on the training data."""
-        import sklearn_crfsuite
-
         entity_taggers = OrderedDict()
 
         for tag_name in crf_order: