def _generate(self, state, instantiation):
qa_pairs = []
for container_identifier in state.get_container_identifiers():
for container_state in state.get_container(container_identifier):
if container_state.number > 0:
verb_pos_instant = np.random.choice(self._verb_pos_instants)
verb_pos = verb_pos_instant["vocab_obj"]["value"]
entity_attrs = concat_container_entity_attributes(container_state.entity_attributes)
# ContainerType.environment.value
if container_state.container_type == ContainerType.environment.value:
question = \
f"How many {entity_attrs} {container_state.entity} were " \
f"in {container_identifier} ?"
# ContainerType.agent.value
else:
question = \
f"How many {entity_attrs} {container_state.entity} did " \
f"{container_identifier} {verb_pos} ?"
answer = container_state.number
expression = container_state.records
qa_pairs.append(QuestionAnswerPair(
question=question, answer=answer, expression=expression
))
return qa_pairs
def _generate(self, state, instantiation):
qa_pairs = []
for container_identifier in self.container_state_objs:
state_objs = self.container_state_objs[container_identifier]
for state_obj in state_objs:
verb_pos_instant = np.random.choice(self._verb_pos_instants)
verb_pos = verb_pos_instant["vocab_obj"]["value"]
for super_word, ans_number in \
zip(["highest", "lowest"],
[max(state_obj.records), min(state_obj.records)]):
# generate "lowest" question only in case the minimal number is positive.
if super_word == "lowest" and ans_number < 0:
continue
entity_attrs = concat_container_entity_attributes(state_obj.entity_attributes)
# ContainerType.environment.value
if state_obj.container_type == ContainerType.environment.value:
question = f"What was the {super_word} number of " \
f"{entity_attrs} {state_obj.entity} {verb_pos} in {container_identifier} ?"
# ContainerType.agent.value
else:
question = f"What is the {super_word} number of " \
f"{entity_attrs} {state_obj.entity} {container_identifier} {verb_pos} ?"
answer = ans_number
expression = [ans_number]
qa_pairs.append(QuestionAnswerPair(
question=question, answer=answer, expression=expression
))
return qa_pairs
def _generate(self, state, instantiation):
qa_pairs = []
for container_identifier in self._container_identifiers:
for entity_state_objs in self._container_identifiers[container_identifier]:
entity_sum = sum([entity_state_obj.number for entity_state_obj in entity_state_objs])
for entity_state_obj in entity_state_objs:
entity_state_obj_attrs = concat_container_entity_attributes(entity_state_obj.entity_attributes)
question = \
f"How many {entity_state_obj.entity} of {container_identifier} were " \
f"{entity_state_obj_attrs} {entity_state_obj.entity} ?"
qa_pairs.append(QuestionAnswerPair(
question=question,
answer=entity_state_obj.number,
expression=[entity_state_obj.number]
))
question = \
f"How many {entity_state_obj.entity} of {container_identifier} were not " \
f"{entity_state_obj_attrs} {entity_state_obj.entity} ?"
answer = entity_sum - entity_state_obj.number
qa_pairs.append(QuestionAnswerPair(
question=question,
answer=answer,
expression=[1 * entity_sum, -1 * entity_state_obj.number]
))
return qa_pairs
def _generate(self, state, instantiation):
qa_pairs = []
for container_identifier in self._container_identifiers:
state_objs = self._container_identifiers[container_identifier]
num_state_objs = len(state_objs)
for i in range(num_state_objs):
for j in range(i+1, num_state_objs):
if state_objs[i].number > state_objs[j].number:
bigger_obj = state_objs[i]
smaller_obj = state_objs[j]
elif state_objs[j].number > state_objs[i].number:
bigger_obj = state_objs[j]
smaller_obj = state_objs[i]
else:
continue
bigger_obj_entity_attrs = concat_container_entity_attributes(bigger_obj.entity_attributes)
smaller_obj_entity_attrs = concat_container_entity_attributes(smaller_obj.entity_attributes)
# ContainerType.environment.value
if bigger_obj.container_type == ContainerType.environment.value:
question = \
f"How many more {bigger_obj_entity_attrs} {bigger_obj.entity} were " \
f"in {container_identifier} than {smaller_obj_entity_attrs} {smaller_obj.entity} ?"
# ContainerType.agent.value
else:
question = \
f"How many more {bigger_obj_entity_attrs} {bigger_obj.entity} did " \
f"{container_identifier} have than {smaller_obj_entity_attrs} {smaller_obj.entity} ?"
answer = bigger_obj.number - smaller_obj.number
expression = [1 * bigger_obj.number, -1 * smaller_obj.number]
qa_pairs.append(QuestionAnswerPair(
question=question, answer=answer, expression=expression
))
return qa_pairs
def _is_compatible(self, state, instantiation):
self.entity_attrs_to_state_objs = {}
# create a mapping of entity to list of agent containers consisting them.
entity_attrs_to_state_objs = {}
for container_identifier in state.get_container_identifiers():
for state_obj in state.get_container(container_identifier):
# consider only agent containers.
if state_obj.container_type == ContainerType.agent.value:
entity_attrs = concat_container_entity_attributes(sorted(state_obj.entity_attributes))
key = (state_obj.entity, entity_attrs)
value = (container_identifier, state_obj)
if key in entity_attrs_to_state_objs:
entity_attrs_to_state_objs[key].append(value)
else:
entity_attrs_to_state_objs[key] = [value]
# going over every entity container list, and checking there are no parent-child pairs,
# and that there's at least one container with a positive number per entity.
for entity_attrs in entity_attrs_to_state_objs:
# check that there are at least two containers with the given entity
state_objs = entity_attrs_to_state_objs[entity_attrs]
if len(state_objs) <= 1:
continue
# check that there's at least one container with a positive number
container_entity_positive_numbers = [
state_obj.number
for container_identifier, state_obj in state_objs
if state_obj.number > 0
]
if len(container_entity_positive_numbers) == 0:
continue
# check that there are no parent-child container pairs
is_comparable_container_list = True
num_state_objs = len(state_objs)
for i in range(num_state_objs):
for j in range(i+1, num_state_objs):
if state.are_containers_related(state_objs[i][0], state_objs[j][0]):
is_comparable_container_list = False
break
if not is_comparable_container_list:
break
if not is_comparable_container_list:
continue
self.entity_attrs_to_state_objs[entity_attrs] = state_objs
return len(self.entity_attrs_to_state_objs) > 0
def _generate(self, state, instantiation):
qa_pairs = []
for container_identifiers in self._container_identifiers:
first_container_identifier, second_container_identifier = container_identifiers
state_obj_pairs = self._container_identifiers[container_identifiers]
for first_state_obj, second_state_obj in state_obj_pairs:
if first_state_obj.number > second_state_obj.number:
bigger_obj = first_state_obj
smaller_obj = second_state_obj
bigger_identifier = first_container_identifier
smaller_identifier = second_container_identifier
elif second_state_obj.number > first_state_obj.number:
bigger_obj = second_state_obj
smaller_obj = first_state_obj
bigger_identifier = second_container_identifier
smaller_identifier = first_container_identifier
else:
continue
entity = bigger_obj.entity
entity_attrs = concat_container_entity_attributes(bigger_obj.entity_attributes)
identifiers = [first_container_identifier, second_container_identifier]
for comp_word, ans_obj in zip(["more", "less"],
[(bigger_identifier, bigger_obj), (smaller_identifier, smaller_obj)]):
np.random.shuffle(identifiers)
# ContainerType.environment.value
if bigger_obj.container_type == ContainerType.environment.value:
question = \
f"Were there {comp_word} {entity_attrs} {entity} in " \
f"{identifiers[0]} or in {identifiers[1]} ?"
# ContainerType.agent.value
else:
question = \
f"Who had {comp_word} {entity_attrs} {entity}, " \
f"{identifiers[0]} or {identifiers[1]} ?"
answer = ans_obj[0]
expression = [ans_obj[1].number]
qa_pairs.append(QuestionAnswerPair(
question=question, answer=answer, expression=expression
))
return qa_pairs