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 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 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 __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