rasa-pro 3.10.9.dev1__py3-none-any.whl → 3.10.10__py3-none-any.whl

rasa/constants.py

@@ -18,7 +18,7 @@ CONFIG_TELEMETRY_ID = "rasa_user_id"
 CONFIG_TELEMETRY_ENABLED = "enabled"
 CONFIG_TELEMETRY_DATE = "date"
 
-MINIMUM_COMPATIBLE_VERSION = "3.10.9.dev1"
+MINIMUM_COMPATIBLE_VERSION = "3.10.0rc1"
 
 GLOBAL_USER_CONFIG_PATH = os.path.expanduser("~/.config/rasa/global.yml")
 

rasa/core/featurizers/single_state_featurizer.py

@@ -1,8 +1,7 @@
 import logging
-from typing import List, Optional, Dict, Text, Set, Any
-
 import numpy as np
 import scipy.sparse
+from typing import List, Optional, Dict, Text, Set, Any
 
 from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
 from rasa.nlu.extractors.extractor import EntityTagSpec
@@ -361,26 +360,6 @@ class SingleStateFeaturizer:
             for action in domain.action_names_or_texts
         ]
 
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "action_texts": self.action_texts,
-            "entity_tag_specs": self.entity_tag_specs,
-            "feature_states": self._default_feature_states,
-        }
-
-    @classmethod
-    def create_from_dict(
-        cls, data: Dict[str, Any]
-    ) -> Optional["SingleStateFeaturizer"]:
-        if not data:
-            return None
-
-        featurizer = SingleStateFeaturizer()
-        featurizer.action_texts = data["action_texts"]
-        featurizer._default_feature_states = data["feature_states"]
-        featurizer.entity_tag_specs = data["entity_tag_specs"]
-        return featurizer
-
 
 class IntentTokenizerSingleStateFeaturizer(SingleStateFeaturizer):
     """A SingleStateFeaturizer for use with policies that predict intent labels."""

rasa/core/featurizers/tracker_featurizers.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
-
-import logging
-from abc import abstractmethod
-from collections import defaultdict
 from pathlib import Path
