def test_before_after_relations_asserted():
ball = object_variable("ball", root_node=BALL)
box = object_variable("box", root_node=BOX)
ground = object_variable("ground", root_node=GROUND)
template_action = Phase1SituationTemplate(
"Before/After Relation",
salient_object_variables=[ball, box],
background_object_variables=[ground],
actions=[
Action(
ROLL,
argument_roles_to_fillers=[(AGENT, ball)],
auxiliary_variable_bindings=[(ROLL_SURFACE_AUXILIARY, ground)],
)
],
before_action_relations=flatten_relations([on(ball, box)]),
after_action_relations=flatten_relations([far(ball, box)]),
)
situation_with_relations = tuple(
sampled(
template_action,
ontology=GAILA_PHASE_1_ONTOLOGY,
chooser=RandomChooser.for_seed(0),
max_to_sample=1,
))
assert situation_with_relations[0].before_action_relations
assert situation_with_relations[0].after_action_relations
def build_object_multiples_situations(
ontology: Ontology,
*,
samples_per_object: int = 3,
chooser: RandomChooser) -> Iterable[HighLevelSemanticsSituation]:
for object_type in PHASE_1_CURRICULUM_OBJECTS:
# Exclude slow objects for now
if object_type.handle in ["bird", "dog", "truck"]:
continue
is_liquid = ontology.has_all_properties(object_type, [LIQUID])
# don't want multiples of named people
if not is_recognized_particular(ontology,
object_type) and not is_liquid:
for _ in range(samples_per_object):
num_objects = chooser.choice(range(2, 4))
yield HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[
SituationObject.instantiate_ontology_node(
ontology_node=object_type,
debug_handle=object_type.handle + f"_{idx}",
ontology=GAILA_PHASE_1_ONTOLOGY,
) for idx in range(num_objects)
],
axis_info=AxesInfo(),
)
def test_liquid_perceivable():
juice_perception = _PERCEPTION_GENERATOR.generate_perception(
HighLevelSemanticsSituation(ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[situation_object(JUICE)]),
chooser=RandomChooser.for_seed(0),
).frames[0]
assert _some_object_has_binary_property(juice_perception, LIQUID)
def test_gaze_specified():
cookie = situation_object(COOKIE)
table = situation_object(TABLE)
dad = situation_object(DAD)
situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[cookie, table, dad],
actions=[
Action(EAT,
argument_roles_to_fillers=[(AGENT, dad), (PATIENT, cookie)])
],
gazed_objects=[cookie],
)
perception = _PERCEPTION_GENERATOR.generate_perception(
situation, chooser=RandomChooser.for_seed(0))
frame = perception.frames[0]
cookie_perception = perception_with_handle(frame, "**cookie_0")
dad_perception = perception_with_handle(frame, "**Dad_0")
table_perception = perception_with_handle(frame, "**table_0")
# only the cookie is gazed at, because the user said so.
assert HasBinaryProperty(cookie_perception,
GAZED_AT) in frame.property_assertions
assert HasBinaryProperty(dad_perception,
GAZED_AT) not in frame.property_assertions
assert HasBinaryProperty(table_perception,
GAZED_AT) not in frame.property_assertions
def test_objects_in_something_not_implcitly_grounded():
box = situation_object(ontology_node=BOX)
ball = situation_object(ontology_node=BALL)
situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[box, ball],
always_relations=[
Relation(
IN_REGION,
ball,
Region(
box,
distance=PROXIMAL,
direction=Direction(
positive=True,
relative_to_axis=HorizontalAxisOfObject(box, index=0),
),
),
)
],
)
perception = _PERCEPTION_GENERATOR.generate_perception(
situation, chooser=RandomChooser.for_seed(0)
)
first_frame = perception.frames[0]
ball_perception = perception_with_handle(first_frame, "**ball_0")
ground_perception = perception_with_handle(first_frame, "the ground")
box_perception = perception_with_handle(first_frame, "**box_0")
first_frame_relations = first_frame.relations
assert on(ball_perception, ground_perception)[0] in first_frame_relations
assert on(box_perception, ground_perception)[0] in first_frame_relations
def test_dynamic_prepositions_implicit_grounding():
truck = situation_object(ontology_node=TRUCK)
baby = situation_object(ontology_node=BABY)
situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[baby, truck],
actions=[Action(FALL, argument_roles_to_fillers=[(THEME, baby)])],
after_action_relations=[on(baby, truck)],
)
perception = _PERCEPTION_GENERATOR.generate_perception(
situation, chooser=RandomChooser.for_seed(0)
)
first_frame = perception.frames[0]
baby_perception = perception_with_handle(first_frame, "**baby_0")
ground_perception = perception_with_handle(first_frame, "the ground")
truck_perception = perception_with_handle(first_frame, "**truck_0")
first_frame_relations = first_frame.relations
second_frame_relations = perception.frames[1].relations
assert on(baby_perception, truck_perception)[0] not in first_frame_relations
assert on(baby_perception, truck_perception)[0] in second_frame_relations
assert on(baby_perception, ground_perception)[0] not in second_frame_relations
assert on(truck_perception, ground_perception)[0] in first_frame_relations
assert on(truck_perception, ground_perception)[0] in second_frame_relations
def test_recognizes_ontology_objects(object_type, language_mode):
situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[
SituationObject.instantiate_ontology_node(
ontology_node=object_type, ontology=GAILA_PHASE_1_ONTOLOGY)
],
)
perception_generator = HighLevelSemanticsSituationToDevelopmentalPrimitivePerceptionGenerator(
GAILA_PHASE_1_ONTOLOGY)
perception = perception_generator.generate_perception(
situation, chooser=RandomChooser.for_seed(0), include_ground=False)
learner = IntegratedTemplateLearner(
object_learner=LANGUAGE_MODE_TO_TEMPLATE_LEARNER_OBJECT_RECOGNIZER[
language_mode])
descriptions = learner.describe(perception)
assert descriptions
if language_mode == LanguageMode.ENGLISH:
assert object_type.handle in one(
descriptions.items())[0].as_token_sequence()
else:
mappings = (
GAILA_PHASE_1_CHINESE_LEXICON._ontology_node_to_word # pylint:disable=protected-access
)
for k, v in mappings.items():
if k.handle == object_type.handle:
assert v.base_form in one(
descriptions.items())[0].as_token_sequence()
def test_object_not_on_ground():
"""
Intended to test that one can specify an object is not on the ground
"""
table = situation_object(TABLE)
ground = situation_object(GROUND)
perception = _PERCEPTION_GENERATOR.generate_perception(
HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=immutableset([table]),
other_objects=immutableset([ground]),
always_relations=flatten_relations(negate(on(table, ground))),
),
chooser=RandomChooser.for_seed(0),
)
frame = perception.frames[0]
relations = frame.relations
table_perception = perception_with_handle(frame, "**table_0")
ground_perception = perception_with_handle(frame, "the ground")
assert not any(
relation.relation_type == IN_REGION
and relation.first_slot == table_perception
and isinstance(relation.second_slot, Region)
and relation.region.reference_object == ground_perception
and relation.region.distance == EXTERIOR_BUT_IN_CONTACT
for relation in relations
)
def test_person_and_ball_color():
person = situation_object(PERSON)
ball = situation_object(BALL, properties=[RED])
person_and_ball_situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY, salient_objects=[person, ball]
)
person_and_ball_perception = _PERCEPTION_GENERATOR.generate_perception(
person_and_ball_situation, chooser=RandomChooser.for_seed(0)
)
assert len(person_and_ball_perception.frames) == 1
frame = person_and_ball_perception.frames[0]
assert (
prop_assertion is PropertyPerception
for prop_assertion in frame.property_assertions
)
person_perception = perception_with_handle(frame, "**person_0")
ball_perception = perception_with_handle(frame, "**ball_0")
assert HasBinaryProperty(person_perception, ANIMATE) in frame.property_assertions
assert HasBinaryProperty(person_perception, SELF_MOVING) in frame.property_assertions
assert HasBinaryProperty(ball_perception, INANIMATE) in frame.property_assertions
assert any(
isinstance(property_, HasColor) and property_.perceived_object == ball_perception
for property_ in frame.property_assertions
)
def test_trivial_dynamic_situation_with_schemaless_object(language_mode):
dad_situation_object = SituationObject.instantiate_ontology_node(
ontology_node=DAD, ontology=GAILA_PHASE_1_ONTOLOGY)
situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[dad_situation_object])
perception_generator = HighLevelSemanticsSituationToDevelopmentalPrimitivePerceptionGenerator(
GAILA_PHASE_1_ONTOLOGY)
# We explicitly exclude ground in perception generation
# this generates a static perception...
perception = perception_generator.generate_perception(
situation, chooser=RandomChooser.for_seed(0), include_ground=False)
# so we need to construct a dynamic one by hand from two identical scenes
dynamic_perception = PerceptualRepresentation(
frames=[perception.frames[0], perception.frames[0]])
perception_graph = PerceptionGraph.from_dynamic_perceptual_representation(
dynamic_perception)
perception_semantic_alignment = PerceptionSemanticAlignment.create_unaligned(
perception_graph)
(_, description_to_matched_semantic_node
) = LANGUAGE_MODE_TO_OBJECT_RECOGNIZER[language_mode].match_objects(
perception_semantic_alignment)
assert len(description_to_matched_semantic_node) == 1
assert (language_mode == LanguageMode.ENGLISH and
("Dad", ) in description_to_matched_semantic_node) or (
language_mode == LanguageMode.CHINESE and
("ba4 ba4", ) in description_to_matched_semantic_node)
def test_two_objects():
two_object_template = Phase1SituationTemplate(
"two-objects",
salient_object_variables=[
object_variable("person", root_node=_PERSON),
object_variable("toy_vehicle", required_properties=[_TOY_VEHICLE]),
],
)
reference_object_sets = {
immutableset(["mom", "toy_truck"]),
immutableset(["dad", "toy_truck"]),
immutableset(["learner", "toy_truck"]),
immutableset(["mom", "toy_car"]),
immutableset(["dad", "toy_car"]),
immutableset(["learner", "toy_car"]),
}
generated_object_sets = set(
immutableset(situation_object.ontology_node.handle
for situation_object in situation.salient_objects)
for situation in all_possible(
two_object_template,
ontology=_TESTING_ONTOLOGY,
chooser=RandomChooser.for_seed(0),
default_addressee_node=_LEARNER,
))
assert generated_object_sets == reference_object_sets
def test_colors_across_part_of_relations():
"""
Intended to test color inheritance across part-of relations
with objects that have a prototypical color
"""
learner_perception = _PERCEPTION_GENERATOR.generate_perception(
HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY, salient_objects=[situation_object(TRUCK)]
),
chooser=RandomChooser.for_seed(0),
)
frame = learner_perception.frames[0]
property_assertions = frame.property_assertions
truck_perception = perception_with_handle(frame, "**truck_0")
flatbed_perception = perception_with_handle(frame, "**flatbed_0")
tire0_perception = perception_with_handle(frame, "**tire_0")
tire1_perception = perception_with_handle(frame, "**tire_1")
tire2_perception = perception_with_handle(frame, "**tire_2")
tire3_perception = perception_with_handle(frame, "**tire_3")
tire4_perception = perception_with_handle(frame, "**tire_4")
tire5_perception = perception_with_handle(frame, "**tire_5")
tire6_perception = perception_with_handle(frame, "**tire_6")
tire7_perception = perception_with_handle(frame, "**tire_7")
blue_options = COLORS_TO_RGBS[BLUE]
blue_perceptions = [RgbColorPerception(r, g, b) for r, g, b in blue_options]
red_options = COLORS_TO_RGBS[RED]
red_perceptions = [RgbColorPerception(r, g, b) for r, g, b in red_options]
black_options = COLORS_TO_RGBS[BLACK]
black_perceptions = [RgbColorPerception(r, g, b) for r, g, b in black_options]
assert any(
HasColor(truck_perception, blue_perception) in property_assertions
for blue_perception in blue_perceptions
) or any(
HasColor(truck_perception, red_perception) in property_assertions
for red_perception in red_perceptions
)
assert any(
HasColor(flatbed_perception, blue_perception) in property_assertions
for blue_perception in blue_perceptions
) or any(
HasColor(flatbed_perception, red_perception) in property_assertions
for red_perception in red_perceptions
)
assert any(
(
HasColor(tire0_perception, black_perception)
and HasColor(tire1_perception, black_perception)
and HasColor(tire2_perception, black_perception)
and HasColor(tire3_perception, black_perception)
and HasColor(tire4_perception, black_perception)
and HasColor(tire5_perception, black_perception)
and HasColor(tire6_perception, black_perception)
and HasColor(tire7_perception, black_perception)
)
in property_assertions
for black_perception in black_perceptions
)
def test_perceive_explicit_relations():
# we want to test that relations explicitly called out in the situation are perceived.
# Such relations fall into three buckets:
# those which hold before an action,
# those which hold after an action,
# and those which hold both before and after an action.
# To test all three of these at once, we use a situation where
# (a) Mom is putting a ball on a table
# (b) before the action the ball is far from a box,
# (c) but after the action the ball is near the box,
# (d) throughout the action the box is on the table.
mom = situation_object(MOM)
ball = situation_object(BALL)
box = situation_object(BOX)
table = situation_object(TABLE)
situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[mom, box, ball, table],
always_relations=[on(ball, table)],
before_action_relations=[far(ball, box)],
after_action_relations=[near(ball, box)],
actions=[
Action(
PUT,
argument_roles_to_fillers=[
(AGENT, mom),
(THEME, ball),
(
GOAL,
Region(
reference_object=table,
distance=EXTERIOR_BUT_IN_CONTACT,
direction=GRAVITATIONAL_UP,
),
),
],
)
],
)
perception = _PERCEPTION_GENERATOR.generate_perception(
situation, chooser=RandomChooser.for_seed(0)
)
ball_perception = perception_with_handle(perception.frames[0], "**ball_0")
box_perception = perception_with_handle(perception.frames[0], "**box_0")
table_perception = perception_with_handle(perception.frames[0], "**table_0")
assert only(on(ball_perception, table_perception)) in perception.frames[0].relations
assert only(on(ball_perception, table_perception)) in perception.frames[0].relations
assert only(far(ball_perception, box_perception)) in perception.frames[0].relations
assert (
only(far(ball_perception, box_perception)) not in perception.frames[1].relations
)
assert (
only(near(ball_perception, box_perception)) not in perception.frames[0].relations
)
assert only(near(ball_perception, box_perception)) in perception.frames[1].relations
def test_liquid_in_and_out_of_container():
juice = situation_object(JUICE)
box = situation_object(ontology_node=BOX)
table = situation_object(ontology_node=TABLE)
two_d_situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[juice, table],
always_relations=[on(juice, table)],
)
two_d_perception = _PERCEPTION_GENERATOR.generate_perception(
two_d_situation, chooser=RandomChooser.for_seed(0)
)
three_d_situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[juice, box],
always_relations=[
Relation(IN_REGION, juice, Region(box, distance=INTERIOR, direction=None))
],
)
three_d_perception = _PERCEPTION_GENERATOR.generate_perception(
three_d_situation, chooser=RandomChooser.for_seed(0)
)
two_perceived_objects = two_d_perception.frames[0].perceived_objects
two_object_handles = set(obj.debug_handle for obj in two_perceived_objects)
assert all(handle in two_object_handles for handle in {"**juice_0", "**table_0"})
three_perceived_objects = three_d_perception.frames[0].perceived_objects
three_object_handles = set(obj.debug_handle for obj in three_perceived_objects)
assert all(handle in three_object_handles for handle in {"**juice_0", "**box_0"})
assert any(
isinstance(p, HasBinaryProperty)
and perception_with_handle(two_d_perception.frames[0], "**juice_0")
== p.perceived_object
and p.binary_property == TWO_DIMENSIONAL
for p in two_d_perception.frames[0].property_assertions
)
assert not any(
isinstance(p, HasBinaryProperty)
and perception_with_handle(three_d_perception.frames[0], "**juice_0")
== p.perceived_object
and p.binary_property == TWO_DIMENSIONAL
for p in three_d_perception.frames[0].property_assertions
)
def all_possible_test(
template: Phase1SituationTemplate
) -> Iterable[HighLevelSemanticsSituation]:
"""
Shorcut for `all_possible` with the GAILA phase 1 ontology and a `RandomChooser` with seed 0.
"""
return all_possible(template,
chooser=RandomChooser.for_seed(0),
ontology=GAILA_PHASE_1_ONTOLOGY)
def test_simple_experiment():
language_generator = SingleObjectLanguageGenerator(
GAILA_PHASE_1_ENGLISH_LEXICON)
perception_generator = DummyVisualPerceptionGenerator()
only_show_truck = GeneratedFromSituationsInstanceGroup(
name="only-ball",
situations=[
LocatedObjectSituation([(
SituationObject.instantiate_ontology_node(
BALL, ontology=GAILA_PHASE_1_ONTOLOGY),
Point(0.0, 0.0, 0.0),
)])
],
language_generator=language_generator,
perception_generator=perception_generator,
chooser=RandomChooser.for_seed(0),
)
pre_acc = CandidateAccuracyObserver("pre")
post_acc = CandidateAccuracyObserver("post")
test_acc = CandidateAccuracyObserver("test")
experiment = Experiment(
name="simple",
training_stages=[only_show_truck],
learner_factory=MemorizingLanguageLearner,
pre_example_training_observers=[
TopChoiceExactMatchObserver("pre"), pre_acc
],
post_example_training_observers=[
TopChoiceExactMatchObserver("post"), post_acc
],
warm_up_test_instance_groups=[only_show_truck],
test_instance_groups=[only_show_truck],
test_observers=[TopChoiceExactMatchObserver("test"), test_acc],
sequence_chooser=RandomChooser.for_seed(0),
)
execute_experiment(experiment)
assert pre_acc.accuracy() == 0.0
assert post_acc.accuracy() == 1.0
assert test_acc.accuracy() == 1.0
def test_person_and_ball():
person = situation_object(PERSON)
ball = situation_object(BALL)
person_and_ball_situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY, salient_objects=[person, ball]
)
person_and_ball_perception = _PERCEPTION_GENERATOR.generate_perception(
person_and_ball_situation, chooser=RandomChooser.for_seed(0)
)
perceived_objects = person_and_ball_perception.frames[0].perceived_objects
object_handles = set(obj.debug_handle for obj in perceived_objects)
assert len(person_and_ball_perception.frames) == 1
assert object_handles == {
"**ball_0",
"**person_0",
"**head_0",
"**torso_0",
"**arm_0",
"**armsegment_0",
"**armsegment_1",
"**hand_0",
"**arm_1",
"**armsegment_2",
"**armsegment_3",
"**hand_1",
"**(animal) leg_0",
"**leg-segment_0",
"**leg-segment_1",
"**foot_0",
"**(animal) leg_1",
"**leg-segment_2",
"**leg-segment_3",
"**foot_1",
"the ground",
}
assert person_and_ball_perception.frames[0].relations
person_perception = perception_with_handle(
person_and_ball_perception.frames[0], "**person_0"
)
ball_perception = perception_with_handle(
person_and_ball_perception.frames[0], "**ball_0"
)
assert set(person_and_ball_perception.frames[0].property_assertions).issuperset(
{
HasBinaryProperty(person_perception, ANIMATE),
HasBinaryProperty(person_perception, SELF_MOVING),
HasBinaryProperty(ball_perception, INANIMATE),
}
)
def test_choose_first():
generator = ChooseFirstLanguageGenerator(DummyLanguageGenerator())
# pycharm fails to recognize converter
# noinspection PyTypeChecker
situation = LocatedObjectSituation([(situation_object(BALL),
Point(0, 0, 0))])
generated_descriptions = generator.generate_language(
situation, RandomChooser.for_seed(0))
assert len(generated_descriptions) == 1
assert generated_descriptions[0].as_token_sequence() == ("hello", "world")
def test_speaker_perceivable():
speaker_situation_perception = _PERCEPTION_GENERATOR.generate_perception(
HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[situation_object(PERSON, properties=[IS_SPEAKER])],
),
chooser=RandomChooser.for_seed(0),
)
assert _some_object_has_binary_property(
speaker_situation_perception.frames[0], IS_SPEAKER
)
def test_not_two_speakers():
with pytest.raises(RuntimeError):
_PERCEPTION_GENERATOR.generate_perception(
HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[
situation_object(PERSON, properties=[IS_SPEAKER]),
situation_object(PERSON, properties=[IS_SPEAKER]),
],
),
chooser=RandomChooser.for_seed(0),
)
def test_implicit_ground():
table_perception = _PERCEPTION_GENERATOR.generate_perception(
HighLevelSemanticsSituation(ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[situation_object(TABLE)]),
chooser=RandomChooser.for_seed(0),
)
perceived_objects = table_perception.frames[0].perceived_objects
object_handles = set(obj.debug_handle for obj in perceived_objects)
# assert that a "ground" object is perceived
assert "the ground" in object_handles
def test_single_object_generator():
# warning due to PyCharm bug
# noinspection PyTypeChecker
situation = LocatedObjectSituation(
objects_to_locations=((situation_object(BALL), Point(0, 0, 0)), ))
single_obj_generator = SingleObjectLanguageGenerator(
GAILA_PHASE_1_ENGLISH_LEXICON)
languages_for_situation = single_obj_generator.generate_language(
situation, RandomChooser.for_seed(0))
assert len(languages_for_situation) == 1
assert languages_for_situation[0].as_token_sequence() == ("ball", )
def test_explicit_ground():
ground_perception = _PERCEPTION_GENERATOR.generate_perception(
HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY, salient_objects=[situation_object(GROUND)]
),
chooser=RandomChooser.for_seed(0),
)
perceived_objects = ground_perception.frames[0].perceived_objects
object_handles = set(obj.debug_handle for obj in perceived_objects)
# assert that a second "ground" object was not generated
assert object_handles == {"the ground"}
def test_perceive_relations_during():
learner_perception = _PERCEPTION_GENERATOR.generate_perception(
make_bird_flies_over_a_house(), chooser=RandomChooser.for_seed(0)
)
assert learner_perception.during
bird = perception_with_handle(learner_perception.frames[0], "**bird_0")
house = perception_with_handle(learner_perception.frames[0], "**house_0")
bird_over_the_house = Relation(
IN_REGION,
bird,
Region(reference_object=house, distance=DISTAL, direction=GRAVITATIONAL_UP),
)
assert bird_over_the_house in learner_perception.during.at_some_point
def log_experiment_entry_point(params: Parameters) -> None:
experiment_name = params.string("experiment")
debug_log_dir = params.optional_creatable_directory("debug_log_directory")
graph_logger: Optional[HypothesisLogger]
if debug_log_dir:
logging.info("Debug graphs will be written to %s", debug_log_dir)
graph_logger = HypothesisLogger(debug_log_dir,
enable_graph_rendering=True)
else:
graph_logger = None
logger = LearningProgressHtmlLogger.create_logger(params)
language_mode = params.enum("language_mode",
LanguageMode,
default=LanguageMode.ENGLISH)
(training_instance_groups,
test_instance_groups) = curriculum_from_params(params, language_mode)
execute_experiment(
Experiment(
name=experiment_name,
training_stages=training_instance_groups,
learner_factory=learner_factory_from_params(
params, graph_logger, language_mode),
pre_example_training_observers=[
logger.pre_observer(),
CandidateAccuracyObserver("pre-acc-observer"),
],
post_example_training_observers=[logger.post_observer()],
test_instance_groups=test_instance_groups,
test_observers=[logger.test_observer()],
sequence_chooser=RandomChooser.for_seed(0),
),
log_path=params.optional_creatable_directory("hypothesis_log_dir"),
log_hypotheses_every_n_examples=params.integer(
"log_hypothesis_every_n_steps", default=250),
log_learner_state=params.boolean("log_learner_state", default=True),
learner_logging_path=params.optional_creatable_directory(
"experiment_group_dir"),
starting_point=params.integer("starting_point", default=-1),
point_to_log=params.integer("point_to_log", default=0),
load_learner_state=params.optional_existing_file("learner_state_path"),
)
def test_path_from_action_description():
ball = situation_object(BALL)
situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[ball],
actions=[Action(FALL, argument_roles_to_fillers=[(THEME, ball)])],
)
perception = _PERCEPTION_GENERATOR.generate_perception(
situation, chooser=RandomChooser.for_seed(0)
)
ball_perception = perception_with_handle(perception.frames[0], "**ball_0")
ground_perception = perception_with_handle(perception.frames[0], "the ground")
assert perception.during
assert perception.during.objects_to_paths
assert len(perception.during.objects_to_paths) == 1
path = only(perception.during.objects_to_paths[ball_perception])
assert path.reference_object == ground_perception
assert path.operator == TOWARD
def test_relations_between_objects_and_ground():
# person_put_ball_on_table
person = situation_object(ontology_node=PERSON)
ball = situation_object(ontology_node=BALL)
table = situation_object(ontology_node=TABLE)
situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[person, ball, table],
actions=[
# What is the best way of representing the destination in the high-level semantics?
# Here we represent it as indicating a relation which should be true.
Action(
PUT,
(
(AGENT, person),
(THEME, ball),
(
GOAL,
Region(
reference_object=table,
distance=EXTERIOR_BUT_IN_CONTACT,
direction=GRAVITATIONAL_UP,
),
),
),
)
],
)
perception = _PERCEPTION_GENERATOR.generate_perception(
situation, chooser=RandomChooser.for_seed(0)
)
first_frame = perception.frames[0]
ball_perception = perception_with_handle(first_frame, "**ball_0")
ground_perception = perception_with_handle(first_frame, "the ground")
table_perception = perception_with_handle(first_frame, "**table_0")
first_frame_relations = first_frame.relations
second_frame_relations = perception.frames[1].relations
assert on(ball_perception, ground_perception)[0] in first_frame_relations
assert on(ball_perception, ground_perception)[0] not in second_frame_relations
assert on(table_perception, ground_perception)[0] in first_frame_relations
assert on(table_perception, ground_perception)[0] in second_frame_relations
def from_params(
params: Parameters,
*,
ontology: Optional[Ontology] = None,
graph_logger: Optional[GraphLogger] = None,
) -> "ProposeButVerifyObjectLearner":
rng = RandomChooser.for_seed(
params.optional_integer("random_seed", default=0))
return ProposeButVerifyObjectLearner(
graph_match_confirmation_threshold=params.floating_point(
"graph_match_confirmation_threshold", default=0.8),
graph_logger=graph_logger,
rng=rng,
ontology=ontology if ontology else GAILA_PHASE_1_ONTOLOGY,
language_mode=params.enum("language_mode",
LanguageMode,
default=LanguageMode.ENGLISH),
)
def test_subobject_perception_has_appropriate_properties():
"""
Intended to test that an object's subobjects have their properties assigned to them properly
"""
learner_perception = _PERCEPTION_GENERATOR.generate_perception(
HighLevelSemanticsSituation(ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[situation_object(TABLE)]),
chooser=RandomChooser.for_seed(0),
)
frame = learner_perception.frames[0]
property_assertions = frame.property_assertions
leg_perceptions = [
perception_with_handle(frame, "**(furniture) leg_0"),
perception_with_handle(frame, "**(furniture) leg_1"),
perception_with_handle(frame, "**(furniture) leg_2"),
perception_with_handle(frame, "**(furniture) leg_3"),
]
assert all(
HasBinaryProperty(leg_perception, INANIMATE) in property_assertions
for leg_perception in leg_perceptions)
def test_grounding_of_unsupported_objects():
box = situation_object(ontology_node=BOX)
ball = situation_object(ontology_node=BALL)
situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_1_ONTOLOGY,
salient_objects=[box, ball],
always_relations=[Relation(IN_REGION, ball, Region(box, distance=INTERIOR))],
)
perception = _PERCEPTION_GENERATOR.generate_perception(
situation, chooser=RandomChooser.for_seed(0)
)
first_frame = perception.frames[0]
ball_perception = perception_with_handle(first_frame, "**ball_0")
ground_perception = perception_with_handle(first_frame, "the ground")
box_perception = perception_with_handle(first_frame, "**box_0")
first_frame_relations = first_frame.relations
assert on(ball_perception, ground_perception)[0] not in first_frame_relations
assert on(box_perception, ground_perception)[0] in first_frame_relations
