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

rasa/core/train.py

@@ -0,0 +1,105 @@
+import argparse
+import logging
+import os
+from pathlib import Path
+from typing import Dict, Optional, Text, List
+
+import rasa.shared.utils.io
+import rasa.utils.io
+from rasa.constants import NUMBER_OF_TRAINING_STORIES_FILE, PERCENTAGE_KEY
+from rasa.shared.importers.importer import TrainingDataImporter
+
+logger = logging.getLogger(__name__)
+
+
+async def train_comparison_models(
+    story_file: Text,
+    domain: Text,
+    output_path: Text = "",
+    exclusion_percentages: Optional[List] = None,
+    policy_configs: Optional[List] = None,
+    runs: int = 1,
+    additional_arguments: Optional[Dict] = None,
+) -> None:
+    """Trains multiple models for comparison of policies."""
+    import rasa.model_training
+
+    exclusion_percentages = exclusion_percentages or []
+    policy_configs = policy_configs or []
+
+    for r in range(runs):
+        logging.info("Starting run {}/{}".format(r + 1, runs))
+
+        for current_run, percentage in enumerate(exclusion_percentages, 1):
+            for policy_config in policy_configs:
+                config_name = os.path.splitext(os.path.basename(policy_config))[0]
+                logging.info(
+                    "Starting to train {} round {}/{} with {}% exclusion".format(
+                        config_name, current_run, len(exclusion_percentages), percentage
+                    )
+                )
+
+                await rasa.model_training.train_core(
+                    domain,
+                    policy_config,
+                    stories=story_file,
+                    output=str(Path(output_path, f"run_{r +1}")),
+                    fixed_model_name=config_name + PERCENTAGE_KEY + str(percentage),
+                    additional_arguments={
+                        **additional_arguments,
+                        "exclusion_percentage": percentage,
+                    },
+                )
+
+
+def get_no_of_stories(story_file: Text, domain: Text) -> int:
+    """Gets number of stories in a file."""
+    importer = TrainingDataImporter.load_from_dict(
+        domain_path=domain, training_data_paths=[story_file]
+    )
+    story_graph = importer.get_stories()
+    return len(story_graph.story_steps)
+
+
+async def do_compare_training(
+    args: argparse.Namespace,
+    story_file: Text,
+    additional_arguments: Optional[Dict] = None,
+) -> None:
+    """Train multiple models for comparison of policies and dumps the result."""
+    await train_comparison_models(
+        story_file=story_file,
+        domain=args.domain,
+        output_path=args.out,
+        exclusion_percentages=args.percentages,
+        policy_configs=args.config,
+        runs=args.runs,
+        additional_arguments=additional_arguments,
+    )
+    no_stories = get_no_of_stories(args.stories, args.domain)
+
+    # store the list of the number of stories present at each exclusion
+    # percentage
+    story_range = [
+        no_stories - round((x / 100.0) * no_stories) for x in args.percentages
+    ]
+
+    training_stories_per_model_file = os.path.join(
+        args.out, NUMBER_OF_TRAINING_STORIES_FILE
+    )
+    rasa.shared.utils.io.dump_obj_as_json_to_file(
+        training_stories_per_model_file, story_range
+    )
+
+
+def do_interactive_learning(
+    args: argparse.Namespace, file_importer: TrainingDataImporter
+) -> None:
+    from rasa.core.training import interactive
+
+    interactive.run_interactive_learning(
+        file_importer=file_importer,
+        skip_visualization=args.skip_visualization,
+        conversation_id=args.conversation_id,
+        server_args=args.__dict__,
+    )

rasa/core/training/__init__.py

@@ -0,0 +1,89 @@
+from typing import Text, List, Optional, Union, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
+    from rasa.shared.core.generator import TrackerWithCachedStates
+    from rasa.shared.core.training_data.structures import StoryGraph
+    from rasa.shared.importers.importer import TrainingDataImporter
+
+
+def extract_story_graph(
+    resource_name: Text, domain: "Domain", exclusion_percentage: Optional[int] = None
+) -> "StoryGraph":
+    """Loads training stories / rules from file or directory.
+
+    Args:
+        resource_name: Path to file or directory.
+        domain: The model domain.
+        exclusion_percentage: Percentage of stories which should be dropped. `None`
+            if all training data should be used.
+
+    Returns:
+        The loaded training data as graph.
+    """
+    from rasa.shared.core.training_data.structures import StoryGraph
+    import rasa.shared.core.training_data.loading as core_loading
+
+    story_steps = core_loading.load_data_from_resource(
+        resource_name, domain, exclusion_percentage=exclusion_percentage
+    )
+    return StoryGraph(story_steps)
+
+
+def load_data(
+    resource_name: Union[Text, "TrainingDataImporter"],
+    domain: "Domain",
+    remove_duplicates: bool = True,
+    unique_last_num_states: Optional[int] = None,
+    augmentation_factor: int = 50,
+    tracker_limit: Optional[int] = None,
+    use_story_concatenation: bool = True,
+    debug_plots: bool = False,
+    exclusion_percentage: Optional[int] = None,
+) -> List["TrackerWithCachedStates"]:
+    """Load training data from a resource.
+
+    Args:
+        resource_name: resource to load the data from. either a path or an importer
+        domain: domain used for loading
+        remove_duplicates: should duplicated training examples be removed?
+        unique_last_num_states: number of states in a conversation that make the
+            a tracker unique (this is used to identify duplicates)
+        augmentation_factor:
+            by how much should the story training data be augmented
+        tracker_limit:
+            maximum number of trackers to generate during augmentation
+        use_story_concatenation:
+            should stories be concatenated when doing data augmentation
+        debug_plots:
+            generate debug plots during loading
+        exclusion_percentage:
+            how much data to exclude
+
+    Returns:
+        list of loaded trackers
+    """
+    from rasa.shared.core.generator import TrainingDataGenerator
+    from rasa.shared.importers.importer import TrainingDataImporter
+
+    if resource_name:
+        if isinstance(resource_name, TrainingDataImporter):
+            graph = resource_name.get_stories(exclusion_percentage=exclusion_percentage)
+        else:
+            graph = extract_story_graph(
+                resource_name, domain, exclusion_percentage=exclusion_percentage
+            )
+
+        g = TrainingDataGenerator(
+            graph,
+            domain,
+            remove_duplicates,
+            unique_last_num_states,
+            augmentation_factor,
+            tracker_limit,
+            use_story_concatenation,
+            debug_plots,
+        )
+        return g.generate()
+    else:
+        return []

