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()