rasa-pro 3.10.16__py3-none-any.whl → 3.11.0a1__py3-none-any.whl

rasa/engine/recipes/graph_recipe.py

@@ -73,7 +73,6 @@ class GraphV1Recipe(Recipe):
             training_type=training_type,
             assistant_id=config.get(ASSISTANT_ID_KEY),
             language=config.get("language"),
-            spaces=config.get("spaces"),
             core_target=core_target,
             nlu_target=nlu_target,
         )

rasa/engine/runner/dask.py

@@ -220,7 +220,7 @@ async def execute_dask_graph(dsk: Dict[str, Any], result: List[str]) -> Any:
     # if start_state_from_dask fails, we will have something
     # to pass to the final block.
     state = {}
-    keyorder = dask.local.order(dsk)  # type:ignore[no-untyped-call]
+    keyorder = dask.local.order(dsk)
 
     state = dask.local.start_state_from_dask(dsk, cache=cache, sortkey=keyorder.get)  # type:ignore[no-untyped-call]
 
@@ -235,7 +235,7 @@ async def execute_dask_graph(dsk: Dict[str, Any], result: List[str]) -> Any:
         # Notify task is running
         state["running"].add(key)
 
-        dependencies = dask.local.get_dependencies(dsk, key)  # type:ignore[no-untyped-call]
+        dependencies = dask.local.get_dependencies(dsk, key)
         # Prep args to send
         data = {dep: state["cache"][dep] for dep in dependencies}
 

rasa/engine/storage/local_model_storage.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import shutil
 import sys
 import tempfile
@@ -7,21 +8,19 @@ import uuid
 from contextlib import contextmanager
 from datetime import datetime
 from pathlib import Path
-from typing import Generator, Optional, Text, Tuple, Union
-
-import structlog
 from tarsafe import TarSafe
+from typing import Generator, Optional, Text, Tuple, Union
 
-import rasa.model
-import rasa.shared.utils.io
 import rasa.utils.common
+import rasa.shared.utils.io
+from rasa.engine.storage.storage import ModelMetadata, ModelStorage
 from rasa.engine.graph import GraphModelConfiguration
 from rasa.engine.storage.resource import Resource
-from rasa.engine.storage.storage import ModelMetadata, ModelStorage
 from rasa.exceptions import UnsupportedModelVersionError
 from rasa.shared.core.domain import Domain
+import rasa.model
 
-structlogger = structlog.get_logger()
+logger = logging.getLogger(__name__)
 
 # Paths within model archive
 MODEL_ARCHIVE_COMPONENTS_DIR = "components"
@@ -87,14 +86,7 @@ class LocalModelStorage(ModelStorage):
             cls._extract_archive_to_directory(
                 model_archive_path, temporary_directory_path
             )
-            structlogger.debug(
-                "local_model_storage.from_model_archive",
-                event_info=(
-                    f"Extracted model '{model_archive_path}' to "
-                    f"'{temporary_directory_path}'."
-                ),
-            )
-
+            logger.debug(f"Extracted model to '{temporary_directory_path}'.")
             cls._initialize_model_storage_from_model_archive(
                 temporary_directory_path, storage_path
             )
@@ -150,10 +142,6 @@ class LocalModelStorage(ModelStorage):
         temporary_directory: Path, storage_path: Path
     ) -> None:
         for path in (temporary_directory / MODEL_ARCHIVE_COMPONENTS_DIR).glob("*"):
-            structlogger.debug(
-                "local_model_storage._initialize_model_storage_from_model_archive",
-                event_info=f"Moving '{path}' to '{storage_path}'.",
-            )
             shutil.move(str(path), str(storage_path))
 
     @staticmethod
@@ -167,10 +155,7 @@ class LocalModelStorage(ModelStorage):
     @contextmanager
     def write_to(self, resource: Resource) -> Generator[Path, None, None]:
         """Persists data for a resource (see parent class for full docstring)."""
-        structlogger.debug(
-            "local_model_storage.write_to.resource_write_requested",
-            event_info=f"Resource '{resource.name}' was requested for writing.",
-        )
+        logger.debug(f"Resource '{resource.name}' was requested for writing.")
         directory = self._directory_for_resource(resource)
 
         if not directory.exists():
@@ -178,10 +163,7 @@ class LocalModelStorage(ModelStorage):
 
         yield directory
 
