code stringlengths 17 6.64M |
|---|
class NameMatcher(object):
def __init__(self, rules=None):
if (rules is None):
self._rules = []
elif isinstance(rules, dict):
self._rules = list(rules.items())
else:
assert isinstance(rules, collections.Iterable)
self._rules = list(rules)
... |
class IENameMatcher(object):
def __init__(self, include=None, exclude=None):
if (include is None):
self.include = None
else:
self.include = NameMatcher([(i, True) for i in include])
if (exclude is None):
self.exclude = None
else:
sel... |
def map_exec(func, *iterables):
return list(map(func, *iterables))
|
class AverageMeter(object):
'Computes and stores the average and current value'
val = 0
avg = 0
sum = 0
count = 0
tot_count = 0
def __init__(self):
self.reset()
self.tot_count = 0
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
... |
class GroupMeters(object):
def __init__(self):
self._meters = collections.defaultdict(AverageMeter)
def reset(self):
map_exec(AverageMeter.reset, self._meters.values())
def update(self, updates=None, value=None, n=1, **kwargs):
'\n Example:\n >>> meters.update(... |
class JsonObjectEncoder(json.JSONEncoder):
'Adapted from https://stackoverflow.com/a/35483750'
def default(self, obj):
if hasattr(obj, '__jsonify__'):
json_object = obj.__jsonify__()
if isinstance(json_object, six.string_types):
return json_object
r... |
class ModelIOKeysMixin(object):
def _get_input(self, feed_dict):
return feed_dict['input']
def _get_label(self, feed_dict):
return feed_dict['label']
def _get_covariate(self, feed_dict):
'For cox'
return feed_dict['X']
def _get_fail_indicator(self, feed_dict):
... |
class MLPModel(MLPLayer):
def freeze_weights(self):
for (name, p) in self.named_parameters():
if (name != 'mu'):
p.requires_grad = False
def get_gates(self, mode):
if (mode == 'raw'):
return self.mu.detach().cpu().numpy()
elif (mode == 'prob'):... |
class L1RegressionModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, output_dim, hidden_dims, device, batch_norm=None, dropout=None, activation='relu', sigma=1.0, lam=0.1):
super().__init__(input_dim, output_dim, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activation)
... |
class L1GateRegressionModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, output_dim, hidden_dims, device, batch_norm=None, dropout=None, activation='relu', sigma=1.0, lam=0.1):
super().__init__(input_dim, output_dim, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activation... |
class SoftThreshRegressionModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, output_dim, hidden_dims, device, batch_norm=None, dropout=None, activation='relu', sigma=1.0, lam=0.1):
super().__init__(input_dim, output_dim, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activa... |
class STGRegressionModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, output_dim, hidden_dims, device, batch_norm=None, dropout=None, activation='relu', sigma=1.0, lam=0.1):
super().__init__(input_dim, output_dim, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activation)
... |
class STGClassificationModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, nr_classes, hidden_dims, device, batch_norm=None, dropout=None, activation='relu', sigma=1.0, lam=0.1):
super().__init__(input_dim, nr_classes, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activatio... |
class STGCoxModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, nr_classes, hidden_dims, device, lam, batch_norm=None, dropout=None, activation='relu', sigma=1.0):
super().__init__(input_dim, nr_classes, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activation)
self... |
class MLPCoxModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, nr_classes, hidden_dims, batch_norm=None, dropout=None, activation='relu'):
super().__init__(input_dim, nr_classes, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activation)
self.loss = PartialLogLikeli... |
class MLPRegressionModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, output_dim, hidden_dims, batch_norm=None, dropout=None, activation='relu'):
super().__init__(input_dim, output_dim, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activation)
self.loss = nn.MSELos... |
class MLPClassificationModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, nr_classes, hidden_dims, batch_norm=None, dropout=None, activation='relu'):
super().__init__(input_dim, nr_classes, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activation)
self.softmax = nn... |
class LinearRegressionModel(MLPRegressionModel):
def __init__(self, input_dim, output_dim):
super().__init__(input_dim, output_dim, [])
|
class LinearClassificationModel(MLPClassificationModel):
def __init__(self, input_dim, nr_classes):
super().__init__(input_dim, nr_classes, [])
|
def _standard_truncnorm_sample(lower_bound, upper_bound, sample_shape=torch.Size()):
'\n Implements accept-reject algorithm for doubly truncated standard normal distribution.\n (Section 2.2. Two-sided truncated normal distribution in [1])\n [1] Robert, Christian P. "Simulation of truncated normal variabl... |
class STG(object):
def __init__(self, device, input_dim=784, output_dim=10, hidden_dims=[400, 200], activation='relu', sigma=0.5, lam=0.1, optimizer='Adam', learning_rate=1e-05, batch_size=100, freeze_onward=None, feature_selection=True, weight_decay=0.001, task_type='classification', report_maps=False, random_s... |
class SimpleDataset(Dataset):
'\n Assuming X and y are numpy arrays and \n with X.shape = (n_samples, n_features) \n y.shape = (n_samples,)\n '
def __init__(self, X, y=None):
self.X = X
self.y = y
def __len__(self):
return len(self.X)
def __getitem__(self,... |
class FastTensorDataLoader():
'\n A DataLoader-like object for a set of tensors that can be much faster than\n TensorDataset + DataLoader because dataloader grabs individual indices of\n the dataset and calls cat (slow).\n Source: https://discuss.pytorch.org/t/dataloader-much-slower-than-manual-batchi... |
def standardize_dataset(dataset, offset, scale):
norm_ds = copy.deepcopy(dataset)
norm_ds['x'] = ((norm_ds['x'] - offset) / scale)
return norm_ds
|
def load_datasets(dataset_file):
datasets = defaultdict(dict)
with h5py.File(dataset_file, 'r') as fp:
for ds in fp:
for array in fp[ds]:
datasets[ds][array] = fp[ds][array][:]
return datasets
|
def load_cox_gaussian_data():
dataset_file = os.path.join(os.path.dirname(__file__), 'datasets/gaussian_survival_data.h5')
datasets = defaultdict(dict)
with h5py.File(dataset_file, 'r') as fp:
for ds in fp:
for array in fp[ds]:
datasets[ds][array] = fp[ds][array][:]
... |
def prepare_data(x, label):
if isinstance(label, dict):
(e, t) = (label['e'], label['t'])
sort_idx = np.argsort(t)[::(- 1)]
x = x[sort_idx]
e = e[sort_idx]
t = t[sort_idx]
return (x, e, t)
|
def probe_infnan(v, name, extras={}):
nps = torch.isnan(v)
s = nps.sum().item()
if (s > 0):
print('>>> {} >>>'.format(name))
print(name, s)
print(v[nps])
for (k, val) in extras.items():
print(k, val, val.sum().item())
quit()
|
class Identity(nn.Module):
def forward(self, *args):
if (len(args) == 1):
return args[0]
return args
|
def get_batcnnorm(bn, nr_features=None, nr_dims=1):
if isinstance(bn, nn.Module):
return bn
assert (1 <= nr_dims <= 3)
if (bn in (True, 'async')):
clz_name = 'BatchNorm{}d'.format(nr_dims)
return getattr(nn, clz_name)(nr_features)
else:
raise ValueError('Unknown type of... |
def get_dropout(dropout, nr_dims=1):
if isinstance(dropout, nn.Module):
return dropout
if (dropout is True):
dropout = 0.5
if (nr_dims == 1):
return nn.Dropout(dropout, True)
else:
clz_name = 'Dropout{}d'.format(nr_dims)
return getattr(nn, clz_name)(dropout)
|
def get_activation(act):
if isinstance(act, nn.Module):
return act
assert (type(act) is str), 'Unknown type of activation: {}.'.format(act)
act_lower = act.lower()
if (act_lower == 'identity'):
return Identity()
elif (act_lower == 'relu'):
return nn.ReLU(True)
elif (act... |
def get_optimizer(optimizer, model, *args, **kwargs):
if isinstance(optimizer, optim.Optimizer):
return optimizer
if (type(optimizer) is str):
try:
optimizer = getattr(optim, optimizer)
except AttributeError:
raise ValueError('Unknown optimizer type: {}.'.format... |
def stmap(func, iterable):
if isinstance(iterable, six.string_types):
return func(iterable)
elif isinstance(iterable, (collections.Sequence, collections.UserList)):
return [stmap(func, v) for v in iterable]
elif isinstance(iterable, collections.Set):
return {stmap(func, v) for v in... |
def _as_tensor(o):
from torch.autograd import Variable
if isinstance(o, SKIP_TYPES):
return o
if isinstance(o, Variable):
return o
if torch.is_tensor(o):
return o
return torch.from_numpy(np.array(o))
|
def as_tensor(obj):
return stmap(_as_tensor, obj)
|
def _as_numpy(o):
from torch.autograd import Variable
if isinstance(o, SKIP_TYPES):
return o
if isinstance(o, Variable):
o = o
if torch.is_tensor(o):
return o.cpu().numpy()
return np.array(o)
|
def as_numpy(obj):
return stmap(_as_numpy, obj)
|
def _as_float(o):
if isinstance(o, SKIP_TYPES):
return o
if torch.is_tensor(o):
return o.item()
arr = as_numpy(o)
assert (arr.size == 1)
return float(arr)
|
def as_float(obj):
return stmap(_as_float, obj)
|
def _as_cpu(o):
from torch.autograd import Variable
if (isinstance(o, Variable) or torch.is_tensor(o)):
return o.cpu()
return o
|
def as_cpu(obj):
return stmap(_as_cpu, obj)
|
def create_twomoon_dataset(n, p):
(relevant, y) = make_moons(n_samples=n, shuffle=True, noise=0.1, random_state=None)
print(y.shape)
noise_vector = norm.rvs(loc=0, scale=1, size=[n, (p - 2)])
data = np.concatenate([relevant, noise_vector], axis=1)
print(data.shape)
return (data, y)
|
def create_sin_dataset(n, p):
x1 = (5 * np.random.uniform(0, 1, n).reshape((- 1), 1))
x2 = (5 * np.random.uniform(0, 1, n).reshape((- 1), 1))
y = (np.sin(x1) * (np.cos(x2) ** 3))
relevant = np.hstack((x1, x2))
noise_vector = norm.rvs(loc=0, scale=1, size=[n, (p - 2)])
data = np.concatenate([re... |
def create_simple_sin_dataset(n, p):
'This dataset was added to provide an example of L1 norm reg failure for presentation.\n '
assert (p == 2)
x1 = np.random.uniform((- math.pi), math.pi, n).reshape(n, 1)
x2 = np.random.uniform((- math.pi), math.pi, n).reshape(n, 1)
y = np.sin(x1)
data = n... |
def getRelDict(graph):
rel = dict()
counter = 0
for triple in graph:
(s, p, o) = triple
if ((str(p) not in rel) and isinstance(o, rdflib.URIRef)):
rel[str(p)] = counter
counter += 1
return rel
|
def get_attr_set(graph):
attr_set = set()
for triple in graph:
(s, p, o) = triple
if isinstance(o, rdflib.Literal):
attr_set.add(p)
return attr_set
|
def get_training_attrs(graph, attr_set):
training_attrs = set()
for subject in graph.subjects():
row = list()
row.append(str(subject))
count = 0
for triple in graph.triples((subject, None, None)):
(s, p, o) = triple
if (p in attr_set):
ro... |
def get_ent_set(graph):
ent_set = set()
for triple in graph:
(s, p, o) = triple
if (str(s) not in ent_set):
ent_set.add(str(s))
if (isinstance(o, rdflib.URIRef) and (str(o) not in ent_set)):
ent_set.add(str(o))
return ent_set
|
def get_ent_dict(graph, start_id):
ent_set = get_ent_set(graph)
count = start_id
res = dict()
for e in ent_set:
res[e] = count
count += 1
return res
|
class Linf_SGD(Optimizer):
'Implements stochastic gradient descent (optionally with momentum).\n Nesterov momentum is based on the formula from\n `On the importance of initialization and momentum in deep learning`__.\n Args:\n params (iterable): iterable of parameters to optimize or dicts defining... |
def Linf_PGD_alpha(model, X, y, epsilon, steps=7, random_start=True):
training = model.training
if training:
model.eval()
saved_params = [p.clone() for p in model.arch_parameters()]
optimizer = Linf_SGD(model.arch_parameters(), lr=((2 * epsilon) / steps))
with torch.no_grad():
loss... |
def Random_alpha(model, X, y, epsilon):
for p in model.arch_parameters():
p.data.add_(torch.zeros_like(p).uniform_((- epsilon), epsilon))
model.clip()
|
def Linf_PGD_alpha_RNN(model, X, y, hidden, epsilon, steps=7, random_start=True):
training = model.training
if training:
model.eval()
saved_params = [p.clone() for p in model.arch_parameters()]
optimizer = Linf_SGD(model.arch_parameters(), lr=((2 * epsilon) / steps))
with torch.no_grad():
... |
def Random_alpha_RNN(model, X, y, hidden, epsilon):
for p in model.arch_parameters():
p.data.add_(torch.zeros_like(p).uniform_((- epsilon), epsilon))
model.clip()
|
def calculate_md5(fpath, chunk_size=(1024 * 1024)):
md5 = hashlib.md5()
with open(fpath, 'rb') as f:
for chunk in iter((lambda : f.read(chunk_size)), b''):
md5.update(chunk)
return md5.hexdigest()
|
def check_md5(fpath, md5, **kwargs):
return (md5 == calculate_md5(fpath, **kwargs))
|
def check_integrity(fpath, md5=None):
if (not os.path.isfile(fpath)):
return False
if (md5 is None):
return True
else:
return check_md5(fpath, md5)
|
class ImageNet16(data.Dataset):
train_list = [['train_data_batch_1', '27846dcaa50de8e21a7d1a35f30f0e91'], ['train_data_batch_2', 'c7254a054e0e795c69120a5727050e3f'], ['train_data_batch_3', '4333d3df2e5ffb114b05d2ffc19b1e87'], ['train_data_batch_4', '1620cdf193304f4a92677b695d70d10f'], ['train_data_batch_5', '348b... |
class Architect(object):
def __init__(self, model, args):
self.network_momentum = args.momentum
self.network_weight_decay = args.weight_decay
self.model = model
self.optimizer = torch.optim.Adam(self.model.arch_parameters(), lr=args.arch_learning_rate, betas=(0.5, 0.999), weight_d... |
def get_combination(space, num):
combs = []
for i in range(num):
if (i == 0):
for func in space:
combs.append([(func, i)])
else:
new_combs = []
for string in combs:
for func in space:
xstring = (string + [(... |
class Structure():
def __init__(self, genotype):
assert (isinstance(genotype, list) or isinstance(genotype, tuple)), 'invalid class of genotype : {:}'.format(type(genotype))
self.node_num = (len(genotype) + 1)
self.nodes = []
self.node_N = []
for (idx, node_info) in enumer... |
def pt_project(train_queue, valid_queue, model, architect, criterion, optimizer, epoch, args, infer, query):
def project(model, args):
(num_edge, num_op) = (model.num_edge, model.num_op)
remain_eids = torch.nonzero(model.candidate_flags).cpu().numpy().T[0]
if (args.edge_decision == 'rando... |
class TinyNetwork(nn.Module):
def __init__(self, C, N, max_nodes, num_classes, criterion, search_space, args, affine=False, track_running_stats=True):
super(TinyNetwork, self).__init__()
self._C = C
self._layerN = N
self.max_nodes = max_nodes
self._num_classes = num_classe... |
class TinyNetworkDarts(TinyNetwork):
def __init__(self, C, N, max_nodes, num_classes, criterion, search_space, args, affine=False, track_running_stats=True):
super(TinyNetworkDarts, self).__init__(C, N, max_nodes, num_classes, criterion, search_space, args, affine=affine, track_running_stats=track_runnin... |
class TinyNetworkDartsProj(TinyNetwork):
def __init__(self, C, N, max_nodes, num_classes, criterion, search_space, args, affine=False, track_running_stats=True):
super(TinyNetworkDartsProj, self).__init__(C, N, max_nodes, num_classes, criterion, search_space, args, affine=affine, track_running_stats=trac... |
def main():
torch.set_num_threads(3)
if (not torch.cuda.is_available()):
logging.info('no gpu device available')
sys.exit(1)
np.random.seed(args.seed)
gpu = (ig_utils.pick_gpu_lowest_memory() if (args.gpu == 'auto') else int(args.gpu))
torch.cuda.set_device(gpu)
cudnn.benchmark... |
def train(train_queue, valid_queue, model, architect, optimizer, lr, epoch):
objs = ig_utils.AvgrageMeter()
top1 = ig_utils.AvgrageMeter()
top5 = ig_utils.AvgrageMeter()
for step in range(len(train_queue)):
model.train()
(input, target) = next(iter(train_queue))
input = input.c... |
def infer(valid_queue, model, criterion, log=True, eval=True, weights=None, double=False, bn_est=False):
objs = ig_utils.AvgrageMeter()
top1 = ig_utils.AvgrageMeter()
top5 = ig_utils.AvgrageMeter()
(model.eval() if eval else model.train())
if bn_est:
_data_loader = deepcopy(valid_queue)
... |
def distill(result):
result = result.split('\n')
cifar10 = result[5].replace(' ', '').split(':')
cifar100 = result[7].replace(' ', '').split(':')
imagenet16 = result[9].replace(' ', '').split(':')
cifar10_train = float(cifar10[1].strip(',test')[(- 7):(- 2)].strip('='))
cifar10_test = float(cif... |
def query(api, genotype, logging):
result = api.query_by_arch(genotype)
logging.info('{:}'.format(result))
(cifar10_train, cifar10_test, cifar100_train, cifar100_valid, cifar100_test, imagenet16_train, imagenet16_valid, imagenet16_test) = distill(result)
logging.info('cifar10 train %f test %f', cifar1... |
class Cell(nn.Module):
def __init__(self, genotype, C_prev_prev, C_prev, C, reduction, reduction_prev):
super(Cell, self).__init__()
if reduction_prev:
self.preprocess0 = FactorizedReduce(C_prev_prev, C)
else:
self.preprocess0 = ReLUConvBN(C_prev_prev, C, 1, 1, 0)
... |
class AuxiliaryHead(nn.Module):
def __init__(self, C, num_classes):
'assuming input size 8x8'
super(AuxiliaryHead, self).__init__()
self.features = nn.Sequential(nn.ReLU(inplace=True), nn.AvgPool2d(5, stride=3, padding=0, count_include_pad=False), nn.Conv2d(C, 128, 1, bias=False), nn.Batc... |
class Network(nn.Module):
def __init__(self, C, num_classes, layers, auxiliary, genotype):
super(Network, self).__init__()
self._layers = layers
self._auxiliary = auxiliary
stem_multiplier = 3
C_curr = (stem_multiplier * C)
self.stem = nn.Sequential(nn.Conv2d(3, C_... |
class Cell(nn.Module):
def __init__(self, genotype, C_prev_prev, C_prev, C, reduction, reduction_prev):
super(Cell, self).__init__()
print(C_prev_prev, C_prev, C)
if reduction_prev:
self.preprocess0 = FactorizedReduce(C_prev_prev, C)
else:
self.preprocess0 ... |
class AuxiliaryHeadImageNet(nn.Module):
def __init__(self, C, num_classes):
'assuming input size 14x14'
super(AuxiliaryHeadImageNet, self).__init__()
self.features = nn.Sequential(nn.ReLU(inplace=True), nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False), nn.Conv2d(C, 128, 1, bi... |
class NetworkImageNet(nn.Module):
def __init__(self, C, num_classes, layers, auxiliary, genotype):
super(NetworkImageNet, self).__init__()
self._layers = layers
self._auxiliary = auxiliary
self.drop_path_prob = 0.0
self.stem0 = nn.Sequential(nn.Conv2d(3, (C // 2), kernel_s... |
class MixedOp(nn.Module):
def __init__(self, C, stride, PRIMITIVES):
super(MixedOp, self).__init__()
self._ops = nn.ModuleList()
for primitive in PRIMITIVES:
op = OPS[primitive](C, stride, False)
if ('pool' in primitive):
op = nn.Sequential(op, nn.B... |
class Cell(nn.Module):
def __init__(self, steps, multiplier, C_prev_prev, C_prev, C, reduction, reduction_prev):
super(Cell, self).__init__()
self.reduction = reduction
self.primitives = self.PRIMITIVES[('primitives_reduct' if reduction else 'primitives_normal')]
if reduction_prev... |
class Network(nn.Module):
def __init__(self, C, num_classes, layers, criterion, primitives, args, steps=4, multiplier=4, stem_multiplier=3, drop_path_prob=0):
super(Network, self).__init__()
self._C = C
self._num_classes = num_classes
self._layers = layers
self._criterion ... |
class DartsNetworkProj(Network):
def __init__(self, C, num_classes, layers, criterion, primitives, args, steps=4, multiplier=4, stem_multiplier=3, drop_path_prob=0.0):
super(DartsNetworkProj, self).__init__(C, num_classes, layers, criterion, primitives, args, steps=steps, multiplier=multiplier, stem_mult... |
class SDartsNetwork(Network):
def __init__(self, C, num_classes, layers, criterion, primitives, args, steps=4, multiplier=4, stem_multiplier=3, drop_path_prob=0.0):
super(SDartsNetwork, self).__init__(C, num_classes, layers, criterion, primitives, args, steps, multiplier, stem_multiplier, drop_path_prob)... |
class SDartsNetworkProj(DartsNetworkProj):
def __init__(self, C, num_classes, layers, criterion, primitives, args, steps=4, multiplier=4, stem_multiplier=3, drop_path_prob=0.0):
super(SDartsNetworkProj, self).__init__(C, num_classes, layers, criterion, primitives, args, steps=steps, multiplier=multiplier... |
def project_op(model, proj_queue, args, infer, cell_type, selected_eid=None):
' operation '
(num_edges, num_ops) = (model.num_edges, model.num_ops)
candidate_flags = model.candidate_flags[cell_type]
proj_crit = args.proj_crit[cell_type]
if (selected_eid is None):
remain_eids = torch.nonzer... |
def project_edge(model, proj_queue, args, infer, cell_type):
' topology '
candidate_flags = model.candidate_flags_edge[cell_type]
proj_crit = args.proj_crit[cell_type]
remain_nids = torch.nonzero(candidate_flags).cpu().numpy().T[0]
if (args.edge_decision == 'random'):
selected_nid = np.ran... |
def pt_project(train_queue, valid_queue, model, architect, optimizer, epoch, args, infer, perturb_alpha, epsilon_alpha):
model.train()
model.printing(logging)
(train_acc, train_obj) = infer(train_queue, model, log=False)
logging.info('train_acc %f', train_acc)
logging.info('train_loss %f', train_... |
def main():
torch.set_num_threads(3)
if (not torch.cuda.is_available()):
logging.info('no gpu device available')
sys.exit(1)
if args.queue:
ig_utils.queue_gpu()
np.random.seed(args.seed)
gpu = (ig_utils.pick_gpu_lowest_memory() if (args.gpu == 'auto') else int(args.gpu))
... |
def train(train_queue, model, criterion, optimizer):
objs = ig_utils.AvgrageMeter()
top1 = ig_utils.AvgrageMeter()
top5 = ig_utils.AvgrageMeter()
model.train()
for (step, (input, target)) in enumerate(train_queue):
input = input.cuda()
target = target.cuda(non_blocking=True)
... |
def infer(valid_queue, model, criterion):
objs = ig_utils.AvgrageMeter()
top1 = ig_utils.AvgrageMeter()
top5 = ig_utils.AvgrageMeter()
model.eval()
with torch.no_grad():
for (step, (input, target)) in enumerate(valid_queue):
input = input.cuda()
target = target.cuda... |
class CrossEntropyLabelSmooth(nn.Module):
def __init__(self, num_classes, epsilon):
super(CrossEntropyLabelSmooth, self).__init__()
self.num_classes = num_classes
self.epsilon = epsilon
self.logsoftmax = nn.LogSoftmax(dim=1)
def forward(self, inputs, targets):
log_pro... |
def main():
if (not torch.cuda.is_available()):
logging.info('no gpu device available')
sys.exit(1)
np.random.seed(args.seed)
torch.cuda.set_device(args.gpu)
cudnn.benchmark = True
torch.manual_seed(args.seed)
cudnn.enabled = True
torch.cuda.manual_seed(args.seed)
loggi... |
def train(train_queue, model, criterion, optimizer):
objs = utils.AvgrageMeter()
top1 = utils.AvgrageMeter()
top5 = utils.AvgrageMeter()
model.train()
for (step, (input, target)) in enumerate(train_queue):
input = input.cuda()
target = target.cuda(non_blocking=True)
optimiz... |
def infer(valid_queue, model, criterion):
objs = utils.AvgrageMeter()
top1 = utils.AvgrageMeter()
top5 = utils.AvgrageMeter()
model.eval()
with torch.no_grad():
for (step, (input, target)) in enumerate(valid_queue):
input = input.cuda()
target = target.cuda(non_bloc... |
def main():
torch.set_num_threads(3)
if (not torch.cuda.is_available()):
logging.info('no gpu device available')
sys.exit(1)
np.random.seed(args.seed)
gpu = (ig_utils.pick_gpu_lowest_memory() if (args.gpu == 'auto') else int(args.gpu))
torch.cuda.set_device(gpu)
cudnn.benchmark... |
def train(train_queue, valid_queue, model, architect, optimizer, lr, epoch, perturb_alpha, epsilon_alpha):
objs = ig_utils.AvgrageMeter()
top1 = ig_utils.AvgrageMeter()
top5 = ig_utils.AvgrageMeter()
for step in range(len(train_queue)):
model.train()
(input, target) = next(iter(train_q... |
def infer(valid_queue, model, log=True, _eval=True, weights_dict=None):
objs = ig_utils.AvgrageMeter()
top1 = ig_utils.AvgrageMeter()
top5 = ig_utils.AvgrageMeter()
(model.eval() if _eval else model.train())
with torch.no_grad():
for (step, (input, target)) in enumerate(valid_queue):
... |
def plot(genotype, filename, mode=''):
g = Digraph(format='pdf', edge_attr=dict(fontsize='40', fontname='times'), node_attr=dict(style='filled', shape='rect', align='center', fontsize='40', height='0.5', width='0.5', penwidth='2', fontname='times'), engine='dot')
g.body.extend(['rankdir=LR'])
g.body.exten... |
def plot_space(primitives, filename):
g = Digraph(format='pdf', edge_attr=dict(fontsize='20', fontname='times'), node_attr=dict(style='filled', shape='rect', align='center', fontsize='20', height='0.5', width='0.5', penwidth='2', fontname='times'), engine='dot')
g.body.extend(['rankdir=LR'])
g.body.extend... |
def plot(genotype, filename):
g = Digraph(format='pdf', edge_attr=dict(fontsize='100', fontname='times'), node_attr=dict(style='filled', shape='rect', align='center', fontsize='100', height='0.5', width='0.5', penwidth='2', fontname='times'), engine='dot')
g.body.extend(['rankdir=LR'])
g.body.extend(['rat... |
def conv3x3(in_planes, out_planes, stride=1):
'3x3 convolution with padding'
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.