rasa-pro 3.9.18__py3-none-any.whl

rasa/core/nlg/response.py

@@ -0,0 +1,155 @@
+import copy
+import logging
+from rasa.core.constants import DEFAULT_TEMPLATE_ENGINE, TEMPLATE_ENGINE_CONFIG_KEY
+
+from rasa.shared.core.trackers import DialogueStateTracker
+from typing import Text, Any, Dict, Optional, List
+
+from rasa.core.nlg import interpolator
+from rasa.core.nlg.generator import NaturalLanguageGenerator, ResponseVariationFilter
+from rasa.shared.constants import RESPONSE_CONDITION
+from rasa.shared.core.domain import RESPONSE_KEYS_TO_INTERPOLATE
+from rasa.shared.nlu.constants import METADATA
+
+logger = logging.getLogger(__name__)
+
+
+class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
+    """Natural language generator that generates messages based on responses.
+
+    The responses can use variables to customize the utterances based on the
+    state of the dialogue.
+    """
+
+    def __init__(self, responses: Dict[Text, List[Dict[Text, Any]]]) -> None:
+        """Creates a Template Natural Language Generator.
+
+        Args:
+            responses: responses that will be used to generate messages.
+        """
+        self.responses = responses
+
+    # noinspection PyUnusedLocal
+    def _random_response_for(
+        self, utter_action: Text, output_channel: Text, filled_slots: Dict[Text, Any]
+    ) -> Optional[Dict[Text, Any]]:
+        """Select random response for the utter action from available ones.
+
+        If channel-specific responses for the current output channel are given,
+        only choose from channel-specific ones.
+        """
+        import numpy as np
+
+        if utter_action in self.responses:
+            response_filter = ResponseVariationFilter(self.responses)
+            suitable_responses = response_filter.responses_for_utter_action(
+                utter_action, output_channel, filled_slots
+            )
+
+            if suitable_responses:
+                selected_response = np.random.choice(suitable_responses)
+                condition = selected_response.get(RESPONSE_CONDITION)
+                if condition:
+                    formatted_response_conditions = self._format_response_conditions(
+                        condition
+                    )
+                    logger.debug(
+                        "Selecting response variation with conditions:"
+                        f"{formatted_response_conditions}"
+                    )
+                return selected_response
+            else:
+                return None
+        else:
+            return None
+
+    async def generate(
+        self,
+        utter_action: Text,
+        tracker: DialogueStateTracker,
+        output_channel: Text,
+        **kwargs: Any,
+    ) -> Optional[Dict[Text, Any]]:
+        """Generate a response for the requested utter action."""
+        filled_slots = tracker.current_slot_values()
+        stack_context = tracker.stack.current_context()
+        return self.generate_from_slots(
+            utter_action, filled_slots, stack_context, output_channel, **kwargs
+        )
+
+    def generate_from_slots(
+        self,
+        utter_action: Text,
+        filled_slots: Dict[Text, Any],
+        stack_context: Dict[Text, Any],
+        output_channel: Text,
+        **kwargs: Any,
+    ) -> Optional[Dict[Text, Any]]:
+        """Generate a response for the requested utter action."""
+        # Fetching a random response for the passed utter action
+        r = copy.deepcopy(
+            self._random_response_for(utter_action, output_channel, filled_slots)
+        )
+        # Filling the slots in the response with placeholders and returning the response
+        if r is not None:
+            return self._fill_response(r, filled_slots, stack_context, **kwargs)
+        else:
+            return None
+
+    def _fill_response(
+        self,
+        response: Dict[Text, Any],
+        filled_slots: Dict[Text, Any],
+        stack_context: Dict[Text, Any],
+        **kwargs: Any,
+    ) -> Dict[Text, Any]:
+        """Combine slot values and key word arguments to fill responses."""
+        # Getting the slot values in the response variables
+        response_vars = self._response_variables(filled_slots, stack_context, kwargs)
+
+        # template formatting method
+        method = response.get(METADATA, {}).get(
+            TEMPLATE_ENGINE_CONFIG_KEY, DEFAULT_TEMPLATE_ENGINE
+        )
+
+        if response_vars:
+            for key in RESPONSE_KEYS_TO_INTERPOLATE:
+                if key in response:
+                    response[key] = interpolator.interpolate(
+                        response[key],
+                        response_vars,
+                        method=method,
+                    )
+        return response
+
+    @staticmethod
+    def _response_variables(
+        filled_slots: Dict[Text, Any],
+        stack_context: Dict[Text, Any],
+        kwargs: Dict[Text, Any],
+    ) -> Dict[Text, Any]:
+        """Combine slot values and key word arguments to fill responses."""
+        if filled_slots is None:
+            filled_slots = {}
+
+        # copy in the context from the stack
+        response_vars = {"context": stack_context}
+        # Copying the filled slots in the response variables.
+        response_vars.update(filled_slots)
+        response_vars.update(kwargs)
+        return response_vars
+
+    @staticmethod
+    def _format_response_conditions(response_conditions: List[Dict[Text, Any]]) -> Text:
+        formatted_response_conditions = [""]
+        for index, condition in enumerate(response_conditions):
+            constraints = []
+            constraints.append(f"type: {condition['type']!s}")
+            constraints.append(f"name: {condition['name']!s}")
+            constraints.append(f"value: {condition['value']!s}")
+
+            condition_message = " | ".join(constraints)
+            formatted_condition = f"[condition {index + 1!s}] {condition_message}"
+            formatted_response_conditions.append(formatted_condition)
+
+        return "\n".join(formatted_response_conditions)

