def preds(self, feats):
key = feats
if key in self._preds:
return self._preds[key]
assert isinstance(feats, Output)
params_before = len(self.N.params())
if self.W is None:
preds = self.N.FC(feats, nout=self.nout, stddev=self.stddev)
else:
assert len(self.W) == 1
W = Output(self.W[0])
preds = self.N.FCMult(feats, W)
net_params = self.N.params()
num_new_params = len(net_params) - params_before
if self.W is None:
assert num_new_params >= 1
self.W = net_params[-num_new_params:]
else:
assert num_new_params == 0
if self.bias:
params_before = len(self.N.params())
if self.b is None:
preds = self.N.Bias(preds)
else:
preds = self.N.BiasAdd(preds, self.b, axis=1)
net_params = self.N.params()
num_new_params = len(net_params) - params_before
if self.b is None:
assert num_new_params == 1
self.b = Output(net_params[-1], shape=(self.nout,))
else:
assert num_new_params == 0
self._preds[key] = preds
return preds
def __init__(self,
num,
definition,
limits=default_limits,
internal_rng=False,
name=None):
assert len(limits) == 2
assert limits[1] > limits[0]
self.limits = tuple(float(l) for l in limits)
self.span = limits[1] - limits[0]
if len(definition) != 1:
raise ValueError(
'definition should have 1 parameter (dim), not %d' %
len(definition))
try:
dim = int(definition[0])
except ValueError:
raise ValueError('non-integer dim: %s' % dim)
self.recon_dim = self.sample_dim = dim
self.num = num
self.rangekw = dict(low=self.limits[0], high=self.limits[1])
if internal_rng:
self.placeholders = [
t_rng.uniform(size=(num, dim), **self.rangekw)
]
else:
self.placeholders = [T.matrix()]
self.flat_data = [Output(self.placeholders[0], shape=(self.num, dim))]
def __init__(self,
num,
definition,
mean=0,
stdev=None,
internal_rng=False):
self.mean = mean
if len(definition) != 1:
raise ValueError(
'definition should have 1 parameter (dim), not %d' %
len(definition))
try:
dim = int(definition[0])
except ValueError:
raise ValueError('non-integer dim: %s' % dim)
if stdev is None:
var = 2 * np.log(2)
stdev = var**0.5
else:
var = stdev**2
self.var, self.stdev = (floatX(x) for x in (var, stdev))
self.recon_dim = self.sample_dim = dim
self.num = num
if internal_rng:
self.placeholders = [
t_rng.normal(size=(num, dim), avg=mean, std=self.stdev)
]
else:
self.placeholders = [T.matrix()]
self.flat_data = [Output(self.placeholders[0], shape=(num, dim))]
def __init__(self,
args,
dist,
nc,
z=None,
source=None,
mode='train',
bnkwargs={},
gen_transform=None):
N = self.net = Net(source=source, name='Generator')
self.set_mode(mode)
h_and_weights = dist.embed_data()
bn_use_ave = (mode == 'test')
self.data, _ = get_deconvnet(image_size=args.crop_resize,
name=args.gen_net)(
h_and_weights,
N=N,
nout=nc,
size=args.gen_net_size,
num_fc=args.net_fc,
fc_dims=args.net_fc_dims,
nonlin=args.deconv_nonlin,
bn_use_ave=bn_use_ave,
ksize=args.deconv_ksize,
**bnkwargs)
if gen_transform is not None:
self.data = Output(gen_transform(self.data.value),
shape=self.data.shape)
def logits_to_recon(self, recon_logits):
def blend(mask, true, false):
return mask * true + (1 - mask) * false
shape = self.num, self.recon_dim
# clamp recon in the dist. range
recon = recon_logits
recon = blend(recon < self.limits[0], self.limits[0], recon)
recon = blend(recon > self.limits[1], self.limits[1], recon)
return [Output(recon, shape)]
def logits_to_sample(self, recon_logits):
recon_mean = recon_logits[:, :self.slice_point]
recon_log_var = recon_logits[:, self.slice_point:]
if self.log_var_bias != 0:
recon_log_var += self.log_var_bias
recon_logstd = recon_log_var / 2
recon_std = T.exp(recon_logstd)
standard_sample = t_rng.normal(size=recon_mean.shape)
sample = recon_mean + standard_sample * recon_std
sample = [Output(sample, (self.num, self.sample_dim))]
return sample
def validate(val_loader, model, criterion, print_freq, args):
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to evaluate mode
model.eval()
end = time.time()
for i, (input, target) in enumerate(val_loader):
# convert tensor to np to feed into encoder
input_np = input.numpy()
X = Output(input_transform(input_np), (args.batch_size, nc, args.crop_size, args.crop_size))
with nostdout():
hs = sample_z_from_x(X)[0].value.eval()
input_h = torch.from_numpy(hs)
target = target.cuda(async=True)
input_var = torch.autograd.Variable(input_h.cuda(), volatile=True)
target_var = torch.autograd.Variable(target.cuda(), volatile=True)
# compute output
output = model(input_var)
loss = criterion(output, target_var)
# measure accuracy and record loss
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.data[0], input.size(0))
top1.update(prec1[0], input.size(0))
top5.update(prec5[0], input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % print_freq == 0:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
i, len(val_loader), batch_time=batch_time, loss=losses,
top1=top1, top5=top5))
print(' * Prec@1 {top1.avg:.3f} Prec@5 {top5.avg:.3f}'
.format(top1=top1, top5=top5))
return top1.avg
def logits_to_recon(self, recon_logits):
"""Returns the nearest possible `sample()` output from `recon_logits`."""
return [Output(recon_logits, (self.num, self.recon_dim))]
def logits_to_recon(self, recon_logits):
recon_mean = recon_logits[:, :self.slice_point]
return [Output(recon_mean, (self.num, self.sample_dim))]
def logits_to_recon(self, recon_logits):
shape = self.num, self.recon_dim
recon = T.tanh(recon_logits)
limits = -1, 1
return [Output(self._scale_and_shift(recon, limits), shape)]
def logits_to_recon(self, recon_logits):
shape = self.num, self.recon_dim
return [Output(recon_logits, shape)]
def logits_to_recon(self, recon_logits):
shape = self.num, self.recon_dim
recon = T.nnet.sigmoid(recon_logits)
limits = 0, 1
return [Output(self._scale_and_shift(recon, limits), shape)]
args.noise_input_joint_discrim = [
bool(float(x)) for x in args.noise_input_joint_discrim.split(',')
]
assert len(args.noise_input_joint_discrim) == len(args.noise.split('_'))
dist = MultiDistribution(args.batch_size,
args.noise,
normalize=args.encode_normalize,
weights=args.noise_weight,
weight_embed=args.noise_input_weight)
for d in dist.dists:
d.log_var_bias = args.log_var_bias
# input placeholders
Xi = T.tensor4(dtype='uint8')
X = Output(input_transform(Xi),
(args.batch_size, nc, args.crop_size, args.crop_size))
assert args.crop_resize <= args.crop_size
if args.crop_size == args.crop_resize:
Xis = Xi
else:
Xis = T.tensor4(dtype='uint8')
Xs = Output(input_transform(Xis),
(args.batch_size, nc, args.crop_resize, args.crop_resize))
Z = dist.placeholders
if args.classifier:
Y = T.ivector()
y = Output(Y, shape=(args.batch_size, ), index_max=ny)
else:
Y = None
y = None
def logits_to_recon(self, recon_logits):
return [Output(recon_logits, (self.num, self.recon_dim))]
