rasa-pro 3.9.18__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
+        )