def find_net_config_path(cls, config_name_or_dir: str, pattern: str = '') -> str: """ find a standard network config, get its full path, try: 1) look up if config_name_or_dir matches a name (e.g. DARTS) in the common configs 2) otherwise assume it is a dir, try to return a network config which name contains the pattern :param config_name_or_dir: dir or full path of a config :param pattern: if a config has to be searched in the dir """ # already done? if '/' in config_name_or_dir and config_name_or_dir.endswith( cls.extension_net_config): return config_name_or_dir # search in the common configs for a given name p = replace_standard_paths( '{path_conf_net}' ) + '/**/' + config_name_or_dir + '*' + cls.extension_net_config paths = glob(p, recursive=True) if len(paths) == 1: return paths[0] # find any unique network config in the given path p = '%s/**/*%s*%s' % (replace_standard_paths(config_name_or_dir), pattern, cls.extension_net_config) paths = glob(p, recursive=True) if len(paths) == 1: return paths[0] raise FileNotFoundError( 'can not find (unique) network config with given name/path "%s"' % config_name_or_dir)
def assert_stats_match(name, task_cfg, cfg: dict, num_params=None, num_macs=None): cfg_dir = replace_standard_paths('{path_tmp}/tests/cfgs/') cfg_path = Builder.save_config(cfg, cfg_dir, name) exp = Main.new_task( task_cfg, args_changes={ '{cls_data}.fake': True, '{cls_data}.batch_size_train': 2, '{cls_data}.batch_size_test': -1, '{cls_task}.is_test_run': True, '{cls_task}.save_dir': '{path_tmp}/tests/workdir/', "{cls_network}.config_path": cfg_path, "{cls_trainer}.ema_decay": -1, 'cls_network_heads': 'ClassificationHead', # necessary for the DARTS search space to disable the aux heads }, raise_unparsed=False) net = exp.get_method().get_network() macs = exp.get_method().profile_macs() net.eval() # print(net) cp = count_parameters(net) if num_params is not None: assert cp == num_params, 'Got unexpected num params for %s: %d, expected %d, diff: %d'\ % (name, cp, num_params, abs(cp - num_params)) if num_macs is not None: assert macs == num_macs, 'Got unexpected num macs for %s: %d, expected %d, diff: %d'\ % (name, macs, num_macs, abs(macs - num_macs))
def __init__(self, args: Namespace, *args_, **kwargs): super().__init__(args, *args_, **kwargs) # args self.s1_path = replace_standard_paths( self._parsed_argument('s1_path', args)) self.reset_bn = self._parsed_argument('reset_bn', args) # files self.tmp_load_path = '%s/checkpoints/checkpoint.tmp.pt' % self.save_dir os.makedirs(os.path.dirname(self.tmp_load_path), exist_ok=True) shutil.copyfile('%s/data.meta.pt' % self.s1_path, '%s/data.meta.pt' % self.save_dir) # one method, one trainer... could be executed in parallel in future? log_headline(self.logger, 'setting up...') self.add_method() self.add_trainer(method=self.get_method(), save_dir=self.save_dir, num_devices=-1) self.log_detailed() self.get_method().get_network().set_forward_strategy(False) # algorithms estimator_kwargs = dict(trainer=self.trainer[0], load_path=self.tmp_load_path) self.algorithm, self.estimators, self.termination = PymooHPOUtils.prepare( self, self.logger, estimator_kwargs, args)
def visualize_config(config: dict, save_path: str): save_path = replace_standard_paths(save_path) cfg_path = Builder.save_config(config, replace_standard_paths('{path_tmp}/viz/'), 'viz') exp = Main.new_task(run_config, args_changes={ '{cls_data}.fake': True, '{cls_data}.batch_size_train': 4, '{cls_task}.is_test_run': True, '{cls_task}.save_dir': '{path_tmp}/viz/task/', '{cls_task}.save_del_old': True, "{cls_network}.config_path": cfg_path, }) net = exp.get_method().get_network() vt = VizTree(net) vt.print() vt.plot(save_path + 'net', add_subgraphs=True) print('Saved cell viz to %s' % save_path)
def find_last_checkpoint_path(cls, save_dir: str, index=0, try_general_checkpoint=True) -> str: """ attempt finding the checkpoint path in a dir, if 'save_dir' is a file, return it if there is a general checkpoint and 'try_general_checkpoint', return its path otherwise try finding the most recent checkpoint of the CheckpointCallback with index 'index' """ save_dir = replace_standard_paths(save_dir) # try as path and general path if os.path.isfile(save_dir): return save_dir if try_general_checkpoint and os.path.isfile( cls._general_checkpoint_file(save_dir)): return cls._general_checkpoint_file(save_dir) # try by index lst = sorted(cls.list_infos(save_dir, index), key=lambda inf: inf.checkpoint_path) if len(lst) > 0: return lst[-1].checkpoint_path # try to find any checkpoint.pt in dir for path in glob.glob('%s/**/checkpoint.pt' % save_dir, recursive=True): return path # failure LoggerManager().get_logger().info( 'Can not find a uninas checkpoint (history) in: %s' % save_dir) return ''
def find_pretrained_weights_path(cls, path: str, name: str = 'pretrained', raise_missing=True) -> str: """ attempt finding pretrained weights in a dir, no matter if checkpoint or external """ maybe_path = maybe_download(path, FileType.WEIGHTS) if isinstance(maybe_path, str): return maybe_path path = replace_standard_paths(path) if len(path) == 0 or os.path.isfile(path): return path # try looking for a checkpoint p = cls.find_last_checkpoint_path(path) if os.path.isfile(p): return p # glob any .pt/.pth file with the network name in it glob_path = '%s/**/*%s*.pt*' % (path, name) paths = glob.glob(glob_path, recursive=True) if len(paths) > 0: return paths[0] # failure if raise_missing: raise FileNotFoundError( 'can not find any pretrained weights in "%s" or "%s"' % (path, glob_path)) return ''
def run(self): try: path = replace_standard_paths('{path_tmp}/tmp.run_config') self.interactive.to_json(path) Main.new_task(path).run() except Exception as e: LoggerManager().get_logger().error(str(e), exc_info=e) tkm.showwarning(message=str(e))
def make_nats(path_full: str, path_save: str = None) -> MiniNATSBenchTabularBenchmark: api = create(replace_standard_paths(path_full), 'tss', fast_mode=True, verbose=True) mini = MiniNATSBenchTabularBenchmark.make_from_full_api(api) if isinstance(path_save, str): mini.save(path_save) return mini
def visualize_config(config: dict, save_path: str): save_path = replace_standard_paths(save_path) cfg_path = Builder.save_config(config, replace_standard_paths('{path_tmp}/viz/'), 'viz') exp = Main.new_task(run_config, args_changes={ '{cls_data}.fake': True, '{cls_data}.batch_size_train': 2, '{cls_task}.is_test_run': True, '{cls_task}.save_dir': '{path_tmp}/viz/task/', '{cls_task}.save_del_old': True, "{cls_task}.note": "viz", "{cls_network}.config_path": cfg_path, }) net = exp.get_method().get_network() for s in ['n', 'r']: for cell in net.get_cells(): if cell.name.startswith(s): visualize_cell(cell, save_path, s) break print('Saved cell viz to %s' % save_path)
def load_config(cls, config_file_path: str) -> dict: """ load a json config file from given path """ config_file_path = replace_standard_paths(config_file_path) if os.path.isfile(config_file_path): with open(config_file_path, 'r') as file: return json.load(file) else: raise FileNotFoundError( 'Could not find file "%s" / "%s"' % (config_file_path, os.path.abspath(config_file_path)))
def arg_list_from_json(paths: str) -> [str]: args = [] for path in split(paths): path = replace_standard_paths(path) print('using config file: %s' % path) with open(path) as config_file: config = json.load(config_file) for k, v in config.items(): args.append('--%s=%s' % (k, v)) return args
def visualize_genotype(wrapper: NetWrapper, save_dir: str): config_name = get_var_name(wrapper) save_dir = replace_standard_paths('%s%s/' % (save_dir, config_name)) wrapper_net, config, _ = wrapper.generate(save_dir, 'viz') assert isinstance(wrapper_net, SearchUninasNetwork) g = Digraph(format='pdf', engine='dot', edge_attr=dict(fontsize='20', fontname="times"), node_attr=dict(style='filled', shape='rect', align='center', fontsize='20', height='0.5', penwidth='2', fontname="times")) cell_order = config.get('kwargs').get('cell_order') stem_name = wrapper_net.get_network().get_stem().__class__.__name__ g.node('stem', label=short_name.get(stem_name, stem_name), width=width_str(expansion='3'), fillcolor=colors.get('misc')) node_names = ['stem'] for i, cell in enumerate(wrapper_net.get_network().get_cells()): assert isinstance(cell, SingleLayerCell) name = cell_order[i] op_cfg = config.get('kwargs').get('cell_configs').get(name).get('submodules').get('op') cell_cls = op_cfg.get('name') op_kwargs = op_cfg.get('kwargs') e = op_kwargs.get('expansion') k = op_kwargs.get('k_size') s_in = cell.cached.get('shape_in')[0] s_out = cell.cached.get('shape_out')[0] label = '{name} E{e} K{k}'.format(**{ 'name': short_name.get(cell_cls, cell_cls), 'e': e, 'k': k, }) g.node(name, label=label, width=width_str(expansion=e), fillcolor=colors.get(k)) node_names.append(name) if len(node_names) > 1: g.edge(node_names[-2], node_names[-1], label='\t'+'*'.join([str(s) for s in s_in.shape])) print('{:<10}{:<30}{:<30}{:<30}{}'.format(cell.name, cell_cls, s_in.str(), s_out.str(), str(op_kwargs))) head = wrapper_net.get_network().get_heads()[-1] assert isinstance(head, FeatureMixClassificationHead) g.node('fmix', label='Conv K1', width=width_str(expansion='3'), fillcolor=colors.get('misc')) node_names.append('fmix') s_in = head.cached.get('shape_in') g.edge(node_names[-2], node_names[-1], label='\t'+'*'.join([str(s) for s in s_in.shape])) g.node('head', label='classification', width=width_str(expansion='3'), fillcolor=colors.get('misc')) node_names.append('head') s_in = head.cached.get('shape_inner') g.edge(node_names[-2], node_names[-1], label='\t'+'*'.join([str(s) for s in s_in.shape])) g.view(filename='%snet' % save_dir) print('Saved cell viz to %s' % save_dir)
def save_config(cls, config: dict, config_dir: str, config_name: str) -> str: if config is None: return '' os.makedirs(config_dir, exist_ok=True) path = '%s/%s%s' % (replace_standard_paths(config_dir), config_name, cls.extension_net_config) path = os.path.abspath(path) with open(path, 'w+') as outfile: json.dump(config, outfile, ensure_ascii=False, indent=2) LoggerManager().get_logger().info('Wrote net config to %s' % path) return path
def find_classes_in_config(self, config_file_path: str) -> {str: list}: """ load a json config file from given path and figure out the used classes in it """ config_file_path = replace_standard_paths(config_file_path) cfg = self.load_config(config_file_path) names = self._rec_list_attr(cfg, 'name') return { 'cls_network_body': [n for n in names if n.endswith('NetworkBody')], 'cls_network_cells': [n for n in names if n.endswith('Cell')], 'cls_network_stem': [n for n in names if n.endswith('Stem')], 'cls_network_heads': [n for n in names if n.endswith('Head')], }
def from_file(cls, file_path: str): """ create and load a profiler from a profiler save file """ file_path = replace_standard_paths(file_path) assert os.path.isfile( file_path), "File does not exist: %s" % str(file_path) cls_name = torch.load(file_path).get('meta').get('cls') profiler = Register.profilers.get(cls_name)() profiler.load(file_path) if profiler.get('is_test_run'): LoggerManager().get_logger().warning( "Loading profiler data from a file created in a test run!") return profiler
def from_args(cls, args: Namespace, index: int = None) -> 'AbstractDataSet': # parsed arguments, and the global save dir all_args = cls._all_parsed_arguments(args, index=index) data_dir = replace_standard_paths(all_args.pop('dir')) fake = all_args.pop('fake') download = all_args.pop('download') and not fake try: _, save_dir = find_in_args(args, '.save_dir') save_dir = replace_standard_paths(save_dir) except ValueError: save_dir = "" # augmentations per data point and batch, for training and test tr_d, tr_b, te_d, te_b = [], [], [], [] for i, aug_set in enumerate(cls._parsed_meta_arguments(Register.augmentation_sets, 'cls_augmentations', args, index=index)): tr_d_, tr_b_ = aug_set.get_train_transforms(args, i, cls) te_d_, te_b_ = aug_set.get_test_transforms(args, i, cls) tr_d.extend(tr_d_) tr_b.extend(tr_b_) te_d.extend(te_d_) te_b.extend(te_b_) if cls.is_on_images(): final_transforms = [transforms.ToTensor(), transforms.Normalize(cls.data_mean, cls.data_std)] else: final_transforms = [] train_transforms = transforms.Compose(tr_d + final_transforms) test_transforms = transforms.Compose(te_d + final_transforms) train_batch_aug = BatchAugmentations(tr_b) if len(tr_b) > 0 else None test_batch_aug = BatchAugmentations(te_b) if len(te_b) > 0 else None return cls(data_dir=data_dir, save_dir=save_dir, bs_train=all_args.pop('batch_size_train'), bs_test=all_args.pop('batch_size_test'), train_transforms=train_transforms, test_transforms=test_transforms, train_batch_aug=train_batch_aug, test_batch_aug=test_batch_aug, num_workers=all_args.pop('num_workers'), num_prefetch=all_args.pop('num_prefetch'), valid_split=all_args.pop('valid_split'), valid_shuffle=all_args.pop('valid_shuffle'), fake=fake, download=download, **all_args)
def get_imagenet(data_dir: str, num_workers=8, batch_size=8, aug_dict: dict = None) -> AbstractDataSet: data_kwargs = { "cls_data": "Imagenet1000Data", "Imagenet1000Data.fake": False, "Imagenet1000Data.dir": replace_standard_paths(data_dir), "Imagenet1000Data.num_workers": num_workers, "Imagenet1000Data.batch_size_train": batch_size, "Imagenet1000Data.batch_size_test": batch_size, } if aug_dict is None: aug_dict = { "cls_augmentations": "DartsImagenetAug", "DartsImagenetAug#0.crop_size": 224, } data_kwargs.update(aug_dict) return get_dataset(data_kwargs)
def load(cls, file_path: str, pl_module: AbstractMethod = None) -> dict: """ load method checkpoint from method checkpoint file and return it """ file_path = replace_standard_paths(file_path) if os.path.isfile(file_path): LoggerManager().get_logger().info('Found checkpoint: %s' % file_path) checkpoint = torch.load(file_path) if pl_module is not None: pl_module.load_state_dict(checkpoint['state_dict']) pl_module.on_load_checkpoint(checkpoint) LoggerManager().get_logger().info( 'Loaded weights from file: %s' % file_path) return checkpoint else: LoggerManager().get_logger().info( 'Can not load weights, does not exist / not a file: %s' % file_path) return {}
def test_examples(self): """ run all examples in /experiments/examples/ in ascending name order """ paths = sorted( glob.glob("%s/experiments/examples/*.py" % replace_standard_paths("{path_project_dir}"))) start_idx = 0 # just to get quickly to the failing one for i, path in enumerate(paths): if i < start_idx: continue if path.endswith('__init__.py'): continue if 'pbt' in path: continue if os.system("python3 %s" % path) > 0: assert False, "Failed running i=%d path=%s, got an error" % ( i, path)
def _save(self, save_path: str): if isinstance(save_path, str): save_path = replace_standard_paths(save_path) name = os.path.basename(save_path) path = os.path.dirname(save_path) os.makedirs(path, exist_ok=True) s = '%s/%s' % (path, name) data = dict( cls=self.__class__.__name__, default_data_set=self.default_data_set, default_result_type=self.default_result_type, value_space=self.get_value_space(), bench_name=self.bench_name, bench_description=self.bench_description, results={k: r.state_dict() for k, r in self.results.items()}, arch_to_idx=self.arch_to_idx, tuple_to_str=self.tuple_to_str, tuple_to_idx=self.tuple_to_idx) torch.save(data, s)
def save_as_json(args: args_type, file_path: str, wildcards: dict): """ save the given Namespace as ordered json file, replacing names with wildcards """ file_path = replace_standard_paths(file_path) name_to_wildcard = {'%s.' % v: '{%s}.' % k for k, v in wildcards.items()} # generate a run_config from current args, replace with wildcards, sort in order of cls_* meta args config, config_sorted = {}, {} for k, v in items(args).items(): for k2, v2 in name_to_wildcard.items(): k = k.replace(k2, v2) config[k] = v for i, name in enumerate(config.keys()): if name.startswith('cls_'): for k, v in config.items(): if k.startswith(name) or k.startswith('{%s' % name): config_sorted[k] = v os.makedirs(os.path.dirname(file_path), exist_ok=True) with open(file_path, 'w+') as outfile: json.dump(config_sorted, outfile, indent=4) pass
def main(): parser = argparse.ArgumentParser( description= 'uninas generate a network config from simple genotype description') parser.add_argument('--cells', type=str, default=None, help='which config to generate, all available if None') args = parser.parse_args() args.save_dir = replace_standard_paths('{path_conf_net_originals}/') if args.cells is not None: all_cell_names = [args.cells] else: all_cell_names = [] for key, value in list(globals().items()): if isinstance(value, Genotype): all_cell_names.append(key) for cell_name in all_cell_names: print('Name:\t\t%s' % cell_name) generate_from_name(cell_name)
def __init__(self, args: Namespace, *args_, **kwargs): AbstractNetTask.__init__(self, args, *args_, **kwargs) # args self.reset_bn = self._parsed_argument('reset_bn', args) self.s1_path = replace_standard_paths( self._parsed_argument('s1_path', args)) # files self.tmp_load_path = '%s/checkpoint.tmp.pt' % self.save_dir os.makedirs(os.path.dirname(self.tmp_load_path), exist_ok=True) shutil.copyfile('%s/data.meta.pt' % self.s1_path, '%s/data.meta.pt' % self.save_dir) # one method, one trainer... could be executed in parallel in future? log_headline(self.logger, 'setting up...') self.add_method() self.add_trainer(method=self.get_method(), save_dir=self.save_dir, num_devices=-1) self.log_detailed() self.get_method().get_network().set_forward_strategy(False) # algorithms estimator_kwargs = dict(trainer=self.trainer[0], load_path=self.tmp_load_path) self.hpo, self.constraints, self.objectives = SelfHPOUtils.prepare( self, self.logger, estimator_kwargs, args) # arc space space = ValueSpace(*[ DiscreteValues.interval(0, n) for n in self.get_method().strategy_manager.get_num_choices( unique=True) ]) self._architecture_space = SelfHPOUtils.mask_architecture_space( self.args, space)
def __init__(self, data_dir: str, save_dir: Union[str, None], bs_train: int, bs_test: int, train_transforms: transforms.Compose, test_transforms: transforms.Compose, train_batch_aug: Union[BatchAugmentations, None], test_batch_aug: Union[BatchAugmentations, None], num_workers: int, num_prefetch: int, valid_split: Union[int, float], valid_shuffle: bool, fake: bool, download: bool, **additional_args): """ :param data_dir: where to find (or download) the data set :param save_dir: global save dir, can store and reuse the info which data was used in the random valid split :param bs_train: batch size for the train loader :param bs_test: batch size for the test loader, <= 0 to have the same as bs_train :param train_transforms: train augmentations (on each data point individually) :param test_transforms: test augmentations (on each data point individually) :param train_batch_aug: train augmentations (across the entire batch) :param test_batch_aug: test augmentations (across the entire batch) :param num_workers: number of workers prefetching data :param num_prefetch: number of batches prefetched by every worker :param valid_split: absolute number of data points if int or >1, otherwise a fraction of the training set :param valid_shuffle: whether to shuffle validation data :param fake: use fake data instead (no need to provide either real data or enabling downloading) :param download: whether downloading is allowed :param additional_args: arguments that are added and used by child classes """ super().__init__() logger = LoggerManager().get_logger() self.dir = data_dir self.bs_train = bs_train self.bs_test = bs_test if bs_test > 0 else self.bs_train self.num_workers, self.num_prefetch = num_workers, num_prefetch self.valid_shuffle = valid_shuffle self.additional_args = additional_args self.fake = fake self.download = download and not self.fake if self.download and (not self.can_download): LoggerManager().get_logger().warning("The dataset can not be downloaded, but may be asked to.") self.train_transforms = train_transforms self.test_transforms = test_transforms self.train_batch_augmentations = train_batch_aug self.test_batch_augmentations = test_batch_aug # load/create meta info dict if isinstance(save_dir, str) and len(save_dir) > 0: meta_path = '%s/data.meta.pt' % replace_standard_paths(save_dir) if os.path.isfile(meta_path): meta = torch.load(meta_path) else: meta = defaultdict(dict) else: meta, meta_path = defaultdict(dict), None # give subclasses a good spot to react to additional arguments self._before_loading() # data if self.fake: train_data = self._get_fake_train_data(self.train_transforms) self.test_data = self._get_fake_test_data(self.test_transforms) else: train_data = self._get_train_data(self.train_transforms) self.test_data = self._get_test_data(self.test_transforms) # split train into train+valid or using stand-alone valid set if valid_split > 0: s1 = int(valid_split) if valid_split >= 1 else int(len(train_data)*valid_split) if s1 >= len(train_data): logger.warning("Tried to set valid split larger than the training set size, setting to 0.5") s1 = len(train_data)//2 s0 = len(train_data) - s1 if meta['splits'].get((s0, s1), None) is None: meta['splits'][(s0, s1)] = torch.randperm(s0+s1).tolist() indices = meta['splits'][(s0, s1)] self.valid_data = torch.utils.data.Subset(train_data, np.array(indices[s0:]).astype(np.int)) train_data = torch.utils.data.Subset(train_data, np.array(indices[0:s0]).astype(np.int)) logger.info('Data Set: splitting training set, will use %s data points as validation set' % s1) if self.length[1] > 0: logger.info('Data Set: a dedicated validation set exists, but it will be replaced.') elif self.length[1] > 0: if self.fake: self.valid_data = self._get_fake_valid_data(self.test_transforms) else: self.valid_data = self._get_valid_data(self.test_transforms) logger.info('Data Set: using the dedicated validation set with test augmentations') else: self.valid_data = None logger.info('Data Set: not using a validation set at all.') self.train_data = train_data # shapes data, label = self.train_data[0] self.data_shape = Shape(list(data.shape)) # save meta info dict if meta_path is not None: torch.save(meta, meta_path)
metrics[k] = metrics.get(k, {data_set_name: -1}) # result r = MiniResult( arch_index=i, arch_str="%s(%s)" % (space_name, ", ".join([str(v) for v in candidate.values])), arch_tuple=candidate.values, **metrics ) assert tuple_to_str.get(r.arch_tuple) is None, "can not yet merge duplicate architecture results" results[i] = r arch_to_idx[r.arch_str] = i tuple_to_idx[r.arch_tuple] = i tuple_to_str[r.arch_tuple] = r.arch_str data_sets = list(results.get(0).params.keys()) return MiniNASSearchTabularBenchmark( default_data_set=data_sets[0], default_result_type=default_result_type, bench_name="%s on %s" % (space_name, data_sets[0]), bench_description="super-network evaluation results", value_space=space, results=results, arch_to_idx=arch_to_idx, tuple_to_str=tuple_to_str, tuple_to_idx=tuple_to_idx) if __name__ == '__main__': Builder() path_ = replace_standard_paths('{path_tmp}/s2_bench/bench-SearchUninasNetwork_on_Imagenet1000Data.pt') mini_ = MiniNASSearchTabularBenchmark.load(path_) explore(mini_)
def visualize(self): visualize_args_tree(self.interactive.root).view( filename="args_tree", directory=replace_standard_paths("{path_tmp}"), quiet_view=True, cleanup=True)
from uninas.utils.paths import replace_standard_paths from uninas.register import Register def example_export_network(path: str) -> AbstractUninasNetwork: """ create a new network and export it, does not require to have onnx installed """ network = get_network("FairNasC", Shape([3, 224, 224]), Shape([1000]), weights_path=None) network = network.cuda() network.export_onnx(path, export_params=True) return network try: import onnx if __name__ == '__main__': logger = LoggerManager().get_logger() export_path = replace_standard_paths("{path_tmp}/onnx/FairNasC.onnx") net1 = example_export_network(export_path) log_headline(logger, "onnx graph") net2 = onnx.load(export_path) onnx.checker.check_model(net2) logger.info(onnx.helper.printable_graph(net2.graph)) except ImportError as e: Register.missing_import(e)
def visualize_args_tree(node: ArgsTreeNode): g = Digraph(format='pdf', engine='dot', edge_attr=dict(fontsize='20', fontname="times"), node_attr=dict(style='filled', shape='rect', align='center', fontsize='20', height='0.5', penwidth='2', fontname="times")) _visualize_args_tree(node, g) return g if __name__ == '__main__': from uninas.builder import Builder Builder() args_list = arg_list_from_json("/tmp/uninas/s1/task.run_config") root = ArgsTreeNode(Main) root.build_from_args(args_list) print("-" * 200) visualize_args_tree(root).view( filename="args_tree", directory=replace_standard_paths("{path_tmp}"), cleanup=True, quiet_view=True)
def __init__(self, save_dir: str, index: int, **_): super().__init__() self._save_dir = replace_standard_paths(save_dir) assert isinstance(index, int) self._index = index
value_space = ValueSpace( *[DiscreteValues.interval(0, 5) for _ in range(6)]) return MiniNASParsedTabularBenchmark.make_from_dirs( path, space_name, value_space) def sample_architectures(mini: MiniNASParsedTabularBenchmark, n=10): """ sample some random architectures to train """ for i in range(n): print(i, '\t\t', mini.get_value_space().random_sample()) if __name__ == '__main__': Builder() path_ = replace_standard_paths( '{path_data}/generated_bench/bench201_n5c16_1.pt') # mini_ = create_bench201("/mnt/tcml-master01/mnt/beegfs/home/laube/Data/experiments/git/uninas/full/test_s3_bench/Cifar100Data/bench201_n5c16/") # path_ = replace_standard_paths('{path_data}/generated_bench/bench201_n4c64_1.pt') # mini_ = create_bench201("/mnt/tcml-master01/mnt/beegfs/home/laube/Data/experiments/git/uninas/full/test_s3_bench/Cifar100Data/bench201_n4c64/") # path_ = replace_standard_paths('{path_data}/generated_bench/SIN_fairnas_mini_only2.pt') # mini_ = create_fairnas("/mnt/tcml-master01/mnt/beegfs/home/laube/Data/experiments/git/uninas/full/s3sin/SubImagenet100Data/fairnas/2/") # path_ = replace_standard_paths('{path_data}/generated_bench/SIN_fairnas_mini_all.pt') # mini_ = create_fairnas("/mnt/tcml-master01/mnt/beegfs/home/laube/Data/experiments/git/uninas/full/s3sin/SubImagenet100Data/fairnas/") mini_ = MiniNASParsedTabularBenchmark.load(path_) sample_architectures(mini_)