def gen_classes(name, steps, classes, interpolate=False, start=None):
bymb = get_buffer_y(steps, num_buffer_classes, 3) # dont know why but samples better when
bzmb = get_buffer_z(steps, num_buffer_classes, 3) # included is a buffer of common classes
offset = bymb.shape[0]
numtargets = len(classes)
targets = np.asarray([[classes[i] for _ in range(steps)] for i in range(numtargets)])
ymb = floatX(OneHot(targets.flatten(), ny))
zmb = floatX(np_rng.uniform(-1., 1., size=(numtargets * steps, nz)))
ymb = np.vstack((bymb, ymb))
zmb = np.vstack((bzmb, zmb))
if interpolate:
if numtargets > 1:
for i in range(numtargets):
y1 = classes[i]
y2 = classes[(i+1) % numtargets]
for j in range(steps):
y = offset + steps * i + j
ymb[y] = np.zeros(ny)
if y1 == y2:
ymb[y][y1] = 1.0
else:
ymb[y][y1] = 1.0 - j / (steps-1.0)
ymb[y][y2] = j / (steps-1.0)
zmb = setup_z(zmb, offset, classes, numtargets, steps, start)
indexes = range(offset, ymb.shape[0])
samples = gen_image(name, ymb, zmb, steps, indexes)
gen_image_set(name, ymb, zmb, indexes)
return ymb[offset:], zmb[offset:], samples
def gpu_nnc_predict(trX, trY, teX, metric='cosine', batch_size=4096):
if metric == 'cosine':
metric_fn = cosine_dist
else:
metric_fn = euclid_dist
idxs = []
for i in range(0, len(teX), batch_size):
mb_dists = []
mb_idxs = []
for j in range(0, len(trX), batch_size):
dist = metric_fn(floatX(teX[i:i + batch_size]),
floatX(trX[j:j + batch_size]))
if metric == 'cosine':
mb_dists.append(np.max(dist, axis=1))
mb_idxs.append(j + np.argmax(dist, axis=1))
else:
mb_dists.append(np.min(dist, axis=1))
mb_idxs.append(j + np.argmin(dist, axis=1))
mb_idxs = np.asarray(mb_idxs)
mb_dists = np.asarray(mb_dists)
if metric == 'cosine':
i = mb_idxs[np.argmax(mb_dists, axis=0),
np.arange(mb_idxs.shape[1])]
else:
i = mb_idxs[np.argmin(mb_dists, axis=0),
np.arange(mb_idxs.shape[1])]
idxs.append(i)
idxs = np.concatenate(idxs, axis=0)
nearest = trY[idxs]
return nearest
def gen_samples(n, nbatch=128):
samples = []
labels = []
n_gen = 0
for i in range(n / nbatch):
print 'i:', i
# ymb.shape = (nbatch, ny)
ymb = floatX(OneHot(np_rng.randint(0, 10, nbatch), NUM_LABEL))
print 'gen_samples: ymb:', ymb.shape
print ymb
# zmb.shape = (nbatch, DIM_Z)
zmb = floatX(np_rng.uniform(-1., 1., size=(nbatch, DIM_Z)))
print 'gen_samples: zmb:', zmb.shape
print zmb
# xmd
xmb = _gen(zmb, ymb)
print 'gen_samples: xmb:', xmb.shape
print rH2
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
n_gen += len(xmb)
n_left = n - n_gen
ymb = floatX(OneHot(np_rng.randint(0, 10, n_left), NUM_LABEL))
zmb = floatX(np_rng.uniform(-1., 1., size=(n_left, DIM_Z)))
xmb = _gen(zmb, ymb)
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
return np.concatenate(samples, axis=0), np.concatenate(labels, axis=0)
def init_z(self, frame_id=0, image_id=0):
# print('init z!!!!!')
nz = 100
n_sigma = 0.5
self.iter_total = 0
# set prev_z
if self.z_seq is not None:
image_id = image_id % self.z_seq.shape[0]
frame_id = frame_id % self.z_seq.shape[1]
print('set z as image %d, frame %d' % (image_id, frame_id))
self.prev_z = self.z_seq[image_id, frame_id]
if self.prev_z is None:
# print('random initialization')
self.z0_f = floatX(
np_rng.uniform(-1.0, 1.0, size=(self.batch_size, nz)))
self.zero_z_const()
self.z_i = self.z0_f.copy(
) # floatX(np_rng.uniform(-1.0, 1.0, size=(batch_size, nz)))
self.z1 = self.z0_f.copy()
else:
z0_r = np.tile(self.prev_z, [self.batch_size, 1])
z0_n = floatX(
np_rng.uniform(-1.0, 1.0, size=(self.batch_size, nz)) *
n_sigma)
self.z0_f = floatX(np.clip(z0_r + z0_n, -0.99, 0.99))
self.z_i = np.tile(self.prev_z, [self.batch_size, 1])
self.z1 = z0_r.copy()
z = self.invert_model[2]
z.set_value(floatX(np.arctanh(self.z0_f)))
self.just_fixed = True
def __call__(self, params, cost):
updates = []
grads = T.grad(cost, params)
grads = clip_norms(grads, self.clipnorm)
t = theano.shared(floatX(0.))
b1_t = self.b1 * self.l**t
tp1 = t + 1.
for p, g in zip(params, grads):
g = self.regularizer.gradient_regularize(p, g)
value = p.get_value() * 0.
if p.dtype == theano.config.floatX:
value = floatX(value)
m = theano.shared(value)
v = theano.shared(value)
m_t = b1_t * m + (1 - b1_t) * g
v_t = self.b2 * v + (1 - self.b2) * g**2
m_c = m_t / (1 - self.b1**tp1)
v_c = v_t / (1 - self.b2**tp1)
p_t = p - (self.lr * m_c) / (T.sqrt(v_c) + self.e)
p_t = self.regularizer.weight_regularize(p_t)
updates.append((m, m_t))
updates.append((v, v_t))
updates.append((p, p_t))
updates.append((t, tp1))
return updates
def invert_bfgs(gen_model,
invert_model,
ftr_model,
im,
z_predict=None,
npx=64):
_f, z = invert_model
nz = gen_model.nz
if z_predict is None:
z_predict = np_rng.uniform(-1., 1., size=(1, nz))
else:
z_predict = floatX(z_predict)
z_predict = np.arctanh(z_predict)
im_t = gen_model.transform(im)
ftr = ftr_model(im_t)
prob = optimize.minimize(f_bfgs,
z_predict,
args=(_f, im_t, ftr),
tol=1e-6,
jac=True,
method='L-BFGS-B',
options={'maxiter': 200})
print('n_iters = %3d, f = %.3f' % (prob.nit, prob.fun))
z_opt = prob.x
z_opt_n = floatX(z_opt[np.newaxis, :])
[f_opt, g, gx] = _f(z_opt_n, im_t, ftr)
gx = gen_model.inverse_transform(gx, npx=npx)
z_opt = np.tanh(z_opt)
return gx, z_opt, f_opt
def set_sample_switch(self, source='inf'):
'''
Set the latent sample switch to use samples from the given source.
'''
assert (source_name in ['inf', 'gen'])
switch_val = floatX([1.]) if (source_name == 'inf') else floatX([0.])
self.sample_switch.set_value(switch_val)
return
def _get_batch(self, X, index, batch_size):
size = X.shape[0]
n1 = (index*batch_size)%size
n2 = ((index+1)*batch_size-1)%size+1
if n1>n2:
return floatX(np.concatenate((X[n1:], X[:n2])))
else:
return floatX(X[n1:n2])
def rand_gen(size, noise_type='normal'):
if noise_type == 'normal':
r_vals = floatX(np_rng.normal(size=size))
elif noise_type == 'uniform':
r_vals = floatX(np_rng.uniform(size=size, low=-1.0, high=1.0))
else:
assert False, "unrecognized noise type!"
return r_vals
def reset_adam(_updates):
for n, update in enumerate(_updates):
value = update[0].get_value()
if n == 2:
continue
if n == 3:
update[0].set_value(floatX(1.0))
continue
update[0].set_value(floatX(np.zeros_like(value)))
def reset_adam(_updates):
for n, update in enumerate(_updates):
value = update[0].get_value()
if n == 2:
continue
if n == 3:
update[0].set_value(floatX(1.0))
continue
update[0].set_value(floatX(np.zeros_like(value)))
def get_hog(self, x_o):
use_bin = self.use_bin
NO = self.NO
BS = self.BS
nc = self.nc
x = (x_o + sharedX(1)) / (sharedX(2))
Gx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) / 4.0
Gy = Gx.T
f1_w = []
for i in range(NO):
t = np.pi / NO * i
g = np.cos(t) * Gx + np.sin(t) * Gy
gg = np.tile(g[np.newaxis, np.newaxis, :, :], [1, 1, 1, 1])
f1_w.append(gg)
f1_w = np.concatenate(f1_w, axis=0)
G = np.concatenate([
Gx[np.newaxis, np.newaxis, :, :], Gy[np.newaxis, np.newaxis, :, :]
],
axis=0)
G_f = sharedX(floatX(G))
a = np.cos(np.pi / NO)
l1 = sharedX(floatX(1 / (1 - a)))
l2 = sharedX(floatX(a / (1 - a)))
eps = sharedX(1e-3)
if nc == 3:
x_gray = T.mean(x, axis=1).dimshuffle(0, 'x', 1, 2)
else:
x_gray = x
f1 = sharedX(floatX(f1_w))
h0 = T.abs_(dnn_conv(x_gray, f1, subsample=(1, 1), border_mode=(1, 1)))
g = dnn_conv(x_gray, G_f, subsample=(1, 1), border_mode=(1, 1))
if use_bin:
gx = g[:, [0], :, :]
gy = g[:, [1], :, :]
gg = T.sqrt(gx * gx + gy * gy + eps)
hk = T.maximum(0, l1 * h0 - l2 * gg)
bf_w = np.zeros((NO, NO, 2 * BS, 2 * BS))
b = 1 - np.abs(
(np.arange(1, 2 * BS + 1) - (2 * BS + 1.0) / 2.0) / BS)
b = b[np.newaxis, :]
bb = b.T.dot(b)
for n in range(NO):
bf_w[n, n] = bb
bf = sharedX(floatX(bf_w))
h_f = dnn_conv(hk,
bf,
subsample=(BS, BS),
border_mode=(BS / 2, BS / 2))
return h_f
else:
return g
def __init__(self,
td_modules,
bu_modules_gen, im_modules_gen,
bu_modules_inf, im_modules_inf,
merge_info):
# grab the bottom-up, top-down, and info merging modules
self.td_modules = [m for m in td_modules]
self.bu_modules_gen = [m for m in bu_modules_gen]
self.im_modules_gen = [m for m in im_modules_gen]
self.bu_modules_inf = [m for m in bu_modules_inf]
self.im_modules_inf = [m for m in im_modules_inf]
# get dicts for referencing modules by name
self.td_modules_dict = {m.mod_name: m for m in td_modules}
self.td_modules_dict[None] = None
self.bu_modules_gen_dict = {m.mod_name: m for m in bu_modules_gen}
self.bu_modules_gen_dict[None] = None
self.bu_modules_inf_dict = {m.mod_name: m for m in bu_modules_inf}
self.bu_modules_inf_dict[None] = None
self.im_modules_gen_dict = {m.mod_name: m for m in im_modules_gen}
self.im_modules_gen_dict[None] = None
self.im_modules_inf_dict = {m.mod_name: m for m in im_modules_inf}
self.im_modules_inf_dict[None] = None
# grab the full set of trainable parameters in these modules
self.gen_params = [] # modules that aren't just for inference
self.inf_params = [] # modules that are just for inference
# get generator params (these only get to adapt to the training set)
self.generator_modules = self.td_modules + self.bu_modules_gen + \
self.im_modules_gen
for mod in self.generator_modules:
self.gen_params.extend(mod.params)
# get inferencer params (these can be fine-tuned at test time)
self.inferencer_modules = self.bu_modules_inf + self.im_modules_inf
for mod in self.inferencer_modules:
self.inf_params.extend(mod.params)
# filter redundant parameters, to allow parameter sharing
p_dict = {}
for p in self.gen_params:
p_dict[p.name] = p
self.gen_params = p_dict.values()
p_dict = {}
for p in self.inf_params:
p_dict[p.name] = p
self.inf_params = p_dict.values()
# add a distribution scaling parameter to the generator
self.dist_scale = sharedX(floatX([0.2]))
self.gen_params.append(self.dist_scale)
# gather a list of all parameters in this network
self.all_params = self.inf_params + self.gen_params
# get instructions for how to merge bottom-up and top-down info
self.merge_info = merge_info
# make a switch for alternating between generator and inferencer
# conditionals over the latent variables
self.sample_switch = sharedX(floatX([1.0]))
return
def _chunck_eval(X_test, y_test, theta0):
chunk_size = X_test.shape[0] // 3
rmse_1, ll_1 = _evaluate(X_test[:chunk_size], y_test[:chunk_size], floatX(theta0))
# print 'rmse 1', rmse_1, ll_1
rmse_2, ll_2 = _evaluate(X_test[chunk_size:2*chunk_size], y_test[chunk_size:2*chunk_size], floatX(theta0))
# print 'rmse 2', rmse_2, ll_2
rmse_3, ll_3 = _evaluate(X_test[2*chunk_size:], y_test[2*chunk_size:], floatX(theta0))
# print 'rmse 3', rmse_3, ll_3
return (rmse_1 + rmse_2 + rmse_3)/ 3., (ll_1 + ll_2 + ll_3)/ 3.
def gen_samples(n, nbatch=128):
samples = []
n_gen = 0
for i in range(n/nbatch):
zmb = floatX(np_rng.uniform(-1., 1., size=(nbatch, nz)))
xmb = _gen(zmb)
samples.append(xmb)
n_gen += len(xmb)
n_left = n-n_gen
zmb = floatX(np_rng.uniform(-1., 1., size=(n_left, nz)))
xmb = _gen(zmb)
samples.append(xmb)
return np.concatenate(samples, axis=0)
def gen_samples(n, nbatch=128):
samples = []
n_gen = 0
for i in range(n / nbatch):
zmb = floatX(np_rng.uniform(-1., 1., size=(nbatch, nz)))
xmb = _gen(zmb)
samples.append(xmb)
n_gen += len(xmb)
n_left = n - n_gen
zmb = floatX(np_rng.uniform(-1., 1., size=(n_left, nz)))
xmb = _gen(zmb)
samples.append(xmb)
return np.concatenate(samples, axis=0)
def test_model(model_config_dict, model_test_name):
import glob
model_list = glob.glob(samples_dir +'/*.pkl')
# load parameters
model_param_dicts = unpickle(model_list[0])
# load generator
generator_models = load_generator_model(min_num_gen_filters=model_config_dict['min_num_gen_filters'],
model_params_dict=model_param_dicts)
generator_function = generator_models[0]
print 'COMPILING SAMPLING FUNCTION'
t=time()
sampling_function = set_sampling_function(generator_function=generator_function)
print '%.2f SEC '%(time()-t)
print 'START SAMPLING'
for s in xrange(model_config_dict['num_sampling']):
print '{} sampling'.format(s)
hidden_data = floatX(np_rng.uniform(low=-model_config_dict['hidden_distribution'],
high=model_config_dict['hidden_distribution'],
size=(model_config_dict['num_display'], model_config_dict['hidden_size'])))
sample_data = sampling_function(hidden_data)[0]
sample_data = inverse_transform(np.asarray(sample_data)).transpose([0,2,3,1])
save_as = samples_dir + '/' + model_test_name + '_SAMPLES(TRAIN){}.png'.format(s+1)
color_grid_vis(sample_data, (16, 16), save_as)
def features(X, nbatch=128):
Xfs = []
for xmb in iter_data(X, size=nbatch):
fmbs = _features(floatX(xmb))
for i, fmb in enumerate(fmbs):
Xfs.append(fmb)
return np.concatenate(Xfs, axis=0)
def gen_samples(self,
z0=None,
n=32,
batch_size=32,
nz=100,
use_transform=True):
assert n % batch_size == 0
samples = []
if z0 is None:
z0 = np_rng.uniform(-1., 1., size=(n, nz))
else:
n = len(z0)
batch_size = max(n, 64)
n_batches = int(np.ceil(n / float(batch_size)))
for i in range(n_batches):
zmb = floatX(z0[batch_size * i:min(len(z0), batch_size *
(i + 1)), :])
xmb = self._gen(zmb)
samples.append(xmb)
samples = np.concatenate(samples, axis=0)
if use_transform:
samples = self.inverse_transform(samples, npx=self.npx)
samples = (samples * 255).astype(np.uint8)
return samples
def features(X, nbatch=128):
Xfs = []
for xmb in iter_data(X, size=nbatch):
fmbs = _features(floatX(xmb))
for i, fmb in enumerate(fmbs):
Xfs.append(fmb)
return np.concatenate(Xfs, axis=0)
def interpolate(url0, url1, output_image):
model_class = locate('model_def.dcgan_theano')
model_file = './models/handbag_64.dcgan_theano'
model = model_class.Model(
model_name="handbag_64", model_file=model_file)
# save images
for j, url in enumerate([url0, url1]):
r = requests.get(url)
i = Image.open(StringIO(r.content))
i.save("pics/url"+str(j)+".jpg")
z0 = iGAN_predict.find_latent(url=url0).reshape((100,))
z1 = iGAN_predict.find_latent(url=url1).reshape((100,))
delta = 1.0/32.0
arrays = [p*z0+(1-p)*z1 for p in np.arange(-16*delta, 1+16*delta-0.0001, delta)]
z = np.stack(arrays)
print(z.shape)
zmb = floatX(z[0 : 64, :])
xmb = model._gen(zmb)
samples = [xmb]
samples = np.concatenate(samples, axis=0)
print(samples.shape)
samples = model.inverse_transform(samples, npx=model.npx, nc=model.nc)
samples = (samples * 255).astype(np.uint8)
# generate grid visualization
im_vis = utils.grid_vis(samples, 8, 8)
# write to the disk
im_vis = cv2.cvtColor(im_vis, cv2.COLOR_BGR2RGB)
cv2.imwrite(output_image, im_vis)
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 interpolate_full(self, img0, img1, interp=serp, x0=-0.5, x1=1.5, delta=1/32.0):
"""Return a visualization of an interpolation between img0 and img1,
using interpolation method interp. The interpolation starts
with parameter x0 and goes to x1, in increments of delta.
Note that img0 corresponds to parameter x0=0 and img1 to
parameter x1=1. The default is to start outside that range,
and so we do some extrapolation.
"""
z0 = self.get_lv(img0).reshape((100,))
z1 = self.get_lv(img1).reshape((100,))
ps = np.arange(x0, x1-0.000001, delta)
n = ps.size
arrays = [lerp(z0, z1, p) for p in ps]
z = np.stack(arrays); print z.shape
zmb = floatX(z[0 : n, :]); print zmb.shape
xmb = self.model._gen(zmb); print xmb.shape
samples = [xmb]
samples = np.concatenate(samples, axis=0)
samples = self.model.inverse_transform(
samples, npx=self.model.npx, nc=self.model.nc)
samples = (samples * 255).astype(np.uint8)
m = math.ceil(math.sqrt(n))
img_vis = utils.grid_vis(samples, m, m)
return img_vis
def def_invert(self,
model,
batch_size=1,
beta=0.5,
lr=0.1,
b1=0.9,
nz=100,
use_bin=True):
beta_r = sharedX(beta)
x_c = T.tensor4()
m_c = T.tensor4()
x_e = T.tensor4()
m_e = T.tensor4()
z0 = T.matrix()
z = sharedX(floatX(np_rng.uniform(-1., 1., size=(batch_size, nz))))
gx = model.model_G(z)
mm_c = T.tile(m_c, (1, gx.shape[1], 1, 1))
color_all = T.mean(T.sqr(gx - x_c) * mm_c, axis=(1, 2, 3)) / (
T.mean(m_c, axis=(1, 2, 3)) + sharedX(1e-5))
gx_edge = HOGNet.get_hog(gx, use_bin)
x_edge = HOGNet.get_hog(x_e, use_bin)
mm_e = T.tile(m_e, (1, gx_edge.shape[1], 1, 1))
sum_e = T.sum(T.abs_(mm_e))
sum_x_edge = T.sum(T.abs_(x_edge))
edge_all = T.mean(T.sqr(x_edge - gx_edge) * mm_e, axis=(1, 2, 3)) / (
T.mean(m_e, axis=(1, 2, 3)) + sharedX(1e-5))
rec_all = color_all + edge_all * sharedX(0.2)
z_const = sharedX(10.0)
init_all = T.mean(T.sqr(z0 - z)) * z_const
if beta > 0:
print('using D')
p_gen = model.model_D(gx)
real_all = T.nnet.binary_crossentropy(p_gen, T.ones(
p_gen.shape)).T # costs.bce(p_gen, T.ones(p_gen.shape))
cost_all = rec_all + beta_r * real_all[0] + init_all
else:
print('without D')
cost_all = rec_all + init_all
real_all = T.zeros(cost_all.shape)
cost = T.sum(cost_all)
d_updater = updates.Adam(
lr=sharedX(lr),
b1=sharedX(b1)) # ,regularizer=updates.Regularizer(l2=l2))
output = [
gx, cost, cost_all, rec_all, real_all, init_all, sum_e, sum_x_edge
]
print 'COMPILING...'
t = time()
z_updates = d_updater([z], cost)
_invert = theano.function(inputs=[x_c, m_c, x_e, m_e, z0],
outputs=output,
updates=z_updates)
print '%.2f seconds to compile _invert function' % (time() - t)
return [_invert, z_updates, z, beta_r, z_const]
def sample(self, num=None):
if num is None: num = self.num
return [
floatX(
np.random.normal(loc=self.mean,
scale=self.stdev,
size=(num, self.sample_dim)))
]
def tf( X, npx ):
assert X[ 0 ].shape == ( npx, npx, 3 ) or X[ 0 ].shape == ( 3, npx, npx )
if X[ 0 ].shape == ( npx, npx, 3 ):
X = X.astype('float32')
X[:,:,:,0] /= 50
X[:,:,:,1] /= 127.5
X[:,:,:,2] /= 127.5
X = X.transpose( 0, 3, 1, 2 )
return floatX( X - 1. )
def gen_samples(n, nbatch=128):
samples = []
labels = []
n_gen = 0
for i in range(n / nbatch):
ymb = floatX(OneHot(np_rng.randint(0, 10, nbatch), ny))
zmb = floatX(np_rng.uniform(-1., 1., size=(nbatch, nz)))
xmb = _gen(zmb, ymb)
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
n_gen += len(xmb)
n_left = n - n_gen
ymb = floatX(OneHot(np_rng.randint(0, 10, n_left), ny))
zmb = floatX(np_rng.uniform(-1., 1., size=(n_left, nz)))
xmb = _gen(zmb, ymb)
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
return np.concatenate(samples, axis=0), np.concatenate(labels, axis=0)
def gen_samples(n, nbatch=128):
samples = []
labels = []
n_gen = 0
for i in range(n/nbatch):
ymb = floatX(OneHot(np_rng.randint(0, ny, nbatch), ny))
zmb = floatX(np_rng.uniform(-1., 1., size=(nbatch, nz)))
xmb = _gen(zmb, ymb)
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
n_gen += len(xmb)
n_left = n-n_gen
ymb = floatX(OneHot(np_rng.randint(0, ny, n_left), ny))
zmb = floatX(np_rng.uniform(-1., 1., size=(n_left, nz)))
xmb = _gen(zmb, ymb)
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
return np.concatenate(samples, axis=0), np.concatenate(labels, axis=0)
def imagify(self, z):
"""Return an image corresponding to the latent vector z."""
z = np.stack([z.reshape((100,))])
zmb = floatX(z[0 : 1, :]);
xmb = self.model._gen(zmb);
samples = np.concatenate([xmb], axis=0)
samples = self.model.inverse_transform(
samples, npx=self.model.npx, nc=self.model.nc)
samples = (samples * 255).astype(np.uint8)
img_vis = utils.grid_vis(samples, 1, 1)
return img_vis
def def_comp_mask(self):
BS = self.BS
print('COMPILING')
t = time()
m = T.tensor4()
bf_w = np.ones((1, 1, 2 * BS, 2 * BS))
bf = sharedX(floatX(bf_w))
m_b = dnn_conv(m, bf, subsample=(BS, BS), border_mode=(BS / 2, BS / 2))
_comp_mask = theano.function(inputs=[m], outputs=m_b)
print('%.2f seconds to compile [compMask] functions' % (time() - t))
return _comp_mask
def cal_margin():
ll = 0
teX = shuffle(X_test)
m = 1000
batch_size = ntest // m
for i in range(m):
batch = [t % ntest for t in range(i*batch_size, (i+1)*batch_size)]
imb = floatX(teX[batch])
ll += _marginal(imb) * len(batch)
return ll / ntest
def gen_classes_arithmetic(name, steps, classes, weights):
bymb = get_buffer_y(steps, num_buffer_classes, 3) # dont know why but samples better when
bzmb = get_buffer_z(steps, num_buffer_classes, 3) # included is a buffer of common classes
offset = bymb.shape[0]
numtargets = len(classes)+1
targets = np.asarray([[classes[i % (numtargets-1)] for _ in range(steps)] for i in range(numtargets)])
ymb = floatX(OneHot(targets.flatten(), ny))
zmb = floatX(np_rng.uniform(-1., 1., size=(numtargets * steps, nz)))
ymb = np.vstack((bymb, ymb))
zmb = np.vstack((bzmb, zmb))
for i in range(numtargets):
for j in range(steps):
y_idx = offset + steps * i + j
ymb[y_idx] = np.zeros(ny)
if i == numtargets-1:
for k, c in enumerate(classes):
ymb[y_idx][c] = weights[k]
else:
ymb[y_idx][classes[i]] = 1.0
frac = j / (steps-1.0)
if frac > 0.5:
frac = 2.0 * (1.0 - frac)
else:
frac = 2.0 * frac
if (i == numtargets-1):
z1 = zf[classes[0]][0]
z2 = zf[classes[0]][1]
else:
z1 = zf[classes[i]][0]
z2 = zf[classes[i]][1]
for k in range(nz):
z = (1.0 - frac) * z1[k] + frac * z2[k]
#z = min(z, z2 - z)
zmb[y_idx][k] = z
indexes = range(offset, ymb.shape[0])
samples = gen_image(name, ymb, zmb, steps, indexes)
gen_image_set(name, ymb, zmb, indexes)
return ymb[offset:], zmb[offset:], samples
def gpu_nnd_score(trX, teX, metric='cosine', batch_size=4096):
if metric == 'cosine':
metric_fn = cosine_dist
else:
metric_fn = euclid_dist
dists = []
for i in range(0, len(teX), batch_size):
mb_dists = []
for j in range(0, len(trX), batch_size):
dist = metric_fn(floatX(teX[i:i + batch_size]),
floatX(trX[j:j + batch_size]))
if metric == 'cosine':
mb_dists.append(np.max(dist, axis=1))
else:
mb_dists.append(np.min(dist, axis=1))
mb_dists = np.asarray(mb_dists)
if metric == 'cosine':
d = np.max(mb_dists, axis=0)
else:
d = np.min(mb_dists, axis=0)
dists.append(d)
dists = np.concatenate(dists, axis=0)
return float(np.mean(dists))
def gen_samples(n, nbatch, ysize):
samples = []
labels = []
n_gen = 0
for i in range(n / nbatch):
ymb = floatX(OneHot(np_rng.randint(0, 10, nbatch), ysize))
zmb = sample_z(nbatch, Z_SIZE)
xmb, ot_lYS, ot_G3_1, ot_G3_2, ot_G10, ot_G11, ot_G12 = _gen(zmb, ymb)
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
n_gen += len(xmb)
# fraction part
n_left = n - n_gen
ymb = floatX(OneHot(np_rng.randint(0, 10, nbatch), ysize))
zmb = sample_z(nbatch, Z_SIZE)
xmb, ot_lYS, ot_G3_1, ot_G3_2, ot_G10, ot_G11, ot_G12 = _gen(zmb, ymb)
xmb = xmb[0:n_left]
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
return np.concatenate(samples, axis=0), np.concatenate(labels, axis=0)
def gen_samples(n, nbatch=128):
samples = []
labels = []
n_gen = 0
for i in range(n / nbatch):
ymb = floatX(OneHot(np_rng.randint(0, 10, nbatch), ny))
zmb = floatX(np_rng.uniform(-1., 1., size=(nbatch, nz)))
xmb, tmp_yb, yb2, d, h3, h5 = _gen(zmb, ymb)
print 'tmp_yb:', tmp_yb.shape
print 'yb2:', yb2.shape
print 'd:', d.shape
print 'h3:', h3.shape
print 'h5:', h5.shape
sys.exit()
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
n_gen += len(xmb)
n_left = n - n_gen
ymb = floatX(OneHot(np_rng.randint(0, 10, n_left), ny))
zmb = floatX(np_rng.uniform(-1., 1., size=(n_left, nz)))
xmb = _gen(zmb, ymb)
samples.append(xmb)
labels.append(np.argmax(ymb, axis=1))
return np.concatenate(samples, axis=0), np.concatenate(labels, axis=0)
def set_lr(epoch):
if epoch < niter: # constant LR
value = lr
else:
if args.linear_decay:
# compute proportion_complete as (k-1)/n so that last epoch (n-1),
# has non-zero learning rate even if args.final_lr_mult == 0, per
# the default for linear decay.
proportion_complete = (epoch - niter) / float(niter_decay)
value = lr + proportion_complete * (final_lr - lr)
else: # exponential decay
proportion_complete = (epoch - niter + 1) / float(niter_decay)
log_value = log_lr + proportion_complete * (log_final_lr - log_lr)
value = np.exp(log_value)
lrt.set_value(floatX(value))
def def_invert(self, model, batch_size=1, d_weight=0.5, nc=1, lr=0.1, b1=0.9, nz=100, use_bin=True):
d_weight_r = sharedX(d_weight)
x_c = T.tensor4()
m_c = T.tensor4()
x_e = T.tensor4()
m_e = T.tensor4()
z0 = T.matrix()
z = sharedX(floatX(np_rng.uniform(-1., 1., size=(batch_size, nz))))
gx = model.model_G(z)
# input: im_c: 255: no edge; 0: edge; transform=> 1: no edge, 0: edge
if nc == 1: # gx, range [0, 1] => edge, 1
gx3 = 1.0 - gx # T.tile(gx, (1, 3, 1, 1))
else:
gx3 = gx
mm_c = T.tile(m_c, (1, gx3.shape[1], 1, 1))
color_all = T.mean(T.sqr(gx3 - x_c) * mm_c, axis=(1, 2, 3)) / (T.mean(m_c, axis=(1, 2, 3)) + sharedX(1e-5))
gx_edge = self.hog.get_hog(gx3)
x_edge = self.hog.get_hog(x_e)
mm_e = T.tile(m_e, (1, gx_edge.shape[1], 1, 1))
sum_e = T.sum(T.abs_(mm_e))
sum_x_edge = T.sum(T.abs_(x_edge))
edge_all = T.mean(T.sqr(x_edge - gx_edge) * mm_e, axis=(1, 2, 3)) / (T.mean(m_e, axis=(1, 2, 3)) + sharedX(1e-5))
rec_all = color_all + edge_all * sharedX(0.2)
z_const = sharedX(5.0)
init_all = T.mean(T.sqr(z0 - z)) * z_const
if d_weight > 0:
print('using D')
p_gen = model.model_D(gx)
real_all = T.nnet.binary_crossentropy(p_gen, T.ones(p_gen.shape)).T
cost_all = rec_all + d_weight_r * real_all[0] + init_all
else:
print('without D')
cost_all = rec_all + init_all
real_all = T.zeros(cost_all.shape)
cost = T.sum(cost_all)
d_updater = updates.Adam(lr=sharedX(lr), b1=sharedX(b1))
output = [gx, cost, cost_all, rec_all, real_all, init_all, sum_e, sum_x_edge]
print('COMPILING...')
t = time()
z_updates = d_updater([z], cost)
_invert = theano.function(inputs=[x_c, m_c, x_e, m_e, z0], outputs=output, updates=z_updates)
print('%.2f seconds to compile _invert function' % (time() - t))
return [_invert, z_updates, z, d_weight_r, z_const]
def def_invert(self, model, batch_size=1, d_weight=0.5, nc=1, lr=0.1, b1=0.9, nz=100, use_bin=True):
d_weight_r = sharedX(d_weight)
x_c = T.tensor4()
m_c = T.tensor4()
x_e = T.tensor4()
m_e = T.tensor4()
z0 = T.matrix()
z = sharedX(floatX(np_rng.uniform(-1., 1., size=(batch_size, nz))))
gx = model.model_G(z)
# input: im_c: 255: no edge; 0: edge; transform=> 1: no edge, 0: edge
if nc == 1: # gx, range [0, 1] => edge, 1
gx3 = 1.0-gx #T.tile(gx, (1, 3, 1, 1))
else:
gx3 = gx
mm_c = T.tile(m_c, (1, gx3.shape[1], 1, 1))
color_all = T.mean(T.sqr(gx3 - x_c) * mm_c, axis=(1, 2, 3)) / (T.mean(m_c, axis=(1, 2, 3)) + sharedX(1e-5))
gx_edge = self.hog.get_hog(gx3)
x_edge = self.hog.get_hog(x_e)
mm_e = T.tile(m_e, (1, gx_edge.shape[1], 1, 1))
sum_e = T.sum(T.abs_(mm_e))
sum_x_edge = T.sum(T.abs_(x_edge))
edge_all = T.mean(T.sqr(x_edge - gx_edge) * mm_e, axis=(1, 2, 3)) / (T.mean(m_e, axis=(1, 2, 3)) + sharedX(1e-5))
rec_all = color_all + edge_all * sharedX(0.2)
z_const = sharedX(5.0)
init_all = T.mean(T.sqr(z0 - z)) * z_const
if d_weight > 0:
print('using D')
p_gen = model.model_D(gx)
real_all = T.nnet.binary_crossentropy(p_gen, T.ones(p_gen.shape)).T
cost_all = rec_all + d_weight_r * real_all[0] + init_all
else:
print('without D')
cost_all = rec_all + init_all
real_all = T.zeros(cost_all.shape)
cost = T.sum(cost_all)
d_updater = updates.Adam(lr=sharedX(lr), b1=sharedX(b1))
output = [gx, cost, cost_all, rec_all, real_all, init_all, sum_e, sum_x_edge]
print('COMPILING...')
t = time()
z_updates = d_updater([z], cost)
_invert = theano.function(inputs=[x_c, m_c, x_e, m_e, z0], outputs=output, updates=z_updates)
print('%.2f seconds to compile _invert function' % (time() - t))
return [_invert, z_updates, z, d_weight_r, z_const]
def tf( X, npx ):
assert X[ 0 ].shape == ( npx, npx, 3 ) or X[ 0 ].shape == ( 3, npx, npx )
#pdb.set_trace()
if X[ 0 ].shape == ( npx, npx, 3 ):
#X = X.transpose( 0, 3, 1, 2 )
#pdb.set_trace()
#color_grid_vis( X[[1],:,:,:], (1,1), os.path.join('3.png'))
#pdb.set_trace()
X = X.astype('float32')
#pdb.set_trace()
X[:,:,:,0] /= 50
X[:,:,:,1] /= 127.5
X[:,:,:,2] /= 127.5
X = X.transpose( 0, 3, 1, 2 )
#pdb.set_trace()
return floatX( X - 1. )
def apply_cond(N, h, cond=None, ksize=1, bn=None, bn_separate=False):
if cond is not None:
stddev = 0.02
if not bn_separate:
stddev *= ksize ** 2
b = multifc(N, cond, nout=h.shape[1], stddev=stddev)
if (bn is not None) and bn_separate:
b = bn(b)
h = bn(h)
h = N.BiasAdd(h, b)
if (bn is not None) and bn_separate:
scale = floatX(1. / np.sqrt(2))
h = N.Scale(h, scale=scale)
if (bn is not None) and ((not bn_separate) or (cond is None)):
h = bn(h)
return h
def infer_bnorm_stats(X, nbatch=128):
U = [np.zeros(128, dtype=theano.config.floatX), np.zeros(256, dtype=theano.config.floatX)]
S = [np.zeros(128, dtype=theano.config.floatX), np.zeros(256, dtype=theano.config.floatX)]
n = 0
for xmb in iter_data(X, size=nbatch):
stats = _bnorm_stats(floatX(xmb))
umb = stats[:2]
smb = stats[2:]
for i, u in enumerate(umb):
U[i] += u
for i, s in enumerate(smb):
S[i] += s
n += 1
U = [u/n for u in U]
S = [s/n for s in S]
return U, S
def infer_bnorm_stats(X, nbatch=128):
U = [np.zeros(128, dtype=theano.config.floatX), np.zeros(256, dtype=theano.config.floatX)]
S = [np.zeros(128, dtype=theano.config.floatX), np.zeros(256, dtype=theano.config.floatX)]
n = 0
for xmb in iter_data(X, size=nbatch):
stats = _bnorm_stats(floatX(xmb))
umb = stats[:2]
smb = stats[2:]
for i, u in enumerate(umb):
U[i] += u
for i, s in enumerate(smb):
S[i] += s
n += 1
U = [u/n for u in U]
S = [s/n for s in S]
return U, S
def __call__(self, params, cost):
updates = []
grads = T.grad(cost, params)
grads = clip_norms(grads, self.clipnorm)
for p, g in zip(params, grads):
g = self.regularizer.gradient_regularize(p, g)
value = p.get_value() * 0.
if p.dtype == theano.config.floatX:
value = floatX(value)
m = theano.shared(value)
v = (self.momentum * m) - (self.lr * g)
updates.append((m, v))
updated_p = p + v
updated_p = self.regularizer.weight_regularize(updated_p)
updates.append((p, updated_p))
return updates
def load_params(self, f_name=None):
'''
Load params from a file saved via self.dump_params.
'''
assert(not (f_name is None))
pickle_file = open(f_name)
# reload the parameter dicts for generator modules
mod_param_dicts = cPickle.load(pickle_file)
for param_dict, mod in zip(mod_param_dicts, self.generator_modules):
mod.load_params(param_dict=param_dict)
# reload the parameter dicts for inferencer modules
mod_param_dicts = cPickle.load(pickle_file)
for param_dict, mod in zip(mod_param_dicts, self.inferencer_modules):
mod.load_params(param_dict=param_dict)
# load dist_scale parameter
ds_ary = cPickle.load(pickle_file)
self.dist_scale.set_value(floatX(ds_ary))
pickle_file.close()
return
def set_lr(epoch, lr=args.learning_rate,
final_lr=args.final_lr_mult*args.learning_rate):
if epoch < niter: # constant LR
value = lr
else:
assert 0 <= final_lr <= lr
if args.linear_decay:
# compute proportion_complete as (k-1)/n so that last epoch (n-1),
# has non-zero learning rate even if args.final_lr_mult == 0, per
# the default for linear decay.
proportion_complete = (epoch-niter) / float(niter_decay)
value = lr + proportion_complete * (final_lr - lr)
else: # exponential decay
assert final_lr > 0, \
'For exponential decay, final LR must be strictly positive (> 0)'
proportion_complete = (epoch-niter+1) / float(niter_decay)
log_value = np.log(lr) + \
proportion_complete * (np.log(final_lr) - np.log(lr))
value = np.exp(log_value)
lrt.set_value(floatX(value))
def generate(z, output_image):
model_class = locate('model_def.dcgan_theano')
model_file = './models/handbag_64.dcgan_theano'
model = model_class.Model(
model_name="handbag_64", model_file=model_file)
samples = []
n = 1
batch_size = 1
z = z.reshape((1, 100))
zmb = floatX(z[0 : n, :])
xmb = model._gen(zmb)
samples.append(xmb)
samples = np.concatenate(samples, axis=0)
samples = model.inverse_transform(samples, npx=model.npx, nc=model.nc)
samples = (samples * 255).astype(np.uint8)
#samples = model.gen_samples(z0=None, n=196, batch_size=49, use_transform=True)
# generate grid visualization
im_vis = utils.grid_vis(samples, 1, 1)
# write to the disk
im_vis = cv2.cvtColor(im_vis, cv2.COLOR_BGR2RGB)
cv2.imwrite(output_image, im_vis)
def gen_samples(self, z0=None, n=32, batch_size=32, use_transform=True):
assert n % batch_size == 0
samples = []
if z0 is None:
z0 = np_rng.uniform(-1., 1., size=(n, self.nz))
else:
n = len(z0)
batch_size = max(n, 64)
n_batches = int(np.ceil(n/float(batch_size)))
for i in range(n_batches):
zmb = floatX(z0[batch_size * i:min(n, batch_size * (i + 1)), :])
xmb = self._gen(zmb)
samples.append(xmb)
samples = np.concatenate(samples, axis=0)
if use_transform:
samples = self.inverse_transform(samples, npx=self.npx, nc=self.nc)
samples = (samples * 255).astype(np.uint8)
return samples
def target_transform(X):
return floatX(X).transpose(0, 3, 1, 2)/127.5 - 1.
def continue_train_model(last_batch_idx,
data_stream,
energy_optimizer,
generator_optimizer,
model_config_dict,
model_test_name):
model_list = glob.glob(samples_dir +'/*.pkl')
# load parameters
model_param_dicts = unpickle(model_list[0])
generator_models = load_generator_model(min_num_gen_filters=model_config_dict['min_num_gen_filters'],
model_params_dict=model_param_dicts)
generator_function = generator_models[0]
generator_params = generator_models[1]
energy_models = load_energy_model(num_experts=model_config_dict['expert_size'],
model_params_dict=model_param_dicts)
feature_function = energy_models[0]
# norm_function = energy_models[1]
expert_function = energy_models[1]
# prior_function = energy_models[3]
energy_params = energy_models[2]
# compile functions
print 'COMPILING MODEL UPDATER'
t=time()
generator_updater, generator_optimizer_params = set_generator_update_function(energy_feature_function=feature_function,
# energy_norm_function=norm_function,
energy_expert_function=expert_function,
# energy_prior_function=prior_function,
generator_function=generator_function,
generator_params=generator_params,
generator_optimizer=generator_optimizer,
init_param_dict=model_param_dicts)
energy_updater, energy_optimizer_params = set_energy_update_function(energy_feature_function=feature_function,
# energy_norm_function=norm_function,
energy_expert_function=expert_function,
# energy_prior_function=prior_function,
generator_function=generator_function,
energy_params=energy_params,
energy_optimizer=energy_optimizer,
init_param_dict=model_param_dicts)
print '%.2f SEC '%(time()-t)
print 'COMPILING SAMPLING FUNCTION'
t=time()
sampling_function = set_sampling_function(generator_function=generator_function)
print '%.2f SEC '%(time()-t)
# set fixed hidden data for sampling
fixed_hidden_data = floatX(np_rng.uniform(low=-model_config_dict['hidden_distribution'],
high=model_config_dict['hidden_distribution'],
size=(model_config_dict['num_display'], model_config_dict['hidden_size'])))
print 'START TRAINING'
# for each epoch
input_energy_list = []
sample_energy_list = []
batch_count = 0
for e in xrange(model_config_dict['epochs']):
# train phase
batch_iters = data_stream.get_epoch_iterator()
# for each batch
for b, batch_data in enumerate(batch_iters):
# batch count up
batch_count += 1
if batch_count<last_batch_idx:
continue
# set update function inputs
input_data = transform(batch_data[0])
num_data = input_data.shape[0]
hidden_data = floatX(np_rng.uniform(low=-model_config_dict['hidden_distribution'],
high=model_config_dict['hidden_distribution'],
size=(num_data, model_config_dict['hidden_size'])))
noise_data = floatX(np_rng.normal(scale=0.01, size=input_data.shape))
update_input = [hidden_data, noise_data]
update_output = generator_updater(*update_input)
entropy_weights = update_output[1].mean()
entropy_cost = update_output[2].mean()
noise_data = floatX(np_rng.normal(scale=0.01, size=input_data.shape))
update_input = [input_data, hidden_data, noise_data]
update_output = energy_updater(*update_input)
input_energy = update_output[0].mean()
sample_energy = update_output[1].mean()
input_energy_list.append(input_energy)
sample_energy_list.append(sample_energy)
if batch_count%10==0:
print '================================================================'
print 'BATCH ITER #{}'.format(batch_count), model_test_name
print '================================================================'
print ' TRAIN RESULTS'
print '================================================================'
print ' input energy : ', input_energy_list[-1]
print '----------------------------------------------------------------'
print ' sample energy : ', sample_energy_list[-1]
print '----------------------------------------------------------------'
print ' entropy weight : ', entropy_weights
print '----------------------------------------------------------------'
print ' entropy cost : ', entropy_cost
print '================================================================'
if batch_count%100==0:
# sample data
sample_data = sampling_function(fixed_hidden_data)[0]
sample_data = np.asarray(sample_data)
save_as = samples_dir + '/' + model_test_name + '_SAMPLES{}.png'.format(batch_count)
color_grid_vis(inverse_transform(sample_data).transpose([0,2,3,1]), (16, 16), save_as)
np.save(file=samples_dir + '/' + model_test_name +'_input_energy',
arr=np.asarray(input_energy_list))
np.save(file=samples_dir + '/' + model_test_name +'_sample_energy',
arr=np.asarray(sample_energy_list))
save_as = samples_dir + '/' + model_test_name + '_MODEL.pkl'
save_model(tensor_params_list=generator_params[0] + generator_params[1] + energy_params + generator_optimizer_params + energy_optimizer_params,
save_to=save_as)
def transform(X):
return floatX(X)/127.5 - 1.
####################
# COMPILE FUNCTION #
####################
print 'COMPILING'
t = time()
_train_g = theano.function([X, N, Z, Temp], cost, updates=g_updates)
_train_d = theano.function([X, N, Z, Temp], cost, updates=d_updates)
_gen = theano.function([Z], gX)
print '%.2f seconds to compile theano functions'%(time()-t)
#####################################
# SAMPLE RANDOM DATA FOR GENERATION #
#####################################
sample_zmb = floatX(np_rng.uniform(-1., 1., size=(nvis, nz)))
###################
# GENERATE SAMPLE #
###################
def gen_samples(n, nbatch=128):
samples = []
n_gen = 0
for i in range(n/nbatch):
zmb = floatX(np_rng.uniform(-1., 1., size=(nbatch, nz)))
xmb = _gen(zmb)
samples.append(xmb)
n_gen += len(xmb)
n_left = n-n_gen
zmb = floatX(np_rng.uniform(-1., 1., size=(n_left, nz)))
xmb = _gen(zmb)
def draw_transform(X):
# transform vectorized observations into drawable greyscale images
X = X * 255.0
return floatX(X.reshape(-1, nc, npx, npx).transpose(0, 2, 3, 1))
def train_transform(X):
# transform vectorized observations into convnet inputs
X = binarize_data(X)
return floatX(X.reshape(-1, nc, npx, npx).transpose(0, 1, 2, 3))
# construct the "wrapper" object for managing all our modules
seq_cond_gen_model = \
DeepSeqCondGenRNN(
td_modules=td_modules,
bu_modules_gen=bu_modules_gen,
im_modules_gen=im_modules_gen,
bu_modules_inf=bu_modules_inf,
im_modules_inf=im_modules_inf,
merge_info=merge_info)
# inf_gen_model.load_params(inf_gen_param_file)
####################################
# Setup the optimization objective #
####################################
lam_kld = sharedX(floatX([1.0]))
c0 = sharedX(floatX(np.zeros((1, nc, npx, npx))))
gen_params = seq_cond_gen_model.gen_params + [c0]
inf_params = seq_cond_gen_model.inf_params
all_params = seq_cond_gen_model.all_params + [c0]
######################################################
# BUILD THE MODEL TRAINING COST AND UPDATE FUNCTIONS #
######################################################
def clip_sigmoid(x):
output = sigmoid(T.clip(x, -15.0, 15.0))
return output
def transform(X):
assert X[0].shape == (npx, npx, 3) or X[0].shape == (3, npx, npx)
if X[0].shape == (npx, npx, 3):
X = X.transpose(0, 3, 1, 2)
return floatX(X / 127.5 - 1.)
# construct the "wrapper" object for managing all our modules
inf_gen_model = CondInfGenModel(
td_modules=td_modules,
bu_modules_gen=bu_modules_gen,
im_modules_gen=im_modules_gen,
bu_modules_inf=bu_modules_inf,
im_modules_inf=im_modules_inf,
merge_info=merge_info,
output_transform=output_noop)
# inf_gen_model.load_params(inf_gen_param_file)
####################################
# Setup the optimization objective #
####################################
lam_kld = sharedX(floatX([1.0]))
X_init = sharedX(floatX(np.zeros((1, nc, npx, npx)))) # default "initial state"
noise = sharedX(floatX([noise_std]))
gen_params = inf_gen_model.gen_params
inf_params = inf_gen_model.inf_params
all_params = inf_gen_model.all_params + [X_init]
######################################################
# BUILD THE MODEL TRAINING COST AND UPDATE FUNCTIONS #
######################################################
# Setup symbolic vars for the model inputs, outputs, and costs
Xg_gen = T.tensor4() # symbolic var for inputs to inference network
Xm_gen = T.tensor4()
Xg_inf = T.tensor4() # symbolic var for inputs to generator network
Xm_inf = T.tensor4()
'n_examples',
'n_seconds',
'1k_va_nnd',
'10k_va_nnd',
'100k_va_nnd',
'g_cost',
'd_cost',
]
tr_data, te_data, tr_stream, val_stream, te_stream = faces(ntrain=ntrain) # Only tr_data/tr_stream are used.
tr_handle = tr_data.open()
vaX, = tr_data.get_data(tr_handle, slice(0, 10000))
vaX = transform(vaX)
vis_idxs = py_rng.sample(np.arange(len(vaX)), nvis)
vaX_vis = inverse_transform(vaX[vis_idxs])
color_grid_vis(vaX_vis, (14, 14), 'samples/%s_etl_test.png'%desc)
sample_zmb = floatX(np_rng.uniform(-1., 1., size=(nvis, nz)))
vaX = vaX.reshape(len(vaX), -1)
# DEFINE NETWORKS.
relu = activations.Rectify()
sigmoid = activations.Sigmoid()
lrelu = activations.LeakyRectify()
tanh = activations.Tanh()
bce = T.nnet.binary_crossentropy
gifn = inits.Normal(scale=0.02)
difn = inits.Normal(scale=0.02)
gain_ifn = inits.Normal(loc=1., scale=0.02)
bias_ifn = inits.Constant(c=0.)
gw = gifn((nz, ngf*8*4*4), 'gw')
gg = gain_ifn((ngf*8*4*4), 'gg')
gb = bias_ifn((ngf*8*4*4), 'gb')
n_updates = 0
n_examples = 0
t = time()
sample_z0mb = rand_gen(size=(200, nz0)) # noise samples for top generator module
for epoch in range(1, niter+niter_decay+1):
Xtr = shuffle(Xtr)
g_cost = 0
d_cost = 0
gc_iter = 0
dc_iter = 0
for imb in tqdm(iter_data(Xtr, size=nbatch), total=ntrain/nbatch):
imb = train_transform(imb)
z0mb = rand_gen(size=(len(imb), nz0))
if n_updates % (k+1) == 0:
g_cost += _train_g(imb, z0mb)[0]
gc_iter += 1
else:
d_cost += _train_d(imb, z0mb)[1]
dc_iter += 1
n_updates += 1
n_examples += len(imb)
print("g_cost: {0:.4f}, d_cost: {1:.4f}".format((g_cost/gc_iter),(d_cost/dc_iter)))
samples = np.asarray(_gen(sample_z0mb))
color_grid_vis(draw_transform(samples), (10, 20), "{}/{}.png".format(sample_dir, n_epochs))
n_epochs += 1
if n_epochs > niter:
lrt.set_value(floatX(lrt.get_value() - lr/niter_decay))
if n_epochs in [1, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 150, 200, 250, 300]:
joblib.dump([p.get_value() for p in gen_params], "{}/{}_gen_params.jl".format(model_dir, n_epochs))
joblib.dump([p.get_value() for p in discrim_params], "{}/{}_discrim_params.jl".format(model_dir, n_epochs))
def rand_gen(size):
#r_vals = floatX(np_rng.uniform(-1., 1., size=size))
r_vals = floatX(np_rng.normal(size=size))
return r_vals
desc = 'dcgan'
model_dir = 'models/%s'%desc
samples_dir = 'samples/%s'%desc
if not os.path.exists('logs/'):
os.makedirs('logs/')
if not os.path.exists(model_dir):
os.makedirs(model_dir)
if not os.path.exists(samples_dir):
os.makedirs(samples_dir)
X_sample = data.get_unlab_batch(0,monitor_size)
X_sample = data.center_crop(X_sample,img_size)
color_grid_vis(X_sample.transpose(0, 2, 3, 1), (14, 14), 'samples/%s_etl_test.png'%desc)
Z_sample = floatX(np_rng.uniform(-1., 1., size=(monitor_size, model.gen_dim)))
print desc.upper()
print "starting training"
with open('errors.log', 'w') as f:
f.write('# iter data_seen epoch dis_loss g_loss')
f.write(' c_loss c_val_err c_test_err\n')
with open('best.log', 'w') as f:
f.write('# iter data_seen epoch c_val_err c_test_err\n')
n_iter = n_epochs*(data.unlab_size/batch_size+1)
best_err = 1e6
