rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc2__py3-none-any.whl

rasa/model_manager/config.py

@@ -1,8 +1,10 @@
 import sys
 import os
 
+DEFAULT_SERVER_BASE_WORKING_DIRECTORY = "working-data"
+
 SERVER_BASE_WORKING_DIRECTORY = os.environ.get(
-    "RASA_MODEL_SERVER_BASE_DIRECTORY", "working-data"
+    "RASA_MODEL_SERVER_BASE_DIRECTORY", DEFAULT_SERVER_BASE_WORKING_DIRECTORY
 )
 
 SERVER_BASE_URL = os.environ.get("RASA_MODEL_SERVER_BASE_URL", None)
@@ -14,7 +16,17 @@ SERVER_MODEL_REMOTE_STORAGE = os.environ.get("RASA_REMOTE_STORAGE", None)
 # we will use the same python to run training / bots
 RASA_PYTHON_PATH = sys.executable
 
-# the max limit for parallel training and bot run requests
-MAX_PARALLEL_TRAININGS = os.getenv("MAX_PARALLEL_TRAININGS", 10)
+# the max limit for parallel training requests
+DEFAULT_MAX_PARALLEL_TRAININGS = 10
+
+MAX_PARALLEL_TRAININGS = os.getenv(
+    "MAX_PARALLEL_TRAININGS", DEFAULT_MAX_PARALLEL_TRAININGS
+)
+# the max limit for parallel running bots
+DEFAULT_MAX_PARALLEL_BOT_RUNS = 10
+
+MAX_PARALLEL_BOT_RUNS = os.getenv(
+    "MAX_PARALLEL_BOT_RUNS", DEFAULT_MAX_PARALLEL_BOT_RUNS
+)
 
 DEFAULT_SERVER_PATH_PREFIX = "talk"

rasa/model_manager/model_api.py

