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

rasa/nlu/featurizers/dense_featurizer/mitie_featurizer.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+import numpy as np
+import logging
+import typing
+from typing import Any, List, Text, Dict, Tuple, Type
+
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.recipes.default_recipe import DefaultV1Recipe
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.nlu.featurizers.dense_featurizer.dense_featurizer import DenseFeaturizer
+from rasa.nlu.tokenizers.tokenizer import Token, Tokenizer
+from rasa.nlu.constants import (
+    DENSE_FEATURIZABLE_ATTRIBUTES,
+    FEATURIZER_CLASS_ALIAS,
+    TOKENS_NAMES,
+)
+from rasa.nlu.utils.mitie_utils import MitieModel, MitieNLP
+from rasa.utils.tensorflow.constants import MEAN_POOLING, POOLING
+from rasa.shared.nlu.training_data.features import Features
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.constants import FEATURE_TYPE_SENTENCE, FEATURE_TYPE_SEQUENCE
+from rasa.shared.nlu.training_data.training_data import TrainingData
+
+if typing.TYPE_CHECKING:
+    import mitie
+
+logger = logging.getLogger(__name__)
+
+
+@DefaultV1Recipe.register(
+    DefaultV1Recipe.ComponentType.MESSAGE_FEATURIZER,
+    is_trainable=False,
+    model_from="MitieNLP",
+)
+class MitieFeaturizer(DenseFeaturizer, GraphComponent):
+    """A class that featurizes using Mitie."""
+
+    @classmethod
+    def required_components(cls) -> List[Type]:
+        """Components that should be included in the pipeline before this component."""
+        return [MitieNLP, Tokenizer]
+
+    @staticmethod
+    def get_default_config() -> Dict[Text, Any]:
+        """Returns the component's default config."""
+        return {
+            **DenseFeaturizer.get_default_config(),
+            # Specify what pooling operation should be used to calculate the vector of
+            # the complete utterance. Available options: 'mean' and 'max'
+            POOLING: MEAN_POOLING,
+        }
+
+    @staticmethod
+    def required_packages() -> List[Text]:
+        """Any extra python dependencies required for this component to run."""
+        return ["mitie", "numpy"]
+
+    def __init__(
+        self, config: Dict[Text, Any], execution_context: ExecutionContext
+    ) -> None:
+        """Instantiates a new `MitieFeaturizer` instance."""
+        super().__init__(execution_context.node_name, config)
+        self.pooling_operation = self._config[POOLING]
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> MitieFeaturizer:
+        """Creates a new untrained component (see parent class for full docstring)."""
+        return cls(config, execution_context)
+
+    @classmethod
+    def validate_config(cls, config: Dict[Text, Any]) -> None:
+        """Validates that the component is configured properly."""
+        pass
+
+    def ndim(self, feature_extractor: "mitie.total_word_feature_extractor") -> int:
+        """Returns the number of dimensions."""
+        return feature_extractor.num_dimensions
+
+    def process(self, messages: List[Message], model: MitieModel) -> List[Message]:
+        """Featurizes all given messages in-place.
+
+        Returns:
+          The given list of messages which have been modified in-place.
+        """
+        for message in messages:
+            self._process_message(message, model)
+        return messages
+
+    def process_training_data(
+        self, training_data: TrainingData, model: MitieModel
+    ) -> TrainingData:
+        """Processes the training examples in the given training data in-place.
+
+        Args:
+          training_data: Training data.
+          model: A Mitie model.
+
+        Returns:
+          Same training data after processing.
+        """
+        self.process(training_data.training_examples, model)
+        return training_data
+
+    def _process_message(self, message: Message, model: MitieModel) -> None:
+        """Processes a message."""
+        for attribute in DENSE_FEATURIZABLE_ATTRIBUTES:
+            self._process_training_example(
+                message, attribute, model.word_feature_extractor
+            )
+
+    def _process_training_example(
+        self,
+        example: Message,
+        attribute: Text,
+        mitie_feature_extractor: "mitie.total_word_feature_extractor",
+    ) -> None:
+        tokens = example.get(TOKENS_NAMES[attribute])
+
+        if tokens:
+            sequence_features, sentence_features = self.features_for_tokens(
+                tokens, mitie_feature_extractor
+            )
+
+            self._set_features(example, sequence_features, sentence_features, attribute)
+
+    def _set_features(
+        self,
+        message: Message,
+        sequence_features: np.ndarray,
+        sentence_features: np.ndarray,
+        attribute: Text,
+    ) -> None:
+        final_sequence_features = Features(
+            sequence_features,
+            FEATURE_TYPE_SEQUENCE,
+            attribute,
+            self._config[FEATURIZER_CLASS_ALIAS],
+        )
+        message.add_features(final_sequence_features)
+
+        final_sentence_features = Features(
+            sentence_features,
+            FEATURE_TYPE_SENTENCE,
+            attribute,
+            self._config[FEATURIZER_CLASS_ALIAS],
+        )
+        message.add_features(final_sentence_features)
+
+    def features_for_tokens(
+        self,
+        tokens: List[Token],
+        feature_extractor: "mitie.total_word_feature_extractor",
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """Calculates features."""
+        sequence_features = np.array(
+            [feature_extractor.get_feature_vector(token.text) for token in tokens]
+        )
+
+        sentence_fetaures = self.aggregate_sequence_features(
+            sequence_features, self.pooling_operation
+        )
+
+        return sequence_features, sentence_fetaures

rasa/nlu/featurizers/dense_featurizer/spacy_featurizer.py

@@ -0,0 +1,132 @@
+import numpy as np
+import typing
+import logging
+from typing import Any, Text, Dict, List, Type
+
+from rasa.engine.recipes.default_recipe import DefaultV1Recipe
+from rasa.engine.graph import ExecutionContext, GraphComponent
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.nlu.featurizers.dense_featurizer.dense_featurizer import DenseFeaturizer
+from rasa.nlu.tokenizers.spacy_tokenizer import SpacyTokenizer
+from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.nlu.training_data.features import Features
+from rasa.shared.nlu.training_data.message import Message
+from rasa.nlu.constants import (
+    SPACY_DOCS,
+    DENSE_FEATURIZABLE_ATTRIBUTES,
+    FEATURIZER_CLASS_ALIAS,
+)
+from rasa.shared.nlu.constants import TEXT, FEATURE_TYPE_SENTENCE, FEATURE_TYPE_SEQUENCE
+from rasa.utils.tensorflow.constants import POOLING, MEAN_POOLING
+
+if typing.TYPE_CHECKING:
+    from spacy.tokens import Doc
+
+logger = logging.getLogger(__name__)
+
+
+@DefaultV1Recipe.register(
+    DefaultV1Recipe.ComponentType.MESSAGE_FEATURIZER, is_trainable=False
+)
+class SpacyFeaturizer(DenseFeaturizer, GraphComponent):
+    """Featurize messages using SpaCy."""
+
+    @classmethod
+    def required_components(cls) -> List[Type]:
+        """Components that should be included in the pipeline before this component."""
+        return [SpacyTokenizer]
+
+    @staticmethod
+    def required_packages() -> List[Text]:
+        """Any extra python dependencies required for this component to run."""
+        return ["spacy"]
+
+    @staticmethod
+    def get_default_config() -> Dict[Text, Any]:
+        """The component's default config (see parent class for full docstring)."""
+        return {
+            **DenseFeaturizer.get_default_config(),
+            # Specify what pooling operation should be used to calculate the vector of
+            # the complete utterance. Available options: 'mean' and 'max'
+            POOLING: MEAN_POOLING,
+        }
+
+    def __init__(self, config: Dict[Text, Any], name: Text) -> None:
+        """Initializes SpacyFeaturizer."""
+        super().__init__(name, config)
+        self.pooling_operation = self._config[POOLING]
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> GraphComponent:
+        """Creates a new component (see parent class for full docstring)."""
+        return cls(config, execution_context.node_name)
+
+    def _features_for_doc(self, doc: "Doc") -> np.ndarray:
+        """Feature vector for a single document / sentence / tokens."""
+        return np.array([t.vector for t in doc if t.text and t.text.strip()])
+
+    def _get_doc(self, message: Message, attribute: Text) -> Any:
+        return message.get(SPACY_DOCS[attribute])
+
+    def process(self, messages: List[Message]) -> List[Message]:
+        """Processes incoming messages and computes and sets features."""
+        for message in messages:
+            for attribute in DENSE_FEATURIZABLE_ATTRIBUTES:
+                self._set_spacy_features(message, attribute)
+        return messages
+
+    def process_training_data(self, training_data: TrainingData) -> TrainingData:
+        """Processes the training examples in the given training data in-place.
+
+        Args:
+          training_data: Training data.
+
+        Returns:
+          Same training data after processing.
+        """
+        self.process(training_data.training_examples)
+        return training_data
+
+    def _set_spacy_features(self, message: Message, attribute: Text = TEXT) -> None:
+        """Adds the spacy word vectors to the messages features."""
+        doc = self._get_doc(message, attribute)
+
+        if doc is None:
+            return
+
+        # in case an empty spaCy model was used, no vectors are present
+        if doc.vocab.vectors_length == 0:
+            logger.debug("No features present. You are using an empty spaCy model.")
+            return
+
+        sequence_features = self._features_for_doc(doc)
+        sentence_features = self.aggregate_sequence_features(
+            sequence_features, self.pooling_operation
+        )
+
+        final_sequence_features = Features(
+            sequence_features,
+            FEATURE_TYPE_SEQUENCE,
+            attribute,
+            self._config[FEATURIZER_CLASS_ALIAS],
+        )
+        message.add_features(final_sequence_features)
+        final_sentence_features = Features(
+            sentence_features,
+            FEATURE_TYPE_SENTENCE,
+            attribute,
+            self._config[FEATURIZER_CLASS_ALIAS],
+        )
+        message.add_features(final_sentence_features)
+
+    @classmethod
+    def validate_config(cls, config: Dict[Text, Any]) -> None:
+        """Validates that the component is configured properly."""
+        pass

rasa/nlu/featurizers/featurizer.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+from abc import abstractmethod, ABC
+from collections import Counter
+from typing import Generic, Iterable, Text, Optional, Dict, Any, TypeVar
+
+from rasa.nlu.constants import FEATURIZER_CLASS_ALIAS
+from rasa.shared.nlu.training_data.features import Features
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.exceptions import InvalidConfigException
+from rasa.shared.nlu.constants import FEATURE_TYPE_SENTENCE, FEATURE_TYPE_SEQUENCE
+
+FeatureType = TypeVar("FeatureType")
+
+
+class Featurizer(Generic[FeatureType], ABC):
+    """Base class for all featurizers."""
+
+    @staticmethod
+    def get_default_config() -> Dict[Text, Any]:
+        """Returns the component's default config."""
+        return {FEATURIZER_CLASS_ALIAS: None}
+
+    def __init__(self, name: Text, config: Dict[Text, Any]) -> None:
+        """Instantiates a new featurizer.
+
+        Args:
+          config: configuration
+          name: a name that can be used as identifier, in case the configuration does
+            not specify an `alias` (or this `alias` is None)
+        """
+        super().__init__()
+        self.validate_config(config)
+        self._config = config
+        self._identifier = self._config[FEATURIZER_CLASS_ALIAS] or name
+
+    @classmethod
+    @abstractmethod
+    def validate_config(cls, config: Dict[Text, Any]) -> None:
+        """Validates that the component is configured properly."""
+        ...
+
+    def add_features_to_message(
+        self,
+        sequence: FeatureType,
+        sentence: Optional[FeatureType],
+        attribute: Text,
+        message: Message,
+    ) -> None:
+        """Adds sequence and sentence features for the attribute to the given message.
+
+        Args:
+          sequence: sequence feature matrix
+          sentence: sentence feature matrix
+          attribute: the attribute which both features describe
+          message: the message to which we want to add those features
+        """
+        for type, features in [
+            (FEATURE_TYPE_SEQUENCE, sequence),
+            (FEATURE_TYPE_SENTENCE, sentence),
+        ]:
+            if features is not None:
+                wrapped_feature = Features(features, type, attribute, self._identifier)
+                message.add_features(wrapped_feature)
+
+    @staticmethod
+    def raise_if_featurizer_configs_are_not_compatible(
+        featurizer_configs: Iterable[Dict[Text, Any]],
+    ) -> None:
+        """Validates that the given configurations of featurizers can be used together.
+
+        Raises:
+          `InvalidConfigException` if the given featurizers should not be used in
+            the same graph.
+        """
+        # NOTE: this assumes the names given via the execution context are unique
+        alias_counter = Counter(
+            config[FEATURIZER_CLASS_ALIAS]
+            for config in featurizer_configs
+            if FEATURIZER_CLASS_ALIAS in config
+        )
+        if not alias_counter:  # no alias found
+            return
+        if alias_counter.most_common(1)[0][1] > 1:
+            raise InvalidConfigException(
+                f"Expected the featurizers to have unique names but found "
+                f" (name, count): {alias_counter.most_common()}. "
+                f"Please update your config such that each featurizer has a unique "
+                f"alias."
+            )