async def inner(file_name: Path,
ignore_action_unlikely_intent: bool) -> Agent:
config = textwrap.dedent(f"""
version: "{LATEST_TRAINING_DATA_FORMAT_VERSION}"
policies:
- name: RulePolicy
restrict_rules: false
""")
config_path = tmp_path / "config.yml"
rasa.shared.utils.io.write_text_file(config, config_path)
rule_file = tmp_path / "rules.yml"
shutil.copy2(file_name, rule_file)
training_data = rule_file.read_text()
training_data_for_rules = training_data.replace("stories:", "rules:")
training_data_for_rules = training_data_for_rules.replace(
"story:", "rule:")
rule_file.write_text(training_data_for_rules)
model_path = await trained_async(moodbot_domain_path, str(config_path),
str(rule_file))
monkeypatch.setattr(
RulePolicy,
"_prediction_states",
_custom_prediction_states_for_rules(ignore_action_unlikely_intent),
)
return Agent.load_local_model(model_path)
async def form_bot_agent(trained_async, tmpdir_factory) -> Agent:
zipped_model = await trained_async(
domain="examples/formbot/domain.yml",
config="examples/formbot/config.yml",
training_files=["examples/formbot/data/stories.md"],
)
return Agent.load_local_model(zipped_model)
async def response_selector_agent(trained_async: Callable) -> Agent:
zipped_model = await trained_async(
domain="examples/responseselectorbot/domain.yml",
config="examples/responseselectorbot/config.yml",
training_files=[
"examples/responseselectorbot/data/rules.yml",
"examples/responseselectorbot/data/stories.yml",
"examples/responseselectorbot/data/nlu.yml",
],
)
return Agent.load_local_model(zipped_model)
async def form_bot_agent(trained_async: Callable) -> Agent:
endpoint = EndpointConfig("https://example.com/webhooks/actions")
zipped_model = await trained_async(
domain="examples/formbot/domain.yml",
config="examples/formbot/config.yml",
training_files=[
"examples/formbot/data/rules.yml",
"examples/formbot/data/stories.yml",
],
)
return Agent.load_local_model(zipped_model, action_endpoint=endpoint)
async def test_end_to_evaluation_trips_circuit_breaker(
e2e_story_file_trips_circuit_breaker_path: Text,
trained_async: Callable,
tmp_path: Path,
):
config = textwrap.dedent(f"""
version: '{LATEST_TRAINING_DATA_FORMAT_VERSION}'
policies:
- name: MemoizationPolicy
max_history: 11
pipeline: []
""")
config_path = tmp_path / "config.yml"
rasa.shared.utils.io.write_text_file(config, config_path)
model_path = await trained_async(
"data/test_domains/default.yml",
str(config_path),
e2e_story_file_trips_circuit_breaker_path,
)
agent = Agent.load_local_model(model_path)
generator = _create_data_generator(
e2e_story_file_trips_circuit_breaker_path,
agent,
use_conversation_test_files=True,
)
test_stories = generator.generate_story_trackers()
story_evaluation, num_stories, _ = await _collect_story_predictions(
test_stories, agent)
circuit_trip_predicted = [
"utter_greet",
"utter_greet",
"utter_greet",
"utter_greet",
"utter_greet",
"utter_greet",
"utter_greet",
"utter_greet",
"utter_greet",
"utter_greet",
"circuit breaker tripped",
"circuit breaker tripped",
]
assert (story_evaluation.evaluation_store.action_predictions ==
circuit_trip_predicted)
assert num_stories == 1
async def _trained_default_agent(
tmp_path_factory: TempPathFactory, stories_path: Text, trained_async: Callable
) -> Agent:
project_path = tmp_path_factory.mktemp("project")
config = textwrap.dedent(
f"""
version: "{LATEST_TRAINING_DATA_FORMAT_VERSION}"
policies:
- name: AugmentedMemoizationPolicy
max_history: 3
- name: RulePolicy
"""
)
config_path = project_path / "config.yml"
rasa.shared.utils.io.write_text_file(config, config_path)
model_path = await trained_async(
"data/test_domains/default_with_slots.yml", str(config_path), [stories_path]
)
return Agent.load_local_model(model_path)
async def e2e_bot_agent(e2e_bot: Optional[Path],) -> Agent:
return Agent.load_local_model(e2e_bot)
async def response_selector_agent(
trained_response_selector_bot: Optional[Path],
) -> Agent:
return Agent.load_local_model(trained_response_selector_bot)
def mood_agent(trained_moodbot_path: Text) -> Agent:
return Agent.load_local_model(model_path=trained_moodbot_path)
async def form_bot_agent(trained_formbot: Text) -> Agent:
endpoint = EndpointConfig("https://example.com/webhooks/actions")
return Agent.load_local_model(trained_formbot, action_endpoint=endpoint)
async def restaurantbot_agent(trained_restaurantbot: Optional[Path],) -> Agent:
return Agent.load_local_model(trained_restaurantbot)
async def test_predict_next_action_with_hidden_rules(trained_async: Callable,
tmp_path: Path):
rule_intent = "rule_intent"
rule_action = "rule_action"
story_intent = "story_intent"
story_action = "story_action"
rule_slot = "rule_slot"
story_slot = "story_slot"
domain_content = textwrap.dedent(f"""
version: "2.0"
intents:
- {rule_intent}
- {story_intent}
actions:
- {rule_action}
- {story_action}
slots:
{rule_slot}:
type: text
{story_slot}:
type: text
""")
domain = Domain.from_yaml(domain_content)
domain_path = tmp_path / "domain.yml"
rasa.shared.utils.io.write_text_file(domain_content, domain_path)
training_data = textwrap.dedent(f"""
version: "{LATEST_TRAINING_DATA_FORMAT_VERSION}"
rules:
- rule: rule
steps:
- intent: {rule_intent}
- action: {rule_action}
- slot_was_set:
- {rule_slot}: {rule_slot}
stories:
- story: story
steps:
- intent: {story_intent}
- action: {story_action}
- slot_was_set:
- {story_slot}: {story_slot}
""")
training_data_path = tmp_path / "data.yml"
rasa.shared.utils.io.write_text_file(training_data, training_data_path)
config = textwrap.dedent(f"""
version: "{LATEST_TRAINING_DATA_FORMAT_VERSION}"
policies:
- name: RulePolicy
- name: MemoizationPolicy
""")
config_path = tmp_path / "config.yml"
rasa.shared.utils.io.write_text_file(config, config_path)
model_path = await trained_async(str(domain_path), str(config_path),
[str(training_data_path)])
agent = Agent.load_local_model(model_path)
processor = agent.create_processor()
tracker = DialogueStateTracker.from_events(
"casd",
evts=[
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered(intent={"name": rule_intent}),
],
slots=domain.slots,
)
action, prediction = processor.predict_next_action(tracker)
assert action._name == rule_action
assert prediction.hide_rule_turn
processor._log_action_on_tracker(tracker, action,
[SlotSet(rule_slot, rule_slot)],
prediction)
action, prediction = processor.predict_next_action(tracker)
assert isinstance(action, ActionListen)
assert prediction.hide_rule_turn
processor._log_action_on_tracker(tracker, action, None, prediction)
tracker.events.append(UserUttered(intent={"name": story_intent}))
# rules are hidden correctly if memo policy predicts next actions correctly
action, prediction = processor.predict_next_action(tracker)
assert action._name == story_action
assert not prediction.hide_rule_turn
processor._log_action_on_tracker(tracker, action,
[SlotSet(story_slot, story_slot)],
prediction)
action, prediction = processor.predict_next_action(tracker)
assert isinstance(action, ActionListen)
assert not prediction.hide_rule_turn
async def restaurantbot_agent(trained_restaurantbot: Path) -> Agent:
return Agent.load_local_model(str(trained_restaurantbot))
import asyncio
import yaml
from rasa.core.agent import Agent
from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH
from rasa.utils.endpoints import EndpointConfig
# 需要先训练好一个模型
with open(DEFAULT_ENDPOINTS_PATH) as fp:
endpoint = EndpointConfig.from_dict(yaml.load(fp).get("action_endpoint"))
agent = Agent.load_local_model(
model_path="models",
action_endpoint=endpoint
)
print(asyncio.run(agent.handle_text("rasax")))
print(asyncio.run(agent.handle_text("你是机器人吗？")))
print(asyncio.run(agent.handle_text("成都天气好吗？")))
