def test_jump(language_mode, learner):
jumper = standard_object(
"jumper_0",
THING,
required_properties=[CAN_JUMP],
banned_properties=[IS_SPEAKER, IS_ADDRESSEE],
)
jumped_over = standard_object("jumped_over",
banned_properties=[IS_SPEAKER, IS_ADDRESSEE])
for situation_template in make_jump_templates(None):
run_verb_test(
learner(language_mode),
situation_template,
language_generator=phase1_language_generator(language_mode),
)
for situation_template in [
_jump_over_template(jumper, jumped_over, immutableset())
]:
run_verb_test(
learner(language_mode),
situation_template,
language_generator=phase1_language_generator(language_mode),
)
def test_throw_animacy(language_mode, learner):
# shuffle both together for the train curriculum
train_curriculum = phase1_instances(
"train",
chain(*[
sampled(
situation_template=situation_template,
max_to_sample=10,
ontology=GAILA_PHASE_1_ONTOLOGY,
chooser=PHASE1_CHOOSER_FACTORY(),
block_multiple_of_the_same_type=True,
) for situation_template in make_throw_animacy_templates(None)
]),
language_generator=phase1_language_generator(language_mode),
)
# shuffle both together for test curriculum
test_curriculum = phase1_instances(
"test",
chain(*[
sampled(
situation_template=situation_template,
max_to_sample=1,
ontology=GAILA_PHASE_1_ONTOLOGY,
chooser=PHASE1_CHOOSER_FACTORY(),
block_multiple_of_the_same_type=True,
) for situation_template in make_throw_animacy_templates(None)
]),
language_generator=phase1_language_generator(language_mode),
)
# instantiate and test the learner
learner = learner(language_mode)
for (
_,
linguistic_description,
perceptual_representation,
) in train_curriculum.instances():
learner.observe(
LearningExample(perceptual_representation, linguistic_description))
for (
_,
test_lingustics_description,
test_perceptual_representation,
) in test_curriculum.instances():
descriptions_from_learner = learner.describe(
test_perceptual_representation)
gold = test_lingustics_description.as_token_sequence()
assert descriptions_from_learner
assert gold in [
desc.as_token_sequence() for desc in descriptions_from_learner
]
def test_roll(language_mode, learner):
for situation_template in make_roll_templates(None):
run_verb_test(
learner(language_mode),
situation_template,
language_generator=phase1_language_generator(language_mode),
)
def test_object_recognition_with_drink_perception():
"""
Regression test to confirm we can perform object recognition on a pickled and unpickled "drink"
perception. If we do this using the normal pickling interface we get an error. This test checks
that we don't run into such an error when we instead pickle and unpickle the perception using
the AdamPickler and AdamUnpickler.
See https://github.com/isi-vista/adam/issues/958.
"""
language_mode = LanguageMode.ENGLISH
template = drink_test_template()
curriculum = phase1_instances(
"train",
sampled(
template,
max_to_sample=3,
ontology=GAILA_PHASE_1_ONTOLOGY,
chooser=PHASE1_CHOOSER_FACTORY(),
block_multiple_of_the_same_type=True,
),
language_generator=phase1_language_generator(language_mode),
)
object_recognizer = LANGUAGE_MODE_TO_TEMPLATE_LEARNER_OBJECT_RECOGNIZER[
language_mode]
learner = IntegratedTemplateLearner(object_learner=object_recognizer)
for (_, linguistic_description,
perceptual_representation) in curriculum.instances():
new_perceptual_representation = _pickle_and_unpickle_object(
perceptual_representation)
learner.observe(
LearningExample(new_perceptual_representation,
linguistic_description))
def test_fly(language_mode, learner):
for situation_template in make_fly_templates(immutableset()):
run_verb_test(
learner(language_mode),
situation_template,
phase1_language_generator(language_mode),
)
def test_pursuit_preposition_on_learner(language_mode):
rng = random.Random()
rng.seed(0)
learner = PrepositionPursuitLearner(
learning_factor=0.5,
graph_match_confirmation_threshold=0.7,
lexicon_entry_threshold=0.7,
rng=rng,
smoothing_parameter=0.001,
ontology=GAILA_PHASE_1_ONTOLOGY,
object_recognizer=LANGUAGE_MODE_TO_OBJECT_RECOGNIZER[language_mode],
language_mode=language_mode,
) # type: ignore
ball = standard_object("ball", BALL)
table = standard_object("table", TABLE)
language_generator = phase1_language_generator(language_mode)
on_train_curriculum = phase1_instances(
"Preposition Unit Train",
situations=sampled(
_on_template(ball, table, immutableset(), is_training=True),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=10,
),
language_generator=language_generator,
)
on_test_curriculum = phase1_instances(
"Preposition Unit Test",
situations=sampled(
_on_template(ball, table, immutableset(), is_training=False),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
),
language_generator=language_generator,
)
for (
_,
linguistic_description,
perceptual_representation,
) in on_train_curriculum.instances():
# Get the object matches first - preposition learner can't learn without already recognized objects
learner.observe(
LearningExample(perceptual_representation, linguistic_description))
for (
_,
test_lingustics_description,
test_perceptual_representation,
) in on_test_curriculum.instances():
descriptions_from_learner = learner.describe(
test_perceptual_representation)
gold = test_lingustics_description.as_token_sequence()
assert descriptions_from_learner
assert [
desc.as_token_sequence() for desc in descriptions_from_learner
][0] == gold
def test_pursuit_preposition_has_learner(language_mode, learner):
person = standard_object("person",
PERSON,
banned_properties=[IS_SPEAKER, IS_ADDRESSEE])
inanimate_object = standard_object("inanimate-object",
INANIMATE_OBJECT,
required_properties=[PERSON_CAN_HAVE])
ball = standard_object("ball", BALL)
language_generator = phase1_language_generator(language_mode)
has_train_curriculum = phase1_instances(
"Has Unit Train",
situations=sampled(
_x_has_y_template(person, inanimate_object),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=2,
block_multiple_of_the_same_type=True,
),
language_generator=language_generator,
)
has_test_curriculum = phase1_instances(
"Has Unit Test",
situations=sampled(
_x_has_y_template(person, ball),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
block_multiple_of_the_same_type=True,
),
language_generator=language_generator,
)
processing_learner = learner(language_mode)
for (
_,
linguistic_description,
perceptual_representation,
) in has_train_curriculum.instances():
processing_learner.observe(
LearningExample(perceptual_representation, linguistic_description))
for (
_,
test_lingustics_description,
test_perceptual_representation,
) in has_test_curriculum.instances():
descriptions_from_learner = processing_learner.describe(
test_perceptual_representation)
gold = test_lingustics_description.as_token_sequence()
assert descriptions_from_learner
assert gold in [
desc.as_token_sequence() for desc in descriptions_from_learner
]
def test_pursuit_preposition_over_learner(language_mode, learner):
ball = standard_object("ball", BALL)
table = standard_object("table", TABLE)
language_generator = phase1_language_generator(language_mode)
over_train_curriculum = phase1_instances(
"Preposition Over Unit Train",
situations=sampled(
_over_template(ball,
table,
immutableset(),
is_training=True,
is_distal=True),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=10,
block_multiple_of_the_same_type=True,
),
language_generator=language_generator,
)
over_test_curriculum = phase1_instances(
"Preposition Over Unit Test",
situations=sampled(
_over_template(ball,
table,
immutableset(),
is_training=False,
is_distal=True),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
block_multiple_of_the_same_type=True,
),
language_generator=language_generator,
)
processing_learner = learner(language_mode)
for (
_,
linguistic_description,
perceptual_representation,
) in over_train_curriculum.instances():
processing_learner.observe(
LearningExample(perceptual_representation, linguistic_description))
for (
_,
test_linguistic_description,
test_perceptual_representation,
) in over_test_curriculum.instances():
descriptions_from_learner = processing_learner.describe(
test_perceptual_representation)
gold = test_linguistic_description.as_token_sequence()
assert descriptions_from_learner
assert gold in [
desc.as_token_sequence() for desc in descriptions_from_learner
]
def test_subset_preposition_in(language_mode, learner):
water = object_variable("water", WATER)
cup = standard_object("cup", CUP)
run_preposition_test(
learner(language_mode),
_in_template(water, cup, immutableset(), is_training=True),
language_generator=phase1_language_generator(language_mode),
)
def test_subset_preposition_on(language_mode, learner):
ball = standard_object("ball", BALL)
table = standard_object("table", TABLE)
run_preposition_test(
learner(language_mode),
_on_template(ball, table, immutableset(), is_training=True),
language_generator=phase1_language_generator(language_mode),
)
def test_pursuit_preposition_in_learner(language_mode):
rng = random.Random()
rng.seed(0)
learner = PrepositionPursuitLearner(
learning_factor=0.5,
graph_match_confirmation_threshold=0.7,
lexicon_entry_threshold=0.7,
rng=rng,
smoothing_parameter=0.001,
ontology=GAILA_PHASE_1_ONTOLOGY,
object_recognizer=LANGUAGE_MODE_TO_OBJECT_RECOGNIZER[language_mode],
language_mode=language_mode,
) # type: ignore
water = object_variable("water", WATER)
cup = standard_object("cup", CUP)
language_generator = phase1_language_generator(language_mode)
in_train_curriculum = phase1_instances(
"Preposition In Unit Train",
situations=sampled(
_in_template(water, cup, immutableset(), is_training=True),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=10,
),
language_generator=language_generator,
)
in_test_curriculum = phase1_instances(
"Preposition In Unit Test",
situations=sampled(
_in_template(water, cup, immutableset(), is_training=False),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
),
language_generator=language_generator,
)
for (
_,
linguistic_description,
perceptual_representation,
) in in_train_curriculum.instances():
learner.observe(
LearningExample(perceptual_representation, linguistic_description))
for (
_,
test_linguistic_description,
test_perceptual_representation,
) in in_test_curriculum.instances():
descriptions_from_learner = learner.describe(
test_perceptual_representation)
gold = test_linguistic_description.as_token_sequence()
assert descriptions_from_learner
assert [
desc.as_token_sequence() for desc in descriptions_from_learner
][0] == gold
def test_come(language_mode, learner):
movee = standard_object(
"movee",
required_properties=[SELF_MOVING],
banned_properties=[IS_SPEAKER, IS_ADDRESSEE],
)
learner_obj = standard_object("leaner_0", LEARNER)
speaker = standard_object(
"speaker",
PERSON,
banned_properties=[IS_SPEAKER, IS_ADDRESSEE],
added_properties=[IS_SPEAKER],
)
object_ = standard_object("object_0",
THING,
banned_properties=[IS_SPEAKER, IS_ADDRESSEE])
ground = standard_object("ground", root_node=GROUND)
come_to_speaker = Phase1SituationTemplate(
"come-to-speaker",
salient_object_variables=[movee, speaker],
actions=[
Action(COME,
argument_roles_to_fillers=[(AGENT, movee), (GOAL, speaker)])
],
)
come_to_learner = Phase1SituationTemplate(
"come-to-leaner",
salient_object_variables=[movee],
actions=[
Action(COME,
argument_roles_to_fillers=[(AGENT, movee),
(GOAL, learner_obj)])
],
)
come_to_object = Phase1SituationTemplate(
"come-to-object",
salient_object_variables=[movee, object_],
actions=[
Action(COME,
argument_roles_to_fillers=[(AGENT, movee), (GOAL, object_)])
],
)
for situation_template in [
_make_come_down_template(movee, object_, speaker, ground,
immutableset()),
come_to_speaker,
come_to_learner,
come_to_object,
]:
run_verb_test(
learner(language_mode),
situation_template,
language_generator=phase1_language_generator(language_mode),
)
def test_subset_preposition_in_front(language_mode, learner):
ball = standard_object("ball", BALL)
table = standard_object("table", TABLE)
speaker = standard_object("speaker", MOM, added_properties=[IS_SPEAKER])
run_preposition_test(
learner(language_mode),
_in_front_template(ball,
table, [speaker],
is_training=True,
is_near=True),
language_generator=phase1_language_generator(language_mode),
)
def test_eat_simple(language_mode, learner):
object_to_eat = standard_object("object_0", required_properties=[EDIBLE])
eater = standard_object(
"eater_0",
THING,
required_properties=[ANIMATE],
banned_properties=[IS_SPEAKER, IS_ADDRESSEE],
)
run_verb_test(
learner(language_mode),
make_eat_template(eater, object_to_eat),
language_generator=phase1_language_generator(language_mode),
)
def test_go(language_mode, learner):
goer = standard_object("goer", THING, required_properties=[ANIMATE])
under_goal_reference = standard_object(
"go-under-goal", THING, required_properties=[HAS_SPACE_UNDER])
under_templates = [
_go_under_template(goer, under_goal_reference, [], is_distal=is_distal)
for is_distal in (True, False)
]
for situation_template in make_go_templates(None):
run_verb_test(
learner(language_mode),
situation_template,
language_generator=phase1_language_generator(language_mode),
)
for situation_template in under_templates:
run_verb_test(
learner(language_mode),
situation_template,
language_generator=phase1_language_generator(language_mode),
)
def test_pursuit_preposition_in_learner(language_mode, learner):
water = object_variable("water", WATER)
cup = standard_object("cup", CUP)
language_generator = phase1_language_generator(language_mode)
in_train_curriculum = phase1_instances(
"Preposition In Unit Train",
situations=sampled(
_in_template(water, cup, immutableset(), is_training=True),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=10,
block_multiple_of_the_same_type=True,
),
language_generator=language_generator,
)
in_test_curriculum = phase1_instances(
"Preposition In Unit Test",
situations=sampled(
_in_template(water, cup, immutableset(), is_training=False),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
block_multiple_of_the_same_type=True,
),
language_generator=language_generator,
)
processing_learner = learner(language_mode)
for (
_,
linguistic_description,
perceptual_representation,
) in in_train_curriculum.instances():
processing_learner.observe(
LearningExample(perceptual_representation, linguistic_description))
for (
_,
test_linguistic_description,
test_perceptual_representation,
) in in_test_curriculum.instances():
descriptions_from_learner = processing_learner.describe(
test_perceptual_representation)
gold = test_linguistic_description.as_token_sequence()
assert descriptions_from_learner
assert gold in [
desc.as_token_sequence() for desc in descriptions_from_learner
]
def test_take(language_mode, learner):
run_verb_test(
learner(language_mode),
make_take_template(
agent=standard_object(
"taker_0",
THING,
required_properties=[ANIMATE],
banned_properties=[IS_SPEAKER, IS_ADDRESSEE],
),
theme=standard_object("object_taken_0",
required_properties=[INANIMATE]),
use_adverbial_path_modifier=False,
),
language_generator=phase1_language_generator(language_mode),
)
def test_subset_preposition_behind(language_mode, learner):
ball = standard_object("ball", BALL)
table = standard_object("table", TABLE)
run_preposition_test(
learner(language_mode),
_behind_template(
ball,
table,
immutableset(),
is_training=True,
is_near=True,
speaker_root_node=MOM,
),
language_generator=phase1_language_generator(language_mode),
)
def test_push(language_mode, learner):
for situation_template in make_push_templates(
agent=standard_object(
"pusher",
THING,
required_properties=[ANIMATE],
banned_properties=[IS_SPEAKER, IS_ADDRESSEE],
),
theme=standard_object("pushee", INANIMATE_OBJECT),
push_surface=standard_object(
"push_surface",
THING,
required_properties=[CAN_HAVE_THINGS_RESTING_ON_THEM]),
push_goal=standard_object("push_goal", INANIMATE_OBJECT),
use_adverbial_path_modifier=False,
):
run_verb_test(
learner(language_mode),
situation_template,
language_generator=phase1_language_generator(language_mode),
)
def test_drink(language_mode, learner):
run_verb_test(
learner(language_mode),
drink_test_template(),
language_generator=phase1_language_generator(language_mode),
)
def test_tall(learner, language):
run_imprecise_test(
learner(language),
_tall_x_template(background=[]),
language_generator=phase1_language_generator(language),
)
print(f"\nObject:", word)
print(
f"Associated Colors:", [(r[0].replace("_slot1", ""), r[1]) for r in results]
)
learner.log_hypotheses(Path(f"./renders/{experiment_id}"))
learner.render_semantics_to_file(
graph=learner.semantics_graph,
graph_name="semantics",
output_file=Path(f"./renders/{experiment_id}/semantics.png"),
)
if __name__ == "__main__":
for lm in [LanguageMode.ENGLISH]:
language_generator = phase1_language_generator(lm)
for num_samples in [100]:
pretraining_curriculas = {
"objects-and-colors": [
_make_each_object_by_itself_curriculum(
num_samples, 0, language_generator
),
_make_objects_with_colors_curriculum(
num_samples, None, language_generator
),
]
}
for curricula_name, pretraining_curricula in pretraining_curriculas.items():
# Run experiment
experiment = f"attribute_semantics_ns-{num_samples}_cur-{curricula_name}"
def test_pursuit_object_learner_with_gaze(language_mode):
target_objects = [
BALL,
# PERSON,
# CHAIR,
# TABLE,
DOG,
# BIRD,
BOX,
]
language_generator = phase1_language_generator(language_mode)
target_test_templates = []
for obj in target_objects:
# Create train and test templates for the target objects
test_obj_object = object_variable("obj-with-color", obj)
test_template = Phase1SituationTemplate(
"colored-obj-object",
salient_object_variables=[test_obj_object],
syntax_hints=[IGNORE_COLORS],
gazed_objects=[test_obj_object],
)
target_test_templates.extend(
all_possible(
test_template,
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
))
rng = random.Random()
rng.seed(0)
# We can use this to generate the actual pursuit curriculum
train_curriculum = make_simple_pursuit_curriculum(
target_objects=target_objects,
num_instances=30,
num_objects_in_instance=3,
num_noise_instances=0,
language_generator=language_generator,
add_gaze=True,
)
test_obj_curriculum = phase1_instances(
"obj test",
situations=target_test_templates,
language_generator=language_generator,
)
# All parameters should be in the range 0-1.
# Learning factor works better when kept < 0.5
# Graph matching threshold doesn't seem to matter that much, as often seems to be either a
# complete or a very small match.
# The lexicon threshold works better between 0.07-0.3, but we need to play around with it because we end up not
# lexicalize items sufficiently because of diminishing lexicon probability through training
rng = random.Random()
rng.seed(0)
learner = IntegratedTemplateLearner(object_learner=PursuitObjectLearnerNew(
learning_factor=0.05,
graph_match_confirmation_threshold=0.7,
lexicon_entry_threshold=0.7,
rng=rng,
smoothing_parameter=0.002,
ontology=GAILA_PHASE_1_ONTOLOGY,
language_mode=language_mode,
rank_gaze_higher=True,
))
for training_stage in [train_curriculum]:
for (
_,
linguistic_description,
perceptual_representation,
) in training_stage.instances():
learner.observe(
LearningExample(perceptual_representation,
linguistic_description))
for test_instance_group in [test_obj_curriculum]:
for (
_,
test_instance_language,
test_instance_perception,
) in test_instance_group.instances():
logging.info("lang: %s", test_instance_language)
descriptions_from_learner = learner.describe(
test_instance_perception)
gold = test_instance_language.as_token_sequence()
assert gold in [
desc.as_token_sequence() for desc in descriptions_from_learner
]
def test_subset_preposition_has(language_mode, learner):
person = standard_object("person", PERSON)
cup = standard_object("cup", CUP)
book = standard_object("book", BOOK)
ball = standard_object("ball", BALL)
language_generator = phase1_language_generator(language_mode)
has_train_curriculum = []
has_train_curriculum.extend(
phase1_instances(
"Has Unit Train",
language_generator=language_generator,
situations=sampled(
_x_has_y_template(person, cup),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
block_multiple_of_the_same_type=True,
),
).instances())
has_train_curriculum.extend(
phase1_instances(
"Has Unit Train",
language_generator=language_generator,
situations=sampled(
_x_has_y_template(person, book),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
block_multiple_of_the_same_type=True,
),
).instances())
has_test_curriculum = phase1_instances(
"Has Unit Test",
situations=sampled(
_x_has_y_template(person, ball),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
block_multiple_of_the_same_type=True,
),
language_generator=language_generator,
)
process_learner = learner(language_mode)
for (_, linguistic_description,
perceptual_representation) in has_train_curriculum:
process_learner.observe(
LearningExample(perceptual_representation, linguistic_description))
for (
_,
test_lingustics_description,
test_perceptual_representation,
) in has_test_curriculum.instances():
descriptions_from_learner = process_learner.describe(
test_perceptual_representation)
gold = test_lingustics_description.as_token_sequence()
assert descriptions_from_learner
assert gold in [
desc.as_token_sequence() for desc in descriptions_from_learner
]
def test_your_attribute_learner(language_mode, learner):
person_0 = standard_object(
"speaker",
PERSON,
banned_properties=[IS_SPEAKER, IS_ADDRESSEE],
added_properties=[IS_SPEAKER],
)
person_1 = standard_object(
"addressee",
PERSON,
banned_properties=[IS_SPEAKER, IS_ADDRESSEE],
added_properties=[IS_ADDRESSEE],
)
inanimate_object = standard_object(
"object", INANIMATE_OBJECT, required_properties=[PERSON_CAN_HAVE]
)
language_generator = phase1_language_generator(language_mode)
your_train_curriculum = phase1_instances(
"your-train",
situations=sampled(
_x_has_y_template(
person_1,
inanimate_object,
background=[person_0],
syntax_hints=[IGNORE_HAS_AS_VERB],
),
ontology=GAILA_PHASE_1_ONTOLOGY,
chooser=PHASE1_CHOOSER_FACTORY(),
max_to_sample=5,
),
language_generator=language_generator,
)
your_test_curriculum = phase1_instances(
"your-test",
situations=sampled(
_x_has_y_template(
person_1,
inanimate_object,
background=[person_0],
syntax_hints=[IGNORE_HAS_AS_VERB],
),
ontology=GAILA_PHASE_1_ONTOLOGY,
chooser=PHASE1_TEST_CHOOSER_FACTORY(),
max_to_sample=1,
),
language_generator=language_generator,
)
process_learner = learner(language_mode)
for (
_,
linguistic_description,
perceptual_representation,
) in your_train_curriculum.instances():
process_learner.observe(
LearningExample(perceptual_representation, linguistic_description)
)
for (
_,
test_lingustics_description,
test_perceptual_representation,
) in your_test_curriculum.instances():
descriptions_from_learner = process_learner.describe(
test_perceptual_representation
)
gold = test_lingustics_description.as_token_sequence()
assert descriptions_from_learner
assert gold in [desc.as_token_sequence() for desc in descriptions_from_learner]
def test_pursuit_color_attribute(color_node, object_0_node, object_1_node,
language_mode, learner):
color = property_variable(f"{color_node.handle}", color_node)
object_0 = standard_object(f"{object_0_node.handle}",
object_0_node,
added_properties=[color])
object_1 = standard_object(f"{object_1_node.handle}",
object_1_node,
added_properties=[color])
color_object_template = _object_with_color_template(object_0, None)
templates_with_n_samples = [
(color_object_template, 2),
(_object_with_color_template(object_1, None), 4),
]
language_generator = phase1_language_generator(language_mode)
color_train_curriculum = phase1_instances(
f"{color.handle} Color Train",
language_generator=language_generator,
situations=chain(*[
flatten([
sampled(
template,
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=n_samples,
block_multiple_of_the_same_type=True,
) for template, n_samples in templates_with_n_samples
])
]),
)
color_test_curriculum = phase1_instances(
f"{color.handle} Color Test",
situations=sampled(
color_object_template,
chooser=PHASE1_TEST_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
block_multiple_of_the_same_type=True,
),
language_generator=language_generator,
)
processing_learner = learner(language_mode)
for (
_,
linguistic_description,
perceptual_representation,
) in color_train_curriculum.instances():
processing_learner.observe(
LearningExample(perceptual_representation, linguistic_description))
for (
_,
test_lingustics_description,
test_perceptual_representation,
) in color_test_curriculum.instances():
descriptions_from_learner = processing_learner.describe(
test_perceptual_representation)
gold = test_lingustics_description.as_token_sequence()
assert descriptions_from_learner
assert gold in [
desc.as_token_sequence() for desc in descriptions_from_learner
]
def test_subset_learner(language_mode, learner):
run_subset_learner_for_object(
[BALL, DOG, BOX],
learner=learner(language_mode),
language_generator=phase1_language_generator(language_mode),
)
def test_pursuit_preposition_has_learner(language_mode):
person = standard_object("person", PERSON)
inanimate_object = standard_object("inanimate-object",
INANIMATE_OBJECT,
required_properties=[PERSON_CAN_HAVE])
ball = standard_object("ball", BALL)
language_generator = phase1_language_generator(language_mode)
has_train_curriculum = phase1_instances(
"Has Unit Train",
situations=sampled(
_x_has_y_template(person, inanimate_object),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=2,
),
language_generator=language_generator,
)
has_test_curriculum = phase1_instances(
"Has Unit Test",
situations=sampled(
_x_has_y_template(person, ball),
chooser=PHASE1_CHOOSER_FACTORY(),
ontology=GAILA_PHASE_1_ONTOLOGY,
max_to_sample=1,
),
language_generator=language_generator,
)
rng = random.Random()
rng.seed(0)
learner = PrepositionPursuitLearner(
learning_factor=0.5,
graph_match_confirmation_threshold=0.7,
lexicon_entry_threshold=0.7,
rng=rng,
smoothing_parameter=0.001,
ontology=GAILA_PHASE_1_ONTOLOGY,
object_recognizer=LANGUAGE_MODE_TO_OBJECT_RECOGNIZER[language_mode],
language_mode=language_mode,
) # type: ignore
for (
_,
linguistic_description,
perceptual_representation,
) in has_train_curriculum.instances():
learner.observe(
LearningExample(perceptual_representation, linguistic_description))
for (
_,
test_lingustics_description,
test_perceptual_representation,
) in has_test_curriculum.instances():
descriptions_from_learner = learner.describe(
test_perceptual_representation)
gold = test_lingustics_description.as_token_sequence()
assert descriptions_from_learner
assert [
desc.as_token_sequence() for desc in descriptions_from_learner
][0] == gold
