def test_reproduce(self):
parser = ArgumentParser()
parser.add_arguments(MyConfig, dest="cfg")
args_none, _ = parser.parse_known_args([])
args, extra = parser.parse_known_args(["--values", "3", "4"])
values = args.cfg.values
# This is what we'd expect:
# assert values == (3, 4)
# assert extra == []
# But instead we get this:
assert values == (3)
assert extra == ["4"]
def parse_setting_and_method_instances(
setting: Union[Setting, Type[Setting]],
method: Union[Method, Type[Method]],
argv: Union[str, List[str]] = None,
strict_args: bool = False,
) -> Tuple[Setting, Method]:
# TODO: Should we raise an error if an argument appears both in the Setting
# and the Method?
parser = ArgumentParser(description=__doc__, add_dest_to_option_strings=False)
if not isinstance(setting, Setting):
assert issubclass(setting, Setting)
setting.add_argparse_args(parser)
if not isinstance(method, Method):
assert method is not None
assert issubclass(method, Method)
method.add_argparse_args(parser)
if strict_args:
args = parser.parse_args(argv)
else:
args, unused_args = parser.parse_known_args(argv)
if unused_args:
logger.warning(UserWarning(f"Unused command-line args: {unused_args}"))
if not isinstance(setting, Setting):
setting = setting.from_argparse_args(args)
if not isinstance(method, Method):
method = method.from_argparse_args(args)
return setting, method
def parse_hparams_and_config() -> Tuple[HParams, MnistConfig]:
# Training settings
parser = ArgumentParser(description='PyTorch MNIST Example')
parser.add_arguments(HParams, "hparams", default=HParams())
parser.add_arguments(MnistConfig, "config", default=MnistConfig())
args, _ = parser.parse_known_args()
hparams: HParams = args.hparams
config: MnistConfig = args.config
return hparams, config
def from_known_args(cls,
argv: Union[str, List[str]] = None,
reorder: bool = True,
strict: bool = False) -> Tuple[P, List[str]]:
# if not is_dataclass(cls):
# raise NotImplementedError(
# f"Don't know how to parse an instance of class {cls} from the "
# f"command-line, as it isn't a dataclass or doesn't have the "
# f"`add_arpargse_args` and `from_argparse_args` classmethods. "
# f"You'll have to override the `from_known_args` classmethod."
# )
if argv is None:
argv = sys.argv[1:]
logger.debug(f"parsing an instance of class {cls} from argv {argv}")
if isinstance(argv, str):
argv = shlex.split(argv)
parser = ArgumentParser(description=cls.__doc__,
add_dest_to_option_strings=False)
cls.add_argparse_args(parser)
# TODO: Set temporarily on the class, so its accessible in the class constructor
cls_argv = cls._argv
cls._argv = argv
instance: P
if strict:
args = parser.parse_args(argv)
unused_args = []
else:
args, unused_args = parser.parse_known_args(
argv, attempt_to_reorder=reorder)
if unused_args:
logger.debug(
RuntimeWarning(
f"Unknown/unused args when parsing class {cls}: {unused_args}"
))
instance = cls.from_argparse_args(args)
# Save the argv that were used to create the instance on its `_argv`
# attribute.
instance._argv = argv
cls._argv = cls_argv
return instance, unused_args
def get_args():
parser = ArgumentParser()
parser.add_argument('--runner',
default='test',
choices=runner_registry.keys(),
help="Specify whether to train or test an agent")
parser.add_argument('--environment',
default="car",
choices=environment_registry.keys(),
help="Environment to train/test agent on")
parser.add_argument('--agent',
default='scp',
choices=agent_registry.keys(),
help='Agent to train/test')
args, _ = parser.parse_known_args()
runner_class = runner_registry[args.runner]
agent_class = agent_registry[args.agent]
environment_class = environment_registry[args.environment]
parser = agent_class.add_argparse_args(parser)
parser = environment_class.add_argparse_args(parser)
parser = runner_class.add_argparse_args(parser)
return parser.parse_args()
def from_args(cls) -> "HParams":
""" Get the hparams of the method from the command-line. """
parser = ArgumentParser(description=cls.__doc__)
parser.add_arguments(cls, dest="hparams")
args, _ = parser.parse_known_args()
return args.hparams
initial_population.extend(
copy.deepcopy(original) for _ in range(options.population_size - 1))
# invoke the epbt function to get a generator of best candidates.
best_candidate_gen = epbt(
n_generations=options.population_size,
initial_population=initial_population,
evaluation_function=evaluate_mnist_classifier,
n_processes=options.n_processes,
multiprocessing=torch.multiprocessing,
)
for i, best_candidate in enumerate(best_candidate_gen):
print(f"Best candidate at step {i}: {best_candidate}")
if __name__ == '__main__':
from epbt.utils import requires_import
options = MnistExampleOptions()
with requires_import("simple_parsing") as simple_parsing:
from simple_parsing import ArgumentParser
parser = ArgumentParser()
parser.add_arguments(MnistExampleOptions,
dest="options",
default=MnistExampleOptions())
args, unknown = parser.parse_known_args()
options = args.options
main(options)