def continue_training():
request.headers.get("Accept")
epochs = request.args.get("epochs", 30)
batch_size = request.args.get("batch_size", 5)
request_params = request.get_json(force=True)
sender_id = UserMessage.DEFAULT_SENDER_ID
try:
tracker = DialogueStateTracker.from_dict(sender_id, request_params,
agent.domain.slots)
except Exception as e:
return error(400, "InvalidParameter",
"Supplied events are not valid. {}".format(e), {
"parameter": "",
"in": "body"
})
try:
# Fetches the appropriate bot response in a json format
agent.continue_training([tracker],
epochs=epochs,
batch_size=batch_size)
return '', 204
except Exception as e:
logger.exception("Caught an exception during prediction.")
return error(500, "TrainingException",
"Server failure. Error: {}".format(e))
async def continue_training(request: Request):
epochs = request.raw_args.get("epochs", 30)
batch_size = request.raw_args.get("batch_size", 5)
request_params = request.json
sender_id = UserMessage.DEFAULT_SENDER_ID
try:
tracker = DialogueStateTracker.from_dict(sender_id,
request_params,
app.agent.domain.slots)
except Exception as e:
raise ErrorResponse(400, "InvalidParameter",
"Supplied events are not valid. {}".format(e),
{"parameter": "", "in": "body"})
try:
# Fetches the appropriate bot response in a json format
app.agent.continue_training([tracker],
epochs=epochs,
batch_size=batch_size)
return response.text('', 204)
except Exception as e:
logger.exception("Caught an exception during prediction.")
raise ErrorResponse(500, "TrainingException",
"Server failure. Error: {}".format(e))
def tracker_predict():
""" Given a list of events, predicts the next action"""
sender_id = UserMessage.DEFAULT_SENDER_ID
request_params = request.get_json(force=True)
verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART)
try:
tracker = DialogueStateTracker.from_dict(sender_id, request_params,
agent.domain.slots)
except Exception as e:
return error(400, "InvalidParameter",
"Supplied events are not valid. {}".format(e), {
"parameter": "",
"in": "body"
})
policy_ensemble = agent.policy_ensemble
probabilities, policy = \
policy_ensemble.probabilities_using_best_policy(tracker,
agent.domain)
scores = [{
"action": a,
"score": p
} for a, p in zip(agent.domain.action_names, probabilities)]
return jsonify({
"scores": scores,
"policy": policy,
"tracker": tracker.current_state(verbosity)
})
def retrieve(self, sender_id):
stored = self.conversations.find_one({"sender_id": sender_id})
# look for conversations which have used an `int` sender_id in the past
# and update them.
if stored is None and sender_id.isdigit():
from pymongo import ReturnDocument
stored = self.conversations.find_one_and_update(
{"sender_id": int(sender_id)},
{"$set": {
"sender_id": str(sender_id)
}},
return_document=ReturnDocument.AFTER)
if stored is not None:
if self.domain:
return DialogueStateTracker.from_dict(sender_id,
stored.get("events"),
self.domain.slots)
else:
logger.warning("Can't recreate tracker from mongo storage "
"because no domain is set. Returning `None` "
"instead.")
return None
else:
return None
def load_tracker_from_json(tracker_dump, domain):
# type: (Text, Agent) -> DialogueStateTracker
"""Read the json dump from the file and instantiate a tracker it."""
tracker_json = json.loads(utils.read_file(tracker_dump))
sender_id = tracker_json.get("sender_id", UserMessage.DEFAULT_SENDER_ID)
return DialogueStateTracker.from_dict(sender_id,
tracker_json.get("events", []),
domain)
def _load_tracker_from_json(tracker_dump, agent):
# type: (Text, Agent) -> DialogueStateTracker
"""Read the json dump from the file and instantiate a tracker it."""
tracker_json = json.loads(utils.read_file(tracker_dump))
sender_id = tracker_json.get("sender_id", UserMessage.DEFAULT_SENDER_ID)
return DialogueStateTracker.from_dict(sender_id,
tracker_json.get("events", []),
agent.domain)
def replace_events(sender_id):
"""Use a list of events to set a conversations tracker to a state."""
request_params = request.get_json(force=True)
tracker = DialogueStateTracker.from_dict(sender_id, request_params,
agent.domain.slots)
# will override an existing tracker with the same id!
agent.tracker_store.save(tracker)
return jsonify(tracker.current_state(EventVerbosity.AFTER_RESTART))
def load_tracker_from_json(tracker_dump: Text,
domain: Domain) -> DialogueStateTracker:
"""Read the json dump from the file and instantiate a tracker it."""
tracker_json = json.loads(utils.read_file(tracker_dump))
sender_id = tracker_json.get("sender_id", UserMessage.DEFAULT_SENDER_ID)
return DialogueStateTracker.from_dict(sender_id,
tracker_json.get("events", []),
domain.slots)
def replace_events(sender_id):
"""Use a list of events to set a conversations tracker to a state."""
request_params = request.get_json(force=True)
tracker = DialogueStateTracker.from_dict(sender_id,
request_params,
agent.domain.slots)
# will override an existing tracker with the same id!
agent.tracker_store.save(tracker)
return jsonify(tracker.current_state(should_include_events=True))
def generate_response(nlg_call, domain):
kwargs = nlg_call.get("arguments", {})
template = nlg_call.get("template")
sender_id = nlg_call.get("tracker", {}).get("sender_id")
events = nlg_call.get("tracker", {}).get("events")
tracker = DialogueStateTracker.from_dict(sender_id, events, domain.slots)
channel_name = nlg_call.get("channel")
return TemplatedNaturalLanguageGenerator(domain.templates).generate(
template, tracker, channel_name, **kwargs)
def _init_tracker(self, sender_id, tracker):
if self.domain:
return DialogueStateTracker.from_dict(sender_id, tracker["events"],
self.domain.slots)
else:
logger.warning("Can't recreate tracker from mongo storage "
"because no domain is set. Returning `None` "
"instead.")
return None
def test_current_state_no_events(default_agent):
tracker_dump = "data/test_trackers/tracker_moodbot.json"
tracker_json = json.loads(utils.read_file(tracker_dump))
tracker = DialogueStateTracker.from_dict(tracker_json.get("sender_id"),
tracker_json.get("events", []),
default_agent.domain.slots)
state = tracker.current_state(EventVerbosity.NONE)
assert state.get("events") is None
def update_tracker(sender_id):
"""Use a list of events to set a conversations tracker to a state."""
request_params = request.get_json(force=True)
tracker = DialogueStateTracker.from_dict(sender_id, request_params,
agent().domain)
agent().tracker_store.save(tracker)
# will override an existing tracker with the same id!
agent().tracker_store.save(tracker)
return jsonify(tracker.current_state(should_include_events=True))
def generate_response(nlg_call, domain):
kwargs = nlg_call.get("arguments", {})
template = nlg_call.get("template")
sender_id = nlg_call.get("tracker", {}).get("sender_id")
events = nlg_call.get("tracker", {}).get("events")
tracker = DialogueStateTracker.from_dict(
sender_id, events, domain.slots)
channel_name = nlg_call.get("channel")
return TemplatedNaturalLanguageGenerator(domain.templates).generate(
template, tracker, channel_name, **kwargs)
def tracker(self,
sender_id: Text,
domain: Domain,
event_verbosity: EventVerbosity = EventVerbosity.ALL,
until: Optional[int] = None):
"""Retrieve and recreate a tracker fetched from the remote instance."""
tracker_json = self.tracker_json(sender_id, event_verbosity, until)
tracker = DialogueStateTracker.from_dict(
sender_id, tracker_json.get("events", []), domain.slots)
return tracker
async def replace_events(request: Request, sender_id: Text):
"""Use a list of events to set a conversations tracker to a state."""
request_params = request.json
verbosity = event_verbosity_parameter(request,
EventVerbosity.AFTER_RESTART)
tracker = DialogueStateTracker.from_dict(sender_id,
request_params,
app.agent.domain.slots)
# will override an existing tracker with the same id!
app.agent.tracker_store.save(tracker)
return response.json(tracker.current_state(verbosity))
def update_tracker(self, request, sender_id):
"""Use a list of events to set a conversations tracker to a state."""
request.setHeader('Content-Type', 'application/json')
request_params = json.loads(request.content.read().decode(
'utf-8', 'strict'))
tracker = DialogueStateTracker.from_dict(sender_id, request_params,
self.agent.domain)
self.agent.tracker_store.save(tracker)
# will override an existing tracker with the same id!
self.agent.tracker_store.save(tracker)
return json.dumps(tracker.current_state(should_include_events=True))
def retrieve(self, sender_id):
stored = self.conversations.find_one({"sender_id": sender_id})
if stored is not None:
if self.domain:
return DialogueStateTracker.from_dict(sender_id,
stored.get("events"),
self.domain.slots)
else:
logger.warning("Can't recreate tracker from mongo storage "
"because no domain is set. Returning `None` "
"instead.")
return None
else:
return None
def test_current_state_all_events(default_agent):
tracker_dump = "data/test_trackers/tracker_moodbot.json"
tracker_json = json.loads(utils.read_file(tracker_dump))
tracker_json["events"].insert(3, {"event": "restart"})
tracker = DialogueStateTracker.from_dict(tracker_json.get("sender_id"),
tracker_json.get("events", []),
default_agent.domain.slots)
evts = [e.as_dict() for e in tracker.events]
state = tracker.current_state(EventVerbosity.ALL)
assert state.get("events") == evts
def retrieve(self, sender_id):
stored = self.conversations.find_one({"sender_id": sender_id})
if stored is not None:
if self.domain:
return DialogueStateTracker.from_dict(sender_id,
stored.get("events"),
self.domain.slots)
else:
logger.warning("Can't recreate tracker from mongo storage "
"because no domain is set. Returning `None` "
"instead.")
return None
else:
return None
async def generate_response(nlg_call, domain):
"""Mock response generator.
Generates the responses from the bot's domain file.
"""
kwargs = nlg_call.get("arguments", {})
template = nlg_call.get("template")
sender_id = nlg_call.get("tracker", {}).get("sender_id")
events = nlg_call.get("tracker", {}).get("events")
tracker = DialogueStateTracker.from_dict(
sender_id, events, domain.slots)
channel_name = nlg_call.get("channel")
return await TemplatedNaturalLanguageGenerator(domain.templates).generate(
template, tracker, channel_name, **kwargs)
def test_read_json_dump(default_agent):
json_content = utils.read_file("data/test_trackers/tracker_moodbot.json")
tracker_json = json.loads(json_content)
sender_id = tracker_json.get("sender_id", UserMessage.DEFAULT_SENDER_ID)
restored_tracker = DialogueStateTracker.from_dict(
sender_id, tracker_json.get("events", []), default_agent.domain)
assert len(restored_tracker.events) == 7
assert restored_tracker.latest_action_name == "action_listen"
assert not restored_tracker.is_paused()
assert restored_tracker.sender_id == "mysender"
assert restored_tracker.events[-1].timestamp == 1517821726.211042
restored_state = restored_tracker.current_state(should_include_events=True)
assert restored_state == tracker_json
def tracker(self,
sender_id, # type: Text
domain, # type: Domain
only_events_after_latest_restart=False, # type: bool
include_events=True, # type: bool
until=None # type: Optional[int]
):
"""Retrieve and recreate a tracker fetched from the remote instance."""
tracker_json = self.tracker_json(
sender_id, only_events_after_latest_restart,
include_events, until)
tracker = DialogueStateTracker.from_dict(
sender_id, tracker_json.get("events", []), domain)
return tracker
def test_dump_and_restore_as_json(default_agent, tmpdir_factory):
trackers = default_agent.load_data(DEFAULT_STORIES_FILE)
for tracker in trackers:
out_path = tmpdir_factory.mktemp("tracker").join("dumped_tracker.json")
dumped = tracker.current_state(should_include_events=True)
utils.dump_obj_as_json_to_file(out_path.strpath, dumped)
tracker_json = json.loads(utils.read_file(out_path.strpath))
sender_id = tracker_json.get("sender_id",
UserMessage.DEFAULT_SENDER_ID)
restored_tracker = DialogueStateTracker.from_dict(
sender_id, tracker_json.get("events", []), default_agent.domain)
assert restored_tracker == tracker
def tracker(
self,
sender_id, # type: Text
domain, # type: Domain
should_ignore_restarts=False, # type: bool
include_events=True, # type: bool
until=None # type: Optional[int]
):
"""Retrieve and recreate a tracker fetched from the remote instance."""
tracker_json = self.tracker_json(sender_id, should_ignore_restarts,
include_events, until)
tracker = DialogueStateTracker.from_dict(
sender_id, tracker_json.get("events", []), domain.slots)
return tracker
def retrieve(self, sender_id: Text) -> DialogueStateTracker:
"""Create a tracker from all previously stored events."""
query = self.session.query(self.SQLEvent)
result = query.filter_by(sender_id=sender_id).all()
events = [json.loads(event.data) for event in result]
if self.domain and len(events) > 0:
logger.debug("Recreating tracker "
"from sender id '{}'".format(sender_id))
return DialogueStateTracker.from_dict(sender_id, events,
self.domain.slots)
else:
logger.debug("Can't retrieve tracker matching"
"sender id '{}' from SQL storage. "
"Returning `None` instead.".format(sender_id))
def tracker_predict():
""" Given a list of events, predicts the next action"""
sender_id = UserMessage.DEFAULT_SENDER_ID
request_params = request.get_json(force=True)
for param in request_params:
if param.get('event', None) is None:
return Response(
"""Invalid list of events provided.""",
status=400)
tracker = DialogueStateTracker.from_dict(sender_id,
request_params,
agent.domain.slots)
policy_ensemble = agent.policy_ensemble
probabilities = policy_ensemble.probabilities_using_best_policy(tracker, agent.domain)
probability_dict = {agent.domain.action_for_index(idx, agent.action_endpoint).name(): probability
for idx, probability in enumerate(probabilities)}
return jsonify(probability_dict)
def test_current_state_applied_events(default_agent):
tracker_dump = "data/test_trackers/tracker_moodbot.json"
tracker_json = json.loads(utils.read_file(tracker_dump))
# add some events that result in other events not being applied anymore
tracker_json["events"].insert(1, {"event": "restart"})
tracker_json["events"].insert(7, {"event": "rewind"})
tracker_json["events"].insert(8, {"event": "undo"})
tracker = DialogueStateTracker.from_dict(tracker_json.get("sender_id"),
tracker_json.get("events", []),
default_agent.domain.slots)
evts = [e.as_dict() for e in tracker.events]
applied_events = [evts[2], evts[9]]
state = tracker.current_state(EventVerbosity.APPLIED)
assert state.get("events") == applied_events
def test_dump_and_restore_as_json(default_agent, tmpdir):
trackers = training.extract_trackers(
DEFAULT_STORIES_FILE, default_agent.domain, default_agent.featurizer,
default_agent.interpreter, default_agent.policy_ensemble.max_history())
out_path = tmpdir.join("dumped_tracker.json")
for tracker in trackers:
dumped = tracker.current_state(should_include_events=True)
utils.dump_obj_as_json_to_file(out_path.strpath, dumped)
tracker_json = json.loads(utils.read_file(out_path.strpath))
sender_id = tracker_json.get("sender_id",
UserMessage.DEFAULT_SENDER_ID)
restored_tracker = DialogueStateTracker.from_dict(
sender_id, tracker_json.get("events", []), default_agent.domain)
assert restored_tracker == tracker
def tracker_predict():
""" Given a list of events, predicts the next action"""
sender_id = UserMessage.DEFAULT_SENDER_ID
request_params = request.get_json(force=True)
for param in request_params:
if param.get('event', None) is None:
return Response("""Invalid list of events provided.""",
status=400)
tracker = DialogueStateTracker.from_dict(sender_id, request_params,
agent.domain.slots)
policy_ensemble = agent.policy_ensemble
probabilities = policy_ensemble.probabilities_using_best_policy(
tracker, agent.domain)
probability_dict = {
agent.domain.action_for_index(idx, agent.action_endpoint).name():
probability
for idx, probability in enumerate(probabilities)
}
return jsonify(probability_dict)
def continue_training():
request.headers.get("Accept")
epochs = request.args.get("epochs", 30)
batch_size = request.args.get("batch_size", 5)
request_params = request.get_json(force=True)
tracker = DialogueStateTracker.from_dict(UserMessage.DEFAULT_SENDER_ID,
request_params,
agent.domain.slots)
try:
# Fetches the appropriate bot response in a json format
agent.continue_training([tracker],
epochs=epochs,
batch_size=batch_size)
return '', 204
except Exception as e:
logger.exception("Caught an exception during prediction.")
return Response(jsonify(error="Server failure. Error: {}"
"".format(e)),
status=500,
content_type="application/json")
def continue_training():
request.headers.get("Accept")
epochs = request.args.get("epochs", 30)
batch_size = request.args.get("batch_size", 5)
request_params = request.get_json(force=True)
tracker = DialogueStateTracker.from_dict(UserMessage.DEFAULT_SENDER_ID,
request_params,
agent.domain.slots)
try:
# Fetches the appropriate bot response in a json format
agent.continue_training([tracker],
epochs=epochs,
batch_size=batch_size)
return '', 204
except Exception as e:
logger.exception("Caught an exception during prediction.")
return Response(jsonify(error="Server failure. Error: {}"
"".format(e)),
status=500,
content_type="application/json")
