def build_size_relationships( relative_size_nodes: Tuple[Tuple[OntologyNode, ...], ...], *, relation_type: OntologyNode, opposite_type: OntologyNode, ): """ Build a dictionary to represent opposite relation_types between OntologyNodes Used primarily to represent relative size_of relationships, this function takes a ranking of `OntologyNode` objects by *relative_size_nodes* which are then assigned the appropriate *relation_type* and *opposite_type* respectively. For use see GAILA_PHASE_1_ONTOLOGY. """ node_to_relations: List[Relation[OntologyNode]] = [] bigger: List[OntologyNode] = [] for nodes in relative_size_nodes: for node in nodes: for entry in bigger: node_to_relations.append( Relation(relation_type=opposite_type, first_slot=node, second_slot=entry)) node_to_relations.append( Relation(relation_type=relation_type, first_slot=entry, second_slot=node)) bigger.extend(nodes) return node_to_relations
def located( arg1s: Union[_ObjectT, Iterable[_ObjectT]], arg2s: Union[_ObjectT, Iterable[_ObjectT]], *, distance: Distance, # We need to do `Direction[Any]` because we can't infer the generic type # when a GeonAxis is used as the relative_to_axis. # Using Any here let's use isolate the type:ignores to this function. direction: Direction[Any], ) -> Tuple[Relation[_ObjectT]]: """ All *arg1s* are located with at the given `Distance` and `Direction` with respect to *args2*. It is usually better to use more specialized relations derived using `make_opposite_dsl_region_relation`, etc., but then can be useful when you need, for example, to refer to particular concrete axes. """ arg1s = _ensure_iterable(arg1s) arg2s = _ensure_iterable(arg2s) return flatten([ tuple( Relation(IN_REGION, arg1, Region(arg2, distance=distance, direction=direction)) for arg1 in arg1s for arg2 in arg2s), tuple( Relation( IN_REGION, arg2, Region(arg1, distance=distance, direction=direction.opposite()), ) for arg1 in arg1s for arg2 in arg2s), ])
def test_dynamic_perception_graph_instantiation(): ball = ObjectPerception("ball", _BALL_SCHEMA.geon.copy()) table = ObjectPerception("table", axes=_TABLE_SCHEMA.axes.copy()) first_frame = DevelopmentalPrimitivePerceptionFrame( perceived_objects=[ball, table], relations=[ above(ball, table), Relation(IN_REGION, ball, Region(table, distance=EXTERIOR_BUT_IN_CONTACT)), Relation(IN_REGION, table, Region(ball, distance=EXTERIOR_BUT_IN_CONTACT)), ], ) second_frame = DevelopmentalPrimitivePerceptionFrame( perceived_objects=[ball, table], relations=[Relation(IN_REGION, ball, Region(table, distance=DISTAL))], ) perception_graph = PerceptionGraph.from_dynamic_perceptual_representation( PerceptualRepresentation(frames=[first_frame, second_frame])) assert perception_graph.dynamic # Ensure we don't attempt to handle more than two frames yet. with pytest.raises(ValueError): PerceptionGraph.from_dynamic_perceptual_representation( PerceptualRepresentation( frames=[first_frame, second_frame, second_frame]))
def dsl_opposite_function( arg1s: Union[_ObjectT, Iterable[_ObjectT]], arg2s: Union[_ObjectT, Iterable[_ObjectT]], ) -> Tuple[Relation[_ObjectT], ...]: arg1s = _ensure_iterable(arg1s) arg2s = _ensure_iterable(arg2s) return flatten([ tuple( Relation(relation_type, arg1, arg2) for arg1 in arg1s for arg2 in arg2s), tuple( Relation(opposite_type, arg2, arg1) for arg1 in arg1s for arg2 in arg2s), ])
def dsl_relation_function( arg1s: Union[_ObjectT, Iterable[_ObjectT]], arg2s: Union[_ObjectT, Iterable[_ObjectT]], **kw_args, ) -> Tuple["Relation[_ObjectT]", ...]: arg1s = _ensure_iterable(arg1s) arg2s = _ensure_iterable(arg2s) return flatten([ tuple( Relation(IN_REGION, arg1, region_factory(arg2, **kw_args)) for arg1 in arg1s for arg2 in arg2s), tuple( Relation(IN_REGION, arg2, region_factory(arg1, **kw_args)) for arg1 in arg1s for arg2 in arg2s), ])
def test_relations(): # ball on a table ball = ObjectPerception("ball", _BALL_SCHEMA.geon.copy()) table = ObjectPerception("table", axes=_TABLE_SCHEMA.axes.copy()) PerceptualRepresentation.single_frame( DevelopmentalPrimitivePerceptionFrame( perceived_objects=[ball, table], relations=[ above(ball, table), Relation(IN_REGION, ball, Region(table, distance=EXTERIOR_BUT_IN_CONTACT)), Relation(IN_REGION, table, Region(ball, distance=EXTERIOR_BUT_IN_CONTACT)), ], ))
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 _get_single_size_relation(self, relation: Relation[Any], relation_set: ImmutableSet[Relation[Any]]): single_size_relation: Optional[Tuple[Any, str, Any]] = None if relation.relation_type in self._opposite_size_relations: if (Relation( self._opposite_size_relations[relation.relation_type], relation.second_slot, relation.first_slot, ) in relation_set): if relation.relation_type == SMALLER_THAN: single_size_relation = ( relation.second_slot, ">", relation.first_slot, ) elif relation.relation_type == BIGGER_THAN: single_size_relation = ( relation.first_slot, ">", relation.second_slot, ) elif relation.relation_type == MUCH_SMALLER_THAN: single_size_relation = ( relation.second_slot, ">>", relation.first_slot, ) else: single_size_relation = ( relation.first_slot, ">>", relation.second_slot, ) return single_size_relation
def make_bird_flies_over_a_house(): bird = situation_object(BIRD) house = situation_object(HOUSE) situation = HighLevelSemanticsSituation( ontology=GAILA_PHASE_1_ONTOLOGY, salient_objects=[bird, house], actions=[ Action( FLY, argument_roles_to_fillers=[(AGENT, bird)], during=DuringAction( at_some_point=[ Relation( IN_REGION, bird, Region( reference_object=house, distance=DISTAL, direction=Direction( positive=True, relative_to_axis=GRAVITATIONAL_AXIS_FUNCTION, ), ), ) ] ), ) ], ) return situation
def dsl_relation_function( arg1s: Union[_ObjectT, Iterable[_ObjectT]], arg2s: Union[_ObjectT, Iterable[_ObjectT]], ) -> Tuple[Relation[_ObjectT], ...]: return tuple( Relation(relation_type, arg1, arg2) for arg1 in _ensure_iterable(arg1s) for arg2 in _ensure_iterable(arg2s))
def dsl_relation_function( arg1s: Union[_ObjectT, Iterable[_ObjectT]], arg2s: Union[_ObjectT, Iterable[_ObjectT]], **kw_args, ) -> Tuple["Relation[_ObjectT]", ...]: return tuple( Relation(IN_REGION, arg1, region_factory(arg2, **kw_args)) for arg1 in _ensure_iterable(arg1s) for arg2 in _ensure_iterable(arg2s))
def test_difference(): ball = ObjectPerception("ball", _BALL_SCHEMA.geon.copy()) cup = ObjectPerception("cup", _make_cup_schema().geon.copy()) table = ObjectPerception("table", axes=_TABLE_SCHEMA.axes.copy()) first_frame = DevelopmentalPrimitivePerceptionFrame( perceived_objects=[ball, table], relations=[ above(ball, table), Relation(IN_REGION, ball, Region(table, distance=EXTERIOR_BUT_IN_CONTACT)), Relation(IN_REGION, table, Region(ball, distance=EXTERIOR_BUT_IN_CONTACT)), ], ) second_frame = DevelopmentalPrimitivePerceptionFrame( perceived_objects=[ball, table, cup], relations=[above(ball, table)]) diff = diff_primitive_perception_frames(before=first_frame, after=second_frame) assert len(diff.removed_relations) == 2 assert not diff.added_relations assert len(diff.added_objects) == 1 assert not diff.removed_objects assert diff.before_axis_info == first_frame.axis_info assert diff.after_axis_info == second_frame.axis_info assert not diff.added_property_assertions assert not diff.removed_property_assertions # Reversed diff_2 = diff_primitive_perception_frames(before=second_frame, after=first_frame) assert len(diff_2.added_relations) == 2 assert not diff_2.removed_relations assert not diff_2.added_objects assert len(diff_2.removed_objects) == 1 assert diff_2.before_axis_info == second_frame.axis_info assert diff_2.after_axis_info == first_frame.axis_info assert not diff_2.added_property_assertions assert not diff_2.removed_property_assertions
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 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 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
def test_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) ) assert len(perception.frames) == 2 first_frame = perception.frames[0] person_perception = perception_with_handle(first_frame, "**person_0") ball_perception = perception_with_handle(first_frame, "**ball_0") table_perception = perception_with_handle(first_frame, "**table_0") hand_perception = perception_with_handle(first_frame, "**hand_0") assert ( HasBinaryProperty(person_perception, ANIMATE) in first_frame.property_assertions ) assert ( HasBinaryProperty(person_perception, SELF_MOVING) in first_frame.property_assertions ) assert ( HasBinaryProperty(ball_perception, INANIMATE) in first_frame.property_assertions ) assert ( HasBinaryProperty(table_perception, INANIMATE) in first_frame.property_assertions ) first_frame_relations = first_frame.relations second_frame_relations = perception.frames[1].relations # assert we generate at least some relations in each frame assert first_frame_relations assert second_frame_relations assert ( Relation(SMALLER_THAN, ball_perception, person_perception) in first_frame_relations ) # Disabled because of https://github.com/isi-vista/adam/issues/673 # assert Relation(PART_OF, hand_perception, person_perception) in first_frame_relations assert ( Relation( IN_REGION, ball_perception, Region(reference_object=hand_perception, distance=EXTERIOR_BUT_IN_CONTACT), ) in first_frame_relations ) # continuing relations: assert ( Relation(SMALLER_THAN, ball_perception, person_perception) in second_frame_relations ) # new relations: ball_on_table_relation = Relation( IN_REGION, ball_perception, Region( table_perception, distance=EXTERIOR_BUT_IN_CONTACT, direction=GRAVITATIONAL_UP ), ) assert ball_on_table_relation in second_frame_relations # removed relations: assert ( Relation( IN_REGION, ball_perception, Region(reference_object=hand_perception, distance=EXTERIOR_BUT_IN_CONTACT), ) not in second_frame_relations ) # proto-role properties assert ( HasBinaryProperty(person_perception, VOLITIONALLY_INVOLVED) in first_frame.property_assertions ) assert ( HasBinaryProperty(person_perception, CAUSES_CHANGE) in first_frame.property_assertions ) assert ( HasBinaryProperty(ball_perception, UNDERGOES_CHANGE) in first_frame.property_assertions ) assert ( HasBinaryProperty(table_perception, STATIONARY) in first_frame.property_assertions )