def validate_rasa_config(config: Dict): """ validates bot config.yml content for invalid entries :param config: configuration :return: None """ rasa_config = RasaNLUModelConfig(config) component_builder = ComponentBuilder() for i in range(len(rasa_config.pipeline)): component_cfg = rasa_config.for_component(i) component_builder.create_component(component_cfg, rasa_config) configuration.load(config)
async def visualize(config_path: Text, domain_path: Text, stories_path: Text, nlu_data_path: Text, output_path: Text, max_history: int): from rasa.core.agent import Agent from rasa.core import config policies = config.load(config_path) agent = Agent(domain_path, policies=policies) # this is optional, only needed if the `/greet` type of # messages in the stories should be replaced with actual # messages (e.g. `hello`) if nlu_data_path is not None: from rasa.nlu.training_data import load_data nlu_data_path = load_data(nlu_data_path) else: nlu_data_path = None logger.info("Starting to visualize stories...") await agent.visualize(stories_path, output_path, max_history, nlu_training_data=nlu_data_path) full_output_path = "file://{}".format(os.path.abspath(output_path)) logger.info( "Finished graph creation. Saved into {}".format(full_output_path)) import webbrowser webbrowser.open(full_output_path)
def train_dialogue(domain_file='./config/domain.yml', model_path='./models/dialogue', training_data_file='./data/stories.md'): policies = config.load("./config/config.yml") agent = Agent(domain_file, policies=policies) loop = asyncio.get_event_loop() data = loop.run_until_complete(agent.load_data(training_data_file)) agent.train(data) agent.persist(model_path) return agent
def train_dialogue_transformer(domain_file="mobile_domain.yml", model_path="models/dialogue_transformer", training_data_file="data/mobile_edit_story.md"): # 通过加载yml配置文件方式配置policy policies = config.load('./policy/attention_policy.yml') agent = Agent(domain_file, policies=policies) training_data = agent.load_data(training_data_file) agent.train(training_data, validation_split=0.2) agent.persist(model_path) return agent
async def train(self): # agent = Agent(domain=self.domainFile, policies=config.load(self.configFile)) agent = SelfAgent(domain=self.domainFile, policies=config.load(self.configFile)) data = await agent.load_data( self.storiesFile, augmentation_factor=self.augmentationFactor) _logger.info("training model start.") agent.train(data) _logger.info('training model end.') _logger.info('save trained model.') agent.persist(self.modelSavePath)
def train_dialog() -> None: training_data_file = './data/stories.md' model_path = './models' policies = policy_config.load("Config.yml") # featurizer = MaxHistoryTrackerFeaturizer(BinarySingleStateFeaturizer(), max_history=5) agent = Agent('domain.yml', policies=policies) data = asyncio.run( agent.load_data(training_data_file, augmentation_factor=50)) # data = agent.load_data(training_data_file) agent.train(data) agent.persist(model_path)
async def visualize( config_path: Text, domain_path: Text, stories_path: Text, nlu_data_path: Text, output_path: Text, max_history: int, ): from rasa.core.agent import Agent from rasa.core import config try: policies = config.load(config_path) except ValueError as e: print_error( "Could not load config due to: '{}'. To specify a valid config file use " "the '--config' argument.".format(e)) return try: agent = Agent(domain=domain_path, policies=policies) except InvalidDomain as e: print_error( "Could not load domain due to: '{}'. To specify a valid domain path use " "the '--domain' argument.".format(e)) return # this is optional, only needed if the `/greet` type of # messages in the stories should be replaced with actual # messages (e.g. `hello`) if nlu_data_path is not None: import rasa.shared.nlu.training_data.loading nlu_training_data = rasa.shared.nlu.training_data.loading.load_data( nlu_data_path) else: nlu_training_data = None logger.info("Starting to visualize stories...") telemetry.track_visualization() await agent.visualize(stories_path, output_path, max_history, nlu_training_data=nlu_training_data) full_output_path = "file://{}".format(os.path.abspath(output_path)) logger.info(f"Finished graph creation. Saved into {full_output_path}") import webbrowser webbrowser.open(full_output_path)
async def train( domain_file: Union[Domain, Text], training_resource: Union[Text, "TrainingDataImporter"], output_path: Text, interpreter: Optional["NaturalLanguageInterpreter"] = None, endpoints: "AvailableEndpoints" = None, policy_config: Optional[Union[Text, Dict]] = None, exclusion_percentage: Optional[int] = None, additional_arguments: Optional[Dict] = None, model_to_finetune: Optional["Agent"] = None, ) -> "Agent": from rasa.core import config, utils from rasa.core.utils import AvailableEndpoints from rasa.core.agent import Agent if not endpoints: endpoints = AvailableEndpoints() if not additional_arguments: additional_arguments = {} policies = config.load(policy_config) agent = Agent( domain_file, generator=endpoints.nlg, action_endpoint=endpoints.action, interpreter=interpreter, policies=policies, ) data_load_args, additional_arguments = utils.extract_args( additional_arguments, { "use_story_concatenation", "unique_last_num_states", "augmentation_factor", "remove_duplicates", "debug_plots", }, ) training_data = await agent.load_data( training_resource, exclusion_percentage=exclusion_percentage, **data_load_args) if model_to_finetune: agent.policy_ensemble = model_to_finetune.policy_ensemble agent.train(training_data, **additional_arguments) agent.persist(output_path) return agent
async def train( domain_file: Union[Domain, Text], stories_file: Text, output_path: Text, interpreter: Optional["NaturalLanguageInterpreter"] = None, endpoints: "AvailableEndpoints" = None, dump_stories: bool = False, policy_config: Text = None, exclusion_percentage: int = None, kwargs: Optional[Dict] = None, ): from rasa.core.agent import Agent from rasa.core import config, utils from rasa.core.utils import AvailableEndpoints if not endpoints: endpoints = AvailableEndpoints() if not kwargs: kwargs = {} policies = config.load(policy_config) agent = Agent( domain_file, generator=endpoints.nlg, action_endpoint=endpoints.action, interpreter=interpreter, policies=policies, ) data_load_args, kwargs = utils.extract_args( kwargs, { "use_story_concatenation", "unique_last_num_states", "augmentation_factor", "remove_duplicates", "debug_plots", }, ) training_data = await agent.load_data( stories_file, exclusion_percentage=exclusion_percentage, **data_load_args) agent.train(training_data, **kwargs) agent.persist(output_path, dump_stories) return agent
async def train_comparison_models( stories, domain, output_path="", exclusion_percentages=None, policy_configs=None, runs=1, dump_stories=False, kwargs=None, ): """Train multiple models for comparison of policies""" from rasa.core import config exclusion_percentages = exclusion_percentages or [] policy_configs = policy_configs or [] for r in range(runs): logging.info("Starting run {}/{}".format(r + 1, runs)) for i in exclusion_percentages: current_round = exclusion_percentages.index(i) + 1 for policy_config in policy_configs: policies = config.load(policy_config) if len(policies) > 1: raise ValueError( "You can only specify one policy per model for comparison" ) policy_name = type(policies[0]).__name__ output = os.path.join( output_path, "run_" + str(r + 1), policy_name + str(current_round) ) logging.info( "Starting to train {} round {}/{}" " with {}% exclusion" "".format(policy_name, current_round, len(exclusion_percentages), i) ) await train( domain, stories, output, policy_config=policy_config, exclusion_percentage=i, kwargs=kwargs, dump_stories=dump_stories, )
async def train( domain_file: Union[Domain, Text], training_resource: Union[Text, "TrainingDataImporter"], output_path: Text, interpreters: Optional[Dict[Text, "NaturalLanguageInterpreter"]] = None, endpoints: "AvailableEndpoints" = None, dump_stories: bool = False, policy_config: Optional[Union[Text, Dict]] = None, exclusion_percentage: int = None, additional_arguments: Optional[Dict] = None, ): from rasa.core.agent import Agent from rasa.core import config, utils from rasa.core.utils import AvailableEndpoints if not endpoints: endpoints = AvailableEndpoints() if not additional_arguments: additional_arguments = {} policies = config.load(policy_config) agent = Agent( domain_file, generator=endpoints.nlg, action_endpoint=endpoints.action, interpreters=interpreters or {}, # fix to avoid model not ready error policies=policies, ) data_load_args, additional_arguments = utils.extract_args( additional_arguments, { "use_story_concatenation", "unique_last_num_states", "augmentation_factor", "remove_duplicates", "debug_plots", }, ) training_data = await agent.load_data( training_resource, exclusion_percentage=exclusion_percentage, **data_load_args) agent.train(training_data, **additional_arguments) agent.persist(output_path, dump_stories) return agent
def train_dialogue(domain_file="domain.yml", model_path="./models/dialogue", training_data_file="./data/stories.md"): #agent = Agent(domain_file, policies=[MemoizationPolicy(max_history=3), KerasPolicy()]) #training_data = agent.load_data(training_data_file) #agent.train(training_data,epochs=400,batch_size=100,validation_split=0.2) #agent.persist(model_path) policies = policy_config.load("./policies.yml") agent = Agent(domain_file, policies=policies) loop = asyncio.get_event_loop() dataa = loop.run_until_complete(agent.load_data(training_data_file)) agent.train(dataa) agent.persist(model_path) return agent
def default_config() -> List[Policy]: return config.load(DEFAULT_CONFIG_PATH)
def test_load_config(filename): loaded = load(filename) assert len(loaded) == 2 assert isinstance(loaded[0], MemoizationPolicy) assert isinstance(loaded[1], ExamplePolicy)
def default_config(): return config.load(DEFAULT_CONFIG_PATH)
def config(config_path: Text) -> List[Policy]: return core_config.load(config_path)
def default_config(default_config_path) -> List[Policy]: return config.load(default_config_path)
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, dump_stories: bool = False, kwargs: Optional[Dict] = None, ): """Train multiple models for comparison of policies""" from rasa.core import config from rasa import model from rasa.importers.importer import TrainingDataImporter 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: policies = config.load(policy_config) if len(policies) > 1: raise ValueError( "You can only specify one policy per model for comparison" ) file_importer = TrainingDataImporter.load_core_importer_from_config( policy_config, domain, [story_file]) policy_name = type(policies[0]).__name__ logging.info("Starting to train {} round {}/{}" " with {}% exclusion" "".format(policy_name, current_run, len(exclusion_percentages), percentage)) with TempDirectoryPath(tempfile.mkdtemp()) as train_path: await train( domain, file_importer, train_path, policy_config=policy_config, exclusion_percentage=current_run, kwargs=kwargs, dump_stories=dump_stories, ) new_fingerprint = await model.model_fingerprint( file_importer) output_dir = os.path.join(output_path, "run_" + str(r + 1)) model_name = policy_name + str(current_run) model.package_model( fingerprint=new_fingerprint, output_directory=output_dir, train_path=train_path, fixed_model_name=model_name, )