def give_instructions(self, event):
# TODO event not used, answer, give_away_message def outside __init__, var separator not used,
""" pick how many objects in total will be enumerated. for last object change separator from "," to "and".
pick object. build up message. update counter. pick object to ask the question
:param event:
:return:
"""
separator = ""
counter = {}
message = ""
total = random.randint(1, 5)
for i in range(0, total):
if i == total - 2:
separator = " and "
elif i == total - 1:
separator = ""
else:
separator = ", "
obj = random.choice(global_objects)
message += msg.indef_article(obj)
message += separator
if obj not in counter:
counter[obj] = 0
counter[obj] += 1
object_in_question = random.choice(global_objects)
self.answer = "Yes" if counter.get(object_in_question, 0) > 0 else "No"
self.give_away_message = "I do have {object}." if self.answer == "Yes" else "I do not have {object}."
self.give_away_message = self.give_away_message.format(object = msg.indef_article(object_in_question))
self.give_away_message = "Wrong. " + self.give_away_message
self.set_message('I have {listing_objects}. Do I have {object}? '.format(
listing_objects = message, object = msg.indef_article(object_in_question)))
def on_object_given(self, event):
object_ = event.get_match(2)
if object_ in self.state.teacher_accepts:
self.state.learner_inventory[object_] -= 1
self.state.teacher_inventory[object_] += 1
self.set_message("You gave me {indef_object}.".format(
indef_object=msg.indef_article(object_)))
else:
self.set_message("I haven't asked you for {indef_object}.".format(
indef_object=msg.indef_article(object_)))
def on_object_given(self, event):
object_ = event.get_match(2)
if object_ in self.state.teacher_accepts:
self.state.learner_inventory[object_] -= 1
self.state.teacher_inventory[object_] += 1
self.set_message("You gave me {indef_object}.".format(
indef_object=msg.indef_article(object_)))
else:
self.set_message("I haven't asked you for {indef_object}.".format(
indef_object=msg.indef_article(object_)))
def on_start(self, event):
ws = self.get_world().state
# pick a random object
target_obj, = random.sample(objects, 1)
self.state.target_obj = target_obj
# save how many objects of this we have
self.state.initial_count = ws.teacher_inventory[target_obj]
# save how many instances of the object the learner intially had
self.state.learner_initial_count = ws.learner_inventory[target_obj]
# choose some random direction
self.direction = random.choice(list(self.get_world().valid_directions
.keys()))
# measure a cell one step in that direction
self.obj_pos = ws.learner_pos + \
self.get_world().valid_directions[self.direction]
# put an object in the given position
self.get_world().put_entity(self.obj_pos, target_obj, True, True)
# initialize a variable to check if the object has been picked up
self.object_picked_up = False
# inform the world that we can expect to receive such an object
ws.teacher_accepts.add(self.state.target_obj)
self.set_message("There is {indef_object} {direction} from you."
" Pick it up and give it to me.".format(
indef_object=msg.indef_article(
self.state.target_obj),
direction=self.direction))
def on_start(self, event):
ws = self.get_world().state
# pick a random object
target_obj, = random.sample(objects, 1)
self.state.target_obj = target_obj
# save how many objects of this we have
self.state.initial_count = ws.teacher_inventory[target_obj]
# save how many instances of the object the learner intially had
self.state.learner_initial_count = ws.learner_inventory[target_obj]
# choose some random direction
self.direction = random.choice(
list(self.get_world().valid_directions.keys()))
# measure a cell one step in that direction
self.obj_pos = ws.learner_pos + \
self.get_world().valid_directions[self.direction]
# put an object in the given position
self.get_world().put_entity(self.obj_pos, target_obj, True, True)
# initialize a variable to check if the object has been picked up
self.object_picked_up = False
# inform the world that we can expect to receive such an object
ws.teacher_accepts.add(self.state.target_obj)
self.set_message("There is {indef_object} {direction} from you."
" Pick it up and give it to me.".format(
indef_object=msg.indef_article(
self.state.target_obj),
direction=self.direction))
def give_instructions(self, event):
# TODO event not used, separator not used, local var separtor not used
""" pick how many objects in total will be described. for last object change separator from "," to "and".
pick object. build up message update counter. pick object to ask the question.
:param event:
:return:
"""
separator = ""
counter = {}
partial_message = ""
total = random.randint(1, max_total)
for i in range(0, total):
if i == total - 2:
separator = " and "
elif i == total - 1:
separator = ""
else:
separator = ", "
obj = vocabulary[random.randint(1, vocab_size - 1)]
partial_message += msg.indef_article(obj)
partial_message += separator
if obj not in counter:
counter[obj] = 0
counter[obj] += 1
object_in_question = vocabulary[random.randint(1, vocab_size - 1)]
# TODO def outside __init__ .answer, .give_away_message
self.answer = msg.numbers_in_words[counter.get(object_in_question, 0)]
self.give_away_message = 'Wrong. The right answer is: {answer}.'.format(
answer=self.answer)
self.set_message(
"I have {listing_objects}. How many {object} do I have? ".format(
listing_objects=partial_message,
object=msg.pluralize(object_in_question, 2)))
def on_gave_me_target_object(self, event):
if self.stage == 'waiting-give-back':
self.time_gave_me_object = self.get_time()
self.set_message(
"Good! You gave me {indef_object}. "
"How many {objects} do you have now?".format(
indef_object=msg.indef_article(self.state.target_obj),
objects=msg.pluralize(self.state.target_obj, 2)))
self.stage = 'final-query'
def on_gave_me_target_object(self, event):
if self.stage == 'waiting-give-back':
self.time_gave_me_object = self.get_time()
self.set_message(
"Good! You gave me {indef_object}. "
"How many {objects} do you have now?".format(
indef_object=msg.indef_article(self.state.target_obj),
objects=msg.pluralize(self.state.target_obj, 2)))
self.stage = 'final-query'
def give_instructions(self, event):
separator = ""
counter = {}
message = ""
# pick how many objects in total will be enumerated
total = random.randint(1, 5)
for i in range(0, total):
# for last object change separator from "," to "and"
if i == total - 2:
separator = " and "
elif i == total - 1:
separator = ""
else:
separator = ", "
# pick object
obj = random.choice(global_objects)
# build up message
message += msg.indef_article(obj)
message += separator
# update counter
if obj not in counter:
counter[obj] = 0
counter[obj] += 1
# pick object to ask the question
object_in_question = random.choice(global_objects)
self.answer = "Yes" if counter.get(object_in_question, 0) > 0 else "No"
self.give_away_message = "I do have {object}." \
if self.answer == "Yes" else "I do not have {object}."
self.give_away_message = self.give_away_message \
.format(object=msg.indef_article(object_in_question))
self.give_away_message = "Wrong. " + self.give_away_message
self.set_message('I have {listing_objects}. Do I have {object}? '
.format(
listing_objects=message,
object=msg.indef_article(object_in_question)
))
def give_instructions(self, event):
separator = ""
counter = {}
message = ""
# pick how many objects in total will be enumerated
total = random.randint(1, 5)
for i in range(0, total):
# for last object change separator from "," to "and"
if i == total - 2:
separator = " and "
elif i == total - 1:
separator = ""
else:
separator = ", "
# pick object
obj = random.choice(global_objects)
# build up message
message += msg.indef_article(obj)
message += separator
# update counter
if obj not in counter:
counter[obj] = 0
counter[obj] += 1
# pick object to ask the question
object_in_question = random.choice(global_objects)
self.answer = "Yes" if counter.get(object_in_question, 0) > 0 else "No"
self.give_away_message = "I do have {object}." \
if self.answer == "Yes" else "I do not have {object}."
self.give_away_message = self.give_away_message \
.format(object=msg.indef_article(object_in_question))
self.give_away_message = "Wrong. " + self.give_away_message
self.set_message('I have {listing_objects}. Do I have {object}? '
.format(
listing_objects=message,
object=msg.indef_article(object_in_question)
))
def on_gave_me_target_object(self, event):
# TODO event not used, time_gave_me_oject, stage def outside __init__
""" if I have one more of the target object, the learner solved the task if it also picked up the object in
the grid.
:param event:
:return:
"""
if self.stage == 'waiting-give-back':
self.time_gave_me_object = self.get_time()
self.set_message("Good! You gave me {indef_object}. " "How many {objects} do you have now?".format(
indef_object = msg.indef_article(self.state.target_obj),
objects = msg.pluralize(self.state.target_obj, 2)))
self.stage = 'final-query'
def on_start(self, event):
ws = self.get_world().state
# pick a random object
self.state.target_obj, = random.sample(objects, 1)
# give one of it to the learner
ws.learner_inventory[self.state.target_obj] += 1
# save how many objects of this we have
self.state.initial_count = ws.teacher_inventory[self.state.target_obj]
# inform the world that we can expect to receive such an object
ws.teacher_accepts.add(self.state.target_obj)
self.set_message("I gave you {indef_object}. Give it back to me "
"by saying \"I give you {indef_object}\"."
.format(indef_object=msg.indef_article(
self.state.target_obj)))
def on_start(self, event):
""" pick a random object. give one of it to the learner. save how many objects of this we have. inform the
world that we can expect to receive such an object.
:param event:
:return:
"""
# TODO event not used
ws = self.get_world().state
self.state.target_obj, = random.sample(objects, 1)
ws.learner_inventory[self.state.target_obj] += 1
self.state.initial_count = ws.teacher_inventory[self.state.target_obj]
ws.teacher_accepts.add(self.state.target_obj)
self.set_message("I gave you {indef_object}. Give it back to me " "by saying \"I give you {indef_object}\"."
.format(indef_object = msg.indef_article(self.state.target_obj)))
def on_start(self, event):
# TODO event not used, Target_obj def outside __inti__
""" choose some random object, find the cell in front of the learner. place the object there
:param event:
:return:
"""
self.target_obj, = random.sample(objects, 1)
ws = self.get_world().state
ld = self.get_world().valid_directions[ws.learner_direction]
lp = ws.learner_pos
self.state.initial_count = ws.learner_inventory[self.target_obj]
self.get_world().put_entity(lp + ld, self.target_obj, True, True)
self.add_handler(on_state_changed(lambda ws, ts: ws.learner_inventory[self.target_obj] == ts.initial_count + 1)
(self.on_object_picked_up))
self.set_message("You have {indef_object} in front of you. " "Pick up the {object}.".format(
indef_object = msg.indef_article(self.target_obj), object = self.target_obj))
def on_answer_query(self, event):
# if we are waiting for an object, then we don't expect an answer
# to a query
if self.stage == 'waiting-give-back':
return
# if you just gave me an object, then this is not the
# answer for a query
if self.time_gave_me_object == self.get_time():
return
# short variable for the world state
ws = self.get_world().state
# we check if the learner's answer matches the number of instances
# it has of the given object
count = ws.learner_inventory[self.state.target_obj]
# get the answer of the learner and parse it
answer = event.get_match(1)
try:
num_answer = msg.string_to_number(answer)
except ValueError:
num_answer = None
# check if the learner has failed
self.failed = self.failed or num_answer != count
# get a feedback response
feedback = random.choice(msg.congratulations) if num_answer == count \
else random.choice(msg.failed)
if self.stage == 'initial-query':
ws.learner_inventory[self.state.target_obj] += 1
self.set_message(
"{feedback} I gave you {indef_object}. "
"How many {objects} do you have now?".format(
indef_object=msg.indef_article(self.state.target_obj),
objects=msg.pluralize(self.state.target_obj, 2),
feedback=feedback))
self.stage = 'one-more-query'
elif self.stage == 'one-more-query':
self.set_message(
"{feedback} Now give the {object} back to me.".format(
object=self.state.target_obj, feedback=feedback))
ws.teacher_accepts.add(self.state.target_obj)
self.stage = 'waiting-give-back'
elif self.stage == 'final-query':
# reward the learner if it replied correctly all the questions
if not self.failed:
self.set_reward(1, feedback)
else:
self.set_reward(0, feedback)
def on_answer_query(self, event):
# if we are waiting for an object, then we don't expect an answer
# to a query
if self.stage == 'waiting-give-back':
return
# if you just gave me an object, then this is not the
# answer for a query
if self.time_gave_me_object == self.get_time():
return
# short variable for the world state
ws = self.get_world().state
# we check if the learner's answer matches the number of instances
# it has of the given object
count = ws.learner_inventory[self.state.target_obj]
# get the answer of the learner and parse it
answer = event.get_match(1)
try:
num_answer = msg.string_to_number(answer)
except ValueError:
num_answer = None
# check if the learner has failed
self.failed = self.failed or num_answer != count
# get a feedback response
feedback = random.choice(msg.congratulations) if num_answer == count \
else random.choice(msg.failed)
if self.stage == 'initial-query':
ws.learner_inventory[self.state.target_obj] += 1
self.set_message(
"{feedback} I gave you {indef_object}. "
"How many {objects} do you have now?".format(
indef_object=msg.indef_article(self.state.target_obj),
objects=msg.pluralize(self.state.target_obj, 2),
feedback=feedback))
self.stage = 'one-more-query'
elif self.stage == 'one-more-query':
self.set_message("{feedback} Now give the {object} back to me."
.format(object=self.state.target_obj,
feedback=feedback))
ws.teacher_accepts.add(self.state.target_obj)
self.stage = 'waiting-give-back'
elif self.stage == 'final-query':
# reward the learner if it replied correctly all the questions
if not self.failed:
self.set_result(1, feedback)
else:
self.set_result(0, feedback)
def on_start(self, event):
# TODO event not used, target_obj, direction, def outside __inti__, ws shadows
""" choose a random object. find a random cell around the learner. place the object there.
:param event:
:return:
"""
self.target_obj, = random.sample(objects, 1)
self.direction = random.choice(list(self.get_world().valid_directions.keys()))
ws = self.get_world().state
p = ws.learner_pos + self.get_world().valid_directions[self.direction]
self.state.initial_count = ws.learner_inventory[self.target_obj]
self.get_world().put_entity(p, self.target_obj, True, True)
self.add_handler(on_state_changed(lambda ws, ts: ws.learner_inventory[self.target_obj] == ts.initial_count + 1)
(self.on_object_picked_up))
self.set_message("There is {indef_object} {direction} from you, " "pick up the {object}.".format(
indef_object = msg.indef_article(self.target_obj),
direction = self.direction, object = self.target_obj))
def give_instructions(self, event):
separator = ""
counter = {}
partial_message = ""
# pick how many objects in total will be described
total = random.randint(1, max_total)
for i in range(0, total):
# for last object change separator from "," to "and"
if i == total - 2:
separator = " and "
elif i == total - 1:
separator = ""
else:
separator = ", "
# pick object
obj = vocabulary[random.randint(1, vocab_size - 1)]
# build up message
partial_message += msg.indef_article(obj)
partial_message += separator
# update counter
if obj not in counter:
counter[obj] = 0
counter[obj] += 1
# pick object to ask the question
object_in_question = vocabulary[random.randint(1, vocab_size - 1)]
self.answer = msg.numbers_in_words[counter.get(object_in_question, 0)]
self.give_away_message = 'Wrong. The right answer is: {answer}.'.format(
answer=self.answer
)
self.set_message("I have {listing_objects}. How many {object} do I have? "\
.format(
listing_objects=partial_message,
object=msg.pluralize(object_in_question, 2)
))
def give_instructions(self, event):
separator = ""
counter = {}
partial_message = ""
# pick how many objects in total will be described
total = random.randint(1, max_total)
for i in range(0, total):
# for last object change separator from "," to "and"
if i == total - 2:
separator = " and "
elif i == total - 1:
separator = ""
else:
separator = ", "
# pick object
obj = vocabulary[random.randint(1, vocab_size - 1)]
# build up message
partial_message += msg.indef_article(obj)
partial_message += separator
# update counter
if obj not in counter:
counter[obj] = 0
counter[obj] += 1
# pick object to ask the question
object_in_question = vocabulary[random.randint(1, vocab_size - 1)]
self.answer = msg.numbers_in_words[counter.get(object_in_question, 0)]
self.give_away_message = 'Wrong. The right answer is: {answer}.'.format(
answer=self.answer
)
self.set_message("I have {listing_objects}. How many {object} do I have? "\
.format(
listing_objects=partial_message,
object=msg.pluralize(object_in_question, 2)
))
def on_start(self, event):
# TODO target_obj, n def outside __init__ event not used
""" choose a random object. select a random number of steps. place the object that number of steps in front
of the learner.
:param event:
:return:
"""
self.target_obj, = random.sample(objects, 1)
ws = self.get_world().state
self.n = random.randint(1, PickUpInFrontTask.max_steps_forward)
p = ws.learner_pos + self.n * self.get_world().valid_directions[ws.learner_direction]
self.state.initial_count = ws.learner_inventory[self.target_obj]
self.get_world().put_entity(p, self.target_obj, True, True)
self.add_handler(
on_state_changed(lambda ws, ts: ws.learner_inventory[self.target_obj] == ts.initial_count + 1)
(self.on_object_picked_up))
self.set_message("There is {indef_object} {n} steps forward, " "pick up the {object}.".format(
indef_object = msg.indef_article(self.target_obj), n = msg.number_to_string(self.n),
object = self.target_obj))
def on_start(self, event):
# choose some random object
self.target_obj, = random.sample(objects, 1)
# find the cell in front of the learner
ws = self.get_world().state
ld = self.get_world().valid_directions[ws.learner_direction]
lp = ws.learner_pos
self.state.initial_count = ws.learner_inventory[self.target_obj]
# place the object there
self.get_world().put_entity(lp + ld, self.target_obj, True, True)
self.add_handler(
on_state_changed(lambda ws, ts:
ws.learner_inventory[self.target_obj] ==
ts.initial_count + 1)
(self.on_object_picked_up))
self.set_message("You have {indef_object} in front of you. "
"Pick up the {object}.".format(
indef_object=msg.indef_article(self.target_obj),
object=self.target_obj))
def give_instructions(self, event):
object_, property_ = self.get_random_object_property()
# we find the set of baskets that have the relevant
# object and property combination
self.basket_set = set(
basket for basket, object_properties in global_properties.items()
if object_ in object_properties
and property_ in object_properties[object_])
# at this point, if baskets list is empty we add "nobody" as
# the only item in it
if not self.basket_set:
self.basket_set.add('nobody')
self.question = "who has {property_object} in the basket?".format(
property_object=msg.indef_article(property_ + " " + object_))
self.set_message(self.question)
# building a regexp to match the answer
enum_re = delimiters.join([r'([a-z]+)'] * len(self.basket_set))
# final string must be delimited by period
enum_re += r'\.$'
self.re_query = re.compile(enum_re)
def on_start(self, event):
# TODO event not used, direction, obj_pos, obj_picked up def outside __inti__
""" pick a random object. save how many objects of this we have. save how many instances of the object the
learner initially had. choose some random direction. measure a cell one step in that direction. put an
object in the given position. initialize a variable to check if the object has been picked up. inform the
world that we can expect to receive such an object.
:param event:
:return:
"""
ws = self.get_world().state
target_obj, = random.sample(objects, 1)
self.state.target_obj = target_obj
self.state.initial_count = ws.teacher_inventory[target_obj]
self.state.learner_initial_count = ws.learner_inventory[target_obj]
self.direction = random.choice(list(self.get_world().valid_directions.keys()))
self.obj_pos = ws.learner_pos + self.get_world().valid_directions[self.direction]
self.get_world().put_entity(self.obj_pos, target_obj, True, True)
self.object_picked_up = False
ws.teacher_accepts.add(self.state.target_obj)
self.set_message("There is {indef_object} {direction} from you." " Pick it up and give it to me.".format(
indef_object = msg.indef_article(self.state.target_obj), direction = self.direction))
def give_instructions(self, event):
object_, property_ = self.get_random_object_property()
# we find the set of baskets that have the relevant
# object and property combination
self.basket_set = set(basket for basket, object_properties
in global_properties.items()
if object_ in object_properties and
property_ in object_properties[object_])
# at this point, if baskets list is empty we add "nobody" as
# the only item in it
if not self.basket_set:
self.basket_set.add('nobody')
self.question = "who has {property_object} in the basket?".format(
property_object=msg.indef_article(property_ + " " + object_))
self.set_message(self.question)
# building a regexp to match the answer
enum_re = delimiters.join(
[r'([a-z]+)'] * len(self.basket_set))
# final string must be delimited by period
enum_re += r'\.$'
self.re_query = re.compile(enum_re)
def on_start(self, event):
# choose a random object
self.target_obj, = random.sample(objects, 1)
# find a random cell around the learner
self.direction = random.choice(list(self.get_world().valid_directions
.keys()))
ws = self.get_world().state
p = ws.learner_pos + self.get_world().valid_directions[self.direction]
self.state.initial_count = ws.learner_inventory[self.target_obj]
# place the object there
self.get_world().put_entity(p, self.target_obj, True, True)
self.add_handler(
on_state_changed(lambda ws, ts:
ws.learner_inventory[self.target_obj] ==
ts.initial_count + 1)
(self.on_object_picked_up))
self.set_message("There is {indef_object} {direction} from you, "
"pick up the {object}.".format(
indef_object=msg.indef_article(self.target_obj),
direction=self.direction,
object=self.target_obj))
def on_start(self, event):
# choose a random object
self.target_obj, = random.sample(objects, 1)
ws = self.get_world().state
# select a random number of steps
self.n = random.randint(1, PickUpInFrontTask.max_steps_forward)
# place the object that number of steps in front of the learner
p = ws.learner_pos + self.n * self.get_world().valid_directions[
ws.learner_direction]
self.state.initial_count = ws.learner_inventory[self.target_obj]
self.get_world().put_entity(p, self.target_obj, True, True)
self.add_handler(
on_state_changed(lambda ws, ts:
ws.learner_inventory[self.target_obj] ==
ts.initial_count + 1)
(self.on_object_picked_up))
self.set_message("There is {indef_object} {n} steps forward, "
"pick up the {object}."
.format(
indef_object=msg.indef_article(self.target_obj),
n=msg.number_to_string(self.n),
object=self.target_obj))
