def __init__(self, dataset, n_blocks, final_shape): GAN.__init__(self, dataset, self.LATENT_DIM) self.n_blocks = n_blocks self.final_shape = final_shape # Works only for 3 dimensional images (HxWxC) self.image_size = final_shape[0:2] # Allows for rectangular images self.channels = final_shape[2]
def __init__(self, dataset, n_blocks, start_shape, latent_dim): GAN.__init__(self, dataset, latent_dim) self.start_shape = start_shape self.discriminator_models = Discriminator.define_discriminator(n_blocks, start_shape) self.generator_models = Generator.define_generator(latent_dim, n_blocks, start_shape) self.gan_models = ProGAN._define_composite(self.discriminator_models, self.generator_models) self.constant_latent_vector = ProGAN._generate_latent_points(self.latent_dim, 1)
def __init__(self, name, learning_rate, n_output, noise_dim, discriminator, generator, beta=0.9, gen_kwargs={}, disc_kwargs={}, graph=None): self.noise_dim = noise_dim self.n_output = n_output out_shape = [None] + self.n_output self.discriminator = discriminator self.generator = generator GAN.__init__(self, name, graph) with tf.variable_scope(name): self.noise = tf.placeholder(tf.float32, shape=[None, noise_dim]) # Noise vector. self.real_pc = tf.placeholder(tf.float32, shape=out_shape) # Ground-truth. with tf.variable_scope('generator'): self.generator_out = self.generator(self.noise, self.n_output[0], **gen_kwargs) with tf.variable_scope('discriminator') as scope: self.real_prob, self.real_logit = self.discriminator( self.real_pc, scope=scope, **disc_kwargs) self.synthetic_prob, self.synthetic_logit = self.discriminator( self.generator_out, reuse=True, scope=scope, **disc_kwargs) self.loss_d = tf.reduce_mean(-safe_log(self.real_prob) - safe_log(1 - self.synthetic_prob)) self.loss_g = tf.reduce_mean(-safe_log(self.synthetic_prob)) train_vars = tf.trainable_variables() d_params = [ v for v in train_vars if v.name.startswith(name + '/discriminator/') ] g_params = [ v for v in train_vars if v.name.startswith(name + '/generator/') ] self.opt_d = self.optimizer(learning_rate, beta, self.loss_d, d_params) self.opt_g = self.optimizer(learning_rate, beta, self.loss_g, g_params) self.saver = tf.train.Saver(tf.global_variables(), max_to_keep=None) self.init = tf.global_variables_initializer() # Launch the session config = tf.ConfigProto() config.gpu_options.allow_growth = True self.sess = tf.Session(config=config) self.sess.run(self.init)
def __init__(self, dset_name, imsize, nc, data_root='./data', results_root='./results', noise_dim=100, dout_dim=1, batch_size=64, max_giters=50000, lr=1e-4, clip_disc=False, disc_size=64, gp_lambda=10., ecfd_type='gaussian_ecfd', sigmas=[1.0], num_freqs=8, optimize_sigma=False, disc_net='flexible-dcgan', gen_net='flexible-dcgan'): """Intializer for a CFGANGP model. Arguments: dset_name {str} -- Name of the dataset. imsize {int} -- Size of the image. nc {int} -- Number of channels. Keyword Arguments: data_root {str} -- Directory where datasets are stored (default: {'./data'}). results_root {str} -- Directory where results will be saved (default: {'./results'}). noise_dim {int} -- Dimension of noise input to generator (default: {100}). dout_dim {int} -- Dimension of output from discriminator (default: {1}). batch_size {int} -- Batch size (default: {64}). max_giters {int} -- Maximum number of generator iterations (default: {50000}). lr {[type]} -- Learning rate (default: {1e-4}). clip_disc {bool} -- Whether to clip the parameters of discriminator in [-0.01, 0.01]. This should be True when gradient penalty is not used (default: {True}). disc_size {int} -- Number of filters in the first Conv layer of critic. (default: {64}). gp_lambda {float} -- Trade-off for gradient penalty (default: {10.0}). ecfd_type {str} -- Weighting distribution for ECFD (default: {'gaussian_ecfd'}). sigmas {list} -- A list of sigmas (default: {[1.0]}). num_freqs {int} -- Number of random frequencies for ECFD (default: {8}). optimize_sigma {bool} -- Whether to optimize sigma (default: {False}). disc_net {str} -- Discriminator network type (default: {'flexible-dcgan'}). gen_net {str} -- Generator network type (default: {'flexible-dcgan'}). """ GAN.__init__(self, dset_name, imsize, nc, data_root=data_root, results_root=results_root, noise_dim=noise_dim, dout_dim=dout_dim, batch_size=batch_size, clip_disc=gp_lambda == 0., max_giters=max_giters, lr=lr, disc_size=disc_size, batch_norm=False, gen_net=gen_net, disc_net=disc_net) self.ecfd_fn = getattr(ecfd, ecfd_type) self.optimize_sigma = optimize_sigma self.num_freqs = num_freqs self.reg_lambda = 16.0 cls_name = self.__class__.__name__.lower() if optimize_sigma: cls_name = 'o' + cls_name self.results_root = os.path.join(results_root, dset_name, cls_name) if optimize_sigma: self.lg_sigmas = torch.zeros((1, dout_dim)).cuda() self.lg_sigmas.requires_grad = True self.d_optim = torch.optim.RMSprop( list(self.discriminator.parameters()) + [self.lg_sigmas], lr=lr) self.results_root += '_{:s}'.format(ecfd_type) else: self.sigmas = sigmas self.results_root += '_{:s}_{:s}'.format( ecfd_type, '_'.join(map(str, sigmas))) self.gp_lambda = gp_lambda self.results_root = os.path.join(self.results_root, self.gen_net) self.ensure_dirs()
def __init__(self, *args, **kwargs): GAN.__init__(self, *args, **kwargs)