-        structlogger.debug(
-            "local_model_storage.write_to.resource_persisted",
-            event_info=f"Resource '{resource.name}' was persisted.",
-        )
+        logger.debug(f"Resource '{resource.name}' was persisted.")
 
     def _directory_for_resource(self, resource: Resource) -> Path:
         return self._storage_path / resource.name
@@ -189,10 +171,7 @@ class LocalModelStorage(ModelStorage):
     @contextmanager
     def read_from(self, resource: Resource) -> Generator[Path, None, None]:
         """Provides the data of a `Resource` (see parent class for full docstring)."""
-        structlogger.debug(
-            "local_model_storage.read_from",
-            event_info=f"Resource '{resource.name}' was requested for reading.",
-        )
+        logger.debug(f"Resource '{resource.name}' was requested for reading.")
         directory = self._directory_for_resource(resource)
 
         if not directory.exists():
@@ -214,12 +193,7 @@ class LocalModelStorage(ModelStorage):
         domain: Domain,
     ) -> ModelMetadata:
         """Creates model package (see parent class for full docstring)."""
-        structlogger.debug(
-            "local_model_storage.create_model_package.started",
-            event_info=(
-                f"Start to created model " f"package for path '{model_archive_path}'.",
-            ),
-        )
+        logger.debug(f"Start to created model package for path '{model_archive_path}'.")
 
         with windows_safe_temporary_directory() as temp_dir:
             temporary_directory = Path(temp_dir)
@@ -240,10 +214,7 @@ class LocalModelStorage(ModelStorage):
             with TarSafe.open(model_archive_path, "w:gz") as tar:
                 tar.add(temporary_directory, arcname="")
 
-        structlogger.debug(
-            "local_model_storage.create_model_package.finished",
-            event_info=f"Model package created in path '{model_archive_path}'.",
-        )
+        logger.debug(f"Model package created in path '{model_archive_path}'.")
 
         return model_metadata
 
@@ -267,7 +238,6 @@ class LocalModelStorage(ModelStorage):
             predict_schema=model_configuration.predict_schema,
             training_type=model_configuration.training_type,
             project_fingerprint=rasa.model.project_fingerprint(),
-            spaces=model_configuration.spaces,
             language=model_configuration.language,
             core_target=model_configuration.core_target,
             nlu_target=model_configuration.nlu_target,

rasa/engine/storage/storage.py

@@ -6,7 +6,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import List, Tuple, Union, Text, Generator, Dict, Any, Optional
+from typing import Tuple, Union, Text, Generator, Dict, Any, Optional
 from packaging import version
 
 from rasa.constants import MINIMUM_COMPATIBLE_VERSION
@@ -140,7 +140,6 @@ class ModelMetadata:
     core_target: Optional[Text]
     nlu_target: Text
     language: Optional[Text]
-    spaces: Optional[List[Dict[Text, Any]]] = None
     training_type: TrainingType = TrainingType.BOTH
 
     def __post_init__(self) -> None:
@@ -170,7 +169,6 @@ class ModelMetadata:
             "core_target": self.core_target,
             "nlu_target": self.nlu_target,
             "language": self.language,
-            "spaces": self.spaces,
         }
 
     @classmethod
@@ -198,6 +196,4 @@ class ModelMetadata:
             core_target=serialized["core_target"],
             nlu_target=serialized["nlu_target"],
             language=serialized["language"],
-            # optional, since introduced later
-            spaces=serialized.get("spaces"),
         )

rasa/engine/validation.py

@@ -16,7 +16,6 @@ from typing import (
     Union,
     TypeVar,
     List,
-    Literal,
 )
 
 import structlog