+from collections import defaultdict
+from abc import abstractmethod
+import jsonpickle
+import logging
+
+from tqdm import tqdm
 from typing import (
     Tuple,
     List,
@@ -16,30 +18,25 @@ from typing import (
     Set,
     DefaultDict,
     cast,
-    Type,
-    Callable,
-    ClassVar,
 )
-
 import numpy as np
-from tqdm import tqdm
 
+from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
+from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
+from rasa.core.exceptions import InvalidTrackerFeaturizerUsageError
 import rasa.shared.core.trackers
 import rasa.shared.utils.io
-from rasa.core.exceptions import InvalidTrackerFeaturizerUsageError
-from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
-from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
+from rasa.shared.nlu.constants import TEXT, INTENT, ENTITIES, ACTION_NAME
+from rasa.shared.nlu.training_data.features import Features
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.core.domain import State, Domain
+from rasa.shared.core.events import Event, ActionExecuted, UserUttered
 from rasa.shared.core.constants import (
     USER,
     ACTION_UNLIKELY_INTENT_NAME,
     PREVIOUS_ACTION,
 )
-from rasa.shared.core.domain import State, Domain
-from rasa.shared.core.events import Event, ActionExecuted, UserUttered
-from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
-from rasa.shared.nlu.constants import TEXT, INTENT, ENTITIES, ACTION_NAME
-from rasa.shared.nlu.training_data.features import Features
 from rasa.utils.tensorflow.constants import LABEL_PAD_ID
 from rasa.utils.tensorflow.model_data import ragged_array_to_ndarray
 
@@ -67,10 +64,6 @@ class InvalidStory(RasaException):
 class TrackerFeaturizer:
     """Base class for actual tracker featurizers."""
 
-    # Class registry to store all subclasses
-    _registry: ClassVar[Dict[str, Type["TrackerFeaturizer"]]] = {}
-    _featurizer_type: str = "TrackerFeaturizer"
-
     def __init__(
         self, state_featurizer: Optional[SingleStateFeaturizer] = None
     ) -> None:
@@ -81,36 +74,6 @@ class TrackerFeaturizer:
         """
         self.state_featurizer = state_featurizer
 
-    @classmethod
-    def register(cls, featurizer_type: str) -> Callable:
-        """Decorator to register featurizer subclasses."""
-
-        def wrapper(subclass: Type["TrackerFeaturizer"]) -> Type["TrackerFeaturizer"]:
-            cls._registry[featurizer_type] = subclass
-            # Store the type identifier in the class for serialization
-            subclass._featurizer_type = featurizer_type
-            return subclass
-
-        return wrapper
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "TrackerFeaturizer":
-        """Create featurizer instance from dictionary."""
-        featurizer_type = data.pop("type")
-
-        if featurizer_type not in cls._registry:
-            raise ValueError(f"Unknown featurizer type: {featurizer_type}")
-
-        # Get the correct subclass and instantiate it
-        subclass = cls._registry[featurizer_type]
-        return subclass.create_from_dict(data)
-
-    @classmethod
-    @abstractmethod
-    def create_from_dict(cls, data: Dict[str, Any]) -> "TrackerFeaturizer":
-        """Each subclass must implement its own creation from dict method."""
-        pass
-
     @staticmethod
     def _create_states(
         tracker: DialogueStateTracker,
@@ -502,7 +465,9 @@ class TrackerFeaturizer:
             self.state_featurizer.entity_tag_specs = []
 
         # noinspection PyTypeChecker
-        rasa.shared.utils.io.dump_obj_as_json_to_file(featurizer_file, self.to_dict())
+        rasa.shared.utils.io.write_text_file(
+            str(jsonpickle.encode(self)), featurizer_file
+        )
 
     @staticmethod
     def load(path: Union[Text, Path]) -> Optional[TrackerFeaturizer]:
@@ -516,17 +481,7 @@ class TrackerFeaturizer:
         """
         featurizer_file = Path(path) / FEATURIZER_FILE
         if featurizer_file.is_file():
-            data = rasa.shared.utils.io.read_json_file(featurizer_file)
-
-            if "type" not in data:
-                logger.error(
-                    f"Couldn't load featurizer for policy. "
-                    f"File '{featurizer_file}' does not contain all "
-                    f"necessary information. 'type' is missing."
-                )
-                return None
-
-            return TrackerFeaturizer.from_dict(data)
+            return jsonpickle.decode(rasa.shared.utils.io.read_file(featurizer_file))
 
         logger.error(
             f"Couldn't load featurizer for policy. "
@@ -553,16 +508,7 @@ class TrackerFeaturizer:
             )
         ]
 
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "type": self.__class__._featurizer_type,
-            "state_featurizer": (
-                self.state_featurizer.to_dict() if self.state_featurizer else None
-            ),
-        }
-
 
-@TrackerFeaturizer.register("FullDialogueTrackerFeaturizer")
 class FullDialogueTrackerFeaturizer(TrackerFeaturizer):
     """Creates full dialogue training data for time distributed architectures.
 
@@ -700,20 +646,7 @@ class FullDialogueTrackerFeaturizer(TrackerFeaturizer):
 
         return trackers_as_states
 
-    def to_dict(self) -> Dict[str, Any]:
-        return super().to_dict()
 
-    @classmethod
-    def create_from_dict(cls, data: Dict[str, Any]) -> "FullDialogueTrackerFeaturizer":
-        state_featurizer = SingleStateFeaturizer.create_from_dict(
-            data["state_featurizer"]
-        )
-        return cls(
-            state_featurizer,
-        )
-
-
-@TrackerFeaturizer.register("MaxHistoryTrackerFeaturizer")
 class MaxHistoryTrackerFeaturizer(TrackerFeaturizer):
     """Truncates the tracker history into `max_history` long sequences.
 
@@ -951,25 +884,7 @@ class MaxHistoryTrackerFeaturizer(TrackerFeaturizer):
 
         return trackers_as_states
 
-    def to_dict(self) -> Dict[str, Any]:
-        data = super().to_dict()
-        data.update(
-            {
-                "remove_duplicates": self.remove_duplicates,
-                "max_history": self.max_history,
-            }
-        )
-        return data
-
-    @classmethod
-    def create_from_dict(cls, data: Dict[str, Any]) -> "MaxHistoryTrackerFeaturizer":
-        state_featurizer = SingleStateFeaturizer.create_from_dict(
-            data["state_featurizer"]
-        )
-        return cls(state_featurizer, data["max_history"], data["remove_duplicates"])
 