rasa/core/nlg/summarize.py

@@ -0,0 +1,69 @@
+from typing import Optional
+
+import structlog
+from jinja2 import Template
+from langchain.llms.base import BaseLLM
+from rasa.core.tracker_store import DialogueStateTracker
+from rasa.shared.utils.llm import (
+    tracker_as_readable_transcript,
+)
+
+structlogger = structlog.get_logger()
+
+_DEFAULT_SUMMARIZER_TEMPLATE = """Summarize the provided conversation between
+a user and a conversational AI. The summary should be a short text that
+captures the main points of the conversation.
+
+Conversation:
+{{conversation}}
+
+Summary:"""
+SUMMARY_PROMPT_TEMPLATE = Template(_DEFAULT_SUMMARIZER_TEMPLATE)
+MAX_TURNS_DEFAULT = 20
+
+
+def _create_summarization_prompt(
+    tracker: DialogueStateTracker, max_turns: Optional[int]
+) -> str:
+    """Creates an LLM prompt to summarize the conversation in the tracker.
+
+    Args:
+        tracker: tracker of the conversation to be summarized
+        max_turns: maximum number of turns to summarize
+
+
+    Returns:
+        The prompt to summarize the conversation.
+    """
+    transcript = tracker_as_readable_transcript(tracker, max_turns=max_turns)
+    return SUMMARY_PROMPT_TEMPLATE.render(
+        conversation=transcript,
+    )
+
+
+async def summarize_conversation(
+    tracker: DialogueStateTracker,
+    llm: BaseLLM,
+    max_turns: Optional[int] = MAX_TURNS_DEFAULT,
+) -> str:
+    """Summarizes the dialogue using the LLM.
+
+    Args:
+        tracker: the tracker to summarize
+        llm: the LLM to use for summarization
+        max_turns: maximum number of turns to summarize
+
+    Returns:
+        The summary of the dialogue.
+    """
+    prompt = _create_summarization_prompt(tracker, max_turns)
+    try:
+        summarization = (await llm.apredict(prompt)).strip()
+        structlogger.debug(
+            "summarization.success", summarization=summarization, prompt=prompt
+        )
+        return summarization
+    except Exception as e:
+        transcript = tracker_as_readable_transcript(tracker, max_turns=max_turns)
+        structlogger.error("summarization.error", error=e)
+        return transcript

rasa/core/policies/ensemble.py

