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