async def train_core_async(
domain: Text,
config: Text,
stories: Text,
output: Text,
train_path: Optional[Text] = None,
kwargs: Optional[Dict] = None,
) -> Optional[Text]:
"""Trains a Core model.
Args:
domain: Path to the domain file.
config: Path to the config file for Core.
stories: Path to the Core training data.
output: Output path.
train_path: If `None` the model will be trained in a temporary
directory, otherwise in the provided directory.
kwargs: Additional training parameters.
Returns:
If `train_path` is given it returns the path to the model archive,
otherwise the path to the directory with the trained model files.
"""
import rasa.core.train
config = get_valid_config(config, CONFIG_MANDATORY_KEYS_CORE)
_train_path = train_path or tempfile.mkdtemp()
# normal (not compare) training
core_model = await rasa.core.train(
domain_file=domain,
stories_file=data.get_core_directory(stories),
output_path=os.path.join(_train_path, "core"),
policy_config=config,
kwargs=kwargs,
)
if not train_path:
# Only Core was trained.
stories = data.get_core_directory(stories)
output_path = create_output_path(output, prefix="core-")
new_fingerprint = model.model_fingerprint(config,
domain,
stories=stories)
model.create_package_rasa(_train_path, output_path, new_fingerprint)
print_success(
"Your Rasa Core model is trained and saved at '{}'.".format(
output_path))
return core_model
def test_core(args: argparse.Namespace) -> None:
from rasa.test import test_core
endpoints = get_validated_path(
args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
)
stories = get_validated_path(args.stories, "stories", DEFAULT_DATA_PATH)
stories = data.get_core_directory(stories)
output = args.output or DEFAULT_RESULTS_PATH
args.config = get_validated_path(args.config, "config", DEFAULT_CONFIG_PATH)
if len(args.model) == 1:
args.model = args.model[0]
model_path = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
test_core(
model=model_path,
stories=stories,
endpoints=endpoints,
output=output,
kwargs=vars(args),
)
else:
test_compare(args.model, stories, output)
def test_get_core_directory(project):
data_dir = os.path.join(project, "data")
core_directory = data.get_core_directory([data_dir])
stories = os.listdir(core_directory)
assert len(stories) == 1
assert stories[0].endswith("stories.md")
def run_core_test(args: argparse.Namespace) -> None:
"""Run core tests."""
from rasa import data
from rasa.test import test_core_models_in_directory, test_core, test_core_models
endpoints = cli_utils.get_validated_path(args.endpoints, "endpoints",
DEFAULT_ENDPOINTS_PATH, True)
stories = cli_utils.get_validated_path(args.stories, "stories",
DEFAULT_DATA_PATH)
stories = data.get_core_directory(stories)
output = args.out or DEFAULT_RESULTS_PATH
io_utils.create_directory(output)
if isinstance(args.model, list) and len(args.model) == 1:
args.model = args.model[0]
if isinstance(args.model, str):
model_path = cli_utils.get_validated_path(args.model, "model",
DEFAULT_MODELS_PATH)
if args.evaluate_model_directory:
test_core_models_in_directory(args.model, stories, output)
else:
test_core(
model=model_path,
stories=stories,
endpoints=endpoints,
output=output,
additional_arguments=vars(args),
)
else:
test_core_models(args.model, stories, output)
async def train_core_async(
domain: Union[Domain, Text],
config: Text,
stories: Text,
output: Text,
train_path: Optional[Text] = None,
fixed_model_name: Optional[Text] = None,
kwargs: Optional[Dict] = None,
) -> Optional[Text]:
"""Trains a Core model.
Args:
domain: Path to the domain file.
config: Path to the config file for Core.
stories: Path to the Core training data.
output: Output path.
train_path: If `None` the model will be trained in a temporary
directory, otherwise in the provided directory.
fixed_model_name: Name of model to be stored.
uncompress: If `True` the model will not be compressed.
kwargs: Additional training parameters.
Returns:
If `train_path` is given it returns the path to the model archive,
otherwise the path to the directory with the trained model files.
"""
skill_imports = SkillSelector.load(config, stories)
if isinstance(domain, str):
try:
domain = Domain.load(domain, skill_imports)
domain.check_missing_templates()
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 None
train_context = TempDirectoryPath(data.get_core_directory(stories, skill_imports))
with train_context as story_directory:
if not os.listdir(story_directory):
print_error(
"No stories given. Please provide stories in order to "
"train a Rasa Core model using the '--stories' argument."
)
return
return await _train_core_with_validated_data(
domain=domain,
config=config,
story_directory=story_directory,
output=output,
train_path=train_path,
fixed_model_name=fixed_model_name,
kwargs=kwargs,
)
def test_core(args: argparse.Namespace) -> None:
from rasa.test import test_core
endpoints = get_validated_path(
args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
)
stories = get_validated_path(args.stories, "stories", DEFAULT_DATA_PATH)
stories = data.get_core_directory(stories)
output = args.out or DEFAULT_RESULTS_PATH
if not os.path.exists(output):
os.makedirs(output)
if isinstance(args.model, list) and len(args.model) == 1:
args.model = args.model[0]
if isinstance(args.model, str):
model_path = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
test_core(
model=model_path,
stories=stories,
endpoints=endpoints,
output=output,
kwargs=vars(args),
)
else:
test_compare_core(args.model, stories, output)
def test_get_core_directory(project):
data_dir = os.path.join(project, "data")
core_directory = data.get_core_directory([data_dir])
core_files = os.listdir(core_directory)
assert len(core_files) == 2
assert any(file.endswith("stories.yml") for file in core_files)
assert any(file.endswith("rules.yml") for file in core_files)
async def train_core_async(
domain: Union[Domain, Text],
config: Text,
stories: Text,
output: Text,
train_path: Optional[Text] = None,
fixed_model_name: Optional[Text] = None,
uncompress: bool = False,
kwargs: Optional[Dict] = None,
) -> Optional[Text]:
"""Trains a Core model.
Args:
domain: Path to the domain file.
config: Path to the config file for Core.
stories: Path to the Core training data.
output: Output path.
train_path: If `None` the model will be trained in a temporary
directory, otherwise in the provided directory.
fixed_model_name: Name of model to be stored.
uncompress: If `True` the model will not be compressed.
kwargs: Additional training parameters.
Returns:
If `train_path` is given it returns the path to the model archive,
otherwise the path to the directory with the trained model files.
"""
config = _get_valid_config(config, CONFIG_MANDATORY_KEYS_CORE)
skill_imports = SkillSelector.load(config)
if isinstance(domain, str):
try:
domain = Domain.load(domain, skill_imports)
except InvalidDomain as e:
print_error(e)
return None
story_directory = data.get_core_directory(stories, skill_imports)
if not os.listdir(story_directory):
print_error(
"No dialogue data given. Please provide dialogue data in order to "
"train a Rasa Core model."
)
return
return await _train_core_with_validated_data(
domain=domain,
config=config,
story_directory=story_directory,
output=output,
train_path=train_path,
fixed_model_name=fixed_model_name,
uncompress=uncompress,
kwargs=kwargs,
)
def show_stories(args: argparse.Namespace):
import rasa_core.visualize
args.config = args.config
args.url = None
args.stories = data.get_core_directory(args.stories)
if os.path.exists(DEFAULT_DATA_PATH):
args.nlu_data = data.get_nlu_directory(DEFAULT_DATA_PATH)
rasa_core.visualize(args.config, args.domain, args.stories, args.nlu_data,
args.output, args.max_history)
def visualize_stories(args: argparse.Namespace):
import rasa.core.visualize
loop = asyncio.get_event_loop()
args.stories = data.get_core_directory(args.stories)
if args.nlu is None and os.path.exists(DEFAULT_DATA_PATH):
args.nlu = data.get_nlu_directory(DEFAULT_DATA_PATH)
loop.run_until_complete(
rasa.core.visualize(args.config, args.domain, args.stories, args.nlu,
args.out, args.max_history))
def interactive(args: argparse.Namespace):
from rasa.core.train import do_interactive_learning
args.finetune = False # Don't support finetuning
zipped_model = train.train(args)
model_path = model.unpack_model(zipped_model)
args.core, args.nlu = model.get_model_subdirectories(model_path)
stories_directory = data.get_core_directory(args.data)
do_interactive_learning(args, stories_directory)
shutil.rmtree(model_path)
def perform_interactive_learning(args, zipped_model):
from rasa.core.train import do_interactive_learning
if zipped_model:
model_path = model.unpack_model(zipped_model)
args.core, args.nlu = model.get_model_subdirectories(model_path)
stories_directory = data.get_core_directory(args.data)
do_interactive_learning(args, stories_directory)
shutil.rmtree(model_path)
else:
print_warning("No initial zipped trained model found.")
def test_core(args: argparse.Namespace, model_path: Optional[Text] = None
) -> None:
from rasa.test import test_core
args.model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
args.endpoints = get_validated_path(args.endpoints, "endpoints",
DEFAULT_ENDPOINTS_PATH, True)
args.config = get_validated_path(args.config, "config", DEFAULT_CONFIG_PATH)
args.stories = get_validated_path(args.stories, "stories",
DEFAULT_DATA_PATH)
args.stories = data.get_core_directory(args.stories)
test_core(model_path=model_path, **vars(args))
def perform_interactive_learning(args, zipped_model):
from rasa.core.train import do_interactive_learning
if zipped_model and os.path.exists(zipped_model):
args.model = zipped_model
with model.unpack_model(zipped_model) as model_path:
args.core, args.nlu = model.get_model_subdirectories(model_path)
stories_directory = data.get_core_directory(args.data)
do_interactive_learning(args, stories_directory)
else:
print_error(
"Interactive learning process cannot be started as no initial model was "
"found. Use 'rasa train' to train a model.")
def perform_interactive_learning(args, zipped_model):
from rasa.core.train import do_interactive_learning
if zipped_model and os.path.exists(zipped_model):
args.model = zipped_model
model_path = model.unpack_model(zipped_model)
args.core, args.nlu = model.get_model_subdirectories(model_path)
stories_directory = data.get_core_directory(args.data)
do_interactive_learning(args, stories_directory)
shutil.rmtree(model_path)
else:
print_error(
"No initial zipped trained model found. Interactive learning process "
"cannot be started.")
def test_core(args: argparse.Namespace,
model_path: Optional[Text] = None) -> None:
from rasa.test import test_core
model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
endpoints = get_validated_path(args.endpoints, "endpoints",
DEFAULT_ENDPOINTS_PATH, True)
stories = get_validated_path(args.stories, "stories", DEFAULT_DATA_PATH)
stories = data.get_core_directory(stories)
output = args.output or DEFAULT_RESULTS_PATH
args.config = get_validated_path(args.config, "config",
DEFAULT_CONFIG_PATH)
test_core(
model=model,
stories=stories,
endpoints=endpoints,
model_path=model_path,
output=output,
kwargs=vars(args),
)
async def train_core_async(domain: Text, config: Text, stories: Text,
output: Text,
train_path: Optional[Text]) -> Optional[Text]:
"""Trains a Core model.
Args:
domain: Path to the domain file.
config: Path to the config file for Core.
stories: Path to the Core training data.
output: Output path.
train_path: If `None` the model will be trained in a temporary
directory, otherwise in the provided directory.
Returns:
If `train_path` is given it returns the path to the model archive,
otherwise the path to the directory with the trained model files.
"""
import rasa_core.train
# normal (not compare) training
core_model = await rasa_core.train(domain_file=domain,
stories_file=stories,
output_path=os.path.join(
train_path, "core"),
policy_config=config)
if not train_path:
# Only Core was trained.
stories = data.get_core_directory(stories)
output_path = create_output_path(output, prefix="core-")
new_fingerprint = model.model_fingerprint(config,
domain,
stories=stories)
model.create_package_rasa(train_path, output_path, new_fingerprint)
print_success("Your Rasa Core model is trained and saved at '{}'."
"".format(output_path))
return core_model
async def train_core_async(
domain: Union[Domain, Text],
config: Text,
stories: Text,
output: Text,
train_path: Optional[Text] = None,
kwargs: Optional[Dict] = None,
) -> Optional[Text]:
"""Trains a Core model.
Args:
domain: Path to the domain file.
config: Path to the config file for Core.
stories: Path to the Core training data.
output: Output path.
train_path: If `None` the model will be trained in a temporary
directory, otherwise in the provided directory.
kwargs: Additional training parameters.
Returns:
If `train_path` is given it returns the path to the model archive,
otherwise the path to the directory with the trained model files.
"""
import rasa.core.train
config = get_valid_config(config, CONFIG_MANDATORY_KEYS_CORE)
_train_path = train_path or tempfile.mkdtemp()
if isinstance(Domain, str) or not train_path:
skill_imports = SkillSelector.load(config)
domain = Domain.load(domain, skill_imports)
story_directory = data.get_core_directory(stories, skill_imports)
else:
story_directory = stories
if not os.listdir(story_directory):
print_error(
"No dialogue data given. Please provide dialogue data in order to "
"train a Rasa Core model.")
return
# normal (not compare) training
print_color("Start training dialogue model ...", color=bcolors.OKBLUE)
await rasa.core.train(
domain_file=domain,
stories_file=story_directory,
output_path=os.path.join(_train_path, "core"),
policy_config=config,
kwargs=kwargs,
)
print_color("Done.", color=bcolors.OKBLUE)
if not train_path:
# Only Core was trained.
output_path = create_output_path(output, prefix="core-")
new_fingerprint = model.model_fingerprint(config,
domain,
stories=story_directory)
model.create_package_rasa(_train_path, output_path, new_fingerprint)
print_success(
"Your Rasa Core model is trained and saved at '{}'.".format(
output_path))
return output_path
return _train_path
