rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/nlu/classifiers/fallback_classifier.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+import copy
+import logging
+from typing import Any, List, Text, Dict, Type, Union, Tuple, Optional
+
+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 DEFAULT_NLU_FALLBACK_INTENT_NAME
+from rasa.core.constants import (
+    DEFAULT_NLU_FALLBACK_THRESHOLD,
+    DEFAULT_NLU_FALLBACK_AMBIGUITY_THRESHOLD,
+)
+from rasa.nlu.classifiers.classifier import IntentClassifier
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.constants import (
+    INTENT,
+    INTENT_NAME_KEY,
+    INTENT_RANKING_KEY,
+    PREDICTED_CONFIDENCE_KEY,
+)
+
+THRESHOLD_KEY = "threshold"
+AMBIGUITY_THRESHOLD_KEY = "ambiguity_threshold"
+
+logger = logging.getLogger(__name__)
+
+
+@DefaultV1Recipe.register(
+    DefaultV1Recipe.ComponentType.INTENT_CLASSIFIER, is_trainable=False
+)
+class FallbackClassifier(GraphComponent, IntentClassifier):
+    """Handles incoming messages with low NLU confidence."""
+
+    @classmethod
+    def required_components(cls) -> List[Type]:
+        """Components that should be included in the pipeline before this component."""
+        return [IntentClassifier]
+
+    @staticmethod
+    def get_default_config() -> Dict[Text, Any]:
+        """The component's default config (see parent class for full docstring)."""
+        # please make sure to update the docs when changing a default parameter
+        return {
+            # If all intent confidence scores are beyond this threshold, set the current
+            # intent to `FALLBACK_INTENT_NAME`
+            THRESHOLD_KEY: DEFAULT_NLU_FALLBACK_THRESHOLD,
+            # If the confidence scores for the top two intent predictions are closer
+            # than `AMBIGUITY_THRESHOLD_KEY`,
+            # then `FALLBACK_INTENT_NAME` is predicted.
+            AMBIGUITY_THRESHOLD_KEY: DEFAULT_NLU_FALLBACK_AMBIGUITY_THRESHOLD,
+        }
+
+    def __init__(self, config: Dict[Text, Any]) -> None:
+        """Constructs a new fallback classifier."""
+        self.component_config = config
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> FallbackClassifier:
+        """Creates a new component (see parent class for full docstring)."""
+        return cls(config)
+
+    def process(self, messages: List[Message]) -> List[Message]:
+        """Process a list of incoming messages.
+
+        This is the component's chance to process incoming
+        messages. The component can rely on
+        any context attribute to be present, that gets created
+        by a call to :meth:`rasa.nlu.components.Component.create`
+        of ANY component and
+        on any context attributes created by a call to
+        :meth:`rasa.nlu.components.Component.process`
+        of components previous to this one.
+
+        Args:
+            messages: List containing :class:
+            `rasa.shared.nlu.training_data.message.Message` to process.
+        """
+        for message in messages:
+            if not self._should_fallback(message):
+                continue
+
+            # we assume that the fallback confidence
+            # is the same as the fallback threshold
+            confidence = self.component_config[THRESHOLD_KEY]
+            message.data[INTENT] = _fallback_intent(confidence)
+            message.data.setdefault(INTENT_RANKING_KEY, [])
+            message.data[INTENT_RANKING_KEY].insert(0, _fallback_intent(confidence))
+
+        return messages
+
+    def _should_fallback(self, message: Message) -> bool:
+        """Check if the fallback intent should be predicted.
+
+        Args:
+            message: The current message and its intent predictions.
+
+        Returns:
+            `True` if the fallback intent should be predicted.
+        """
+        intent_name = message.data[INTENT].get(INTENT_NAME_KEY)
+        below_threshold, nlu_confidence = self._nlu_confidence_below_threshold(message)
+
+        if below_threshold:
+            logger.debug(
+                f"NLU confidence {nlu_confidence} for intent '{intent_name}' is lower "
+                f"than NLU threshold {self.component_config[THRESHOLD_KEY]:.2f}."
+            )
+            return True
+
+        ambiguous_prediction, confidence_delta = self._nlu_prediction_ambiguous(message)
+        if ambiguous_prediction:
+            logger.debug(
+                f"The difference in NLU confidences "
+                f"for the top two intents ({confidence_delta}) is lower than "
+                f"the ambiguity threshold "
+                f"{self.component_config[AMBIGUITY_THRESHOLD_KEY]:.2f}. Predicting "
+                f"intent '{DEFAULT_NLU_FALLBACK_INTENT_NAME}' instead of "
+                f"'{intent_name}'."
+            )
+            return True
+
+        return False
+
+    def _nlu_confidence_below_threshold(self, message: Message) -> Tuple[bool, float]:
+        nlu_confidence = message.data[INTENT].get(PREDICTED_CONFIDENCE_KEY)
+        return nlu_confidence < self.component_config[THRESHOLD_KEY], nlu_confidence
+
+    def _nlu_prediction_ambiguous(
+        self, message: Message
+    ) -> Tuple[bool, Optional[float]]:
+        intents = message.data.get(INTENT_RANKING_KEY, [])
+        if len(intents) >= 2:
+            first_confidence = intents[0].get(PREDICTED_CONFIDENCE_KEY, 1.0)
+            second_confidence = intents[1].get(PREDICTED_CONFIDENCE_KEY, 1.0)
+            difference = first_confidence - second_confidence
+            return (
+                difference < self.component_config[AMBIGUITY_THRESHOLD_KEY],
+                difference,
+            )
+        return False, None
+
+
+def _fallback_intent(confidence: float) -> Dict[Text, Union[Text, float]]:
+    return {
+        INTENT_NAME_KEY: DEFAULT_NLU_FALLBACK_INTENT_NAME,
+        PREDICTED_CONFIDENCE_KEY: confidence,
+    }
+
+
+def is_fallback_classifier_prediction(prediction: Dict[Text, Any]) -> bool:
+    """Checks if the intent was predicted by the `FallbackClassifier`.
+
+    Args:
+        prediction: The prediction of the NLU model.
+
+    Returns:
+        `True` if the top classified intent was the fallback intent.
+    """
+    return (
+        prediction.get(INTENT, {}).get(INTENT_NAME_KEY)
+        == DEFAULT_NLU_FALLBACK_INTENT_NAME
+    )
+
+
+def undo_fallback_prediction(prediction: Dict[Text, Any]) -> Dict[Text, Any]:
+    """Undo the prediction of the fallback intent.
+
+    Args:
+        prediction: The prediction of the NLU model.
+
+    Returns:
+        The prediction as if the `FallbackClassifier` wasn't present in the pipeline.
+        If the fallback intent is the only intent, return the prediction as it was
+        provided.
+    """
+    intent_ranking = prediction.get(INTENT_RANKING_KEY, [])
+    if len(intent_ranking) < 2:
+        return prediction
+
+    prediction = copy.deepcopy(prediction)
+    prediction[INTENT] = intent_ranking[1]
+    prediction[INTENT_RANKING_KEY] = prediction[INTENT_RANKING_KEY][1:]
+
+    return prediction