@@ -0,0 +1,329 @@
+from __future__ import annotations
+from abc import abstractmethod, ABC
+from typing import Optional, Text, List, Dict, Any
+import logging
+
+from rasa.engine.graph import GraphComponent
+from rasa.engine.storage.storage import ModelStorage
+from rasa.engine.storage.resource import Resource
+from rasa.engine.runner.interface import ExecutionContext
+from rasa.core.policies.policy import PolicyPrediction
+from rasa.shared.exceptions import RasaException, InvalidConfigException
+from rasa.shared.core.constants import ACTION_LISTEN_NAME
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import (
+    ActionExecutionRejected,
+    ActionExecuted,
+    DefinePrevUserUtteredFeaturization,
+)
+from rasa.shared.core.trackers import DialogueStateTracker
+
+logger = logging.getLogger(__name__)
+
+
+def is_not_in_training_data(
+    policy_name: Optional[Text], max_confidence: Optional[float] = None
+) -> bool:
+    """Checks whether the prediction is empty or by a policy which did not memoize data.
+
+    Args:
+        policy_name: The name of the policy.
+        max_confidence: The max confidence of the policy's prediction.
+
+    Returns:
+        `False` if and only if an action was predicted (i.e. `max_confidence` > 0) by
+        a `MemoizationPolicy`
+    """
+    from rasa.core.policies.rule_policy import RulePolicy
+    from rasa.core.policies.memoization import (
+        MemoizationPolicy,
+        AugmentedMemoizationPolicy,
+    )
+
+    if not policy_name:
+        return True
+
+    memorizing_policies = [
+        RulePolicy.__name__,
+        MemoizationPolicy.__name__,
+        AugmentedMemoizationPolicy.__name__,
+    ]
+    is_memorized = any(
+        policy_name.endswith(f"_{memoizing_policy}")
+        for memoizing_policy in memorizing_policies
+    )
+
+    # also check if confidence is 0, than it cannot be count as prediction
+    return not is_memorized or max_confidence == 0.0
+
+
+class InvalidPolicyEnsembleConfig(RasaException):
+    """Exception that can be raised when the policy ensemble is not valid."""
+
+
+class PolicyPredictionEnsemble(ABC):
+    """Interface for any policy prediction ensemble.
+
+    Given a list of predictions from policies, which include some meta data about the
+    policies themselves, an "ensemble" decides what the final prediction should be, in
+    the following way:
+    1. If the previously predicted action was rejected, then the ensemble sets the
+       probability for this action to 0.0 (in all given predictions).
+    2. It combines the information from the single predictions, which include some
+       meta data about the policies (e.g. priority), into a final prediction.
+    3. If the sequence of events given at the time of prediction ends with a user
+       utterance, then the ensemble adds a special event to the event-list included in
+       the final prediction that indicates whether the final prediction was made based
+       on the actual text of that user utterance.
+
+    Observe that policies predict "mandatory" as well as "optional"
+    events. The ensemble decides which of the optional events should
+    be passed on.
+    """
+
+    def combine_predictions_from_kwargs(
+        self, tracker: DialogueStateTracker, domain: Domain, **kwargs: Any
+    ) -> PolicyPrediction:
+        """Derives a single prediction from predictions given as kwargs.
+
+        Args:
+            tracker: dialogue state tracker holding the state of the conversation,
+              which may influence the combination of predictions as well
+            domain: the common domain
+            **kwargs: arbitrary keyword arguments. All policy predictions passed as
+              kwargs will be combined.
+
+        Returns:
+            a single prediction
+        """
+        predictions = [
+            value for value in kwargs.values() if isinstance(value, PolicyPrediction)
+        ]
+        return self.combine_predictions(
+            predictions=predictions, tracker=tracker, domain=domain
+        )
+
+    @abstractmethod
+    def combine_predictions(
+        self,
+        predictions: List[PolicyPrediction],
+        tracker: DialogueStateTracker,
+        domain: Domain,
+    ) -> PolicyPrediction:
+        """Derives a single prediction from the given list of predictions.
+
+        Args:
+            predictions: a list of policy predictions that include "confidence scores"
+              which are non-negative but *do not* necessarily up to 1
+            tracker: dialogue state tracker holding the state of the conversation,
+              which may influence the combination of predictions as well
+            domain: the common domain
+
+        Returns:
+            a single prediction
+        """
+        ...
+
+
+class DefaultPolicyPredictionEnsemble(PolicyPredictionEnsemble, GraphComponent):
+    """An ensemble that picks the "best" prediction and combines events from all.
+
+    The following rules determine which prediction is the "best":
+    1. "No user" predictions overrule all other predictions.
+
+    2. End-to-end predictions overrule all other predictions based on
+        user input - if and only if *no* "no user" prediction is present in the
+        given ensemble.
+
+    3. Given two predictions, if the maximum confidence of one prediction is
+        strictly larger than that of the other, then the prediction with the
+        strictly larger maximum confidence is considered to be "better".
+        The priorities of the policies that made these predictions does not matter.
+
+    4. Given two predictions of policies that are equally confident, the
+        prediction of the policy with the higher priority is considered to be
+        "better".
+
+    Observe that this comparison is *not* symmetric if the priorities are allowed to
+    coincide (i.e. if we cannot distinguish two predictions using 1.-4., then
+    the first prediction is considered to be "better").
+
+    The list of events in the final prediction will contain all mandatory
+    events contained in the given predictions, the optional events given in the
+    "best" prediction, and `DefinePrevUserUtteredFeaturization` event (if the
+    prediction was made for a sequence of events ending with a user utterance).
+    """
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> DefaultPolicyPredictionEnsemble:
+        """Creates a new instance (see parent class for full docstring)."""
+        return cls()
+
+    def __str__(self) -> Text:
+        return f"{self.__class__.__name__}()"
+
+    @staticmethod
+    def _pick_best_policy(predictions: List[PolicyPrediction]) -> PolicyPrediction:
+        """Picks the best policy prediction based on probabilities and policy priority.
+
+        Args:
+            predictions: a list containing policy predictions
+
+        Returns:
+            The index of the best prediction
+        """
+        best_confidence = (-1.0, -1)
+        best_index = -1
+
+        # different type of predictions have different priorities
+        # No user predictions overrule all other predictions.
+        is_no_user_prediction = any(
+            prediction.is_no_user_prediction for prediction in predictions
+        )
+        # End-to-end predictions overrule all other predictions based on user input.
+        is_end_to_end_prediction = any(
+            prediction.is_end_to_end_prediction for prediction in predictions
+        )
+
+        policy_events = []
+        for idx, prediction in enumerate(predictions):
+            policy_events += prediction.events
+
+            # No user predictions (e.g. happy path loop predictions)
+            # overrule all other predictions.
+            if prediction.is_no_user_prediction != is_no_user_prediction:
+                continue
+
+            # End-to-end predictions overrule all other predictions based on user input.
+            if (
+                not is_no_user_prediction
+                and prediction.is_end_to_end_prediction != is_end_to_end_prediction
+            ):
+                continue
+
+            confidence = (prediction.max_confidence, prediction.policy_priority)
+            if confidence > best_confidence:
+                # pick the best policy
+                best_confidence = confidence
+                best_index = idx
+
+        if best_index < 0:
+            raise InvalidConfigException(
+                "No best prediction found. Please check your model configuration."
+            )
+
+        best_prediction = predictions[best_index]
+        policy_events += best_prediction.optional_events
+
+        return PolicyPrediction(
+            best_prediction.probabilities,
+            best_prediction.policy_name,
+            best_prediction.policy_priority,
+            policy_events,
+            is_end_to_end_prediction=best_prediction.is_end_to_end_prediction,
+            is_no_user_prediction=best_prediction.is_no_user_prediction,
+            diagnostic_data=best_prediction.diagnostic_data,
+            hide_rule_turn=best_prediction.hide_rule_turn,
+            action_metadata=best_prediction.action_metadata,
+        )
+
+    @staticmethod
+    def _best_policy_prediction(
+        predictions: List[PolicyPrediction],
+        tracker: DialogueStateTracker,
+        domain: Domain,
+    ) -> PolicyPrediction:
+        """Finds the best policy prediction.
+
+        Args:
+            predictions: a list of policy predictions that include "confidence scores"
+              which are non-negative but *do not* necessarily up to 1
+            tracker: dialogue state tracker holding the state of the conversation,
+              which may influence the combination of predictions as well
+            domain: the common domain
+
+        Returns:
+            The winning policy prediction.
+        """
+        last_action_event = next(
+            (
+                event
+                for event in reversed(tracker.events)
+                if isinstance(event, (ActionExecutionRejected, ActionExecuted))
+            ),
+            None,
+        )
+
+        rejected_action_name = None
+        if len(tracker.events) > 0 and isinstance(
+            last_action_event, ActionExecutionRejected
+        ):
+            rejected_action_name = last_action_event.action_name
+
+        if rejected_action_name:
+            logger.debug(
+                f"Execution of '{rejected_action_name}' was rejected. "
+                f"Setting its confidence to 0.0 in all predictions."
+            )
+            index_of_rejected_action = domain.index_for_action(rejected_action_name)
+            for prediction in predictions:
+                prediction.probabilities[index_of_rejected_action] = 0.0
+
+        return DefaultPolicyPredictionEnsemble._pick_best_policy(predictions)
+
+    def combine_predictions(
+        self,
+        predictions: List[PolicyPrediction],
+        tracker: DialogueStateTracker,
+        domain: Domain,
+    ) -> PolicyPrediction:
+        """Derives a single prediction from the given list of predictions.
+
+        Note that you might get unexpected results if the priorities are non-unique.
+        Moreover, the order of events in the result is determined by the order of the
+        predictions passed to this method.
+
+        Args:
+            predictions: a list of policy predictions that include "probabilities"
+              which are non-negative but *do not* necessarily up to 1
+            tracker: dialogue state tracker holding the state of the conversation
+            domain: the common domain
+
+        Returns:
+            The "best" prediction.
+        """
+        if not predictions:
+            raise InvalidConfigException(
+                "Expected at least one prediction. Please check your model "
+                "configuration."
+            )
+        # Reminder: If just a single policy is given, we do *not* just return it because
+        # it is expected that the final prediction contains mandatory and optional
+        # events in the `events` attribute and no optional events.
+
+        winning_prediction = self._best_policy_prediction(
+            predictions=predictions, domain=domain, tracker=tracker
+        )
+
+        if tracker.latest_action_name == ACTION_LISTEN_NAME:
+            if winning_prediction.is_end_to_end_prediction:
+                logger.debug("Made e2e prediction using user text.")
+                logger.debug("Added `DefinePrevUserUtteredFeaturization(True)` event.")
+                winning_prediction.events.append(
+                    DefinePrevUserUtteredFeaturization(True)
+                )
+            else:
+                logger.debug("Made prediction using user intent.")
+                logger.debug("Added `DefinePrevUserUtteredFeaturization(False)` event.")
+                winning_prediction.events.append(
+                    DefinePrevUserUtteredFeaturization(False)
+                )
+
+        logger.debug(f"Predicted next action using {winning_prediction.policy_name}.")
+        return winning_prediction