diff --git a/exps/algos-v2/search-cell.py b/exps/algos-v2/search-cell.py
index 5d507d7..1e3465b 100644
--- a/exps/algos-v2/search-cell.py
+++ b/exps/algos-v2/search-cell.py
@@ -20,6 +20,10 @@
# python ./exps/algos-v2/search-cell.py --dataset cifar10 --data_path $TORCH_HOME/cifar.python --algo random --rand_seed 777
# python ./exps/algos-v2/search-cell.py --dataset cifar100 --data_path $TORCH_HOME/cifar.python --algo random
# python ./exps/algos-v2/search-cell.py --dataset ImageNet16-120 --data_path $TORCH_HOME/cifar.python/ImageNet16 --algo random
+####
+# python ./exps/algos-v2/search-cell.py --dataset cifar10 --data_path $TORCH_HOME/cifar.python --algo enas --arch_weight_decay 0 --arch_learning_rate 0.001 --arch_eps 0.001 --rand_seed 777
+# python ./exps/algos-v2/search-cell.py --dataset cifar100 --data_path $TORCH_HOME/cifar.python --algo enas
+# python ./exps/algos-v2/search-cell.py --dataset ImageNet16-120 --data_path $TORCH_HOME/cifar.python/ImageNet16 --algo enas
######################################################################################
import os, sys, time, random, argparse
import numpy as np
@@ -130,6 +134,11 @@ def search_func(xloader, network, criterion, scheduler, w_optimizer, a_optimizer
network.set_cal_mode('joint', None)
elif algo == 'random':
network.set_cal_mode('urs', None)
+ elif algo == 'enas':
+ with torch.no_grad():
+ network.controller.eval()
+ _, _, sampled_arch = network.controller()
+ network.set_cal_mode('dynamic', sampled_arch)
else:
raise ValueError('Invalid algo name : {:}'.format(algo))
@@ -153,16 +162,21 @@ def search_func(xloader, network, criterion, scheduler, w_optimizer, a_optimizer
network.set_cal_mode('joint', None)
elif algo == 'random':
network.set_cal_mode('urs', None)
- else:
+ elif algo != 'enas':
raise ValueError('Invalid algo name : {:}'.format(algo))
network.zero_grad()
if algo == 'darts-v2':
arch_loss, logits = backward_step_unrolled(network, criterion, base_inputs, base_targets, w_optimizer, arch_inputs, arch_targets)
+ a_optimizer.step()
+ elif algo == 'random' or algo == 'enas':
+ with torch.no_grad():
+ _, logits = network(arch_inputs)
+ arch_loss = criterion(logits, arch_targets)
else:
_, logits = network(arch_inputs)
arch_loss = criterion(logits, arch_targets)
arch_loss.backward()
- a_optimizer.step()
+ a_optimizer.step()
# record
arch_prec1, arch_prec5 = obtain_accuracy(logits.data, arch_targets.data, topk=(1, 5))
arch_losses.update(arch_loss.item(), arch_inputs.size(0))
@@ -182,6 +196,76 @@ def search_func(xloader, network, criterion, scheduler, w_optimizer, a_optimizer
return base_losses.avg, base_top1.avg, base_top5.avg, arch_losses.avg, arch_top1.avg, arch_top5.avg
+def train_controller(xloader, network, criterion, optimizer, prev_baseline, epoch_str, print_freq, logger):
+ # config. (containing some necessary arg)
+ # baseline: The baseline score (i.e. average val_acc) from the previous epoch
+ data_time, batch_time = AverageMeter(), AverageMeter()
+ GradnormMeter, LossMeter, ValAccMeter, EntropyMeter, BaselineMeter, RewardMeter, xend = AverageMeter(), AverageMeter(), AverageMeter(), AverageMeter(), AverageMeter(), AverageMeter(), time.time()
+
+ controller_num_aggregate = 20
+ controller_train_steps = 50
+ controller_bl_dec = 0.99
+ controller_entropy_weight = 0.0001
+
+ network.eval()
+ network.controller.train()
+ network.controller.zero_grad()
+ loader_iter = iter(xloader)
+ for step in range(controller_train_steps * controller_num_aggregate):
+ try:
+ inputs, targets = next(loader_iter)
+ except:
+ loader_iter = iter(xloader)
+ inputs, targets = next(loader_iter)
+ inputs = inputs.cuda(non_blocking=True)
+ targets = targets.cuda(non_blocking=True)
+ # measure data loading time
+ data_time.update(time.time() - xend)
+
+ log_prob, entropy, sampled_arch = network.controller()
+ with torch.no_grad():
+ network.set_cal_mode('dynamic', sampled_arch)
+ _, logits = network(inputs)
+ val_top1, val_top5 = obtain_accuracy(logits.data, targets.data, topk=(1, 5))
+ val_top1 = val_top1.view(-1) / 100
+ reward = val_top1 + controller_entropy_weight * entropy
+ if prev_baseline is None:
+ baseline = val_top1
+ else:
+ baseline = prev_baseline - (1 - controller_bl_dec) * (prev_baseline - reward)
+
+ loss = -1 * log_prob * (reward - baseline)
+
+ # account
+ RewardMeter.update(reward.item())
+ BaselineMeter.update(baseline.item())
+ ValAccMeter.update(val_top1.item()*100)
+ LossMeter.update(loss.item())
+ EntropyMeter.update(entropy.item())
+
+ # Average gradient over controller_num_aggregate samples
+ loss = loss / controller_num_aggregate
+ loss.backward(retain_graph=True)
+
+ # measure elapsed time
+ batch_time.update(time.time() - xend)
+ xend = time.time()
+ if (step+1) % controller_num_aggregate == 0:
+ grad_norm = torch.nn.utils.clip_grad_norm_(network.controller.parameters(), 5.0)
+ GradnormMeter.update(grad_norm)
+ optimizer.step()
+ network.controller.zero_grad()
+
+ if step % print_freq == 0:
+ Sstr = '*Train-Controller* ' + time_string() + ' [{:}][{:03d}/{:03d}]'.format(epoch_str, step, controller_train_steps * controller_num_aggregate)
+ Tstr = 'Time {batch_time.val:.2f} ({batch_time.avg:.2f}) Data {data_time.val:.2f} ({data_time.avg:.2f})'.format(batch_time=batch_time, data_time=data_time)
+ Wstr = '[Loss {loss.val:.3f} ({loss.avg:.3f}) Prec@1 {top1.val:.2f} ({top1.avg:.2f}) Reward {reward.val:.2f} ({reward.avg:.2f})] Baseline {basel.val:.2f} ({basel.avg:.2f})'.format(loss=LossMeter, top1=ValAccMeter, reward=RewardMeter, basel=BaselineMeter)
+ Estr = 'Entropy={:.4f} ({:.4f})'.format(EntropyMeter.val, EntropyMeter.avg)
+ logger.log(Sstr + ' ' + Tstr + ' ' + Wstr + ' ' + Estr)
+
+ return LossMeter.avg, ValAccMeter.avg, BaselineMeter.avg, RewardMeter.avg
+
+
def get_best_arch(xloader, network, n_samples, algo):
with torch.no_grad():
network.eval()
@@ -192,6 +276,11 @@ def get_best_arch(xloader, network, n_samples, algo):
elif algo.startswith('darts') or algo == 'gdas':
arch = network.genotype
archs, valid_accs = [arch], []
+ elif algo == 'enas':
+ archs, valid_accs = [], []
+ for _ in range(n_samples):
+ _, _, sampled_arch = network.controller()
+ archs.append(sampled_arch)
else:
raise ValueError('Invalid algorithm name : {:}'.format(algo))
loader_iter = iter(xloader)
@@ -245,7 +334,7 @@ def main(xargs):
train_data, valid_data, xshape, class_num = get_datasets(xargs.dataset, xargs.data_path, -1)
config = load_config(xargs.config_path, {'class_num': class_num, 'xshape': xshape}, logger)
- search_loader, _, valid_loader = get_nas_search_loaders(train_data, valid_data, xargs.dataset, 'configs/nas-benchmark/', \
+ search_loader, train_loader, valid_loader = get_nas_search_loaders(train_data, valid_data, xargs.dataset, 'configs/nas-benchmark/', \
(config.batch_size, config.test_batch_size), xargs.workers)
logger.log('||||||| {:10s} ||||||| Search-Loader-Num={:}, Valid-Loader-Num={:}, batch size={:}'.format(xargs.dataset, len(search_loader), len(valid_loader), config.batch_size))
logger.log('||||||| {:10s} ||||||| Config={:}'.format(xargs.dataset, config))
@@ -263,7 +352,7 @@ def main(xargs):
logger.log('{:}'.format(search_model))
w_optimizer, w_scheduler, criterion = get_optim_scheduler(search_model.weights, config)
- a_optimizer = torch.optim.Adam(search_model.alphas, lr=xargs.arch_learning_rate, betas=(0.5, 0.999), weight_decay=xargs.arch_weight_decay)
+ a_optimizer = torch.optim.Adam(search_model.alphas, lr=xargs.arch_learning_rate, betas=(0.5, 0.999), weight_decay=xargs.arch_weight_decay, eps=xargs.arch_eps)
logger.log('w-optimizer : {:}'.format(w_optimizer))
logger.log('a-optimizer : {:}'.format(a_optimizer))
logger.log('w-scheduler : {:}'.format(w_scheduler))
@@ -288,6 +377,8 @@ def main(xargs):
start_epoch = last_info['epoch']
checkpoint = torch.load(last_info['last_checkpoint'])
genotypes = checkpoint['genotypes']
+ if xargs.algo == 'enas':
+ baseline = checkpoint['baseline']
valid_accuracies = checkpoint['valid_accuracies']
search_model.load_state_dict( checkpoint['search_model'] )
w_scheduler.load_state_dict ( checkpoint['w_scheduler'] )
@@ -297,6 +388,7 @@ def main(xargs):
else:
logger.log("=> do not find the last-info file : {:}".format(last_info))
start_epoch, valid_accuracies, genotypes = 0, {'best': -1}, {-1: network.return_topK(1, True)[0]}
+ baseline = None
# start training
start_time, search_time, epoch_time, total_epoch = time.time(), AverageMeter(), AverageMeter(), config.epochs + config.warmup
@@ -312,9 +404,13 @@ def main(xargs):
search_time.update(time.time() - start_time)
logger.log('[{:}] search [base] : loss={:.2f}, accuracy@1={:.2f}%, accuracy@5={:.2f}%, time-cost={:.1f} s'.format(epoch_str, search_w_loss, search_w_top1, search_w_top5, search_time.sum))
logger.log('[{:}] search [arch] : loss={:.2f}, accuracy@1={:.2f}%, accuracy@5={:.2f}%'.format(epoch_str, search_a_loss, search_a_top1, search_a_top5))
+ if xargs.algo == 'enas':
+ ctl_loss, ctl_acc, baseline, ctl_reward \
+ = train_controller(valid_loader, network, criterion, a_optimizer, baseline, epoch_str, xargs.print_freq, logger)
+ logger.log('[{:}] controller : loss={:}, acc={:}, baseline={:}, reward={:}'.format(epoch_str, ctl_loss, ctl_acc, baseline, ctl_reward))
genotype, temp_accuracy = get_best_arch(valid_loader, network, xargs.eval_candidate_num, xargs.algo)
- if xargs.algo == 'setn':
+ if xargs.algo == 'setn' or xargs.algo == 'enas':
network.set_cal_mode('dynamic', genotype)
elif xargs.algo == 'gdas':
network.set_cal_mode('gdas', None)
@@ -333,6 +429,7 @@ def main(xargs):
# save checkpoint
save_path = save_checkpoint({'epoch' : epoch + 1,
'args' : deepcopy(xargs),
+ 'baseline' : baseline,
'search_model': search_model.state_dict(),
'w_optimizer' : w_optimizer.state_dict(),
'a_optimizer' : a_optimizer.state_dict(),
@@ -377,7 +474,6 @@ def main(xargs):
logger.close()
-
if __name__ == '__main__':
parser = argparse.ArgumentParser("Weight sharing NAS methods to search for cells.")
parser.add_argument('--data_path' , type=str, help='Path to dataset')
@@ -396,7 +492,8 @@ if __name__ == '__main__':
parser.add_argument('--config_path' , type=str, default='./configs/nas-benchmark/algos/weight-sharing.config', help='The path of configuration.')
# architecture leraning rate
parser.add_argument('--arch_learning_rate', type=float, default=3e-4, help='learning rate for arch encoding')
- parser.add_argument('--arch_weight_decay', type=float, default=1e-3, help='weight decay for arch encoding')
+ parser.add_argument('--arch_weight_decay' , type=float, default=1e-3, help='weight decay for arch encoding')
+ parser.add_argument('--arch_eps' , type=float, default=1e-8, help='weight decay for arch encoding')
parser.add_argument('--drop_path_rate' , type=float, help='The drop path rate.')
# log
parser.add_argument('--workers', type=int, default=2, help='number of data loading workers (default: 2)')
diff --git a/lib/models/cell_searchs/generic_model.py b/lib/models/cell_searchs/generic_model.py
index c90d150..42852ac 100644
--- a/lib/models/cell_searchs/generic_model.py
+++ b/lib/models/cell_searchs/generic_model.py
@@ -5,11 +5,75 @@ import torch, random
import torch.nn as nn
from copy import deepcopy
from typing import Text
+from torch.distributions.categorical import Categorical
from ..cell_operations import ResNetBasicblock, drop_path
from .search_cells import NAS201SearchCell as SearchCell
from .genotypes import Structure
-from .search_model_enas_utils import Controller
+
+
+class Controller(nn.Module):
+ # we refer to https://github.com/TDeVries/enas_pytorch/blob/master/models/controller.py
+ def __init__(self, edge2index, op_names, max_nodes, lstm_size=32, lstm_num_layers=2, tanh_constant=2.5, temperature=5.0):
+ super(Controller, self).__init__()
+ # assign the attributes
+ self.max_nodes = max_nodes
+ self.num_edge = len(edge2index)
+ self.edge2index = edge2index
+ self.num_ops = len(op_names)
+ self.op_names = op_names
+ self.lstm_size = lstm_size
+ self.lstm_N = lstm_num_layers
+ self.tanh_constant = tanh_constant
+ self.temperature = temperature
+ # create parameters
+ self.register_parameter('input_vars', nn.Parameter(torch.Tensor(1, 1, lstm_size)))
+ self.w_lstm = nn.LSTM(input_size=self.lstm_size, hidden_size=self.lstm_size, num_layers=self.lstm_N)
+ self.w_embd = nn.Embedding(self.num_ops, self.lstm_size)
+ self.w_pred = nn.Linear(self.lstm_size, self.num_ops)
+
+ nn.init.uniform_(self.input_vars , -0.1, 0.1)
+ nn.init.uniform_(self.w_lstm.weight_hh_l0, -0.1, 0.1)
+ nn.init.uniform_(self.w_lstm.weight_ih_l0, -0.1, 0.1)
+ nn.init.uniform_(self.w_embd.weight , -0.1, 0.1)
+ nn.init.uniform_(self.w_pred.weight , -0.1, 0.1)
+
+ def convert_structure(self, _arch):
+ genotypes = []
+ for i in range(1, self.max_nodes):
+ xlist = []
+ for j in range(i):
+ node_str = '{:}<-{:}'.format(i, j)
+ op_index = _arch[self.edge2index[node_str]]
+ op_name = self.op_names[op_index]
+ xlist.append((op_name, j))
+ genotypes.append( tuple(xlist) )
+ return Structure(genotypes)
+
+ def forward(self):
+
+ inputs, h0 = self.input_vars, None
+ log_probs, entropys, sampled_arch = [], [], []
+ for iedge in range(self.num_edge):
+ outputs, h0 = self.w_lstm(inputs, h0)
+
+ logits = self.w_pred(outputs)
+ logits = logits / self.temperature
+ logits = self.tanh_constant * torch.tanh(logits)
+ # distribution
+ op_distribution = Categorical(logits=logits)
+ op_index = op_distribution.sample()
+ sampled_arch.append( op_index.item() )
+
+ op_log_prob = op_distribution.log_prob(op_index)
+ log_probs.append( op_log_prob.view(-1) )
+ op_entropy = op_distribution.entropy()
+ entropys.append( op_entropy.view(-1) )
+
+ # obtain the input embedding for the next step
+ inputs = self.w_embd(op_index)
+ return torch.sum(torch.cat(log_probs)), torch.sum(torch.cat(entropys)), self.convert_structure(sampled_arch)
+
class GenericNAS201Model(nn.Module):
@@ -55,7 +119,7 @@ class GenericNAS201Model(nn.Module):
assert self._algo is None, 'This functioin can only be called once.'
self._algo = algo
if algo == 'enas':
- self.controller = Controller(len(self.edge2index), len(self._op_names))
+ self.controller = Controller(self.edge2index, self._op_names, self._max_nodes)
else:
self.arch_parameters = nn.Parameter( 1e-3*torch.randn(self._num_edge, len(self._op_names)) )
if algo == 'gdas':
@@ -116,10 +180,9 @@ class GenericNAS201Model(nn.Module):
def show_alphas(self):
with torch.no_grad():
if self._algo == 'enas':
- import pdb; pdb.set_trace()
- print('-')
+ return 'w_pred :\n{:}'.format(self.controller.w_pred.weight)
else:
- return 'arch-parameters :\n{:}'.format( nn.functional.softmax(self.arch_parameters, dim=-1).cpu() )
+ return 'arch-parameters :\n{:}'.format(nn.functional.softmax(self.arch_parameters, dim=-1).cpu())
def extra_repr(self):