rasa/core/training/converters/responses_prefix_converter.py

@@ -0,0 +1,119 @@
+from pathlib import Path
+from typing import Text
+
+from rasa.shared.core.domain import Domain, InvalidDomain
+from rasa.shared.core.events import ActionExecuted
+from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
+    YAMLStoryReader,
+)
+from rasa.shared.core.training_data.story_writer.yaml_story_writer import (
+    YAMLStoryWriter,
+)
+from rasa.shared.constants import UTTER_PREFIX
+from rasa.utils.converter import TrainingDataConverter
+
+
+OBSOLETE_RESPOND_PREFIX = "respond_"
+
+
+def normalize_utter_action(action_name: Text) -> Text:
+    """Ensure that response names start with `utter_`.
+
+    Args:
+        action_name: The name of the response.
+
+    Returns:
+        The name of the response, starting with `utter_`.
+    """
+    return (
+        f"{UTTER_PREFIX}{action_name[len(OBSOLETE_RESPOND_PREFIX):]}"
+        if action_name.startswith(OBSOLETE_RESPOND_PREFIX)
+        else action_name
+    )
+
+
+class StoryResponsePrefixConverter(TrainingDataConverter):
+    """Converter responsible for ensuring that retrieval intent actions in stories
+    start with `utter_` instead of `respond_`.
+    """
+
+    @classmethod
+    def filter(cls, source_path: Path) -> bool:
+        """Only accept YAML story files.
+
+        Args:
+            source_path: Path to a training data file.
+
+        Returns:
+            `True` if the given file is a YAML stories file, `False` otherwise.
+        """
+        return YAMLStoryReader.is_stories_file(source_path)
+
+    @classmethod
+    async def convert_and_write(cls, source_path: Path, output_path: Path) -> None:
+        """Migrate retrieval intent responses to the new 2.0 format in stories.
+
+        Before 2.0, retrieval intent responses needed to start
+        with `respond_`. Now, they need to start with `utter_`.
+
+        Args:
+            source_path: the source YAML stories file.
+            output_path: Path to the output directory.
+        """
+        reader = YAMLStoryReader()
+        story_steps = reader.read_from_file(source_path)
+
+        for story_step in story_steps:
+            for event in story_step.events:
+                if isinstance(event, ActionExecuted):
+                    event.action_name = normalize_utter_action(event.action_name)
+
+        output_file = cls.generate_path_for_converted_training_data_file(
+            source_path, output_path
+        )
+        YAMLStoryWriter().dump(output_file, story_steps)
+
+
+class DomainResponsePrefixConverter(TrainingDataConverter):
+    """Converter responsible for ensuring that retrieval intent actions in domain
+    start with `utter_` instead of `respond_`.
+    """
+
+    @classmethod
+    def filter(cls, source_path: Path) -> bool:
+        """Only accept domain files.
+
+        Args:
+            source_path: Path to a domain file.
+
+        Returns:
+            `True` if the given file can is a valid domain file, `False` otherwise.
+        """
+        try:
+            Domain.from_path(source_path)
+        except InvalidDomain:
+            return False
+        return True
+
+    @classmethod
+    async def convert_and_write(cls, source_path: Path, output_path: Path) -> None:
+        """Migrate retrieval intent responses to the new 2.0 format in domains.
+
+        Before 2.0, retrieval intent responses needed to start
+        with `respond_`. Now, they need to start with `utter_`.
+
+        Args:
+            source_path: The source domain file.
+            output_path: Path to the output directory.
+        """
+        domain = Domain.from_path(source_path)
+        domain_dict = domain.as_dict()
+        domain_dict["actions"] = [
+            normalize_utter_action(action) for action in domain_dict["actions"]
+        ]
+
+        new_domain = Domain.from_dict(domain_dict)
+        output_file = cls.generate_path_for_converted_training_data_file(
+            source_path, output_path
+        )
+        new_domain.persist(output_file)