def settings(self, key=None, section=None):
"""The settings overridden from the wandb/settings file.
Args:
key (str, optional): If provided only this setting is returned
section (str, optional): If provided this section of the setting file is
used, defaults to "default"
Returns:
A dict with the current settings
{
"entity": "models",
"base_url": "https://api.wandb.ai",
"project": None
}
"""
result = self.default_settings.copy()
result.update(self._settings.items(section=section))
result.update({
'entity': env.get_entity(
self._settings.get(Settings.DEFAULT_SECTION, "entity", fallback=result.get('entity')),
env=self._environ),
'project': env.get_project(
self._settings.get(Settings.DEFAULT_SECTION, "project", fallback=result.get('project')),
env=self._environ),
'base_url': env.get_base_url(
self._settings.get(Settings.DEFAULT_SECTION, "base_url", fallback=result.get('base_url')),
env=self._environ),
'ignore_globs': env.get_ignore(
self._settings.get(Settings.DEFAULT_SECTION, "ignore_globs", fallback=result.get('ignore_globs')),
env=self._environ),
})
return result if key is None else result[key]
def settings(self, key=None, section=None):
"""The settings overridden from the wandb/settings file.
Args:
key (str, optional): If provided only this setting is returned
section (str, optional): If provided this section of the setting file is
used, defaults to "default"
Returns:
A dict with the current settings
{
"entity": "models",
"base_url": "https://api.wandb.ai",
"project": None
}
"""
if not self._settings:
self._settings = self.default_settings.copy()
section = section or self._settings['section']
try:
if section in self._settings_parser.sections():
for option in self._settings_parser.options(section):
self._settings[option] = self._settings_parser.get(
section, option)
except configparser.InterpolationSyntaxError:
print("WARNING: Unable to parse settings file")
self._settings["project"] = env.get_project(
self._settings.get("project"))
self._settings["entity"] = env.get_entity(
self._settings.get("entity"))
self._settings["base_url"] = env.get_base_url(
self._settings.get("base_url"))
return self._settings if key is None else self._settings[key]
def sweep(ctx, project, entity, controller, verbose, name, program, settings, update, config_yaml):
def _parse_settings(settings):
"""settings could be json or comma seperated assignments."""
ret = {}
# TODO(jhr): merge with magic_impl:_parse_magic
if settings.find('=') > 0:
for item in settings.split(","):
kv = item.split("=")
if len(kv) != 2:
wandb.termwarn("Unable to parse sweep settings key value pair", repeat=False)
ret.update(dict([kv]))
return ret
wandb.termwarn("Unable to parse settings parameter", repeat=False)
return ret
if api.api_key is None:
termlog("Login to W&B to use the sweep feature")
ctx.invoke(login, no_offline=True)
sweep_obj_id = None
if update:
parts = dict(entity=entity, project=project, name=update)
err = util.parse_sweep_id(parts)
if err:
wandb.termerror(err)
return
entity = parts.get("entity") or entity
project = parts.get("project") or project
sweep_id = parts.get("name") or update
found = api.sweep(sweep_id, '{}', entity=entity, project=project)
if not found:
wandb.termerror('Could not find sweep {}/{}/{}'.format(entity, project, sweep_id))
return
sweep_obj_id = found['id']
wandb.termlog('{} sweep from: {}'.format(
'Updating' if sweep_obj_id else 'Creating',
config_yaml))
try:
yaml_file = open(config_yaml)
except (OSError, IOError):
wandb.termerror('Couldn\'t open sweep file: %s' % config_yaml)
return
try:
config = util.load_yaml(yaml_file)
except yaml.YAMLError as err:
wandb.termerror('Error in configuration file: %s' % err)
return
if config is None:
wandb.termerror('Configuration file is empty')
return
# Set or override parameters
if name:
config["name"] = name
if program:
config["program"] = program
if settings:
settings = _parse_settings(settings)
if settings:
config.setdefault("settings", {})
config["settings"].update(settings)
if controller:
config.setdefault("controller", {})
config["controller"]["type"] = "local"
is_local = config.get('controller', {}).get('type') == 'local'
if is_local:
tuner = wandb_controller.controller()
err = tuner._validate(config)
if err:
wandb.termerror('Error in sweep file: %s' % err)
return
entity = entity or env.get_entity() or config.get('entity')
project = project or env.get_project() or config.get('project') or util.auto_project_name(
config.get("program"), api)
sweep_id = api.upsert_sweep(config, project=project, entity=entity, obj_id=sweep_obj_id)
wandb.termlog('{} sweep with ID: {}'.format(
'Updated' if sweep_obj_id else 'Created',
click.style(sweep_id, fg="yellow")))
sweep_url = wandb_controller._get_sweep_url(api, sweep_id)
if sweep_url:
wandb.termlog("View sweep at: {}".format(
click.style(sweep_url, underline=True, fg='blue')))
# reprobe entity and project if it was autodetected by upsert_sweep
entity = entity or env.get_entity()
project = project or env.get_project()
if entity and project:
sweep_path = "{}/{}/{}".format(entity, project, sweep_id)
elif project:
sweep_path = "{}/{}".format(project, sweep_id)
else:
sweep_path = sweep_id
wandb.termlog("Run sweep agent with: {}".format(
click.style("wandb agent %s" % sweep_path, fg="yellow")))
if controller:
wandb.termlog('Starting wandb controller...')
tuner = wandb_controller.controller(sweep_id)
tuner.run(verbose=verbose)