@@ -35,7 +34,6 @@ from rasa.dialogue_understanding.coexistence.constants import (
 from rasa.dialogue_understanding.generator import (
     LLMBasedCommandGenerator,
 )
-from rasa.dialogue_understanding.generator.constants import FLOW_RETRIEVAL_KEY
 from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.engine.constants import RESERVED_PLACEHOLDERS
 from rasa.engine.exceptions import GraphSchemaValidationException
@@ -49,15 +47,7 @@ from rasa.engine.graph import (
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.engine.training.fingerprinting import Fingerprintable
-from rasa.shared.constants import (
-    DOCS_URL_GRAPH_COMPONENTS,
-    ROUTE_TO_CALM_SLOT,
-    API_TYPE_CONFIG_KEY,
-    VALID_PROVIDERS_FOR_API_TYPE_CONFIG_KEY,
-    PROVIDER_CONFIG_KEY,
-    LLM_CONFIG_KEY,
-    EMBEDDINGS_CONFIG_KEY,
-)
+from rasa.shared.constants import DOCS_URL_GRAPH_COMPONENTS, ROUTE_TO_CALM_SLOT
 from rasa.shared.core.constants import ACTION_RESET_ROUTING, ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList, Flow
@@ -881,70 +871,3 @@ def validate_command_generator_setup(
 ) -> None:
     schema = model_configuration.predict_schema
     validate_command_generator_exclusivity(schema)
-
-
-def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
-    """Validates the model client configuration setup.
-
-    Validation fails, if
-    - the LLM/embeddings provider is defined using 'api_type' key for providers other
-    than 'openai' or 'azure'
-
-    Args:
-        config: The config dictionary
-    """
-    for outer_key in ["pipeline", "policies"]:
-        if outer_key not in config or config[outer_key] is None:
-            continue
-
-        for component_config in config[outer_key]:
-            for key in [LLM_CONFIG_KEY, EMBEDDINGS_CONFIG_KEY]:
-                validate_api_type_config_key_usage(component_config, key)
-
-            # as flow retrieval is not a component itself, we need to
-            # check it separately
-            if (
-                FLOW_RETRIEVAL_KEY in component_config
-                and EMBEDDINGS_CONFIG_KEY in component_config[FLOW_RETRIEVAL_KEY]
-            ):
-                validate_api_type_config_key_usage(
-                    component_config[FLOW_RETRIEVAL_KEY],
-                    EMBEDDINGS_CONFIG_KEY,
-                    component_config["name"] + "." + FLOW_RETRIEVAL_KEY,
-                )
-
-
-def validate_api_type_config_key_usage(
-    component_config: Dict[str, Any],
-    key: Literal["llm", "embeddings"],
-    component_name: Optional[str] = None,
-) -> None:
-    """Validate the LLM/embeddings configuration of a component.
-
-    Validation fails, if
-    - the LLM/embeddings provider is defined using 'api_type' key for providers other
-    than 'openai' or 'azure'
-
-    Args:
-        component_config: The config of the component
-        key: either 'llm' or 'embeddings'
-        component_name: the name of the component
-    """
-    if component_config is None or key not in component_config:
-        return
-
-    if API_TYPE_CONFIG_KEY in component_config[key]:
-        api_type = component_config[key][API_TYPE_CONFIG_KEY]
-        if api_type not in VALID_PROVIDERS_FOR_API_TYPE_CONFIG_KEY:
-            structlogger.error(
-                "validation.component.api_type_config_key_invalid",
-                event_info=(
-                    f"You specified '{API_TYPE_CONFIG_KEY}: {api_type}' for "
-                    f"'{component_name or component_config['name']}', which is not "
-                    f"allowed. "
-                    f"The '{API_TYPE_CONFIG_KEY}' key can only be used for the "
-                    f"following providers: {VALID_PROVIDERS_FOR_API_TYPE_CONFIG_KEY}. "
-                    f"For other providers, please use the '{PROVIDER_CONFIG_KEY}' key."
-                ),
-            )
-            sys.exit(1)

rasa/keys

@@ -0,0 +1 @@
+{"segment": "CcvVD1I68Nkkxrv93cIqv1twIwrwG8nz", "sentry": "a283f1fde04347b099c8d729109dd450@o251570"}

rasa/model_training.py

@@ -15,6 +15,7 @@ import rasa.shared.utils.common
 import rasa.shared.utils.io
 import rasa.utils.common
 from rasa import telemetry
+from rasa.core.persistor import StorageType
 from rasa.engine.caching import LocalTrainingCache
 from rasa.engine.recipes.recipe import Recipe
 from rasa.engine.runner.dask import DaskGraphRunner
@@ -22,7 +23,6 @@ from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.engine.storage.storage import ModelStorage
 from rasa.engine.training.components import FingerprintStatus
 from rasa.engine.training.graph_trainer import GraphTrainer
-from rasa.nlu.persistor import RemoteStorageType, StorageType
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import SlotSet
 from rasa.shared.core.training_data.structures import StoryGraph
@@ -156,6 +156,7 @@ async def train(
     model_to_finetune: Optional[Text] = None,
     finetuning_epoch_fraction: float = 1.0,
     remote_storage: Optional[StorageType] = None,
+    file_importer: Optional[TrainingDataImporter] = None,
 ) -> TrainingResult:
     """Trains a Rasa model (Core and NLU).
 
@@ -177,14 +178,18 @@ async def train(
             a directory in case the latest trained model should be used.
         finetuning_epoch_fraction: The fraction currently specified training epochs
             in the model configuration which should be used for finetuning.
-        remote_storage: The remote storage which should be used to store the model.
+        remote_storage: Optional name of the remote storage to
+            use for storing the model.
+        file_importer: Instance of `TrainingDataImporter` to use for training.
+            If it is not provided, a new instance will be created.
 
     Returns:
         An instance of `TrainingResult`.
     """
-    file_importer = TrainingDataImporter.load_from_config(
-        config, domain, training_files, core_additional_arguments
-    )
+    if not file_importer:
+        file_importer = TrainingDataImporter.load_from_config(
+            config, domain, training_files, core_additional_arguments
+        )
 
     stories = file_importer.get_stories()
     flows = file_importer.get_flows()
@@ -312,7 +317,6 @@ async def _train_graph(
     rasa.engine.validation.validate_coexistance_routing_setup(
         domain, model_configuration, flows
     )
-    rasa.engine.validation.validate_model_client_configuration_setup(config)
     rasa.engine.validation.validate_flow_component_dependencies(
         flows, model_configuration
     )
@@ -351,25 +355,18 @@ async def _train_graph(
             if remote_storage:
                 push_model_to_remote_storage(full_model_path, remote_storage)
                 full_model_path.unlink()
-                remote_storage_string = (
-                    remote_storage.value
-                    if isinstance(remote_storage, RemoteStorageType)
-                    else remote_storage
-                )
                 structlogger.info(
                     "model_training.train.finished_training",
                     event_info=(
                         f"Your Rasa model {model_name} is trained "
-                        f"and saved at remote storage provider "
-                        f"'{remote_storage_string}'."
+                        f"and saved at remote storage provider '{remote_storage}'."
                     ),
                 )
             else:
                 structlogger.info(
                     "model_training.train.finished_training",
                     event_info=(
-                        f"Your Rasa model is trained and saved at "
-                        f"'{full_model_path}'."
+                        f"Your Rasa model is trained and saved at '{full_model_path}'."
                     ),
                 )
 
@@ -563,7 +560,7 @@ async def train_nlu(
 
 def push_model_to_remote_storage(model_path: Path, remote_storage: StorageType) -> None:
     """push model to remote storage"""
-    from rasa.nlu.persistor import get_persistor
+    from rasa.core.persistor import get_persistor
 
     persistor = get_persistor(remote_storage)
 

rasa/nlu/classifiers/diet_classifier.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
-
 import copy
 import logging
 from collections import defaultdict
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Text, Tuple, Union, TypeVar, Type
+
+from rasa.exceptions import ModelNotFound
+from rasa.nlu.featurizers.featurizer import Featurizer
 
 import numpy as np
 import scipy.sparse
 import tensorflow as tf
 
-from rasa.exceptions import ModelNotFound
-from rasa.nlu.featurizers.featurizer import Featurizer
+from typing import Any, Dict, List, Optional, Text, Tuple, Union, TypeVar, Type
+
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
@@ -19,21 +20,18 @@ from rasa.engine.storage.storage import ModelStorage
 from rasa.nlu.extractors.extractor import EntityExtractorMixin
 from rasa.nlu.classifiers.classifier import IntentClassifier
 import rasa.shared.utils.io
+import rasa.utils.io as io_utils
 import rasa.nlu.utils.bilou_utils as bilou_utils
 from rasa.shared.constants import DIAGNOSTIC_DATA
 from rasa.nlu.extractors.extractor import EntityTagSpec
 from rasa.nlu.classifiers import LABEL_RANKING_LENGTH
 from rasa.utils import train_utils
 from rasa.utils.tensorflow import rasa_layers
-from rasa.utils.tensorflow.feature_array import (
-    FeatureArray,
-    serialize_nested_feature_arrays,
-    deserialize_nested_feature_arrays,
-)
 from rasa.utils.tensorflow.models import RasaModel, TransformerRasaModel
 from rasa.utils.tensorflow.model_data import (
     RasaModelData,
     FeatureSignature,
+    FeatureArray,
 )
 from rasa.nlu.constants import TOKENS_NAMES, DEFAULT_TRANSFORMER_SIZE
 from rasa.shared.nlu.constants import (
@@ -120,6 +118,7 @@ LABEL_SUB_KEY = IDS
 
 POSSIBLE_TAGS = [ENTITY_ATTRIBUTE_TYPE, ENTITY_ATTRIBUTE_ROLE, ENTITY_ATTRIBUTE_GROUP]
 
+
 DIETClassifierT = TypeVar("DIETClassifierT", bound="DIETClassifier")
 
 
@@ -1084,24 +1083,18 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
 
             self.model.save(str(tf_model_file))
 
-            # save data example
-            serialize_nested_feature_arrays(
-                self._data_example,
-                model_path / f"{file_name}.data_example.st",
-                model_path / f"{file_name}.data_example_metadata.json",
-            )
-            # save label data
-            serialize_nested_feature_arrays(
-                dict(self._label_data.data) if self._label_data is not None else {},
-                model_path / f"{file_name}.label_data.st",
-                model_path / f"{file_name}.label_data_metadata.json",
+            io_utils.pickle_dump(
+                model_path / f"{file_name}.data_example.pkl", self._data_example
             )
-
-            rasa.shared.utils.io.dump_obj_as_json_to_file(
-                model_path / f"{file_name}.sparse_feature_sizes.json",
+            io_utils.pickle_dump(
+                model_path / f"{file_name}.sparse_feature_sizes.pkl",
                 self._sparse_feature_sizes,
             )
-            rasa.shared.utils.io.dump_obj_as_json_to_file(
+            io_utils.pickle_dump(
+                model_path / f"{file_name}.label_data.pkl",
+                dict(self._label_data.data) if self._label_data is not None else {},
+            )
+            io_utils.json_pickle(
                 model_path / f"{file_name}.index_label_id_mapping.json",
                 self.index_label_id_mapping,
             )
@@ -1190,22 +1183,15 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
     ]:
         file_name = cls.__name__
 
-        # load data example
-        data_example = deserialize_nested_feature_arrays(
-            str(model_path / f"{file_name}.data_example.st"),
-            str(model_path / f"{file_name}.data_example_metadata.json"),
+        data_example = io_utils.pickle_load(
+            model_path / f"{file_name}.data_example.pkl"
         )
-        # load label data
-        loaded_label_data = deserialize_nested_feature_arrays(
-            str(model_path / f"{file_name}.label_data.st"),
-            str(model_path / f"{file_name}.label_data_metadata.json"),
-        )
-        label_data = RasaModelData(data=loaded_label_data)
-
-        sparse_feature_sizes = rasa.shared.utils.io.read_json_file(
-            model_path / f"{file_name}.sparse_feature_sizes.json"
+        label_data = io_utils.pickle_load(model_path / f"{file_name}.label_data.pkl")
+        label_data = RasaModelData(data=label_data)
+        sparse_feature_sizes = io_utils.pickle_load(
+            model_path / f"{file_name}.sparse_feature_sizes.pkl"
         )
-        index_label_id_mapping = rasa.shared.utils.io.read_json_file(
+        index_label_id_mapping = io_utils.json_unpickle(
             model_path / f"{file_name}.index_label_id_mapping.json"
         )
         entity_tag_specs = rasa.shared.utils.io.read_json_file(
@@ -1225,6 +1211,7 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
             for tag_spec in entity_tag_specs
         ]
 
+        # jsonpickle converts dictionary keys to strings
         index_label_id_mapping = {
             int(key): value for key, value in index_label_id_mapping.items()
         }

rasa/nlu/classifiers/logistic_regression_classifier.py

@@ -1,21 +1,22 @@
 from typing import Any, Text, Dict, List, Type, Tuple
 
+import joblib
 import structlog
 from scipy.sparse import hstack, vstack, csr_matrix
 from sklearn.exceptions import NotFittedError
 from sklearn.linear_model import LogisticRegression
 from sklearn.utils.validation import check_is_fitted
 
-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.engine.recipes.default_recipe import DefaultV1Recipe
+from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.nlu.classifiers import LABEL_RANKING_LENGTH
-from rasa.nlu.classifiers.classifier import IntentClassifier
 from rasa.nlu.featurizers.featurizer import Featurizer
-from rasa.shared.nlu.constants import TEXT, INTENT
-from rasa.shared.nlu.training_data.message import Message
+from rasa.nlu.classifiers.classifier import IntentClassifier
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.constants import TEXT, INTENT
 from rasa.utils.tensorflow.constants import RANKING_LENGTH
 
 structlogger = structlog.get_logger()
@@ -183,11 +184,9 @@ 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)
+            path = model_dir / f"{self._resource.name}.joblib"
+            joblib.dump(self.clf, path)
             structlogger.debug(
                 "logistic_regression_classifier.persist",
                 event_info=f"Saved intent classifier to '{path}'.",
@@ -203,21 +202,9 @@ 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"
-                unknown_types = sio.get_untrusted_types(file=classifier_file)
-
-                if unknown_types:
-                    structlogger.error(
-                        f"Untrusted types found when loading {classifier_file}!",
-                        unknown_types=unknown_types,
-                    )
-                    raise ValueError()
-
-                classifier = sio.load(classifier_file, trusted=unknown_types)
+                classifier = joblib.load(model_dir / f"{resource.name}.joblib")
                 component = cls(
                     config, execution_context.node_name, model_storage, resource
                 )

rasa/nlu/classifiers/sklearn_intent_classifier.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
-
 import logging
+from rasa.nlu.featurizers.dense_featurizer.dense_featurizer import DenseFeaturizer
 import typing
 import warnings
 from typing import Any, Dict, List, Optional, Text, Tuple, Type
@@ -8,18 +8,18 @@ from typing import Any, Dict, List, Optional, Text, Tuple, Type
 import numpy as np
 
 import rasa.shared.utils.io
+import rasa.utils.io as io_utils
 from rasa.engine.graph import GraphComponent, ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
-from rasa.nlu.classifiers import LABEL_RANKING_LENGTH
-from rasa.nlu.classifiers.classifier import IntentClassifier
-from rasa.nlu.featurizers.dense_featurizer.dense_featurizer import DenseFeaturizer
 from rasa.shared.constants import DOCS_URL_TRAINING_DATA_NLU
+from rasa.nlu.classifiers import LABEL_RANKING_LENGTH
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.constants import TEXT
-from rasa.shared.nlu.training_data.message import Message
+from rasa.nlu.classifiers.classifier import IntentClassifier
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.nlu.training_data.message import Message
 from rasa.utils.tensorflow.constants import FEATURIZERS
 
 logger = logging.getLogger(__name__)
@@ -266,20 +266,14 @@ 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"
-            encoder_file_name = model_dir / f"{file_name}_encoder.json"
+            classifier_file_name = model_dir / f"{file_name}_classifier.pkl"
+            encoder_file_name = model_dir / f"{file_name}_encoder.pkl"
 
             if self.clf and self.le:
-                # convert self.le.classes_ (numpy array of strings) to a list in order
-                # to use json dump
-                rasa.shared.utils.io.dump_obj_as_json_to_file(
-                    encoder_file_name, list(self.le.classes_)
-                )
-                sio.dump(self.clf.best_estimator_, classifier_file_name)
+                io_utils.json_pickle(encoder_file_name, self.le.classes_)
+                io_utils.json_pickle(classifier_file_name, self.clf.best_estimator_)
 
     @classmethod
     def load(
@@ -292,36 +286,21 @@ class SklearnIntentClassifier(GraphComponent, IntentClassifier):
     ) -> SklearnIntentClassifier:
         """Loads trained component (see parent class for full docstring)."""
         from sklearn.preprocessing import LabelEncoder
-        import skops.io as sio
 
         try:
             with model_storage.read_from(resource) as model_dir:
                 file_name = cls.__name__
-                classifier_file = model_dir / f"{file_name}_classifier.skops"
+                classifier_file = model_dir / f"{file_name}_classifier.pkl"
 
                 if classifier_file.exists():
-                    unknown_types = sio.get_untrusted_types(file=classifier_file)
-
-                    if unknown_types:
-                        logger.error(
-                            f"Untrusted types ({unknown_types}) found when "
-                            f"loading {classifier_file}!"
-                        )
-                        raise ValueError()
-                    else:
-                        classifier = sio.load(classifier_file, trusted=unknown_types)
-
-                    encoder_file = model_dir / f"{file_name}_encoder.json"
-                    classes = rasa.shared.utils.io.read_json_file(encoder_file)
+                    classifier = io_utils.json_unpickle(classifier_file)
 
+                    encoder_file = model_dir / f"{file_name}_encoder.pkl"
+                    classes = io_utils.json_unpickle(encoder_file)
                     encoder = LabelEncoder()
-                    intent_classifier = cls(
-                        config, model_storage, resource, classifier, encoder
-                    )
-                    # convert list of strings (class labels) back to numpy array of
-                    # strings
-                    intent_classifier.transform_labels_str2num(classes)
-                    return intent_classifier
+                    encoder.classes_ = classes
+
+                    return cls(config, model_storage, resource, classifier, encoder)
         except ValueError:
             logger.debug(
                 f"Failed to load '{cls.__name__}' from model storage. Resource "