code stringlengths 17 6.64M |
|---|
def show_running(func):
@wraps(func)
def g(*args, **kargs):
x = WaitPrint(2, '{}({})... '.format(func.__name__, ', '.join(([repr(x) for x in args] + ['{}={}'.format(key, repr(value)) for (key, value) in kargs.items()]))))
x.start()
t = time.perf_counter()
r = func(*args, **kar... |
def cached_dirpklgz(dirname):
'\n Cache a function with a directory\n '
def decorator(func):
'\n The actual decorator\n '
@lru_cache(maxsize=None)
@wraps(func)
def wrapper(*args):
'\n The wrapper of the function\n '
... |
def test_so3_rfft(b_in, b_out, device):
x = torch.randn((2 * b_in), (2 * b_in), (2 * b_in), dtype=torch.float, device=device)
from s2cnn.soft.so3_fft import so3_rfft
y1 = so3_rfft(x, b_out=b_out)
from s2cnn import so3_rft, so3_soft_grid
import lie_learn.spaces.S3 as S3
weights = torch.tensor(S... |
def test_inverse(f, g, b_in, b_out, device, complex):
if complex:
x = torch.randn((2 * b_in), (2 * b_in), (2 * b_in), 2, dtype=torch.float, device=device)
else:
x = torch.randn((2 * b_in), (2 * b_in), (2 * b_in), dtype=torch.float, device=device)
x = g(f(x, b_out=b_out), b_out=b_in)
y ... |
def test_inverse2(f, g, b_in, b_out, device):
x = torch.randn(((b_in * ((4 * (b_in ** 2)) - 1)) // 3), 2, dtype=torch.float, device=device)
x = g(f(x, b_out=b_out), b_out=b_in)
y = g(f(x, b_out=b_out), b_out=b_in)
assert ((x - y).abs().max().item() < (0.0001 * y.abs().mean().item()))
|
def compare_cpu_gpu(f, x):
z1 = f(x.cpu())
z2 = f(x.cuda()).cpu()
q = ((z1 - z2).abs().max().item() / z1.std().item())
assert (q < 0.0001)
|
def get_test_results(logfile):
perf = {}
with open(logfile, 'r') as f:
prevline = ''
for line in f.readlines():
if ('DATALOADER:0 TEST RESULTS' in prevline):
perf = eval(line)
prevline = line
return perf
|
class CLI(LightningCLI):
def __init__(self, model_class, run=True, **kwargs):
trainer_defaults = {'default_config_files': [os.path.join('perceiver', 'trainer.yaml')]}
super().__init__(model_class, run=run, save_config_overwrite=True, parser_kwargs={'fit': trainer_defaults, 'test': trainer_default... |
class DDPStaticGraphPlugin(DDPPlugin):
def _setup_model(self, model):
wrapped = super()._setup_model(model)
wrapped._set_static_graph()
return wrapped
|
def load_split(root, split):
if (split not in ['train', 'test']):
raise ValueError(f'invalid split: {split}')
raw_x = []
raw_y = []
for (i, label) in enumerate(['neg', 'pos']):
path_pattern = os.path.join(root, f'IMDB/aclImdb/{split}/{label}', '*.txt')
for name in glob.glob(pat... |
class IMDBDataset(Dataset):
def __init__(self, root, split):
(self.raw_x, self.raw_y) = load_split(root, split)
def __len__(self):
return len(self.raw_x)
def __getitem__(self, index):
return (self.raw_y[index], self.raw_x[index])
|
@DATAMODULE_REGISTRY
class IMDBDataModule(pl.LightningDataModule):
def __init__(self, data_dir: str='.cache', vocab_size: int=10003, max_seq_len: int=512, batch_size: int=64, num_workers: int=3, pin_memory: bool=False):
super().__init__()
self.save_hyperparameters()
self.tokenizer_path = ... |
@DATAMODULE_REGISTRY
class MNISTDataModule(mnist_datamodule.MNISTDataModule):
def __init__(self, channels_last: bool=True, random_crop: Optional[int]=None, data_dir: Optional[str]='.cache', val_split: Union[(int, float)]=10000, num_workers: int=3, normalize: bool=True, pin_memory: bool=False, *args, **kwargs):
... |
class MNISTPreprocessor():
def __init__(self, transform=None):
if (transform is None):
self.transform = mnist_transform()
else:
self.transform = transform
def preprocess(self, img):
return self.transform(img)
def preprocess_batch(self, img_batch):
... |
def mnist_transform(normalize: bool=True, channels_last: bool=True, random_crop: Optional[int]=None):
transform_list = []
if random_crop:
transform_list.append(transforms.RandomCrop(random_crop))
transform_list.append(transforms.ToTensor())
if normalize:
transform_list.append(transform... |
def channels_to_last(img: torch.Tensor):
return img.permute(1, 2, 0).contiguous()
|
@DATAMODULE_REGISTRY
class CIFAR100DataModule(pl.LightningDataModule):
def __init__(self, channels_last: bool=True, random_crop: Optional[int]=None, data_dir: Optional[str]='.cache', val_split: Union[(int, float)]=10000, num_workers: int=3, batch_size: int=64, normalize: bool=True, pin_memory: bool=False, *args,... |
def cifar100_transform(normalize: bool=True, channels_last: bool=True, random_crop: Optional[int]=None):
transform_list = []
if random_crop:
transform_list.append(transforms.RandomCrop(random_crop))
transform_list.append(transforms.ToTensor())
if normalize:
mean = [0.4914, 0.4822, 0.44... |
def channels_to_last(img: torch.Tensor):
return img.permute(1, 2, 0).contiguous()
|
@DATAMODULE_REGISTRY
class CosmicDataModule(pl.LightningDataModule):
def __init__(self, channels_last: bool=True, data_dir: Optional[str]='.cache', num_workers: int=3, batch_size: int=4, pin_memory: bool=False, root='../datasets', *args, **kwargs):
super().__init__()
self.save_hyperparameters()
... |
class ToChannelsLast():
def __call__(self, x):
if (x.ndim == 3):
x = x.unsqueeze(0)
elif (x.ndim != 4):
raise RuntimeError
return x.to(memory_format=torch.channels_last)
def __repr__(self):
return (self.__class__.__name__ + '()')
|
def cosmic_transform():
transform_list = []
transform_list.append(transforms.ToTensor())
transform_list.append(ToChannelsLast())
return transforms.Compose(transform_list)
|
def load_cosmic_data(path):
print(path)
train_dirs = np.load(os.path.join(path, 'train_dirs.npy'), allow_pickle=True)
test_dirs = np.load(os.path.join(path, 'test_dirs.npy'), allow_pickle=True)
if (path == 'datasets/cosmic'):
train_dirs = [td[3:] for td in train_dirs]
test_dirs = [td[3... |
@DATAMODULE_REGISTRY
class FSD50KDataModule(pl.LightningDataModule):
def __init__(self, channels_last: bool=True, random_crop: Optional[int]=None, data_dir: Optional[str]='.cache', num_workers: int=3, batch_size: int=64, normalize: bool=True, pin_memory: bool=False, root='../datasets', *args, **kwargs):
... |
def audio_transform(channels_last: bool=True):
transform_list = []
def channels_to_last(img: torch.Tensor):
return img.permute(1, 2, 0).contiguous()
transform_list.append(transforms.ToTensor())
if channels_last:
transform_list.append(channels_to_last)
return transforms.Compose(tra... |
@DATAMODULE_REGISTRY
class PSICOVDataModule(pl.LightningDataModule):
def __init__(self, channels_last: bool=True, data_dir: Optional[str]='.cache', num_workers: int=3, batch_size: int=4, pin_memory: bool=False, root='../datasets', *args, **kwargs):
super().__init__()
self.save_hyperparameters()
... |
def psicov_transform():
transform_list = []
transform_list.append(transforms.ToTensor())
return transforms.Compose(transform_list)
|
def load_psicov_data(path, batch_size):
all_feat_paths = [f'{path}/deepcov/features/', f'{path}/psicov/features/', f'{path}/cameo/features/']
all_dist_paths = [f'{path}/deepcov/distance/', f'{path}/psicov/distance/', f'{path}/cameo/distance/']
deepcov_list = load_list(f'{path}/deepcov.lst', (- 1))
len... |
class TextPreprocessor():
def __init__(self, tokenizer_path: str, max_seq_len: int=512):
self.tokenizer = load_tokenizer(tokenizer_path)
self.collator = TextCollator(self.tokenizer, max_seq_len)
def preprocess(self, text):
return self.preprocess_batch([text])[0][0]
def preproces... |
class TextCollator():
def __init__(self, tokenizer: Tokenizer, max_seq_len: int):
self.pad_id = tokenizer.token_to_id(PAD_TOKEN)
self.tokenizer = tokenizer
self.tokenizer.enable_padding(pad_id=self.pad_id, pad_token=PAD_TOKEN)
self.tokenizer.enable_truncation(max_length=max_seq_le... |
def load_tokenizer(path):
return Tokenizer.from_file(path)
|
def save_tokenizer(tokenizer: Tokenizer, path):
tokenizer.save(path)
|
def train_tokenizer(tokenizer: Tokenizer, data: Iterable[str], vocab_size):
trainer = WordPieceTrainer(vocab_size=vocab_size, special_tokens=[PAD_TOKEN, UNK_TOKEN, MASK_TOKEN])
tokenizer.train_from_iterator(data, trainer)
|
def create_tokenizer(*normalizer: Normalizer):
tokenizer = Tokenizer(WordPiece(unk_token=UNK_TOKEN))
tokenizer.normalizer = Sequence((list(normalizer) + [NFD(), Lowercase(), StripAccents()]))
tokenizer.pre_tokenizer = Whitespace()
tokenizer.decoder = decoders.WordPiece()
return tokenizer
|
class ImageClassifierCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.num_classes', 'model.num_classes', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'model.image_... |
class MaskedLanguageModelCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.add_lr_scheduler_args(torch.optim.lr_scheduler.OneCycleLR, link_to='model.scheduler_init')
parser.link_arguments('trainer.max_steps... |
class ImageClassifierCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.num_classes', 'model.num_classes', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'model.image_... |
class DensePredictorCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.dense_pred_shape', 'model.dense_pred_shape', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'mod... |
class DensePredictorCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.dense_pred_shape', 'model.dense_pred_shape', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'mod... |
class ImageClassifierCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.num_classes', 'model.num_classes', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'model.image_... |
class ImageClassifierCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.num_classes', 'model.num_classes', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'model.image_... |
class ImageClassifierCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.num_classes', 'model.num_classes', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'model.image_... |
class ImageClassifierCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.num_classes', 'model.num_classes', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'model.image_... |
class DensePredictorCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.dense_pred_shape', 'model.dense_pred_shape', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'mod... |
class ImageClassifierCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.num_classes', 'model.num_classes', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'model.image_... |
class ImageClassifierCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.num_classes', 'model.num_classes', apply_on='instantiate')
parser.link_arguments('data.image_shape', 'model.image_... |
class TextClassifierCLI(CLI):
def add_arguments_to_parser(self, parser: LightningArgumentParser) -> None:
super().add_arguments_to_parser(parser)
parser.link_arguments('data.vocab_size', 'model.vocab_size', apply_on='instantiate')
parser.link_arguments('data.max_seq_len', 'model.max_seq_l... |
@task
def install(c):
c.run('conda env update --prune -f environment.yml', pty=_use_pty())
|
@task
def precommit_install(c):
c.run('pre-commit install', pty=_use_pty())
|
@task
def clean_cache(c):
c.run("find . -name '*.pyc' -exec rm -f {} +")
c.run("find . -name '*.pyo' -exec rm -f {} +")
c.run("find . -name '*~' -exec rm -f {} +")
c.run("find . -name '__pycache__' -exec rm -fr {} +")
c.run('rm -fr .mypy_cache')
|
@task
def clean_test(c):
c.run('rm -fr .tox/')
c.run('rm -f .coverage')
c.run('rm -fr htmlcov/')
c.run('rm -fr .pytest_cache')
|
@task
def clean_build(c):
c.run('rm -fr dist')
|
@task
def clean(c):
clean_cache(c)
clean_test(c)
clean_build(c)
|
@task
def build(c):
clean(c)
c.run('poetry build', pty=_use_pty())
|
@task(aliases=['cc'])
def code_check(c):
c.run('pre-commit run --all-files', pty=_use_pty())
|
@task
def test(c, cov=False, cov_report=None):
_run_pytest(c, 'tests --durations=25 --color=yes', cov, cov_report, _use_pty())
|
def _use_pty():
return (platform != 'win32')
|
def _run_pytest(c, test_dir, cov=False, cov_report=None, pty=True):
c.run(f'pytest {test_dir} {_pytest_cov_options(cov, cov_report)}', pty=pty)
|
def _pytest_cov_options(use_cov: bool, cov_reports: Optional[str]):
if (not use_cov):
return ''
cov_report_types = (cov_reports.split(',') if cov_reports else [])
cov_report_types = (['term'] + cov_report_types)
cov_report_params = [f'--cov-report {r}' for r in cov_report_types]
return f"-... |
def test_lit_image_classifier():
LitImageClassifier((64, 64, 3), 2, 16, 16, EncoderConfig(), DecoderConfig(), optimizer_init={})
|
def evaluate_all_datasets(arch: Text, datasets: List[Text], xpaths: List[Text], splits: List[Text], config_path: Text, seed: int, raw_arch_config, workers, logger):
(machine_info, raw_arch_config) = (get_machine_info(), deepcopy(raw_arch_config))
all_infos = {'info': machine_info}
all_dataset_keys = []
... |
def main(save_dir: Path, workers: int, datasets: List[Text], xpaths: List[Text], splits: List[int], seeds: List[int], nets: List[str], opt_config: Dict[(Text, Any)], to_evaluate_indexes: tuple, cover_mode: bool, arch_config: Dict[(Text, Any)]):
log_dir = (save_dir / 'logs')
log_dir.mkdir(parents=True, exist_o... |
def train_single_model(save_dir, workers, datasets, xpaths, splits, use_less, seeds, model_str, arch_config):
assert torch.cuda.is_available(), 'CUDA is not available.'
torch.backends.cudnn.enabled = True
torch.backends.cudnn.deterministic = True
save_dir = ((Path(save_dir) / 'specifics') / '{:}-{:}-{... |
def generate_meta_info(save_dir, max_node, divide=40):
aa_nas_bench_ss = get_search_spaces('cell', 'nas-bench-201')
archs = CellStructure.gen_all(aa_nas_bench_ss, max_node, False)
print('There are {:} archs vs {:}.'.format(len(archs), (len(aa_nas_bench_ss) ** (((max_node - 1) * max_node) / 2))))
rando... |
def traverse_net(max_node):
aa_nas_bench_ss = get_search_spaces('cell', 'nats-bench')
archs = CellStructure.gen_all(aa_nas_bench_ss, max_node, False)
print('There are {:} archs vs {:}.'.format(len(archs), (len(aa_nas_bench_ss) ** (((max_node - 1) * max_node) / 2))))
random.seed(88)
random.shuffle(... |
def filter_indexes(xlist, mode, save_dir, seeds):
all_indexes = []
for index in xlist:
if (mode == 'cover'):
all_indexes.append(index)
else:
for seed in seeds:
temp_path = (save_dir / 'arch-{:06d}-seed-{:04d}.pth'.format(index, seed))
if ... |
def create_result_count(used_seed: int, dataset: Text, arch_config: Dict[(Text, Any)], results: Dict[(Text, Any)], dataloader_dict: Dict[(Text, Any)]) -> ResultsCount:
xresult = ResultsCount(dataset, results['net_state_dict'], results['train_acc1es'], results['train_losses'], results['param'], results['flop'], ar... |
def account_one_arch(arch_index, arch_str, checkpoints, datasets, dataloader_dict):
information = ArchResults(arch_index, arch_str)
for checkpoint_path in checkpoints:
checkpoint = torch.load(checkpoint_path, map_location='cpu')
used_seed = checkpoint_path.name.split('-')[(- 1)].split('.')[0]
... |
def correct_time_related_info(arch_index: int, arch_infos: Dict[(Text, ArchResults)]):
'\n cifar010_latency = (\n api.get_latency(arch_index, "cifar10-valid", hp="200")\n + api.get_latency(arch_index, "cifar10", hp="200")\n ) / 2\n cifar100_latency = api.get_latency(arch_index, "cifar100", ... |
def simplify(save_dir, save_name, nets, total, sup_config):
dataloader_dict = {}
(hps, seeds) = (['12'], set())
for hp in hps:
sub_save_dir = (save_dir / 'raw-data-{:}'.format(hp))
ckps = sorted(list(sub_save_dir.glob('arch-*-seed-*.pth')))
seed2names = defaultdict(list)
fo... |
def traverse_net(max_node):
aa_nas_bench_ss = get_search_spaces('cell', 'nats-bench')
archs = CellStructure.gen_all(aa_nas_bench_ss, max_node, False)
print('There are {:} archs vs {:}.'.format(len(archs), (len(aa_nas_bench_ss) ** (((max_node - 1) * max_node) / 2))))
random.seed(88)
random.shuffle(... |
def get_topology_config_space(search_space, max_nodes=4):
cs = ConfigSpace.ConfigurationSpace()
for i in range(1, max_nodes):
for j in range(i):
node_str = '{:}<-{:}'.format(i, j)
cs.add_hyperparameter(ConfigSpace.CategoricalHyperparameter(node_str, search_space))
return cs... |
def get_size_config_space(search_space):
cs = ConfigSpace.ConfigurationSpace()
for ilayer in range(search_space['numbers']):
node_str = 'layer-{:}'.format(ilayer)
cs.add_hyperparameter(ConfigSpace.CategoricalHyperparameter(node_str, search_space['candidates']))
return cs
|
def config2topology_func(max_nodes=4):
def config2structure(config):
genotypes = []
for i in range(1, max_nodes):
xlist = []
for j in range(i):
node_str = '{:}<-{:}'.format(i, j)
op_name = config[node_str]
xlist.append((op_na... |
def config2size_func(search_space):
def config2structure(config):
channels = []
for ilayer in range(search_space['numbers']):
node_str = 'layer-{:}'.format(ilayer)
channels.append(str(config[node_str]))
return ':'.join(channels)
return config2structure
|
class MyWorker(Worker):
def __init__(self, *args, convert_func=None, dataset=None, api=None, **kwargs):
super().__init__(*args, **kwargs)
self.convert_func = convert_func
self._dataset = dataset
self._api = api
self.total_times = []
self.trajectory = []
def co... |
def main(xargs, api, api_full):
torch.set_num_threads(4)
prepare_seed(xargs.rand_seed)
logger = prepare_logger(args)
logger.log('{:} use api : {:}'.format(time_string(), api))
api.reset_time()
search_space = get_search_spaces(xargs.search_space, 'nats-bench')
if (xargs.search_space == 'tss... |
def get_topology_config_space(search_space, max_nodes=4):
cs = ConfigSpace.ConfigurationSpace()
for i in range(1, max_nodes):
for j in range(i):
node_str = '{:}<-{:}'.format(i, j)
cs.add_hyperparameter(ConfigSpace.CategoricalHyperparameter(node_str, search_space))
return cs... |
def get_size_config_space(search_space):
cs = ConfigSpace.ConfigurationSpace()
for ilayer in range(search_space['numbers']):
node_str = 'layer-{:}'.format(ilayer)
cs.add_hyperparameter(ConfigSpace.CategoricalHyperparameter(node_str, search_space['candidates']))
return cs
|
def config2topology_func(max_nodes=4):
def config2structure(config):
genotypes = []
for i in range(1, max_nodes):
xlist = []
for j in range(i):
node_str = '{:}<-{:}'.format(i, j)
op_name = config[node_str]
xlist.append((op_na... |
def config2size_func(search_space):
def config2structure(config):
channels = []
for ilayer in range(search_space['numbers']):
node_str = 'layer-{:}'.format(ilayer)
channels.append(str(config[node_str]))
return ':'.join(channels)
return config2structure
|
class MyWorker(Worker):
def __init__(self, *args, convert_func=None, dataset=None, api=None, **kwargs):
super().__init__(*args, **kwargs)
self.convert_func = convert_func
self._dataset = dataset
self._api = api
self.total_times = []
self.trajectory = []
def co... |
def main(xargs, api, api_full):
torch.set_num_threads(4)
prepare_seed(xargs.rand_seed)
logger = prepare_logger(args)
logger.log('{:} use api : {:}'.format(time_string(), api))
api.reset_time()
search_space = get_search_spaces(xargs.search_space, 'nats-bench')
if (xargs.search_space == 'tss... |
def random_topology_func(op_names, max_nodes=4):
def random_architecture():
genotypes = []
for i in range(1, max_nodes):
xlist = []
for j in range(i):
node_str = '{:}<-{:}'.format(i, j)
op_name = random.choice(op_names)
xlist... |
def random_size_func(info):
def random_architecture():
channels = []
for i in range(info['numbers']):
channels.append(str(random.choice(info['candidates'])))
return ':'.join(channels)
return random_architecture
|
def main(xargs, api, apu_full):
torch.set_num_threads(4)
prepare_seed(xargs.rand_seed)
logger = prepare_logger(args)
logger.log('{:} use api : {:}'.format(time_string(), api))
api.reset_time()
search_space = get_search_spaces(xargs.search_space, 'nats-bench')
if (xargs.search_space == 'tss... |
class Model(object):
def __init__(self):
self.arch = None
self.accuracy = None
def __str__(self):
'Prints a readable version of this bitstring.'
return '{:}'.format(self.arch)
|
def random_topology_func(op_names, max_nodes=4):
def random_architecture():
genotypes = []
for i in range(1, max_nodes):
xlist = []
for j in range(i):
node_str = '{:}<-{:}'.format(i, j)
op_name = random.choice(op_names)
xlist... |
def random_size_func(info):
def random_architecture():
channels = []
for i in range(info['numbers']):
channels.append(str(random.choice(info['candidates'])))
return ':'.join(channels)
return random_architecture
|
def mutate_topology_func(op_names):
'Computes the architecture for a child of the given parent architecture.\n The parent architecture is cloned and mutated to produce the child architecture. The child architecture is mutated by randomly switch one operation to another.\n '
def mutate_topology_func(par... |
def mutate_size_func(info):
'Computes the architecture for a child of the given parent architecture.\n The parent architecture is cloned and mutated to produce the child architecture. The child architecture is mutated by randomly switch one operation to another.\n '
def mutate_size_func(parent_arch):
... |
def regularized_evolution(cycles, population_size, sample_size, time_budget, random_arch, mutate_arch, api, use_proxy, dataset):
'Algorithm for regularized evolution (i.e. aging evolution).\n\n Follows "Algorithm 1" in Real et al. "Regularized Evolution for Image\n Classifier Architecture Search".\n\n Ar... |
def main(xargs, api, api_full):
torch.set_num_threads(4)
prepare_seed(xargs.rand_seed)
logger = prepare_logger(args)
search_space = get_search_spaces(xargs.search_space, 'nats-bench')
if (xargs.search_space == 'tss'):
random_arch = random_topology_func(search_space)
mutate_arch = m... |
class PolicyTopology(nn.Module):
def __init__(self, search_space, max_nodes=4):
super(PolicyTopology, self).__init__()
self.max_nodes = max_nodes
self.search_space = deepcopy(search_space)
self.edge2index = {}
for i in range(1, max_nodes):
for j in range(i):
... |
class PolicySize(nn.Module):
def __init__(self, search_space):
super(PolicySize, self).__init__()
self.candidates = search_space['candidates']
self.numbers = search_space['numbers']
self.arch_parameters = nn.Parameter((0.001 * torch.randn(self.numbers, len(self.candidates))))
... |
class ExponentialMovingAverage(object):
'Class that maintains an exponential moving average.'
def __init__(self, momentum):
self._numerator = 0
self._denominator = 0
self._momentum = momentum
def update(self, value):
self._numerator = ((self._momentum * self._numerator) +... |
def select_action(policy):
probs = policy()
m = Categorical(probs)
action = m.sample()
return (m.log_prob(action), action.cpu().tolist())
|
def main(xargs, api, api_full):
prepare_seed(xargs.rand_seed)
logger = prepare_logger(args)
search_space = get_search_spaces(xargs.search_space, 'nats-bench')
if (xargs.search_space == 'tss'):
policy = PolicyTopology(search_space)
else:
policy = PolicySize(search_space)
optimiz... |
class LpLoss(object):
def __init__(self, d=2, p=2, size_average=True, reduction=True):
super(LpLoss, self).__init__()
assert ((d > 0) and (p > 0))
self.d = d
self.p = p
self.reduction = reduction
self.size_average = size_average
def abs(self, x, y):
nu... |
def _concat(xs):
return torch.cat([x.view((- 1)) for x in xs])
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.