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 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 main(params: Parameters): conda_script_generator = CondaJobScriptGenerator.from_parameters(params) entry_point = params.string("entry_point") work_dir = params.optional_creatable_directory( "working_directory") or Path(os.getcwd()) stdout_file = params.string("log_file") or work_dir / "___stdout.log" shell_script = conda_script_generator.generate_shell_script( entry_point_name=entry_point, param_file=params.existing_file("job_param_file"), working_directory=work_dir, stdout_file=stdout_file, ) params.creatable_file("conda_script_path").write_text( # type: ignore shell_script, encoding="utf-8") if params.boolean("echo_template", default=False): print(shell_script)
def main(params: Parameters): viz = SituationVisualizer() # try to get the directory for rendering for an experiment adam_root = params.existing_directory("adam_root") root_output_directory = params.optional_creatable_directory( "experiment_group_dir") if root_output_directory is not None: m9_experiments_dir = adam_root / "parameters" / "experiments" / "m9" param_files: List[Path] = [] if params.boolean("include_objects"): param_files.append(m9_experiments_dir / "objects.params") if params.boolean("include_attributes"): param_files.append(m9_experiments_dir / "attributes.params") if params.boolean("include_relations"): param_files.append(m9_experiments_dir / "relations.params") if params.boolean("include_events"): param_files.append(m9_experiments_dir / "events.params") # This activates a special "debug" curriculum, # which is meant to be edited in the code by a developer to do fine-grained debugging. if params.boolean("include_debug", default=False): param_files.append(m9_experiments_dir / "debug.params") # loop over all experiment params files for param_file in param_files: experiment_params = YAMLParametersLoader().load(param_file) if "curriculum" in experiment_params: # get the experiment curriculum list (if there is one) curriculum = curriculum_from_params(experiment_params)[0] directory_name = experiment_params.string( "experiment") + "/renders" if not os.path.isdir(root_output_directory / directory_name): os.mkdir(root_output_directory / directory_name) for instance_group in curriculum: try: make_scenes( params, [instance_group], root_output_directory / directory_name, viz, ) except RuntimeError as err: print(f"uncaught exception: {err}") else: # render phase 1 scenes: root_output_directory = params.optional_creatable_directory( "screenshot_directory") assert root_output_directory is not None if not os.path.isdir(root_output_directory): os.mkdir(root_output_directory) for idx, instance_group in enumerate( build_curriculum(None, None, GAILA_PHASE_1_LANGUAGE_GENERATOR)): # do any filtering here if instance_group.name() in EXCLUDED_CURRICULA: continue directory_name = f"{idx:03}-{instance_group.name()}" if not os.path.isdir(root_output_directory / directory_name): os.mkdir(root_output_directory / directory_name) # type: ignore # then call some function from make_scenes.py to run the curriculum make_scenes(params, [instance_group], root_output_directory / directory_name, viz)
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) curriculum_repository_path = params.optional_existing_directory( "load_from_curriculum_repository") if curriculum_repository_path: curriculum = read_experiment_curriculum(curriculum_repository_path, params, language_mode) (training_instance_groups, test_instance_groups) = ( curriculum.train_curriculum, curriculum.test_curriculum, ) else: (training_instance_groups, test_instance_groups) = curriculum_from_params(params, language_mode) experiment_group_dir = params.optional_creatable_directory( "experiment_group_dir") resume_from_last_logged_state = params.boolean( "resume_from_latest_logged_state", default=False) # Check if we have explicit observer states to load observers_state = params.optional_existing_file("observers_state_path") test_observer = [] # type: ignore pre_observer = [] # type: ignore post_observer = [] # type: ignore if resume_from_last_logged_state and observers_state: raise RuntimeError( f"Can not resume from last logged state and provide explicit observer state paths" ) if resume_from_last_logged_state: if not experiment_group_dir: raise RuntimeError( "experiment_group_dir must be specified when resume_from_last_logged_state is true." ) # Try to Load Observers for _, observers_state_path in observer_states_by_most_recent( cast(Path, experiment_group_dir) / "observer_state", "observers_state_at_"): try: with observers_state_path.open("rb") as f: observers_holder = pickle.load(f) pre_observer = observers_holder.pre_observers post_observer = observers_holder.post_observers test_observer = observers_holder.test_observers except OSError: logging.warning( "Unable to open observer state at %s; skipping.", str(observers_state_path), ) except pickle.UnpicklingError: logging.warning( "Couldn't unpickle observer state at %s; skipping.", str(observers_state_path), ) if not pre_observer and not post_observer and not test_observer: logging.warning("Reverting to default observers.") pre_observer = [ logger.pre_observer( # type: ignore params=params.namespace_or_empty("pre_observer"), experiment_group_dir=experiment_group_dir, ) ] post_observer = [ logger.post_observer( # type: ignore params=params.namespace_or_empty("post_observer"), experiment_group_dir=experiment_group_dir, ) ] test_observer = [ logger.test_observer( # type: ignore params=params.namespace_or_empty("test_observer"), experiment_group_dir=experiment_group_dir, ) ] elif observers_state: try: with observers_state.open("rb") as f: observers_holder = pickle.load(f) pre_observer = observers_holder.pre_observers post_observer = observers_holder.post_observers test_observer = observers_holder.test_observers except OSError: logging.warning("Unable to open observer state at %s; skipping.", str(observers_state)) except pickle.UnpicklingError: logging.warning( "Couldn't unpickle observer state at %s; skipping.", str(observers_state)) else: pre_observer = [ logger.pre_observer( # type: ignore params=params.namespace_or_empty("pre_observer"), experiment_group_dir=experiment_group_dir, ) ] post_observer = [ logger.post_observer( # type: ignore params=params.namespace_or_empty("post_observer"), experiment_group_dir=experiment_group_dir, ) ] test_observer = [ logger.test_observer( # type: ignore params=params.namespace_or_empty("test_observer"), experiment_group_dir=experiment_group_dir, ) ] 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=pre_observer, post_example_training_observers=post_observer, test_instance_groups=test_instance_groups, test_observers=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=experiment_group_dir, starting_point=params.integer("starting_point", default=0), point_to_log=params.integer("point_to_log", default=0), load_learner_state=params.optional_existing_file("learner_state_path"), resume_from_latest_logged_state=resume_from_last_logged_state, debug_learner_pickling=params.boolean("debug_learner_pickling", default=False), )