-
-@TrackerFeaturizer.register("IntentMaxHistoryTrackerFeaturizer")
 class IntentMaxHistoryTrackerFeaturizer(MaxHistoryTrackerFeaturizer):
     """Truncates the tracker history into `max_history` long sequences.
 
@@ -1244,18 +1159,6 @@ class IntentMaxHistoryTrackerFeaturizer(MaxHistoryTrackerFeaturizer):
 
         return trackers_as_states
 
-    def to_dict(self) -> Dict[str, Any]:
-        return super().to_dict()
-
-    @classmethod
-    def create_from_dict(
-        cls, data: Dict[str, Any]
-    ) -> "IntentMaxHistoryTrackerFeaturizer":
-        state_featurizer = SingleStateFeaturizer.create_from_dict(
-            data["state_featurizer"]
-        )
-        return cls(state_featurizer, data["max_history"], data["remove_duplicates"])
-
 
 def _is_prev_action_unlikely_intent_in_state(state: State) -> bool:
     prev_action_name = state.get(PREVIOUS_ACTION, {}).get(ACTION_NAME)

rasa/core/policies/ted_policy.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
-
 import logging
+
+from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from pathlib import Path
 from collections import defaultdict
 import contextlib
-from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
 import numpy as np
 import tensorflow as tf
+from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
-from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
@@ -49,22 +49,18 @@ from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.events import EntitiesAdded, Event
 from rasa.shared.core.domain import Domain
 from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.nlu.training_data.features import (
-    Features,
-    save_features,
-    load_features,
-)
+from rasa.shared.nlu.training_data.features import Features
 import rasa.shared.utils.io
 import rasa.utils.io
 from rasa.utils import train_utils
-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 import rasa_layers
-from rasa.utils.tensorflow.model_data import RasaModelData, FeatureSignature, Data
+from rasa.utils.tensorflow.model_data import (
+    RasaModelData,
+    FeatureSignature,
+    FeatureArray,
+    Data,
+)
 from rasa.utils.tensorflow.model_data_utils import convert_to_data_format
 from rasa.utils.tensorflow.constants import (
     LABEL,
@@ -965,32 +961,22 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted
         """
         model_filename = self._metadata_filename()
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.priority.json", self.priority
-        )
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.meta.json", self.config
+        rasa.utils.io.json_pickle(
+            model_path / f"{model_filename}.priority.pkl", self.priority
         )
-        # save data example
-        serialize_nested_feature_arrays(
-            self.data_example,
-            str(model_path / f"{model_filename}.data_example.st"),
-            str(model_path / f"{model_filename}.data_example_metadata.json"),
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.meta.pkl", self.config
         )
-        # save label data
-        serialize_nested_feature_arrays(
-            dict(self._label_data.data) if self._label_data is not None else {},
-            str(model_path / f"{model_filename}.label_data.st"),
-            str(model_path / f"{model_filename}.label_data_metadata.json"),
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.data_example.pkl", self.data_example
         )
-        # save fake features
-        metadata = save_features(
-            self.fake_features, str(model_path / f"{model_filename}.fake_features.st")
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.fake_features.pkl", self.fake_features
         )
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.fake_features_metadata.json", metadata
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.label_data.pkl",
+            dict(self._label_data.data) if self._label_data is not None else {},
         )
