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,
)