@@ -16,6 +16,7 @@ from rasa.model_manager.config import SERVER_BASE_URL
 from rasa.constants import MODEL_ARCHIVE_EXTENSION
 from rasa.model_manager.runner_service import (
     BotSession,
+    BotSessionStatus,
     fetch_remote_model_to_dir,
     run_bot,
     terminate_bot,
@@ -24,11 +25,13 @@ from rasa.model_manager.runner_service import (
 from rasa.model_manager.socket_bridge import create_bridge_server
 from rasa.model_manager.trainer_service import (
     TrainingSession,
+    TrainingSessionStatus,
     run_training,
     terminate_training,
     update_training_status,
 )
 from rasa.model_manager.utils import (
+    InvalidPathException,
     get_logs_content,
     logs_base_path,
     models_base_path,
@@ -134,7 +137,8 @@ def internal_blueprint() -> Blueprint:
             [
                 training
                 for training in trainings.values()
-                if training.status == "running" and training.process.poll() is None
+                if training.status == TrainingSessionStatus.RUNNING
+                and training.process.poll() is None
             ]
         )
 
@@ -152,7 +156,7 @@ def internal_blueprint() -> Blueprint:
     @bp.on_request  # type: ignore[misc]
     async def limit_parallel_bot_runs(request: Request) -> Any:
         """Limit the number of parallel bot runs."""
-        from rasa.model_manager.config import MAX_PARALLEL_TRAININGS
+        from rasa.model_manager.config import MAX_PARALLEL_BOT_RUNS
 
         if not request.url.endswith("/bot"):
             return None
@@ -161,15 +165,15 @@ def internal_blueprint() -> Blueprint:
             [
                 bot
                 for bot in running_bots.values()
-                if bot.status in {"running", "queued"}
+                if bot.status in {BotSessionStatus.RUNNING, BotSessionStatus.QUEUED}
             ]
         )
 
-        if running_requests >= int(MAX_PARALLEL_TRAININGS):
+        if running_requests >= int(MAX_PARALLEL_BOT_RUNS):
             return response.json(
                 {
                     "message": f"Too many parallel bot runs, above "
-                    f"the limit of {MAX_PARALLEL_TRAININGS}. "
+                    f"the limit of {MAX_PARALLEL_BOT_RUNS}. "
                     f"Retry later or increase your server's "
                     f"memory and CPU resources."
                 },
@@ -244,6 +248,8 @@ def internal_blueprint() -> Blueprint:
             return json({"message": "Training id is required"}, status=400)
 
         try:
+            # file deepcode ignore PT: path traversal is prevented
+            # by the `subpath` function found in the `rasa.model_manager.utils` module
             training_session = run_training(
                 training_id=training_id,
                 assistant_id=assistant_id,
@@ -254,8 +260,10 @@ def internal_blueprint() -> Blueprint:
             return json(
                 {"training_id": training_id, "model_name": training_session.model_name}
             )
-        except Exception as e:
-            return json({"message": str(e)}, status=500)
+        except InvalidPathException as exc:
+            return json({"message": str(exc)}, status=403)
+        except Exception as exc:
+            return json({"message": str(exc)}, status=500)
 
     @bp.get("/training/<training_id>")
     async def get_training(request: Request, training_id: str) -> response.HTTPResponse:

rasa/model_manager/runner_service.py

@@ -87,7 +87,7 @@ async def is_bot_startup_finished(bot: BotSession) -> bool:
         return False
 
 
-def update_bot_to_stopped(bot: BotSession) -> None:
+def set_bot_status_to_stopped(bot: BotSession) -> None:
     """Set a bots state to stopped."""
     structlogger.info(
         "model_runner.bot_stopped",
@@ -97,7 +97,7 @@ def update_bot_to_stopped(bot: BotSession) -> None:
     bot.status = BotSessionStatus.STOPPED
 
 
-def update_bot_to_running(bot: BotSession) -> None:
+def set_bot_status_to_running(bot: BotSession) -> None:
     """Set a bots state to running."""
     structlogger.info(
         "model_runner.bot_running",
@@ -119,7 +119,9 @@ def get_open_port() -> int:
     return port
 
 
-def write_config_data_to_files(encoded_configs: Dict[str, str], base_path: str) -> None:
+def write_encoded_config_data_to_files(
+    encoded_configs: Dict[str, bytes], base_path: str
+) -> None:
     """Write the encoded config data to files."""
     for key, value in encoded_configs.items():
         write_encoded_data_to_file(value, subpath(base_path, f"{key}.yml"))
@@ -155,7 +157,7 @@ def prepare_bot_directory(
         dst=subpath(bot_base_path, "models"),
     )
 
-    write_config_data_to_files(encoded_configs, bot_base_path)
+    write_encoded_config_data_to_files(encoded_configs, bot_base_path)
 
 
 def fetch_remote_model_to_dir(
@@ -253,9 +255,9 @@ def run_bot(
 async def update_bot_status(bot: BotSession) -> None:
     """Update the status of a bot based on the process return code."""
     if bot.has_died_recently():
-        update_bot_to_stopped(bot)
+        set_bot_status_to_stopped(bot)
     elif await bot.completed_startup_recently():
-        update_bot_to_running(bot)
+        set_bot_status_to_running(bot)
 
 
 def terminate_bot(bot: BotSession) -> None:

rasa/model_manager/socket_bridge.py

@@ -84,6 +84,7 @@ def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession])
 
     @sio.on("disconnect")
     async def disconnect(sid: str) -> None:
+        """Disconnect the bot connection."""
         structlogger.debug("model_runner.bot_disconnect", sid=sid)
         if sid in socket_proxy_clients:
             await socket_proxy_clients[sid].disconnect()
@@ -91,10 +92,12 @@ def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession])
 
     @sio.on("*")
     async def handle_message(event: str, sid: str, data: Dict[str, Any]) -> None:
-        # bridge both, incoming messages to the bot_url but also
-        # send the response back to the client. both need to happen
-        # in parallel in an async way
+        """ "Bridge messages between user and bot.
 
+        Both incoming user messages to the bot_url and
+        bot responses sent back to the client need to
+        happen in parallel in an async way.
+        """
         client = socket_proxy_clients.get(sid)
         if client is None:
             structlogger.error("model_runner.bot_not_connected", sid=sid)

rasa/model_manager/trainer_service.py

@@ -52,12 +52,12 @@ class TrainingSession(BaseModel):
 
 def train_path(training_id: str) -> str:
     """Return the path to the training directory for a given training id."""
-    return subpath(config.SERVER_BASE_WORKING_DIRECTORY, f"trainings/{training_id}")
+    return subpath(config.SERVER_BASE_WORKING_DIRECTORY + "/trainings", training_id)
 
 
 def cache_for_assistant_path(assistant_id: str) -> str:
     """Return the path to the cache directory for a given assistant id."""
-    return subpath(config.SERVER_BASE_WORKING_DIRECTORY, f"caches/{assistant_id}")
+    return subpath(config.SERVER_BASE_WORKING_DIRECTORY + "/caches", assistant_id)
 
 
 def terminate_training(training: TrainingSession) -> None:
@@ -132,8 +132,8 @@ def move_model_to_local_storage(training: TrainingSession) -> None:
     ensure_base_directory_exists(models_base_path())
 
     model_path = subpath(
-        train_path(training.training_id),
-        f"models/{training.model_name}.{MODEL_ARCHIVE_EXTENSION}",
+        train_path(training.training_id) + "/models",
+        f"{training.model_name}.{MODEL_ARCHIVE_EXTENSION}",
     )
 
     if os.path.exists(model_path):
@@ -217,9 +217,11 @@ def write_training_data_to_files(
     }
 
     for key, file in data_to_be_written_to_files.items():
+        parent_path, file_name = os.path.split(file)
+
         write_encoded_data_to_file(
             encoded_training_data.get(key, ""),
-            subpath(training_base_path, file),
+            subpath(training_base_path + "/" + parent_path, file_name),
         )
 
 

rasa/model_manager/utils.py

@@ -2,7 +2,16 @@ import os
 import base64
 from typing import Optional
 
+import structlog
+
 from rasa.model_manager import config
+from rasa.shared.exceptions import RasaException
+
+structlogger = structlog.get_logger()
+
+
+class InvalidPathException(RasaException):
+    """Raised if a path is invalid - e.g. path traversal is detected."""
 
 
 def write_encoded_data_to_file(encoded_data: bytes, file: str) -> None:
@@ -17,7 +26,7 @@ def write_encoded_data_to_file(encoded_data: bytes, file: str) -> None:
 
 
 def logs_base_path() -> str:
-    """Return the path to the logs directory."""
+    """Return the path to the logs' directory."""
     return subpath(config.SERVER_BASE_WORKING_DIRECTORY, "logs")
 
 
@@ -31,7 +40,7 @@ def ensure_base_directory_exists(directory: str) -> None:
 
 
 def models_base_path() -> str:
-    """Return the path to the models directory."""
+    """Return the path to the models' directory."""
     return subpath(config.SERVER_BASE_WORKING_DIRECTORY, "models")
 
 
@@ -48,13 +57,24 @@ def subpath(parent: str, child: str) -> str:
     """Return the path to the child directory of the parent directory.
 
     Ensures, that child doesn't navigate to parent directories. Prevents
-    path traversal.
+    path traversal. Raises an InvalidPathException if the path is invalid.
+
+    Based on Snyk's directory traversal mitigation:
+    https://learn.snyk.io/lesson/directory-traversal/
     """
-    path = os.path.abspath(os.path.join(parent, child))
-    if not path.startswith(os.path.abspath(parent)):
-        raise ValueError(f"Invalid path: {path}")
+    safe_path = os.path.abspath(os.path.join(parent, child))
+    parent = os.path.abspath(parent)
+
+    common_base = os.path.commonpath([parent, safe_path])
+    if common_base != parent:
+        raise InvalidPathException(f"Invalid path: {safe_path}")
+
+    if os.path.basename(safe_path) != child:
+        raise InvalidPathException(
+            f"Invalid path - path traversal detected: {safe_path}"
+        )
 
-    return path
+    return safe_path
 
 
 def get_logs_content(action_id: str) -> Optional[str]:
@@ -63,4 +83,5 @@ def get_logs_content(action_id: str) -> Optional[str]:
         with open(logs_path(action_id), "r") as file:
             return file.read()
     except FileNotFoundError:
+        structlogger.debug("model_service.logs.not_found", action_id=action_id)
         return None

rasa/model_service.py

@@ -13,6 +13,9 @@ from rasa.utils.common import configure_logging_and_warnings
 import rasa.utils.licensing
 from urllib.parse import urlparse
 
+from rasa.utils.log_utils import configure_structlog
+from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
+
 structlogger = structlog.get_logger()
 
 MODEL_SERVICE_PORT = 8000
@@ -63,12 +66,14 @@ def main() -> None:
     The API server can receive requests to train models, run bots, and manage
     the lifecycle of models and bots.
     """
+    log_level = logging.DEBUG
     configure_logging_and_warnings(
-        log_level=logging.DEBUG,
+        log_level=log_level,
         logging_config_file=None,
         warn_only_once=True,
         filter_repeated_logs=True,
     )
+    configure_structlog(log_level, include_time=True)
 
     rasa.utils.licensing.validate_license_from_env()
 
@@ -100,7 +105,9 @@ def main() -> None:
     # list all routes
     list_routes(app)
 
-    app.run(host="0.0.0.0", port=MODEL_SERVICE_PORT, legacy=True)
+    register_custom_sanic_error_handler(app)
+
+    app.run(host="0.0.0.0", port=MODEL_SERVICE_PORT, legacy=True, motd=False)
 
 
 if __name__ == "__main__":

rasa/model_training.py

@@ -322,6 +322,8 @@ 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_model_group_configuration_setup()
     rasa.engine.validation.validate_flow_component_dependencies(
         flows, model_configuration
     )

rasa/nlu/classifiers/diet_classifier.py

@@ -1,18 +1,17 @@
 from __future__ import annotations
+
 import copy
 import logging
 from collections import defaultdict
 from pathlib import Path
-
-from rasa.exceptions import ModelNotFound
-from rasa.nlu.featurizers.featurizer import Featurizer
+from typing import Any, Dict, List, Optional, Text, Tuple, Union, TypeVar, Type
 
 import numpy as np
 import scipy.sparse
 import tensorflow as tf
 
-from typing import Any, Dict, List, Optional, Text, Tuple, Union, TypeVar, Type
-
+from rasa.exceptions import ModelNotFound
+from rasa.nlu.featurizers.featurizer import Featurizer
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
@@ -20,18 +19,21 @@ 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 (
@@ -118,7 +120,6 @@ LABEL_SUB_KEY = IDS
 
 POSSIBLE_TAGS = [ENTITY_ATTRIBUTE_TYPE, ENTITY_ATTRIBUTE_ROLE, ENTITY_ATTRIBUTE_GROUP]
 
-
 DIETClassifierT = TypeVar("DIETClassifierT", bound="DIETClassifier")
 
 
@@ -1083,18 +1084,24 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
 
             self.model.save(str(tf_model_file))
 
-            io_utils.pickle_dump(
-                model_path / f"{file_name}.data_example.pkl", self._data_example
-            )
-            io_utils.pickle_dump(
-                model_path / f"{file_name}.sparse_feature_sizes.pkl",
-                self._sparse_feature_sizes,
+            # 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",
             )
-            io_utils.pickle_dump(
-                model_path / f"{file_name}.label_data.pkl",
+            # 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.json_pickle(
+
+            rasa.shared.utils.io.dump_obj_as_json_to_file(
+                model_path / f"{file_name}.sparse_feature_sizes.json",
+                self._sparse_feature_sizes,
+            )
+            rasa.shared.utils.io.dump_obj_as_json_to_file(
                 model_path / f"{file_name}.index_label_id_mapping.json",
                 self.index_label_id_mapping,
             )
@@ -1183,15 +1190,22 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
     ]:
         file_name = cls.__name__
 
-        data_example = io_utils.pickle_load(
-            model_path / f"{file_name}.data_example.pkl"
+        # 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"),
         )
-        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"
+        # 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"
         )
-        index_label_id_mapping = io_utils.json_unpickle(
+        index_label_id_mapping = rasa.shared.utils.io.read_json_file(
             model_path / f"{file_name}.index_label_id_mapping.json"
         )
         entity_tag_specs = rasa.shared.utils.io.read_json_file(
@@ -1211,7 +1225,6 @@ 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,22 +1,21 @@
 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.featurizers.featurizer import Featurizer
 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.nlu.featurizers.featurizer import Featurizer
 from rasa.shared.nlu.constants import TEXT, INTENT
+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 RANKING_LENGTH
 
 structlogger = structlog.get_logger()
@@ -184,9 +183,11 @@ 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}.joblib"
-            joblib.dump(self.clf, path)
+            path = model_dir / f"{self._resource.name}.skops"
+            sio.dump(self.clf, path)
             structlogger.debug(
                 "logistic_regression_classifier.persist",
                 event_info=f"Saved intent classifier to '{path}'.",
@@ -202,9 +203,21 @@ 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 = joblib.load(model_dir / f"{resource.name}.joblib")
+                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)
                 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.shared.constants import DOCS_URL_TRAINING_DATA_NLU
 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.shared.exceptions import RasaException
 from rasa.shared.nlu.constants import TEXT
-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.training_data.training_data import TrainingData
 from rasa.utils.tensorflow.constants import FEATURIZERS
 
 logger = logging.getLogger(__name__)
@@ -266,14 +266,20 @@ 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.pkl"
-            encoder_file_name = model_dir / f"{file_name}_encoder.pkl"
+            classifier_file_name = model_dir / f"{file_name}_classifier.skops"
+            encoder_file_name = model_dir / f"{file_name}_encoder.json"
 
             if self.clf and self.le:
-                io_utils.json_pickle(encoder_file_name, self.le.classes_)
-                io_utils.json_pickle(classifier_file_name, self.clf.best_estimator_)
+                # 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)
 
     @classmethod
     def load(
@@ -286,21 +292,36 @@ 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.pkl"
+                classifier_file = model_dir / f"{file_name}_classifier.skops"
 
                 if classifier_file.exists():
-                    classifier = io_utils.json_unpickle(classifier_file)
+                    unknown_types = sio.get_untrusted_types(file=classifier_file)
 
-                    encoder_file = model_dir / f"{file_name}_encoder.pkl"
-                    classes = io_utils.json_unpickle(encoder_file)
-                    encoder = LabelEncoder()
-                    encoder.classes_ = classes
+                    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)
 
-                    return cls(config, model_storage, resource, classifier, encoder)
+                    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
         except ValueError:
             logger.debug(
                 f"Failed to load '{cls.__name__}' from model storage. Resource "