rasa/nlu/classifiers/keyword_intent_classifier.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+import logging
+import re
+from typing import Any, Dict, Optional, Text, List
+
+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_COMPONENTS
+from rasa.nlu.classifiers.classifier import IntentClassifier
+from rasa.shared.nlu.constants import (
+    INTENT,
+    TEXT,
+    INTENT_NAME_KEY,
+    PREDICTED_CONFIDENCE_KEY,
+)
+import rasa.shared.utils.io
+from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.nlu.training_data.message import Message
+
+logger = logging.getLogger(__name__)
+
+
+@DefaultV1Recipe.register(
+    DefaultV1Recipe.ComponentType.INTENT_CLASSIFIER, is_trainable=True
+)
+class KeywordIntentClassifier(GraphComponent, IntentClassifier):
+    """Intent classifier using simple keyword matching.
+
+    The classifier takes a list of keywords and associated intents as an input.
+    An input sentence is checked for the keywords and the intent is returned.
+    """
+
+    @staticmethod
+    def get_default_config() -> Dict[Text, Any]:
+        """The component's default config (see parent class for full docstring)."""
+        return {"case_sensitive": True}
+
+    def __init__(
+        self,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        intent_keyword_map: Optional[Dict] = None,
+    ) -> None:
+        """Creates classifier."""
+        self.component_config = config
+        self._model_storage = model_storage
+        self._resource = resource
+        self._execution_context = execution_context
+
+        self.case_sensitive = self.component_config.get("case_sensitive")
+        self.intent_keyword_map = intent_keyword_map or {}
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> KeywordIntentClassifier:
+        """Creates a new untrained component (see parent class for full docstring)."""
+        return cls(config, model_storage, resource, execution_context)
+
+    def train(self, training_data: TrainingData) -> Resource:
+        """Trains the intent classifier on a data set."""
+        duplicate_examples = set()
+        for ex in training_data.intent_examples:
+            if (
+                ex.get(TEXT) in self.intent_keyword_map.keys()
+                and ex.get(INTENT) != self.intent_keyword_map[ex.get(TEXT)]
+            ):
+                duplicate_examples.add(ex.get(TEXT))
+                rasa.shared.utils.io.raise_warning(
+                    f"Keyword '{ex.get(TEXT)}' is a keyword to trigger intent "
+                    f"'{self.intent_keyword_map[ex.get(TEXT)]}' and also "
+                    f"intent '{ex.get(INTENT)}', it will be removed "
+                    f"from the list of keywords for both of them. "
+                    f"Remove (one of) the duplicates from the training data.",
+                    docs=DOCS_URL_COMPONENTS + "#keyword-intent-classifier",
+                )
+            else:
+                self.intent_keyword_map[ex.get(TEXT)] = ex.get(INTENT)
+        for keyword in duplicate_examples:
+            self.intent_keyword_map.pop(keyword)
+            logger.debug(
+                f"Removed '{keyword}' from the list of keywords because it was "
+                "a keyword for more than one intent."
+            )
+
+        self._validate_keyword_map()
+        self.persist()
+        return self._resource
+
+    def _validate_keyword_map(self) -> None:
+        re_flag = 0 if self.case_sensitive else re.IGNORECASE
+
+        ambiguous_mappings = []
+        for keyword1, intent1 in self.intent_keyword_map.items():
+            for keyword2, intent2 in self.intent_keyword_map.items():
+                if (
+                    re.search(r"\b" + keyword1 + r"\b", keyword2, flags=re_flag)
+                    and intent1 != intent2
+                ):
+                    ambiguous_mappings.append((intent1, keyword1))
+                    rasa.shared.utils.io.raise_warning(
+                        f"Keyword '{keyword1}' is a keyword of intent '{intent1}', "
+                        f"but also a substring of '{keyword2}', which is a "
+                        f"keyword of intent '{intent2}."
+                        f" '{keyword1}' will be removed from the list of keywords.\n"
+                        f"Remove (one of) the conflicting keywords from the"
+                        f" training data.",
+                        docs=DOCS_URL_COMPONENTS + "#keyword-intent-classifier",
+                    )
+        for intent, keyword in ambiguous_mappings:
+            self.intent_keyword_map.pop(keyword)
+            logger.debug(
+                f"Removed keyword '{keyword}' from intent "
+                f"'{intent}' because it matched a "
+                f"keyword of another intent."
+            )
+
+    def process(self, messages: List[Message]) -> List[Message]:
+        """Sets the message intent and add it to the output if it exists."""
+        for message in messages:
+            intent_name = self._map_keyword_to_intent(message.get(TEXT))
+
+            confidence = 0.0 if intent_name is None else 1.0
+            intent = {
+                INTENT_NAME_KEY: intent_name,
+                PREDICTED_CONFIDENCE_KEY: confidence,
+            }
+
+            if message.get(INTENT) is None or intent_name is not None:
+                message.set(INTENT, intent, add_to_output=True)
+
+        return messages
+
+    def _map_keyword_to_intent(self, text: Text) -> Optional[Text]:
+        re_flag = 0 if self.case_sensitive else re.IGNORECASE
+
+        for keyword, intent in self.intent_keyword_map.items():
+            if re.search(r"\b" + keyword + r"\b", text, flags=re_flag):
+                logger.debug(
+                    f"KeywordClassifier matched keyword '{keyword}' to"
+                    f" intent '{intent}'."
+                )
+                return intent
+
+        logger.debug("KeywordClassifier did not find any keywords in the message.")
+        return None
+
+    def persist(self) -> None:
+        """Persist this model into the passed directory."""
+        with self._model_storage.write_to(self._resource) as model_dir:
+            file_name = f"{self.__class__.__name__}.json"
+            keyword_file = model_dir / file_name
+            rasa.shared.utils.io.dump_obj_as_json_to_file(
+                keyword_file, self.intent_keyword_map
+            )
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        **kwargs: Any,
+    ) -> KeywordIntentClassifier:
+        """Loads trained component (see parent class for full docstring)."""
+        try:
+            with model_storage.read_from(resource) as model_dir:
+                keyword_file = model_dir / f"{cls.__name__}.json"
+                intent_keyword_map = rasa.shared.utils.io.read_json_file(keyword_file)
+        except ValueError:
+            logger.warning(
+                f"Failed to load {cls.__class__.__name__} from model storage. Resource "
+                f"'{resource.name}' doesn't exist."
+            )
+            intent_keyword_map = None
+
+        return cls(
+            config, model_storage, resource, execution_context, intent_keyword_map
+        )

