def build_relation_learner_factory(
params: Parameters, beam_size: int,
language_mode: LanguageMode) -> Optional[TemplateLearner]:
learner_type = params.string("learner_type",
valid_options=["subset", "pursuit", "none"],
default="subset")
ontology, _, _ = ONTOLOGY_STR_TO_ONTOLOGY[params.string(
"ontology",
valid_options=ONTOLOGY_STR_TO_ONTOLOGY.keys(),
default="phase2")]
if learner_type == "subset":
return SubsetRelationLearnerNew(ontology=ontology,
beam_size=beam_size,
language_mode=language_mode)
elif learner_type == "pursuit":
rng = random.Random()
rng.seed(params.integer("random_seed", default=0))
return PursuitRelationLearnerNew(
learning_factor=params.floating_point("learning_factor"),
graph_match_confirmation_threshold=params.floating_point(
"graph_match_confirmation_threshold"),
lexicon_entry_threshold=params.floating_point(
"lexicon_entry_threshold"),
rng=rng,
smoothing_parameter=params.floating_point("smoothing_parameter"),
ontology=ontology,
language_mode=language_mode,
)
elif learner_type == "none":
# We don't want to include this learner type.
return None
else:
raise RuntimeError("Relation learner type invalid ")
def from_parameters(
params: Parameters,
*,
graph_logger: Optional[HypothesisLogger] = None
) -> "ObjectPursuitLearner": # type: ignore
log_word_hypotheses_dir = params.optional_creatable_directory(
"log_word_hypotheses_dir")
if log_word_hypotheses_dir:
logging.info("Hypotheses will be logged to %s",
log_word_hypotheses_dir)
rng = Random()
rng.seed(params.optional_integer("random_seed", default=0))
return ObjectPursuitLearner(
learning_factor=params.floating_point("learning_factor"),
graph_match_confirmation_threshold=params.floating_point(
"graph_match_confirmation_threshold"),
lexicon_entry_threshold=params.floating_point(
"lexicon_entry_threshold"),
smoothing_parameter=params.floating_point("smoothing_parameter"),
hypothesis_logger=graph_logger,
log_learned_item_hypotheses_to=log_word_hypotheses_dir,
rng=rng,
ontology=GAILA_PHASE_1_ONTOLOGY,
language_mode=params.enum("language_mode",
LanguageMode,
default=LanguageMode.ENGLISH),
)
def build_pursuit_curriculum(
num_samples: Optional[int],
num_noise_objects: Optional[int],
language_generator: LanguageGenerator[
HighLevelSemanticsSituation, LinearizedDependencyTree
],
*,
pursuit_curriculum_params: Parameters = Parameters.empty(),
) -> Sequence[Phase1InstanceGroup]:
num_instances = pursuit_curriculum_params.integer(
"num_instances", default=num_samples if num_samples else 10
)
num_noise_instances = pursuit_curriculum_params.integer(
"num_noise_instances", default=num_noise_objects if num_noise_objects else 2
)
num_objects_in_instance = pursuit_curriculum_params.integer(
"num_objects_in_instance", default=3
)
add_gaze = pursuit_curriculum_params.boolean("add_gaze", default=False)
prob_given = pursuit_curriculum_params.floating_point("prob_given", default=1.0)
prob_not_given = pursuit_curriculum_params.floating_point(
"prob_not_given", default=0.0
)
rng = random.Random()
rng.seed(0)
gaze_perciever = GazePerceivedNoisily(
rng=rng,
prob_gaze_perceived_given_gaze=prob_given,
prob_gaze_perceived_given_not_gaze=prob_not_given,
)
perception_generator = HighLevelSemanticsSituationToDevelopmentalPrimitivePerceptionGenerator(
ontology=GAILA_PHASE_2_ONTOLOGY, gaze_strategy=gaze_perciever
)
return [
make_simple_pursuit_curriculum(
target_objects=M6_CURRICULUM_ALL_OBJECTS,
num_instances=num_instances,
num_objects_in_instance=num_objects_in_instance,
num_noise_instances=num_noise_instances,
language_generator=language_generator,
add_gaze=add_gaze,
perception_generator=perception_generator,
)
]
def from_params(
params: Parameters,
*,
ontology: Optional[Ontology] = None,
graph_logger: Optional[GraphLogger] = None,
) -> "CrossSituationalObjectLearner":
return CrossSituationalObjectLearner(
graph_match_confirmation_threshold=params.floating_point(
"graph_match_confirmation_threshold"),
lexicon_entry_threshold=params.floating_point(
"lexicon_entry_threshold"),
smoothing_parameter=params.floating_point("smoothing_parameter"),
expected_number_of_meanings=params.floating_point(
"expected_number_of_meanings"),
graph_logger=graph_logger,
ontology=ontology if ontology else GAILA_PHASE_1_ONTOLOGY,
language_mode=params.enum("language_mode",
LanguageMode,
default=LanguageMode.ENGLISH),
)
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 build_object_learner_experiment_curriculum_train(
num_samples: Optional[int],
num_noise_objects: Optional[int],
language_generator: LanguageGenerator[
HighLevelSemanticsSituation, LinearizedDependencyTree
],
*,
params: Parameters = Parameters.empty(),
) -> Sequence[Phase1InstanceGroup]:
situations = make_multiple_object_situation(
num_samples, num_noise_objects, language_generator
)
accurate_language_chance = params.floating_point(
"accurate_language_percentage", default=0.5
)
output_situations = []
random.seed(params.integer("random_seed", default=0))
rng = RandomChooser.for_seed(params.integer("language_random_seed", default=0))
for (situation, language, perception) in situations.instances():
if random.random() <= accurate_language_chance:
output_language = language
else:
# Make Invalid Language
if situation and isinstance(situation, HighLevelSemanticsSituation):
# First, gather all OntologyNodes which aren't already present in the situation
present_ontology_nodes = [
_object.ontology_node for _object in situation.all_objects
]
valid_other_objects = [
node
for node in PHASE_1_CURRICULUM_OBJECTS
if node not in present_ontology_nodes
]
# Then choose one at random
chosen_ontology_node = rng.choice(valid_other_objects)
# Make a fake situation with just this object in it, ignoring colors
wrong_situation = HighLevelSemanticsSituation(
ontology=GAILA_PHASE_2_ONTOLOGY,
salient_objects=[
SituationObject.instantiate_ontology_node(
chosen_ontology_node, ontology=GAILA_PHASE_2_ONTOLOGY
)
],
syntax_hints=[IGNORE_COLORS],
)
# Generate the language as if it came from this fake situation rather than the original one
fake_language = only(
language_generator.generate_language(wrong_situation, chooser=rng)
)
output_language = LinearizedDependencyTree(
dependency_tree=fake_language.dependency_tree,
surface_token_order=fake_language.surface_token_order,
accurate=False,
)
else:
raise RuntimeError(
f"Unable to make invalid language without a situation of type HighlevelSemanticsSituation. Got situation: {situation}"
)
output_situations.append((situation, output_language, perception))
return [
AblatedLanguageSituationsInstanceGroup(
name=f"{situations.name()}_ablated", instances=output_situations
)
]
def build_object_learner_factory(
params: Parameters, beam_size: int,
language_mode: LanguageMode) -> TemplateLearner:
learner_type = params.string(
"learner_type",
valid_options=[
"subset", "pbv", "cross-situational", "pursuit", "recognizer"
],
default="subset",
)
ontology, objects, perception_gen = ONTOLOGY_STR_TO_ONTOLOGY[params.string(
"ontology",
valid_options=ONTOLOGY_STR_TO_ONTOLOGY.keys(),
default="phase2")]
if learner_type == "subset":
return SubsetObjectLearnerNew(ontology=ontology,
beam_size=beam_size,
language_mode=language_mode)
elif learner_type == "pbv":
chooser = 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),
rng=chooser,
ontology=ontology,
language_mode=language_mode,
)
elif learner_type == "cross-situational":
return CrossSituationalObjectLearner(
graph_match_confirmation_threshold=params.floating_point(
"graph_match_confirmation_threshold"),
lexicon_entry_threshold=params.floating_point(
"lexicon_entry_threshold"),
smoothing_parameter=params.floating_point("smoothing_parameter"),
expected_number_of_meanings=len(
ontology.nodes_with_properties(THING)),
ontology=ontology,
language_mode=language_mode,
)
elif learner_type == "pursuit":
rng = random.Random()
rng.seed(params.integer("random_seed", default=0))
return PursuitObjectLearnerNew(
learning_factor=params.floating_point("learning_factor"),
graph_match_confirmation_threshold=params.floating_point(
"graph_match_confirmation_threshold"),
lexicon_entry_threshold=params.floating_point(
"lexicon_entry_threshold"),
rng=rng,
smoothing_parameter=params.floating_point("smoothing_parameter"),
ontology=ontology,
language_mode=language_mode,
)
elif learner_type == "recognizer":
object_recognizer = ObjectRecognizer.for_ontology_types(
objects,
determiners=ENGLISH_DETERMINERS,
ontology=ontology,
language_mode=language_mode,
perception_generator=perception_gen,
)
return ObjectRecognizerAsTemplateLearner(
object_recognizer=object_recognizer, language_mode=language_mode)
else:
raise RuntimeError("Object learner type invalid")
def object_language_ablation_runner_entry_point(params: Parameters) -> None:
"""This function creates all possible object language ablation param files within a given range"""
initialize_vista_pegasus_wrapper(params)
baseline_parameters = params.namespace("object_language_ablation")
pursuit_resource_request_params = params.namespace(
"pursuit_resource_request")
# get the minimum and maximum number of objects in a scene
min_num_objects = params.integer("min_num_objects", default=1)
max_num_objects = params.integer("max_num_objects", default=7)
# get the minimum and maximum accuracy of the language with the situation
min_language_accuracy = params.floating_point("min_language_accuracy",
default=0.1)
max_language_accuracy = params.floating_point("max_language_accuracy",
default=0.5)
num_language_accuracy_increment = params.integer(
"num_language_accuracy_increment", default=5)
values_for_accuracy = np.linspace(min_language_accuracy,
max_language_accuracy,
num_language_accuracy_increment)
limit_jobs_for_category(
"pursuit", params.integer("num_pursuit_learners_active", default=8))
for num_objects in range(min_num_objects, max_num_objects + 1):
for language_accuracy in values_for_accuracy:
for learner_type in LEARNER_VALUES_TO_PARAMS:
for params_str, learner_params in LEARNER_VALUES_TO_PARAMS[
learner_type]:
experiment_name_string = EXPERIMENT_NAME_FORMAT.format(
num_objects=num_objects,
language_accuracy=language_accuracy,
learner_type=learner_type,
learner_params=params_str,
)
experiment_name = Locator(
experiment_name_string.split("-"))
# Note that the input parameters should include the root params and
# anything else we want.
experiment_params = baseline_parameters.unify(
FIXED_PARAMETERS
).unify({
"experiment":
experiment_name_string,
"experiment_group_dir":
directory_for(experiment_name),
"hypothesis_log_dir":
directory_for(experiment_name) / "hypotheses",
"learner_logging_path":
directory_for(experiment_name),
"log_learner_state":
True,
"resume_from_latest_logged_state":
True,
"train_curriculum": {
"accurate_language_percentage":
float(language_accuracy)
},
"object_learner_type":
learner_type,
"object_learner":
learner_params,
# We subtract one because the target object is a given
"num_noise_objects":
num_objects - 1,
})
run_python_on_parameters(
experiment_name,
log_experiment_script,
experiment_params,
depends_on=[],
resource_request=SlurmResourceRequest.from_parameters(
pursuit_resource_request_params)
if learner_type == "pursuit" else None,
category=learner_type,
)
write_workflow_description()