-
         entity_tag_specs = (
             [tag_spec._asdict() for tag_spec in self._entity_tag_specs]
             if self._entity_tag_specs
@@ -1008,29 +994,18 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted.
         """
         tf_model_file = model_path / f"{cls._metadata_filename()}.tf_model"
-
-        # load data example
-        loaded_data = deserialize_nested_feature_arrays(
-            str(model_path / f"{cls._metadata_filename()}.data_example.st"),
-            str(model_path / f"{cls._metadata_filename()}.data_example_metadata.json"),
+        loaded_data = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.data_example.pkl"
         )
-        # load label data
-        loaded_label_data = deserialize_nested_feature_arrays(
-            str(model_path / f"{cls._metadata_filename()}.label_data.st"),
-            str(model_path / f"{cls._metadata_filename()}.label_data_metadata.json"),
+        label_data = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.label_data.pkl"
         )
-        label_data = RasaModelData(data=loaded_label_data)
-
-        # load fake features
-        metadata = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.fake_features_metadata.json"
+        fake_features = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.fake_features.pkl"
         )
-        fake_features = load_features(
-            str(model_path / f"{cls._metadata_filename()}.fake_features.st"), metadata
-        )
-
-        priority = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.priority.json"
+        label_data = RasaModelData(data=label_data)
+        priority = rasa.utils.io.json_unpickle(
+            model_path / f"{cls._metadata_filename()}.priority.pkl"
         )
         entity_tag_specs = rasa.shared.utils.io.read_json_file(
             model_path / f"{cls._metadata_filename()}.entity_tag_specs.json"
@@ -1048,8 +1023,8 @@ class TEDPolicy(Policy):
             )
             for tag_spec in entity_tag_specs
         ]
-        model_config = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.meta.json"
+        model_config = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.meta.pkl"
         )
 
         return {
@@ -1095,7 +1070,7 @@ class TEDPolicy(Policy):
     ) -> TEDPolicy:
         featurizer = TrackerFeaturizer.load(model_path)
 
-        if not (model_path / f"{cls._metadata_filename()}.data_example.st").is_file():
+        if not (model_path / f"{cls._metadata_filename()}.data_example.pkl").is_file():
             return cls(
                 config,
                 model_storage,

rasa/core/policies/unexpected_intent_policy.py

@@ -5,7 +5,6 @@ from typing import Any, List, Optional, Text, Dict, Type, Union
 
 import numpy as np
 import tensorflow as tf
-
 import rasa.utils.common
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
@@ -17,7 +16,6 @@ from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.constants import SLOTS, ACTIVE_LOOP, ACTION_UNLIKELY_INTENT_NAME
 from rasa.shared.core.events import UserUttered, ActionExecuted
-import rasa.shared.utils.io
 from rasa.shared.nlu.constants import (
     INTENT,
     TEXT,
@@ -105,6 +103,8 @@ from rasa.utils.tensorflow.constants import (
 )
 from rasa.utils.tensorflow import layers
 from rasa.utils.tensorflow.model_data import RasaModelData, FeatureArray, Data
+
+import rasa.utils.io as io_utils
 from rasa.core.exceptions import RasaCoreException
 from rasa.shared.utils import common
 
@@ -881,12 +881,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted
         """
         super().persist_model_utilities(model_path)
-
-        from safetensors.numpy import save_file
-
-        save_file(
-            {str(k): np.array(v) for k, v in self.label_quantiles.items()},
-            model_path / f"{self._metadata_filename()}.label_quantiles.st",
+        io_utils.pickle_dump(
+            model_path / f"{self._metadata_filename()}.label_quantiles.pkl",
+            self.label_quantiles,
         )
 
     @classmethod
@@ -897,14 +894,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted.
         """
         model_utilties = super()._load_model_utilities(model_path)
-
-        from safetensors.numpy import load_file
-
-        loaded_label_quantiles = load_file(
-            model_path / f"{cls._metadata_filename()}.label_quantiles.st"
+        label_quantiles = io_utils.pickle_load(
+            model_path / f"{cls._metadata_filename()}.label_quantiles.pkl"
         )
-        label_quantiles = {int(k): list(v) for k, v in loaded_label_quantiles.items()}
-
         model_utilties.update({"label_quantiles": label_quantiles})
         return model_utilties
 

rasa/e2e_test/e2e_test_runner.py

@@ -1155,6 +1155,8 @@ class E2ETestRunner:
                     flow_paths_stack
                     and self.agent.domain
                     and self.agent.domain.is_custom_action(event.action_name)
+                    and STEP_ID_METADATA_KEY in event.metadata
+                    and ACTIVE_FLOW_METADATA_KEY in event.metadata
                 ):
                     flow_paths_stack[-1].nodes.append(self._create_path_node(event))
 

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
                 )