rasa/nlu/classifiers/logistic_regression_classifier.py

@@ -0,0 +1,253 @@
+from typing import Any, Text, Dict, List, Type, Tuple
+
+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.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.shared.nlu.training_data.training_data import TrainingData
+from rasa.utils.tensorflow.constants import RANKING_LENGTH
+
+structlogger = structlog.get_logger()
+
+
+@DefaultV1Recipe.register(
+    DefaultV1Recipe.ComponentType.INTENT_CLASSIFIER, is_trainable=True
+)
+class LogisticRegressionClassifier(IntentClassifier, GraphComponent):
+    """Intent classifier using the Logistic Regression."""
+
+    @classmethod
+    def required_components(cls) -> List[Type]:
+        """Components that should be included in the pipeline before this component."""
+        return [Featurizer]
+
+    @staticmethod
+    def required_packages() -> List[Text]:
+        """Any extra python dependencies required for this component to run."""
+        return ["sklearn"]
+
+    @staticmethod
+    def get_default_config() -> Dict[Text, Any]:
+        """The component's default config (see parent class for full docstring)."""
+        return {
+            "max_iter": 100,
+            "solver": "lbfgs",
+            "tol": 1e-4,
+            "random_state": 42,
+            RANKING_LENGTH: LABEL_RANKING_LENGTH,
+        }
+
+    def __init__(
+        self,
+        config: Dict[Text, Any],
+        name: Text,
+        model_storage: ModelStorage,
+        resource: Resource,
+    ) -> None:
+        """Construct a new classifier."""
+        self.name = name
+        self.config = {**self.get_default_config(), **config}
+        self.clf = LogisticRegression(
+            solver=self.config["solver"],
+            max_iter=self.config["max_iter"],
+            class_weight="balanced",
+            tol=self.config["tol"],
+            random_state=self.config["random_state"],
+            # Added these parameters to ensure sklearn changes won't affect us.
+            # Should a sklearn update the defaults, we won't be affected.
+            dual=False,
+            fit_intercept=True,
+            intercept_scaling=1,
+            multi_class="auto",
+            verbose=0,
+            warm_start=False,
+            n_jobs=None,
+            l1_ratio=None,
+        )
+
+        # We need to use these later when saving the trained component.
+        self._model_storage = model_storage
+        self._resource = resource
+
+    def _create_X(self, messages: List[Message]) -> csr_matrix:
+        """This method creates a sparse X array that can be used for predicting."""
+        X = []
+        for e in messages:
+            # First element is sequence features, second is sentence features
+            sparse_feats = e.get_sparse_features(attribute=TEXT)[1]
+            # First element is sequence features, second is sentence features
+            dense_feats = e.get_dense_features(attribute=TEXT)[1]
+            together = hstack(
+                [
+                    csr_matrix(sparse_feats.features if sparse_feats else []),
+                    csr_matrix(dense_feats.features if dense_feats else []),
+                ]
+            )
+            X.append(together)
+        return vstack(X)
+
+    def _create_training_matrix(
+        self, training_data: TrainingData
+    ) -> Tuple[csr_matrix, List[str]]:
+        """This method creates a scikit-learn compatible (X, y) training pairs."""
+        y = []
+
+        examples = [
+            e
+            for e in training_data.intent_examples
+            if (e.get("intent") and e.get("text"))
+        ]
+
+        for e in examples:
+            y.append(e.get(INTENT))
+
+        return self._create_X(examples), y
+
+    def train(self, training_data: TrainingData) -> Resource:
+        """Train the intent classifier on a data set."""
+        if not training_data.intent_examples:
+            structlogger.warning(
+                "logistic_regression_classifier.not_able_to_train",
+                event_info=(
+                    f"Cannot train '{self.__class__.__name__}'. No data was provided. "
+                    f"Skipping training of the classifier."
+                ),
+            )
+            return self._resource
+
+        X, y = self._create_training_matrix(training_data)
+        if X.shape[0] == 0:
+            structlogger.debug(
+                "logistic_regression_classifier.not_able_to_train",
+                event_info=(
+                    f"Cannot train '{self.__class__.__name__}'. No data was provided. "
+                    f"Skipping training of the classifier."
+                ),
+            )
+            return self._resource
+
+        self.clf.fit(X, y)
+        self.persist()
+
+        return self._resource
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> "LogisticRegressionClassifier":
+        """Creates a new untrained component (see parent class for full docstring)."""
+        return cls(config, execution_context.node_name, model_storage, resource)
+
+    def process(self, messages: List[Message]) -> List[Message]:
+        """Return the most likely intent and its probability for a message."""
+        # Check if the classifier is trained
+        if not self.is_trained():
+            structlogger.warning(
+                "logistic_regression_classifier.not_trained.skip_intent_prediction",
+                event_info=(
+                    f"The '{self.__class__.__name__}' is not trained. "
+                    f"Skipping intent prediction."
+                ),
+            )
+            return messages
+
+        X = self._create_X(messages)
+        probas = self.clf.predict_proba(X)
+        for idx, message in enumerate(messages):
+            intents = self.clf.classes_
+            intent_ranking = [
+                {"name": k, "confidence": v} for k, v in zip(intents, probas[idx])
+            ]
+            sorted_ranking = sorted(intent_ranking, key=lambda e: -e["confidence"])
+            intent = sorted_ranking[0]
+            if self.config[RANKING_LENGTH] > 0:
+                sorted_ranking = sorted_ranking[: self.config[RANKING_LENGTH]]
+            message.set("intent", intent, add_to_output=True)
+            message.set("intent_ranking", sorted_ranking, add_to_output=True)
+        return messages
+
+    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)
+            structlogger.debug(
+                "logistic_regression_classifier.persist",
+                event_info=f"Saved intent classifier to '{path}'.",
+            )
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        **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)
+                component = cls(
+                    config, execution_context.node_name, model_storage, resource
+                )
+                component.clf = classifier
+                return component
+        except ValueError:
+            structlogger.debug(
+                "logistic_regression_classifier.load",
+                event_info=(
+                    f"Failed to load {cls.__class__.__name__} from model storage. "
+                    f"Resource '{resource.name}' doesn't exist."
+                ),
+            )
+            return cls.create(config, model_storage, resource, execution_context)
+
+    def process_training_data(self, training_data: TrainingData) -> TrainingData:
+        """Process the training data."""
+        self.process(training_data.training_examples)
+        return training_data
+
+    @classmethod
+    def validate_config(cls, config: Dict[Text, Any]) -> None:
+        """Validates that the component is configured properly."""
+        pass
+
+    def is_trained(self) -> bool:
+        """Checks if the model has been trained."""
+        try:
+            # This will raise a NotFittedError if the classifier isn't fitted
+            check_is_fitted(self.clf)
+            return True
+        except NotFittedError:
+            return False