def build(self, net):
config = self.config
gan = self.gan
ops = self.ops
discriminator = DCGANDiscriminator(gan, config)
discriminator.ops = ops
encoder = UniformDistribution(gan, gan.config.encoder)
# careful, this order matters
g2 = gan.generator.reuse(encoder.create())
double = tf.concat([net] + [g2, g2], axis=0)
original = discriminator.build(double)
d1 = self.split_batch(original, 4)
dg = ops.concat([d1[2], d1[3]], axis=0) # xs for baseline
#dx is a sampling of x twice
dx = ops.concat([d1[0], d1[0]], axis=0) # xs for baseline
xinput = ops.concat([d1[0], d1[1]], axis=0)
#dg is a sampling of g twice
# net is [x,g] (stacked)
error = self.f(xinput, dx, dg)
return error
def test_projection_gaussian(self):
config = {
"projections": ['identity', 'gaussian'],
"z": 2,
"min": 0,
"max": 1
}
subject = UniformDistribution(gan, config)
projections = subject.create()
assert int(projections.get_shape()[1]) == len(config['projections'])*config['z']
def test_projection(self):
config = {
"projections": [hg.distributions.uniform_distribution.identity],
"z": 2,
"min": 0,
"max": 1
}
subject = UniformDistribution(gan, config)
projections = subject.create()
assert subject.ops.shape(projections)[1] == 2
def test_projection_gaussian(self):
config = {
"projections": ['identity', 'gaussian'],
"z": 2,
"min": 0,
"max": 1
}
subject = UniformDistribution(gan, config)
with self.test_session():
projections = subject.create()
self.assertEqual(int(projections.get_shape()[1]), len(config['projections'])*config['z'])
def test_projection(self):
config = {
"projections": [hg.distributions.uniform_distribution.identity],
"z": 2,
"min": 0,
"max": 1
}
subject = UniformDistribution(gan, config)
with self.test_session():
projections = subject.create()
self.assertEqual(subject.ops.shape(projections)[1], 2)
def test_projection_twice(self):
config = {
"projections": ['identity', 'identity'],
"z": 2,
"min": 0,
"max": 1
}
subject = UniformDistribution(gan, config)
with self.test_session():
projections = subject.create()
self.assertEqual(int(projections.get_shape()[1]), len(config['projections'])*config['z'])
def encoder(gan):
config = {
"projections": ['identity', 'identity'],
"z": 2,
"min": 0,
"max": 1
}
return UniformDistribution(gan, config)
def test_config(self):
with self.test_session():
gan = mock_gan(batch_size=32)
gan.latent = UniformDistribution(gan, {'z':2, 'min': -1, 'max': 1, 'projections':['identity']})
gan.latent.create()
gan.create()
sampler = GridSampler(gan)
self.assertEqual(sampler._sample()['generator'].shape[-1], 1)
def ec(zt, cp, reuse=True):
if config.noise:
randt = random_like(cp)
if config.proxy:
dist3 = UniformDistribution(self,
config.z_distribution)
proxy_c = self.create_component(config.proxy_c,
name='rand_ct',
input=dist3.sample,
reuse=reuse)
randt = proxy_c.sample
c = self.create_component(config.ec,
name='ec',
input=zt,
features={
'ct-1': cp,
'n': randt
},
reuse=reuse)
elif config.proxyrand:
c = self.create_component(config.ec,
name='ec',
input=zt,
features={
'ct-1': cp,
'n': random_like(zt)
},
reuse=reuse)
elif config.proxyrand2:
c = self.create_component(config.ec,
name='ec',
input=zt,
features={
'ct-1':
(cp + randt * 0.01),
'n': random_like(zt)
},
reuse=reuse)
else:
c = self.create_component(config.ec,
name='ec',
input=zt,
features={
'ct-1': cp,
'n': tf.zeros_like(zt)
},
reuse=reuse)
if not reuse:
if config.proxy:
self._g_vars += proxy_c.variables()
self._g_vars += c.variables()
self.encoder = c
return c.sample
def random_like(x):
return UniformDistribution(self,
config.z_distribution,
output_shape=self.ops.shape(x)).sample
def create(self):
config = self.config
ops = self.ops
d_losses = []
g_losses = []
def random_like(x):
return UniformDistribution(self,
config.z_distribution,
output_shape=self.ops.shape(x)).sample
with tf.device(self.device):
x_input = tf.identity(self.inputs.x, name='input')
encoder = self.create_encoder(self.inputs.x)
# q(z|x)
if config.u_to_z:
latent = UniformDistribution(self, config.latent)
else:
z_shape = self.ops.shape(encoder.sample)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(config.latent.projections
or [1])
latent = UniformDistribution(self,
config.latent,
output_shape=uz_shape)
self.latent = latent
direction, slider = self.create_controls(
self.ops.shape(latent.sample))
z = latent.sample + slider * direction
#projected_encoder = UniformDistribution(self, config.encoder, z=encoder.sample)
feature_dim = len(ops.shape(z)) - 1
#stack_z = tf.concat([encoder.sample, z], feature_dim)
#stack_encoded = tf.concat([encoder.sample, encoder.sample], feature_dim)
stack_z = z
if config.u_to_z:
if config.style_encoder:
style_encoder = self.create_component(config.style_encoder,
input=x_input,
name='style_encoder')
style = style_encoder.sample
#style_sample = tf.concat(style, axis=0)
style_sample = style
#style_sample=random_like(style_sample)
#x_hat_style = style_sample
x_hat_style = random_like(style_sample)
#style_sample = random_like(x_hat_style)
u_to_z = self.create_component(config.u_to_z,
name='u_to_z',
features=[style_sample],
input=z)
generator = self.create_component(config.generator,
input=u_to_z.sample,
features=[style_sample],
name='generator')
else:
u_to_z = self.create_component(config.u_to_z,
name='u_to_z',
input=z)
generator = self.create_component(config.generator,
input=u_to_z.sample,
name='generator')
stacked = [x_input, generator.sample]
self.generator = generator
self.encoder = encoder
features = [encoder.sample, u_to_z.sample]
self.u_to_z = u_to_z
else:
generator = self.create_component(config.generator,
input=stack_z,
name='generator')
self.generator = generator
stacked = [x_input, generator.sample]
self.encoder = encoder
features = ops.concat([encoder.sample, z], axis=0)
if config.style_encoder:
x_hat = self.create_component(config.generator,
input=encoder.sample,
features=[x_hat_style],
reuse=True,
name='generator').sample
stacked += [x_hat]
features += [encoder.sample]
else:
x_hat = self.create_component(config.generator,
input=encoder.sample,
reuse=True,
name='generator').sample
self.autoencoded_x = x_hat
self.uniform_sample = generator.sample
stacked_xg = tf.concat(stacked, axis=0)
features_zs = tf.concat(features, axis=0)
self.features = features_zs
standard_discriminator = self.create_component(
config.discriminator,
name='discriminator',
input=stacked_xg,
features=[features_zs])
self.discriminator = standard_discriminator
d_vars = standard_discriminator.variables()
g_vars = generator.variables() + encoder.variables()
if config.style_encoder:
g_vars += style_encoder.variables()
if config.u_to_z:
g_vars += u_to_z.variables()
if self.config.manifold_guided:
reencode_u_to_z = self.create_encoder(generator.sample,
reuse=True)
stack_z = [encoder.sample, reencode_u_to_z.sample]
stacked_zs = ops.concat(stack_z, axis=0)
z_discriminator = self.create_component(config.z_discriminator,
name='z_discriminator',
input=stacked_zs)
self.z_discriminator = z_discriminator
d_vars += z_discriminator.variables()
self._g_vars = g_vars
self._d_vars = d_vars
standard_loss = self.create_loss(config.loss,
standard_discriminator, x_input,
generator, len(stacked))
if self.gan.config.infogan:
d_vars += self.gan.infogan_q.variables()
loss1 = ["g_loss", standard_loss.g_loss]
loss2 = ["d_loss", standard_loss.d_loss]
if self.config.manifold_guided:
l2 = self.create_loss(config.loss,
z_discriminator,
x_input,
generator,
len(stack_z),
reuse=True)
d_losses.append(l2.d_loss)
g_losses.append(l2.g_loss)
d_losses.append(standard_loss.d_loss)
g_losses.append(standard_loss.g_loss)
if self.config.autoencode:
l2_loss = self.ops.squash(10 * tf.square(x_hat - x_input))
g_losses = [l2_loss]
d_losses = [l2_loss]
if self.config.vae:
mu, sigma = self.encoder.variational
eps = 1e-8
lam = config.vae_lambda or 0.001
latent_loss = lam * (0.5 * self.ops.squash(
tf.square(mu) - tf.square(sigma) -
tf.log(tf.square(sigma) + eps) - 1, tf.reduce_sum))
g_losses.append(latent_loss)
mu, sigma = u_to_z.variational
latent_loss = lam * (0.5 * self.ops.squash(
tf.square(mu) - tf.square(sigma) -
tf.log(tf.square(sigma) + eps) - 1, tf.reduce_sum))
g_losses.append(latent_loss)
for i, l in enumerate(g_losses):
self.add_metric('gl' + str(i), l)
for i, l in enumerate(d_losses):
self.add_metric('dl' + str(i), l)
loss = hc.Config({
'd_fake': standard_loss.d_fake,
'd_real': standard_loss.d_real,
'sample': [tf.add_n(d_losses),
tf.add_n(g_losses)]
})
self.loss = loss
trainer = self.create_component(config.trainer,
g_vars=g_vars,
d_vars=d_vars)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = generator
self.slider = slider
self.direction = direction
self.z = z
self.z_hat = encoder.sample
self.x_input = x_input
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')
self.random_z = tf.random_uniform(ops.shape(latent.sample),
-1,
1,
name='random_z')
if hasattr(generator, 'mask_generator'):
self.mask_generator = generator.mask_generator
self.mask = mask
self.autoencode_mask = generator.mask_generator.sample
self.autoencode_mask_3_channel = generator.mask
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
x_input = tf.identity(self.inputs.x, name='input')
def random_like(x):
return UniformDistribution(
self,
config.z_distribution,
output_shape=self.ops.shape(x)).sample
# q(z|x)
encoder = self.create_component(config.encoder,
input=x_input,
name='z_encoder')
print("ENCODER ", encoder.sample)
self.encoder = encoder
z_shape = self.ops.shape(encoder.sample)
style = self.create_component(config.style_encoder,
input=x_input,
name='style')
self.style = style
self.styleb = style # hack for sampler
self.random_style = random_like(style.sample)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(
config.z_distribution.projections)
UniformDistribution = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
direction, slider = self.create_controls(
self.ops.shape(UniformDistribution.sample))
z = UniformDistribution.sample + slider * direction
#projected_encoder = UniformDistribution(self, config.encoder, z=encoder.sample)
feature_dim = len(ops.shape(z)) - 1
#stack_z = tf.concat([encoder.sample, z], feature_dim)
#stack_encoded = tf.concat([encoder.sample, encoder.sample], feature_dim)
stack_z = z
generator = self.create_component(config.generator,
input=stack_z,
features=[style.sample])
self.uniform_sample = generator.sample
x_hat = generator.reuse(encoder.sample)
features_zs = ops.concat([encoder.sample, z], axis=0)
stacked_xg = ops.concat([x_input, generator.sample], axis=0)
if config.u_to_z:
u_to_z = self.create_component(config.u_to_z,
name='u_to_z',
input=random_like(z))
gu = generator.reuse(u_to_z.sample)
stacked_xg = ops.concat([x_input, gu], axis=0)
features_zs = ops.concat([encoder.sample, u_to_z.sample],
axis=0)
standard_discriminator = self.create_component(
config.discriminator,
name='discriminator',
input=stacked_xg,
features=[features_zs])
standard_loss = self.create_loss(config.loss,
standard_discriminator, x_input,
generator, 2)
l = standard_loss
d_loss1 = l.d_loss
g_loss1 = l.g_loss
d_vars1 = standard_discriminator.variables()
g_vars1 = generator.variables() + encoder.variables(
) + style.variables()
metrics = {'g_loss': l.g_loss, 'd_loss': l.d_loss}
t0 = random_like(
style.sample
) #tf.concat([random_like(style1), random_like(style1)], axis=1)
t1 = style.sample #tf.concat([style1, style2], axis=1)
stack = [t0, t1]
stacked = ops.concat(stack, axis=0)
features = None
z_d = self.create_component(config.z_discriminator,
name='forcerandom_discriminator',
input=stacked)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=x_input,
generator=generator,
split=2)
metrics["forcerandom_gloss"] = loss3.g_loss
metrics["forcerandom_dloss"] = loss3.d_loss
if config.forcerandom:
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
d_vars1 += z_d.variables()
if config.u_to_z:
g_vars1 += u_to_z.variables()
lossa = hc.Config({
'sample': [d_loss1, g_loss1],
'metrics': metrics
})
trainer = ConsensusTrainer(self,
config.trainer,
loss=lossa,
g_vars=g_vars1,
d_vars=d_vars1)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = generator
self.uniform_distribution = uniform_encoder
self.slider = slider
self.direction = direction
self.z = z
self.z_hat = encoder.sample
self.x_input = x_input
self.autoencoded_x = x_hat
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')
self.random_z = tf.random_uniform(ops.shape(
UniformDistribution.sample),
-1,
1,
name='random_z')
if hasattr(generator, 'mask_generator'):
self.mask_generator = generator.mask_generator
self.mask = mask
self.autoencode_mask = generator.mask_generator.sample
self.autoencode_mask_3_channel = generator.mask
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
#x_input = tf.identity(self.inputs.x, name='input')
xa_input = tf.identity(self.inputs.xa, name='xa_i')
xb_input = tf.identity(self.inputs.xb, name='xb_i')
if config.same_g:
ga = self.create_component(config.generator, input=xb_input, name='a_generator')
gb = self.create_component(config.generator, input=xa_input, name='a_generator', reuse=True)
else:
ga = self.create_component(config.generator, input=xb_input, name='a_generator')
gb = self.create_component(config.generator, input=xa_input, name='b_generator')
za = ga.controls["z"]
zb = gb.controls["z"]
self.uniform_sample = ga.sample
xba = ga.sample
xab = gb.sample
xa_hat = ga.reuse(gb.sample)
xb_hat = gb.reuse(ga.sample)
z_shape = self.ops.shape(za)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(config.z_distribution.projections)
ue = UniformDistribution(self, config.z_distribution, output_shape=uz_shape)
ue2 = UniformDistribution(self, config.z_distribution, output_shape=uz_shape)
ue3 = UniformDistribution(self, config.z_distribution, output_shape=uz_shape)
ue4 = UniformDistribution(self, config.z_distribution, output_shape=uz_shape)
print('ue', ue.sample)
zua = ue.sample
zub = ue2.sample
uga = ga.reuse(tf.zeros_like(xb_input), replace_controls={"z":zua})
ugb = gb.reuse(tf.zeros_like(xa_input), replace_controls={"z":zub})
xa = xa_input
xb = xb_input
t0 = xb
t1 = gb.sample
t2 = ga.sample
f0 = za
f1 = zb
f2 = za
stack = [t0, t1]
stacked = ops.concat(stack, axis=0)
features = ops.concat([f0, f1], axis=0)
d = self.create_component(config.discriminator, name='d_ab', input=stacked, features=[features])
self.za = za
self.discriminator = d
l = self.create_loss(config.loss, d, xa_input, ga.sample, len(stack))
loss1 = l
d_loss1 = l.d_loss
g_loss1 = l.g_loss
d_vars1 = d.variables()
print('--', ga, gb)
d_loss = l.d_loss
g_loss = l.g_loss
metrics = {
'g_loss': l.g_loss,
'd_loss': l.d_loss
}
t0 = xb
t1 = gb.sample
f0 = za
f1 = zb
stack = [t0, t1]
stacked = ops.concat(stack, axis=0)
features = ops.concat([f0, f1], axis=0)
d = self.create_component(config.discriminator, name='d_ab', input=stacked, features=[features], reuse=True)
l = self.create_loss(config.loss, d, xa_input, ga.sample, len(stack))
d_loss += l.d_loss
g_loss += l.g_loss
d_vars2 = d.variables()
metrics["ga_gloss"]=l.g_loss
metrics["ga_dloss"]=l.d_loss
loss2=l
g_loss2 = loss2.g_loss
d_loss2 = loss2.d_loss
trainers = []
if(config.alpha):
t0 = zub
t1 = zb
netzd = tf.concat(axis=0, values=[t0,t1])
z_d = self.create_component(config.z_discriminator, name='z_discriminator', input=netzd)
loss3 = self.create_component(config.loss, discriminator = z_d, x=xa_input, generator=ga, split=2)
d_vars1 += z_d.variables()
metrics["za_gloss"]=loss3.g_loss
metrics["za_dloss"]=loss3.d_loss
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
if(config.ug):
t0 = xb
t1 = ugb
netzd = tf.concat(axis=0, values=[t0,t1])
z_d = self.create_component(config.discriminator, name='ug_discriminator', input=netzd)
loss3 = self.create_component(config.loss, discriminator = z_d, x=xa_input, generator=ga, split=2)
d_vars1 += z_d.variables()
metrics["za_gloss"]=loss3.g_loss
metrics["za_dloss"]=loss3.d_loss
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
if(config.alpha2):
t0 = zua
t1 = za
netzd = tf.concat(axis=0, values=[t0,t1])
z_d = self.create_component(config.z_discriminator, name='z_discriminator2', input=netzd)
loss3 = self.create_component(config.loss, discriminator = z_d, x=xa_input, generator=ga, split=2)
d_vars2 += z_d.variables()
metrics["za_gloss"]=loss3.g_loss
metrics["za_dloss"]=loss3.d_loss
d_loss2 += loss3.d_loss
g_loss2 += loss3.g_loss
if config.ug2:
t0 = xa
t1 = uga
netzd = tf.concat(axis=0, values=[t0,t1])
z_d = self.create_component(config.discriminator, name='ug_discriminator2', input=netzd)
loss3 = self.create_component(config.loss, discriminator = z_d, x=xa_input, generator=ga, split=2)
d_vars2 += z_d.variables()
metrics["za_gloss"]=loss3.g_loss
metrics["za_dloss"]=loss3.d_loss
d_loss2 += loss3.d_loss
g_loss2 += loss3.g_loss
loss = hc.Config({
'd_fake':loss1.d_fake,
'd_real':loss1.d_real,
'sample': [tf.add_n([d_loss1, d_loss2]), tf.add_n([g_loss1,g_loss2])]
})
self._g_vars = ga.variables() + gb.variables()
self._d_vars = d_vars1# + d_vars2
self.loss=loss
trainer = self.create_component(config.trainer)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = ga
self.encoder = gb # this is the other gan
self.uniform_distribution = hc.Config({"sample":zb})#uniform_encoder
self.zb = zb
self.z_hat = gb.sample
self.x_input = xa_input
self.autoencoded_x = xa_hat
self.cyca = xa_hat
self.cycb = xb_hat
self.xba = xba
self.xab = xab
self.uga = uga
self.ugb = ugb
rgb = tf.cast((self.generator.sample+1)*127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb, 0xFF000000, name='generator_int')
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
#x_input = tf.identity(self.inputs.x, name='input')
xa_input = tf.identity(self.inputs.xa, name='xa_i')
xb_input = tf.identity(self.inputs.xb, name='xb_i')
if config.same_g:
ga = self.create_component(config.generator,
input=xb_input,
name='a_generator')
gb = self.create_component(config.generator,
input=xa_input,
name='a_generator',
reuse=True)
elif config.two_g:
ga = self.create_component(config.generator1,
input=xb_input,
name='a_generator')
gb = self.create_component(config.generator2,
input=xa_input,
name='b_generator')
else:
ga = self.create_component(config.generator,
input=xb_input,
name='a_generator')
gb = self.create_component(config.generator,
input=xa_input,
name='b_generator')
za = ga.controls["z"]
zb = gb.controls["z"]
self.uniform_sample = ga.sample
xba = ga.sample
xab = gb.sample
xa_hat = ga.sample
xb_hat = gb.sample
#xa_hat = ga.reuse(gb.sample)
#xb_hat = gb.reuse(ga.sample)
z_shape = self.ops.shape(za)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(config.latent.projections
or [1])
ue = UniformDistribution(self,
config.latent,
output_shape=uz_shape)
ue2 = UniformDistribution(self,
config.latent,
output_shape=uz_shape)
ue3 = UniformDistribution(self,
config.latent,
output_shape=uz_shape)
ue4 = UniformDistribution(self,
config.latent,
output_shape=uz_shape)
print('ue', ue.sample)
zua = ue.sample
zub = ue2.sample
uga = ga.sample #ga.reuse(tf.zeros_like(xb_input), replace_controls={"z":zua})
ugb = gb.sample #gb.reuse(tf.zeros_like(xa_input), replace_controls={"z":zub})
xa = xa_input
xb = xb_input
re_ga = self.create_component(config.generator,
input=gb.sample,
name='a_generator',
reuse=True)
re_gb = self.create_component(config.generator,
input=ga.sample,
name='b_generator',
reuse=True)
re_zb = zb #re_gb.controls['z']
t0 = tf.concat([xb, xb], axis=3)
t1 = tf.concat([gb.sample, gb.sample], axis=3)
zaxis = len(self.ops.shape(za)) - 1
f0 = tf.concat([za, za], axis=zaxis)
f1 = tf.concat([zb, zb], axis=zaxis)
#f0 = tf.concat([zb, za], axis=zaxis)
#f1 = tf.concat([za, zb], axis=zaxis)
stack = [t0, t1]
stacked = ops.concat(stack, axis=0)
features = ops.concat([f0, f1], axis=0)
d = self.create_component(config.discriminator,
name='d_ab',
input=stacked,
features=[features])
self.za = za
self.discriminator = d
l = self.create_loss(config.loss, d, None, None, len(stack))
loss = l
d1_lambda = config.d1_lambda
d2_lambda = config.d2_lambda
d_loss1 = d1_lambda * l.d_loss
g_loss1 = d1_lambda * l.g_loss
d_vars1 = d.variables()
d_loss = l.d_loss
g_loss = l.g_loss
metrics = {'g_loss': l.g_loss, 'd_loss': l.d_loss}
self._g_vars = ga.variables() + gb.variables()
self._d_vars = d_vars1
self.loss = loss
self.generator = gb
trainer = self.create_component(config.trainer)
self.initialize_variables()
self.trainer = trainer
self.latent = hc.Config({'sample': zb})
self.generator = gb
self.encoder = gb # this is the other gan
self.uniform_distribution = hc.Config({"sample": zb}) #uniform_encoder
self.zb = zb
self.z_hat = gb.sample
self.x_input = xa_input
self.autoencoded_x = xa_hat
self.cyca = xa_hat
self.cycb = xb_hat
self.xba = xba
self.xab = xab
self.uga = uga
self.ugb = ugb
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')
def random_t(shape):
shape[-1] //= len(config.z_distribution.projections)
return UniformDistribution(self, config.z_distribution, output_shape=shape).sample
def create(self):
config = self.config
ops = self.ops
d_losses = []
g_losses = []
def random_like(x):
return UniformDistribution(self,
config.z_distribution,
output_shape=self.ops.shape(x)).sample
with tf.device(self.device):
x_input = tf.identity(self.inputs.x, name='input')
# q(z|x)
if config.u_to_z:
UniformDistribution = UniformDistribution(
self, config.z_distribution)
else:
z_shape = self.ops.shape(encoder.sample)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(
config.z_distribution.projections)
UniformDistribution = UniformDistribution(
self, config.z_distribution, output_shape=uz_shape)
self.uniform_distribution = uniform_encoder
direction, slider = self.create_controls(
self.ops.shape(UniformDistribution.sample))
z = UniformDistribution.sample + slider * direction
#projected_encoder = UniformDistribution(self, config.encoder, z=encoder.sample)
feature_dim = len(ops.shape(z)) - 1
#stack_z = tf.concat([encoder.sample, z], feature_dim)
#stack_encoded = tf.concat([encoder.sample, encoder.sample], feature_dim)
stack_z = z
u_to_z = self.create_component(config.u_to_z,
name='u_to_z',
input=z)
generator = self.create_component(config.generator,
input=u_to_z.sample,
name='generator')
stacked = [x_input, generator.sample]
self.generator = generator
encoder = self.create_encoder(self.inputs.x)
self.encoder = encoder
features = [encoder.sample, u_to_z.sample]
reencode_u_to_z = self.create_encoder(generator.sample, reuse=True)
print("GEN SAMPLE", generator.sample, reencode_u_to_z.sample,
u_to_z.sample)
reencode_u_to_z_to_g = self.create_component(
config.generator,
input=reencode_u_to_z.sample,
name='generator',
reuse=True)
stacked += [reencode_u_to_z_to_g.sample]
features += [reencode_u_to_z.sample]
x_hat = self.create_component(config.generator,
input=encoder.sample,
reuse=True,
name='generator').sample
self.uniform_sample = generator.sample
stacked_xg = tf.concat(stacked, axis=0)
features_zs = tf.concat(features, axis=0)
standard_discriminator = self.create_component(
config.discriminator,
name='discriminator',
input=stacked_xg,
features=[features_zs])
self.discriminator = standard_discriminator
d_vars = standard_discriminator.variables()
g_vars = generator.variables() + encoder.variables()
g_vars += u_to_z.variables()
self._g_vars = g_vars
self._d_vars = d_vars
standard_loss = self.create_loss(config.loss,
standard_discriminator, x_input,
generator, len(stacked))
if self.gan.config.infogan:
d_vars += self.gan.infogan_q.variables()
loss1 = ["g_loss", standard_loss.g_loss]
loss2 = ["d_loss", standard_loss.d_loss]
d_losses.append(standard_loss.d_loss)
g_losses.append(standard_loss.g_loss)
if self.config.autoencode:
l2_loss = self.ops.squash(10 * tf.square(x_hat - x_input))
g_losses = [l2_loss]
d_losses = [l2_loss]
for i, l in enumerate(g_losses):
self.add_metric('gl' + str(i), l)
for i, l in enumerate(d_losses):
self.add_metric('dl' + str(i), l)
loss = hc.Config({
'd_fake': standard_loss.d_fake,
'd_real': standard_loss.d_real,
'sample': [tf.add_n(d_losses),
tf.add_n(g_losses)]
})
self.loss = loss
self.uniform_distribution = uniform_encoder
trainer = self.create_component(config.trainer,
loss=loss,
g_vars=g_vars,
d_vars=d_vars)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = generator
self.slider = slider
self.direction = direction
self.z = z
self.z_hat = encoder.sample
self.x_input = x_input
self.autoencoded_x = x_hat
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')
self.random_z = tf.random_uniform(ops.shape(
UniformDistribution.sample),
-1,
1,
name='random_z')
if hasattr(generator, 'mask_generator'):
self.mask_generator = generator.mask_generator
self.mask = mask
self.autoencode_mask = generator.mask_generator.sample
self.autoencode_mask_3_channel = generator.mask
def create(self):
config = self.config
ops = self.ops
d_losses = []
g_losses = []
encoder = self.create_encoder(self.inputs.x)
with tf.device(self.device):
x_input = tf.identity(self.inputs.x, name='input')
if config.u_to_z:
latent = UniformDistribution(self, config.latent)
else:
z_shape = self.ops.shape(encoder.sample)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(config.latent.projections)
latent = UniformDistribution(self,
config.latent,
output_shape=uz_shape)
self.uniform_distribution = latent
self.latent = latent
direction, slider = self.create_controls(
self.ops.shape(latent.sample))
z = latent.sample + slider * direction
u_to_z = self.create_component(config.u_to_z,
name='u_to_z',
input=z)
generator = self.create_component(config.generator,
input=u_to_z.sample,
name='generator')
stacked = [x_input, generator.sample]
self.generator = generator
self.encoder = encoder
features = [encoder.sample, u_to_z.sample]
reencode_u_to_z = self.create_encoder(generator.sample, reuse=True)
reencode_u_to_z_to_g = self.create_component(
config.generator,
input=reencode_u_to_z.sample,
name='generator',
reuse=True)
self.reencode_g = reencode_u_to_z_to_g
x_hat = self.create_component(config.generator,
input=encoder.sample,
reuse=True,
name='generator').sample
reencode_x_hat_to_z = self.create_encoder(x_hat, reuse=True)
self.uniform_sample = generator.sample
d_vars = []
g_vars = generator.variables() + encoder.variables()
g_vars += u_to_z.variables()
def ali(*stack, reuse=False):
xs = [t for t, _ in stack]
zs = [t for _, t in stack]
xs = tf.concat(xs, axis=0)
zs = tf.concat(zs, axis=0)
discriminator = self.create_component(config.discriminator,
name='discriminator',
input=xs,
features=[zs],
reuse=reuse)
loss = self.create_loss(config.loss, discriminator, None, None,
len(stack))
return loss, discriminator
def d(name, stack):
if name is None:
name = config
stacked = tf.concat(stack, axis=0)
discriminator = self.create_component(config[name],
name=name,
input=stacked)
loss = self.create_loss(config.loss, discriminator, None, None,
len(stack))
return loss, discriminator
l1, d1 = ali([self.inputs.x, encoder.sample],
[generator.sample, u_to_z.sample],
[reencode_u_to_z_to_g.sample, reencode_u_to_z.sample])
l2, d2 = ali(
[self.inputs.x, tf.zeros_like(encoder.sample)],
[generator.sample,
tf.zeros_like(u_to_z.sample)], [
reencode_u_to_z_to_g.sample,
tf.zeros_like(reencode_u_to_z.sample)
],
reuse=True)
l3, d3 = ali([tf.zeros_like(self.inputs.x), encoder.sample],
[tf.zeros_like(generator.sample), u_to_z.sample], [
tf.zeros_like(reencode_u_to_z_to_g.sample),
reencode_u_to_z.sample
],
reuse=True)
if config.alternate:
d_losses = [
beta * (l1.d_loss - l2.d_loss - l3.d_loss) + l2.d_loss +
2 * l3.d_loss
]
g_losses = [
beta * (l1.g_loss - l2.g_loss - l3.g_loss) + l2.g_loss +
2 * l3.g_loss
]
if config.mutual_only:
d_losses = [2 * l1.d_loss - l2.d_loss - l3.d_loss]
g_losses = [2 * l1.g_loss - l2.g_loss - l3.g_loss]
else:
l4, d4 = d('x_discriminator', [
self.inputs.x, generator.sample,
reencode_u_to_z_to_g.sample
])
l5, d5 = d(
'z_discriminator',
[encoder.sample, u_to_z.sample, reencode_u_to_z.sample])
beta = config.beta or 0.9
d_losses = [
beta * (l1.d_loss - l2.d_loss - l3.d_loss) + l4.d_loss +
2 * l5.d_loss
]
g_losses = [
beta * (l1.g_loss - l2.g_loss - l3.g_loss) + l4.g_loss +
2 * l5.g_loss
]
self.discriminator = d1
self.loss = l1
self.add_metric("ld", d_losses[0])
self.add_metric("lg", g_losses[0])
if config.mutual_only or config.alternate:
for d in [d1]:
d_vars += d.variables()
else:
for d in [d1, d4, d5]:
d_vars += d.variables()
self._g_vars = g_vars
self._d_vars = d_vars
loss = hc.Config({
'd_fake': l1.d_fake,
'd_real': l1.d_real,
'sample': [tf.add_n(d_losses),
tf.add_n(g_losses)]
})
self.loss = loss
self.uniform_distribution = latent
trainer = self.create_component(config.trainer,
g_vars=g_vars,
d_vars=d_vars)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = generator
self.slider = slider
self.direction = direction
self.z = z
self.z_hat = encoder.sample
self.x_input = x_input
self.autoencoded_x = x_hat
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')
self.random_z = tf.random_uniform(ops.shape(latent.sample),
-1,
1,
name='random_z')
if hasattr(generator, 'mask_generator'):
self.mask_generator = generator.mask_generator
self.mask = mask
self.autoencode_mask = generator.mask_generator.sample
self.autoencode_mask_3_channel = generator.mask
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
#x_input = tf.identity(self.inputs.x, name='input')
xa_input = tf.identity(self.inputs.xa, name='xa_i')
xb_input = tf.identity(self.inputs.xb, name='xb_i')
ga = self.create_component(config.generator,
input=xb_input,
name='a_generator')
gb = self.create_component(config.generator,
input=xa_input,
name='b_generator')
za = ga.controls["z"]
zb = gb.controls["z"]
self.uniform_sample = ga.sample
xba = ga.sample
xab = gb.sample
xa_hat = ga.reuse(gb.sample)
xb_hat = gb.reuse(ga.sample)
z_shape = self.ops.shape(za)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(
config.z_distribution.projections)
ue = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
features_a = ops.concat([ga.sample, xa_input], axis=0)
features_b = ops.concat([gb.sample, xb_input], axis=0)
stacked_a = ops.concat([xa_input, ga.sample], axis=0)
stacked_b = ops.concat([xb_input, gb.sample], axis=0)
stacked_z = ops.concat([ue.sample, za, zb], axis=0)
da = self.create_component(config.discriminator,
name='a_discriminator',
input=stacked_a,
features=[features_b])
db = self.create_component(config.discriminator,
name='b_discriminator',
input=stacked_b,
features=[features_a])
dz = self.create_component(config.z_discriminator,
name='z_discriminator',
input=stacked_z)
if config.ali_z:
features_alia = ops.concat([za, ue.sample], axis=0)
features_alib = ops.concat([zb, ue.sample], axis=0)
uga = ga.reuse(tf.zeros_like(xb_input),
replace_controls={"z": ue.sample})
ugb = gb.reuse(tf.zeros_like(xa_input),
replace_controls={"z": ue.sample})
stacked_alia = ops.concat([xa_input, uga], axis=0)
stacked_alib = ops.concat([xb_input, ugb], axis=0)
dalia = self.create_component(config.ali_discriminator,
name='alia_discriminator',
input=stacked_alia,
features=[features_alib])
dalib = self.create_component(config.ali_discriminator,
name='alib_discriminator',
input=stacked_alib,
features=[features_alia])
lalia = self.create_loss(config.loss, dalia, None, None, 2)
lalib = self.create_loss(config.loss, dalib, None, None, 2)
la = self.create_loss(config.loss, da, xa_input, ga.sample, 2)
lb = self.create_loss(config.loss, db, xb_input, gb.sample, 2)
lz = self.create_loss(config.loss, dz, None, None, 3)
d_vars = da.variables() + db.variables() + lz.variables()
if config.ali_z:
d_vars += dalia.variables() + dalib.variables()
g_vars = ga.variables() + gb.variables()
d_loss = la.d_loss + lb.d_loss + lz.d_loss
g_loss = la.g_loss + lb.g_loss + lz.g_loss
metrics = {
'ga_loss': la.g_loss,
'gb_loss': lb.g_loss,
'gz_loss': lz.g_loss,
'da_loss': la.d_loss,
'db_loss': lb.d_loss,
'dz_loss': lz.d_loss
}
if config.ali_z:
d_loss += lalib.d_loss + lalia.d_loss
g_loss += lalib.g_loss + lalia.g_loss
metrics['galia_loss'] = lalia.g_loss
metrics['galib_loss'] = lalib.g_loss
metrics['dalia_loss'] = lalia.d_loss
metrics['dalib_loss'] = lalib.d_loss
loss = hc.Config({'sample': [d_loss, g_loss], 'metrics': metrics})
trainer = ConsensusTrainer(self,
config.trainer,
loss=loss,
g_vars=g_vars,
d_vars=d_vars)
self.initialize_variables()
self.trainer = trainer
self.generator = ga
self.encoder = gb # this is the other gan
self.uniform_distribution = hc.Config({"sample": za}) #uniform_encoder
self.zb = zb
self.z_hat = gb.sample
self.x_input = xa_input
self.autoencoded_x = xa_hat
self.cyca = xa_hat
self.cycb = xb_hat
self.xba = xba
self.xab = xab
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
x_input = tf.identity(self.inputs.x, name='input')
encoder = self.create_encoder(x_input)
self.encoder = encoder
z_shape = self.ops.shape(encoder.sample)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(config.encoder.projections)
UniformDistribution = UniformDistribution(self, config.encoder, output_shape=uz_shape)
direction, slider = self.create_controls(self.ops.shape(UniformDistribution.sample))
z = UniformDistribution.sample + slider * direction
#projected_encoder = UniformDistribution(self, config.encoder, z=encoder.sample)
z_discriminator = self.create_z_discriminator(UniformDistribution.sample, encoder.sample)
feature_dim = len(ops.shape(z))-1
#stack_z = tf.concat([encoder.sample, z], feature_dim)
#stack_encoded = tf.concat([encoder.sample, encoder.sample], feature_dim)
stack_z = z
generator = self.create_component(config.generator, input=stack_z)
self.uniform_sample = generator.sample
x_hat = generator.reuse(encoder.sample)
if hasattr(generator, 'mask_single_channel'):
mask = generator.mask_single_channel
encoder_loss = self.create_loss(config.eloss or config.loss, z_discriminator, z, encoder, 2)
if config.segments_included:
newsample = generator.reuse(stack_z, mask=generator.mask_single_channel)
# stacked = [x_input, generator.sample, newsample, x_hat]
stacked = [x_input, newsample, generator.sample, x_hat, generator.g1x, generator.g2x, generator.g3x]
#stacked = [x_input, g1x, g2x, newsample, generator.sample, x_hat]
#stacked = [x_input, newsample, generator.sample, x_hat]
elif config.simple_d:
stacked = [x_input, self.uniform_sample]
else:
stacked = [x_input, self.uniform_sample, x_hat]
stacked_xg = ops.concat(stacked, axis=0)
standard_discriminator = self.create_component(config.discriminator, name='discriminator', input=stacked_xg)
standard_loss = self.create_loss(config.loss, standard_discriminator, x_input, generator, len(stacked))
#loss terms
cycloss = self.create_cycloss(x_input, x_hat)
z_cycloss = self.create_z_cycloss(UniformDistribution.sample, encoder.sample, encoder, generator)
#first_pixel = tf.slice(generator.mask_single_channel, [0,0,0,0], [-1,1,1,-1]) + 1 # we want to minimize range -1 to 1
#cycloss += tf.reduce_sum(tf.reshape(first_pixel, [-1]), axis=0)
if hasattr(generator, 'mask'): #TODO only segment
cycloss_whitening_lambda = config.cycloss_whitening_lambda or 0.01
cycloss += tf.reduce_mean(tf.reshape(0.5-tf.abs(generator.mask-0.5), [-1]), axis=0) * cycloss_whitening_lambda
#if hasattr(generator, 'mask'): # TODO only multisegment
# cycloss_single_channel_lambda = config.cycloss_single_channel_lambda or 0.01
# m = tf.reduce_sum(generator.mask, 3)
# cycloss += tf.reduce_mean(tf.reshape(tf.abs(1.0-m)/ops.shape(generator.mask)[3], [-1]), axis=0) * cycloss_single_channel_lambda
if hasattr(generator, 'mask'): # TODO only multisegment
# cycloss_single_channel_lambda = config.cycloss_single_channel_lambda or 0.01
m = tf.reduce_mean(generator.mask, 1, keep_dims=True)
m = tf.reduce_mean(m, 2, keep_dims=True)
c = 0.1
cycloss += (c - tf.minimum(tf.reduce_min(m, 3, keep_dims=True), c))
# cycloss += tf.reduce_mean(tf.reshape(tf.abs(1.0-m)/ops.shape(generator.mask)[3], [-1]), axis=0) * cycloss_single_channel_lambda
trainer = self.create_trainer(cycloss, z_cycloss, encoder, generator, encoder_loss, standard_loss, standard_discriminator, z_discriminator)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = generator
self.uniform_distribution = uniform_encoder
self.slider = slider
self.direction = direction
self.z = z
self.z_hat = encoder.sample
self.x_input = x_input
self.autoencoded_x = x_hat
rgb = tf.cast((self.generator.sample+1)*127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb, 0xFF000000, name='generator_int')
self.random_z = tf.random_uniform(ops.shape(UniformDistribution.sample), -1, 1, name='random_z')
if hasattr(generator, 'mask_generator'):
self.mask_generator = generator.mask_generator
self.mask = mask
self.autoencode_mask = generator.mask_generator.sample
self.autoencode_mask_3_channel = generator.mask
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
#x_input = tf.identity(self.inputs.x, name='input')
xa_input = tf.identity(self.inputs.xa, name='xa_i')
xb_input = tf.identity(self.inputs.xb, name='xb_i')
ue = UniformDistribution(self, config.latent)
ue2 = UniformDistribution(self, config.latent)
ue3 = UniformDistribution(self, config.latent)
ue4 = UniformDistribution(self, config.latent)
if config.same_g:
gb = self.create_component(config.generator,
input=ue3.sample,
name='a_generator')
gb = self.create_component(config.generator,
input=ue4.sample,
name='a_generator',
reuse=True)
else:
def _append_xa(gan, config, net):
_x = gan.inputs.xa
s = [int(x) for x in net.get_shape()]
shape = [s[1], s[2]]
_x = tf.image.resize_images(_x, shape, 1)
return _x
def _append_xb(gan, config, net):
_x = gan.inputs.xb
s = [int(x) for x in net.get_shape()]
shape = [s[1], s[2]]
_x = tf.image.resize_images(_x, shape, 1)
return _x
#config.generator['layer_filter'] = _append_xb
#gb = self.create_component(config.generator, input=ue3.sample, name='a_generator')
config.generator['layer_filter'] = _append_xa
gb = self.create_component(config.generator,
input=ue4.sample,
name='b_generator')
za = gb.controls["z"]
zb = gb.controls["z"]
self.uniform_sample = gb.sample
zua = ue.sample
zub = ue2.sample
xa = xa_input
xb = xb_input
t0 = tf.concat([xb, xb], axis=3)
t1 = tf.concat([gb.sample, xb], axis=3)
t0 = xb
t1 = gb.sample
f0 = za
f1 = zb
f2 = zub
stack = [t0, t1]
stacked = ops.concat(stack, axis=0)
features = ops.concat([f0, f1], axis=0)
config.discriminator['layer_filter'] = _append_xa
d = self.create_component(config.discriminator,
name='d_ab',
input=stacked)
self.za = za
self.discriminator = d
l = self.create_loss(config.loss, d, xb_input, gb.sample,
len(stack))
loss1 = l
d1_lambda = config.d1_lambda
d2_lambda = config.d2_lambda
d_loss1 = d1_lambda * l.d_loss
g_loss1 = d1_lambda * l.g_loss
d_vars1 = d.variables()
d_loss = l.d_loss
g_loss = l.g_loss
metrics = {'g_loss': l.g_loss, 'd_loss': l.d_loss}
if d2_lambda > -1:
t0 = xa
t1 = gb.sample
f0 = zb
f1 = za
stack = [t0, t1]
stacked = ops.concat(stack, axis=0)
features = ops.concat([f0, f1], axis=0)
config.discriminator['layer_filter'] = _append_xa
d = self.create_component(config.discriminator,
name='d2_ab',
input=stacked,
features=[features])
self.discriminator2 = d
l = self.create_loss(config.loss, d, xb_input, gb.sample,
len(stack))
d_vars2 = d.variables()
metrics["gb_gloss"] = l.g_loss
metrics["gb_dloss"] = l.d_loss
loss2 = l
g_loss2 = d2_lambda * loss2.g_loss
d_loss2 = d2_lambda * loss2.d_loss
else:
d_loss2 = 0.0
g_loss2 = 0.0
d_vars2 = []
if (config.alpha):
t0 = zub
t1 = zb
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.z_discriminator,
name='z_discriminator',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=gb,
split=2)
d_vars1 += z_d.variables()
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
if (config.ug):
t0 = xb
t1 = ugb
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.discriminator,
name='ug_discriminator',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=gb,
split=2)
d_vars1 += z_d.variables()
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
if (config.alpha2):
t0 = zua
t1 = za
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.z_discriminator,
name='z_discriminator2',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=gb,
split=2)
d_vars2 += z_d.variables()
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_loss2 += loss3.d_loss
g_loss2 += loss3.g_loss
if config.ug2:
t0 = xa
t1 = ugb
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.discriminator,
name='ug_discriminator2',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=gb,
split=2)
d_vars2 += z_d.variables()
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_loss2 += loss3.d_loss
g_loss2 += loss3.g_loss
loss = hc.Config({
'd_fake':
loss1.d_fake,
'd_real':
loss1.d_real,
'sample':
[tf.add_n([d_loss1, d_loss2]),
tf.add_n([g_loss1, g_loss2])]
})
self._g_vars = gb.variables() + gb.variables()
self._d_vars = d_vars1 + d_vars2
self.loss = loss
self.generator = gb
trainer = self.create_component(config.trainer)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.latent = hc.Config({'sample': zb})
self.generator = gb
self.encoder = gb # this is the other gan
self.uniform_distribution = hc.Config({"sample": zb}) #uniform_encoder
self.zb = zb
self.z_hat = gb.sample
self.x_input = xa_input
self.uga = gb.sample
self.ugb = gb.sample
self.cyca = gb.sample
self.cycb = gb.sample
self.xba = gb.sample
self.xab = gb.sample
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')
def create(self):
config = self.config
ops = self.ops
self._g_vars = []
d_vars = []
with tf.device(self.device):
def random_t(shape):
shape[-1] //= len(config.z_distribution.projections)
return UniformDistribution(self, config.z_distribution, output_shape=shape).sample
def random_like(x):
shape = self.ops.shape(x)
return random_t(shape)
self.frame_count = len(self.inputs.frames)
self.frames = self.inputs.frames
dist = UniformDistribution(self, config.z_distribution)
dist2 = UniformDistribution(self, config.z_distribution)
dist3 = UniformDistribution(self, config.z_distribution)
dist4 = UniformDistribution(self, config.z_distribution)
dist5 = UniformDistribution(self, config.z_distribution)
uz = self.create_component(config.uz, name='u_to_z', input=dist.sample)
uc = self.create_component(config.uc, name='u_to_c', input=dist2.sample)
uz2 = self.create_component(config.uz, name='u_to_z', input=dist3.sample, reuse=True)
uc2 = self.create_component(config.uc, name='u_to_c', input=dist4.sample, reuse=True)
uc3 = self.create_component(config.uc, name='u_to_c', input=dist5.sample, reuse=True)
self._g_vars += uz.variables()
self._g_vars += uc.variables()
def ec(zt, cp,reuse=True):
if config.noise:
randt = random_like(cp)
if config.proxy:
dist3 = UniformDistribution(self, config.z_distribution)
proxy_c = self.create_component(config.proxy_c, name='rand_ct', input=dist3.sample, reuse=reuse)
randt = proxy_c.sample
c = self.create_component(config.ec, name='ec', input=zt, features={'ct-1':cp, 'n':randt}, reuse=reuse)
elif config.proxyrand:
c = self.create_component(config.ec, name='ec', input=zt, features={'ct-1':cp, 'n':random_like(zt)}, reuse=reuse)
elif config.proxyrand2:
c = self.create_component(config.ec, name='ec', input=zt, features={'ct-1':(cp+randt*0.01), 'n':random_like(zt) }, reuse=reuse)
else:
c = self.create_component(config.ec, name='ec', input=zt, features={'ct-1':cp, 'n':tf.zeros_like(zt)}, reuse=reuse)
if not reuse:
if config.proxy:
self._g_vars += proxy_c.variables()
self._g_vars += c.variables()
self.encoder = c
return c.sample
def ez(ft, zp,reuse=True):
z = self.create_component(config.ez, name='ez', input=ft, features=[zp], reuse=reuse)
if not reuse:
self._g_vars += z.variables()
return z.sample
def build_g(zt, ct, reuse=True):
print("Gb", reuse,zt,ct)
g = self.create_component(config.generator, name='generator', input=ct, features=[zt], reuse=reuse)
if not reuse:
self._g_vars += g.variables()
return g.sample
def encode_frames(fs, c0, z0, reuse=True):
cs = [c0]
zs = [z0]
x_hats = [build_g(zs[-1], cs[-1], reuse=reuse)]
for i in range(len(fs)):
print("encode frames", i)
_reuse = reuse or (i!=0)
z = ez(fs[i], zs[-1], reuse=_reuse)
c = ec(z, cs[-1], reuse=_reuse)
x_hat = build_g(z, c, reuse=True)
zs.append(z)
cs.append(c)
x_hats.append(x_hat)
return cs, zs, x_hats
def build_sim(z0, c0, steps, reuse=True):
zs = [z0]
cs = [c0]
gs = [build_g(zs[-1], cs[-1], reuse=reuse)]
for i in range(steps):
_reuse = reuse or (i!=0)
z = ez(gs[-1], zs[-1], reuse=_reuse)
c = ec(z, cs[-1], reuse=_reuse)
g = build_g(z, c, reuse=True)
zs.append(z)
cs.append(c)
gs.append(g)
return gs, cs, zs
def rotate(first, second, offset=None):
rotations = [tf.concat(first[:offset], axis=axis)]
elem = first
for e in second:
elem = elem[1:]+[e]
rotations.append(tf.concat(elem[:offset], axis=axis))
return rotations
def disc(metric, name, _inputs, _features, reuse=False):
_is = tf.concat(_inputs,axis=0)
_fs = tf.concat(_features,axis=0)
disc = self.create_component(config[name], name=name, input=_is, features=[_fs], reuse=reuse)
l2 = self.create_loss(config.loss, disc, None, None, len(_inputs))
self.add_metric(metric, l2.d_loss)
self.add_metric(metric, l2.g_loss)
return l2, disc.variables(), disc
def mi(metric, name, _inputs, _features):
_inputsb = [tf.zeros_like(x) for x in _inputs]
_featuresb = [tf.zeros_like(x) for x in _features]
beta = config.bottleneck_beta or 1
ib_2_c = config.ib_2_c or 1
inputs = tf.concat(_inputs, axis=0)
features = tf.concat(_features, axis=0)
gl,dl,d_vars,_ = disc(metric+'1', name, _inputs, _features)
gl2,dl2, _,_ = disc(metric+'2', name, _inputs, _features, reuse=True)
gl3,dl3, _,_ = disc(metric+'3', name, _inputs, _features, reuse=True)
dls = ib_2_c * beta *tf.add_n([dl,-dl2,-dl3])
gls = ib_2_c * beta *tf.add_n([gl,-gl2,-gl3])
return gls, dls, d_vars
#self.frames = [f+tf.random_uniform(self.ops.shape(f), minval=-0.1, maxval=0.1) for f in self.frames ]
#cs, zs, x_hats = encode_frames(self.frames, tf.zeros_like(uc2.sample), tf.zeros_like(uz2.sample), reuse=False)
if config.randd:
cs, zs, x_hats = encode_frames(self.frames, uc2.sample, tf.zeros_like(uz2.sample), reuse=False)
elif config.zerod:
cs, zs, x_hats = encode_frames(self.frames, tf.zeros_like(uc2.sample), tf.zeros_like(uz2.sample), reuse=False)
else:
cs, zs, x_hats = encode_frames(self.frames, uc2.sample, uz2.sample, reuse=False)
extra_frames = config.extra_frames or 2
self.zs = zs
self.cs = cs
if config.zerod:
ugs, ucs, uzs = build_sim(uz.sample, uc.sample, len(self.frames))
else:
ugs, ucs, uzs = build_sim(uz.sample, uc.sample, len(self.frames))
alt_gs, alt_cs, alt_zs = build_sim(zs[1], cs[1], len(self.frames))
self.ucs = ucs
self.alt_cs = alt_cs
self.alt_zs = alt_zs
ugs_next, ucs_next, uzs_next = build_sim(uzs[-1], ucs[-1], len(self.frames))
re_ucs_next, re_uzs_next, re_ugs_next = encode_frames(ugs_next[1:len(self.frames)], ucs_next[0], uzs_next[0])
gs_next, cs_next, zs_next = build_sim(zs[-1], cs[-1], len(self.frames)+extra_frames)
re_ucs, re_uzs, ugs_hat = encode_frames(ugs[1:len(self.frames)], ucs[0], uzs[0])
re_cs, re_zs, re_ugs = encode_frames(x_hats[1:len(self.frames)], cs[0], zs[0])
re_cs_next, re_zs_next, re_gs_next = encode_frames(gs_next[1:len(self.frames)], cs_next[0], zs_next[0])
self.x_hats = x_hats
axis = len(ops.shape(zs[1]))-1
t0 = tf.concat(zs[1:-1], axis=axis)
t1 = tf.concat(uzs[1:-1], axis=axis)
t2 = tf.concat(zs_next[1:len(cs)-1], axis=axis)
if config.manifold_guided:
t1 = tf.concat(re_uzs[1:], axis=axis)
t2 = tf.concat(re_zs_next[1:len(cs)-1], axis=axis)
t3 = re_uzs_next#tf.concat(re_ucs_next, axis=axis)
t0 = tf.concat(self.frames[1:], axis=axis)
f0 = tf.concat(cs[1:-1], axis=axis)
self.x0 = t0
stack = [t0]
features = [f0]
if config.encode_x_hat:
#stack += rotate(ugs[:-2], ugs[-2:]+ugs_next)
#features += rotate(ucs[:-2], ucs[-2:]+ucs_next)
stack += [tf.concat(x_hats[2:], axis=axis)]
features += [tf.concat(cs[1:-1], axis=axis)]
if config.encode_alternate_path:
#stack += rotate(ugs[:-2], ugs[-2:]+ugs_next)
#features += rotate(ucs[:-2], ucs[-2:]+ucs_next)
stack.append(tf.concat([self.frames[1]]+alt_gs[1:-2], axis=axis))
features.append(tf.concat(alt_cs[:-2], axis=axis))
if config.encode_ug:
#stack += rotate(ugs[:-2], ugs[-2:]+ugs_next)
#features += rotate(ucs[:-2], ucs[-2:]+ucs_next)
self.g0 = tf.concat(ugs[1:-1], axis=axis)
self.c0 = tf.concat(ucs[1:-1], axis=axis)
stack.append(self.g0)
features.append(self.c0)
if config.encode_re_ug:
stack.append(tf.concat(re_ugs[1:], axis=axis))
features.append(tf.concat(re_ucs[1:], axis=axis))
if config.encode_forward:
stack += rotate(self.frames[2:]+[gs_next[0]], gs_next[1:])
features += rotate(cs[2:], cs_next[1:])
#print("GS", gs_next, features)
#stack += rotate(gs_next[:-4], gs_next[-4:])
#features += rotate(cs_next[:-4], cs_next[-4:])
#if config.encode_forward_next:
# stack += [tf.concat(gs_next[:-4],axis=axis)]
# features += [tf.concat(cs_next[:-4],axis=axis)]
#d = self.create_component(config.z_discriminator, name='d_img', input=tf.concat(features, axis=0), features=[None])
#_d = d
#d_vars += d.variables()
#l = self.create_loss(config.loss, d, None, None, len(stack))
#Ic =0.1
#d_loss = 2*l.d_loss
#g_loss = 2*l.g_loss
self.video_generator_last_z = uzs[0]
self.video_generator_last_c = ucs[0]
self.gs_next = gs_next
ztn = uzs[1]
ctn = ucs[1]
self.video_generator_last_zn = ztn
self.video_generator_last_cn = ctn
self.c_drift = self.ops.squash(tf.abs(ucs[1]-ucs[0]))
gen = hc.Config({"sample":ugs[0]})
#_stacked = ops.concat(stack, axis=0)
#d = self.create_component(config.discriminator, name='d_manifold', input=_stacked, features=[None])
#d_vars += d.variables()
#l = self.create_loss(config.loss, d, None, None, len(stack))
#d_loss += l.d_loss
#g_loss += l.g_loss
#gl, dl, dvs = mi('mi', 'b_discriminator2', stack, features)
#g_loss += gl
#d_loss += dl
#d_vars += dvs
l,dvs,disc = disc('m1', 'discriminator', stack, features)
self.discriminator = disc
g_loss = l.g_loss
d_loss = l.d_loss
d_vars += dvs
if config.vae:
if(hasattr(self, "variational")):
for i,var in enumerate(self.variational):
mu,sigma = var
eps = 1e-8
lam = config.vae_lambda or 0.01
latent_loss = lam*(0.5 *self.ops.squash(tf.square(mu)-tf.square(sigma) - tf.log(tf.square(sigma)+eps) - 1, tf.reduce_sum ))
self.add_metric("vae"+str(i), latent_loss)
#d_loss += latent_loss
g_loss -= latent_loss
gx_sample = gen.sample
gy_sample = gen.sample
gx = hc.Config({"sample":gx_sample})
gy = hc.Config({"sample":gy_sample})
last_frame = tf.slice(gy_sample, [0,0,0,0], [-1, -1, -1, 3])
self.y = hc.Config({"sample":last_frame})
self.gy = self.y
self.gx = self.y
self.uniform_sample = gen.sample
self.preview = tf.concat(self.inputs.frames[:-1] + [gen.sample], axis=1)#tf.concat(tf.split(gen.sample, (self.ops.shape(gen.sample)[3]//3), 3), axis=1)
trainers = []
lossa = hc.Config({'sample': [d_loss, g_loss], 'd_fake': l.d_fake, 'd_real': l.d_real, 'config': l.config})
self.loss = lossa
self._d_vars = d_vars
trainer = self.create_component(config.trainer, loss = lossa, g_vars = self._g_vars, d_vars = d_vars)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = gx
self.z_hat = gy.sample
self.x_input = self.inputs.frames[0]
self.uga = self.y.sample
self.uniform_distribution = dist
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
x_input = tf.identity(self.inputs.x, name='input')
# q(z|x)
encoder = self.create_encoder(x_input)
self.encoder = encoder
z_shape = self.ops.shape(encoder.sample)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(config.encoder.projections)
UniformDistribution = UniformDistribution(self, config.encoder, output_shape=uz_shape)
direction, slider = self.create_controls(self.ops.shape(UniformDistribution.sample))
z = UniformDistribution.sample + slider * direction
#projected_encoder = UniformDistribution(self, config.encoder, z=encoder.sample)
feature_dim = len(ops.shape(z))-1
#stack_z = tf.concat([encoder.sample, z], feature_dim)
#stack_encoded = tf.concat([encoder.sample, encoder.sample], feature_dim)
stack_z = z
generator = self.create_component(config.generator, input=stack_z)
self.uniform_sample = generator.sample
x_hat = generator.reuse(encoder.sample)
# z = random uniform
# z_hat = z of x
# g = random generated
# x_input
stacked_xg = ops.concat([generator.sample, x_input], axis=0)
stacked_zs = ops.concat([z, encoder.sample], axis=0)
standard_discriminator = self.create_component(config.discriminator, name='discriminator', input=stacked_xg, features=[stacked_zs])
z_discriminator = self.create_z_discriminator(UniformDistribution.sample, encoder.sample)
standard_loss = self.create_loss(config.loss, standard_discriminator, x_input, generator, 2)
encoder_loss = self.create_loss(config.eloss or config.loss, z_discriminator, z, encoder, 2)
trainer = self.create_trainer(None, None, encoder, generator, encoder_loss, standard_loss, standard_discriminator, z_discriminator)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = generator
self.uniform_distribution = uniform_encoder
self.slider = slider
self.direction = direction
self.z = z
self.z_hat = encoder.sample
self.x_input = x_input
self.autoencoded_x = x_hat
rgb = tf.cast((self.generator.sample+1)*127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb, 0xFF000000, name='generator_int')
self.random_z = tf.random_uniform(ops.shape(UniformDistribution.sample), -1, 1, name='random_z')
if hasattr(generator, 'mask_generator'):
self.mask_generator = generator.mask_generator
self.mask = mask
self.autoencode_mask = generator.mask_generator.sample
self.autoencode_mask_3_channel = generator.mask
import hyperchamber as hc
import numpy as np
import hypergan as hg
from hypergan.distributions.uniform_distribution import UniformDistribution
from hypergan.gan_component import ValidationException
from unittest.mock import MagicMock
from tests.mocks import MockDiscriminator, mock_gan
gan = mock_gan()
distribution = UniformDistribution(gan, {
'test':True,
"z": 2,
"min": 0,
"max": 1
})
class TestUniformDistribution:
def test_config(self):
assert distribution.config.test == True
def test_projection(self):
config = {
"projections": [hg.distributions.uniform_distribution.identity],
"z": 2,
"min": 0,
"max": 1
}
subject = UniformDistribution(gan, config)
projections = subject.create()
assert subject.ops.shape(projections)[1] == 2
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
#x_input = tf.identity(self.inputs.x, name='input')
xa_input = tf.identity(self.inputs.xa, name='xa_i')
xb_input = tf.identity(self.inputs.xb, name='xb_i')
if config.same_g:
ga = self.create_component(config.generator,
input=xb_input,
name='a_generator')
gb = hc.Config({
"sample": ga.reuse(xa_input),
"controls": {
"z": ga.controls['z']
},
"reuse": ga.reuse
})
else:
ga = self.create_component(config.generator,
input=xb_input,
name='a_generator')
gb = self.create_component(config.generator,
input=xa_input,
name='b_generator')
za = ga.controls["z"]
zb = gb.controls["z"]
self.uniform_sample = ga.sample
xba = ga.sample
xab = gb.sample
xa_hat = ga.reuse(gb.sample)
xb_hat = gb.reuse(ga.sample)
z_shape = self.ops.shape(za)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(
config.z_distribution.projections)
ue = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
ue2 = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
ue3 = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
ue4 = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
print('ue', ue.sample)
zua = ue.sample
zub = ue2.sample
uga = ga.reuse(tf.zeros_like(xb_input),
replace_controls={"z": zua})
ugb = gb.reuse(tf.zeros_like(xa_input),
replace_controls={"z": zub})
xa = xa_input
xb = xb_input
t0 = ops.concat([xb, xa], axis=3)
t1 = ops.concat([ugb, uga], axis=3)
t2 = ops.concat([gb.sample, ga.sample], axis=3)
f0 = ops.concat([za, zb], axis=3)
f1 = ops.concat([zub, zua], axis=3)
f2 = ops.concat([zb, za], axis=3)
features = ops.concat([f0, f1, f2], axis=0)
stack = [t0, t1, t2]
if config.mess2:
xbxa = ops.concat([xb_input, xa_input], axis=3)
gbga = ops.concat([gb.sample, ga.sample], axis=3)
fa = ops.concat([za, zb], axis=3)
fb = ops.concat([za, zb], axis=3)
features = ops.concat([fa, fb], axis=0)
stack = [xbxa, gbga]
if config.mess6:
t0 = ops.concat([xb, xa], axis=3)
t1 = ops.concat([gb.sample, uga], axis=3)
t2 = ops.concat([gb.sample, xa], axis=3)
t3 = ops.concat([xb, ga.sample], axis=3)
t4 = ops.concat([ugb, ga.sample], axis=3)
features = None
stack = [t0, t1, t2, t3, t4]
if config.mess7:
ugb = gb.reuse(tf.zeros_like(xa_input),
replace_controls={"z": zua})
t0 = ops.concat([xb, ga.sample], axis=3)
t1 = ops.concat([ugb, uga], axis=3)
t2 = ops.concat([gb.sample, xa], axis=3)
features = None
stack = [t0, t1, t2]
if config.mess8:
ugb = gb.reuse(tf.zeros_like(xa_input),
replace_controls={"z": zua})
uga2 = ga.reuse(tf.zeros_like(xa_input),
replace_controls={"z": zub})
ugb2 = gb.reuse(tf.zeros_like(xa_input),
replace_controls={"z": zub})
t0 = ops.concat([xb, ga.sample, xa, gb.sample], axis=3)
t1 = ops.concat([ugb, uga, uga2, ugb2], axis=3)
features = None
stack = [t0, t1]
if config.mess10:
t0 = ops.concat([xb, xa], axis=3)
ugb = gb.reuse(tf.zeros_like(xa_input),
replace_controls={"z": zua})
t1 = ops.concat([ugb, uga], axis=3)
t2 = ops.concat([gb.sample, xa], axis=3)
t3 = ops.concat([xb, ga.sample], axis=3)
features = None
stack = [t0, t1, t2, t3]
if config.mess11:
t0 = ops.concat([xa, xb, ga.sample, gb.sample], axis=3)
ugbga = ga.reuse(ugb)
ugagb = gb.reuse(uga)
t1 = ops.concat([ga.sample, gb.sample, uga, ugb], axis=3)
features = None
stack = [t0, t1]
if config.mess12:
t0 = ops.concat([xb, xa], axis=3)
t2 = ops.concat([gb.sample, ga.sample], axis=3)
f0 = ops.concat([za, zb], axis=3)
f2 = ops.concat([zua, zub], axis=3)
features = ops.concat([f0, f2], axis=0)
stack = [t0, t2]
if config.mess13:
ugb = gb.reuse(tf.zeros_like(xa_input),
replace_controls={"z": zua})
features = None
t0 = ops.concat([xa, gb.sample], axis=3)
t1 = ops.concat([ga.sample, xb], axis=3)
t2 = ops.concat([uga, ugb], axis=3)
stack = [t0, t1, t2]
if config.mess14:
features = None
t0 = ops.concat([xa, gb.sample], axis=3)
t1 = ops.concat([ga.sample, xb], axis=3)
stack = [t0, t1]
stacked = ops.concat(stack, axis=0)
d = self.create_component(config.discriminator,
name='alia_discriminator',
input=stacked,
features=[features])
l = self.create_loss(config.loss, d, xa_input, ga.sample,
len(stack))
d_vars = d.variables()
if config.same_g:
g_vars = ga.variables()
else:
g_vars = ga.variables() + gb.variables()
d_loss = l.d_loss
g_loss = l.g_loss
metrics = {'g_loss': l.g_loss, 'd_loss': l.d_loss}
if (config.alpha):
#t0 = ops.concat([zua,zub], axis=3)
#t1 = ops.concat([za,zb], axis=3)
t0 = zua
t1 = za
t2 = zb
netzd = tf.concat(axis=0, values=[t0, t1, t2])
z_d = self.create_component(config.z_discriminator,
name='z_discriminator',
input=netzd)
print("Z_D", z_d)
lz = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=ga,
split=2)
d_loss += lz.d_loss
g_loss += lz.g_loss
d_vars += z_d.variables()
metrics["a_gloss"] = lz.g_loss
metrics["a_dloss"] = lz.d_loss
if (config.mess13):
t0 = ops.concat([xb, ga.sample], axis=3)
t1 = ops.concat([gb.sample, xa], axis=3)
t2 = ops.concat([ugb, uga], axis=3)
stack = [t0, t1, t2]
features = None
stacked = tf.concat(axis=0, values=stack)
d2 = self.create_component(config.discriminator,
name='align_2',
input=stacked,
features=[features])
lz = self.create_loss(config.loss, d2, xa_input, ga.sample,
len(stack))
d_vars += d2.variables()
d_loss += lz.d_loss
g_loss += lz.g_loss
metrics["mess13_g"] = lz.g_loss
metrics["mess13_d"] = lz.d_loss
if (config.mess14):
t0 = ops.concat([xb, xa], axis=3)
t2 = ops.concat([ugb, uga], axis=3)
stack = [t0, t2]
features = None
stacked = tf.concat(axis=0, values=stack)
d3 = self.create_component(config.discriminator,
name='align_3',
input=stacked,
features=[features])
lz = self.create_loss(config.loss, d3, xa_input, ga.sample,
len(stack))
d_vars += d3.variables()
d_loss += lz.d_loss
g_loss += lz.g_loss
metrics["mess14_g"] = lz.g_loss
metrics["mess14_d"] = lz.d_loss
loss = hc.Config({'sample': [d_loss, g_loss], 'metrics': metrics})
trainer = ConsensusTrainer(self,
config.trainer,
loss=loss,
g_vars=g_vars,
d_vars=d_vars)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = ga
self.encoder = gb # this is the other gan
self.uniform_distribution = hc.Config({"sample": zb}) #uniform_encoder
self.zb = zb
self.z_hat = gb.sample
self.x_input = xa_input
self.autoencoded_x = xa_hat
self.cyca = xa_hat
self.cycb = xb_hat
self.xba = xba
self.xab = xab
self.uga = uga
self.ugb = ugb
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')
def create(self):
config = self.config
ops = self.ops
d_losses = []
g_losses = []
with tf.device(self.device):
x_input = tf.identity(self.inputs.x, name='input')
if config.u_to_z:
latent = UniformDistribution(self, config.z_distribution)
else:
z_shape = self.ops.shape(encoder.sample)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(config.z_distribution.projections)
latent = UniformDistribution(self, config.z_distribution, output_shape=uz_shape)
self.uniform_distribution = latent
self.latent = latent
direction, slider = self.create_controls(self.ops.shape(latent.sample))
z = latent.sample + slider * direction
u_to_z = self.create_component(config.u_to_z, name='u_to_z', input=z)
generator = self.create_component(config.generator, input=u_to_z.sample, name='generator')
stacked = [x_input, generator.sample]
self.generator = generator
encoder = self.create_encoder(self.inputs.x)
self.encoder = encoder
features = [encoder.sample, u_to_z.sample]
reencode_u_to_z = self.create_encoder(generator.sample, reuse=True)
reencode_u_to_z_to_g= self.create_component(config.generator, input=reencode_u_to_z.sample, name='generator', reuse=True)
self.reencode_g = reencode_u_to_z_to_g
x_hat = self.create_component(config.generator, input=encoder.sample, reuse=True, name='generator').sample
reencode_x_hat_to_z = self.create_encoder(x_hat, reuse=True)
self.uniform_sample = generator.sample
d_vars = []
g_vars = generator.variables() + encoder.variables()
g_vars += u_to_z.variables()
def ali(*stack, reuse=False):
xs=[t for t,_ in stack]
zs=[t for _,t in stack]
xs=tf.concat(xs,axis=0)
zs=tf.concat(zs,axis=0)
discriminator = self.create_component(config.discriminator, name='discriminator', input=xs, features=[zs], reuse=reuse)
loss = self.create_loss(config.loss, discriminator, None, None, len(stack))
return loss,discriminator
def d(name, stack):
if name is None:
name = config
stacked = tf.concat(stack,axis=0)
discriminator = self.create_component(config[name], name=name, input=stacked)
loss = self.create_loss(config.loss, discriminator, None, None, len(stack))
return loss,discriminator
l1, d1 = ali([self.inputs.x,encoder.sample],[generator.sample,u_to_z.sample],[reencode_u_to_z_to_g.sample, reencode_u_to_z.sample])
l2, d2 = ali([self.inputs.x,tf.zeros_like(encoder.sample)],[generator.sample,tf.zeros_like(u_to_z.sample)],[reencode_u_to_z_to_g.sample, tf.zeros_like(reencode_u_to_z.sample)], reuse=True)
l3, d3 = ali([tf.zeros_like(self.inputs.x),encoder.sample],[tf.zeros_like(generator.sample),u_to_z.sample],[tf.zeros_like(reencode_u_to_z_to_g.sample), reencode_u_to_z.sample], reuse=True)
l4, d4 = d('x_discriminator', [self.inputs.x, generator.sample, reencode_u_to_z_to_g.sample])
l5, d5 = d('z_discriminator', [encoder.sample, u_to_z.sample, reencode_u_to_z.sample])
self.discriminator = d1
self.loss = l1
beta = config.beta or 0.9
d_losses = [beta * (l1.d_loss - l2.d_loss - l3.d_loss) + l4.d_loss + 2*l5.d_loss]
g_losses = [beta * (l1.g_loss - l2.g_loss - l3.g_loss) + l4.g_loss + 2*l5.g_loss]
if config.alternate:
d_losses = [beta * (l1.d_loss - l2.d_loss - l3.d_loss) + l2.d_loss + 2*l3.d_loss]
g_losses = [beta * (l1.g_loss - l2.g_loss - l3.g_loss) + l2.g_loss + 2*l3.g_loss]
if config.mutual_only:
d_losses = [2*l1.d_loss - l2.d_loss - l3.d_loss)]
g_losses = [2*l1.g_loss - l2.g_loss - l3.g_loss)]
self.add_metric("ld", d_losses[0])
self.add_metric("lg", g_losses[0])
if config.mutual_only or config.alternate:
for d in [d1]:
d_vars += d.variables()
else:
for d in [d1,d4,d5]:
d_vars += d.variables()
self._g_vars = g_vars
self._d_vars = d_vars
loss = hc.Config({
'd_fake':l1.d_fake,
'd_real':l1.d_real,
'sample': [tf.add_n(d_losses), tf.add_n(g_losses)]
})
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
#x_input = tf.identity(self.inputs.x, name='input')
xa_input = tf.identity(self.inputs.xa, name='xa_i')
xb_input = tf.identity(self.inputs.xb, name='xb_i')
if config.same_g:
ga = self.create_component(config.generator,
input=xb_input,
name='a_generator')
gb = hc.Config({
"sample": ga.reuse(xa_input),
"controls": {
"z": ga.controls['z']
},
"reuse": ga.reuse
})
else:
ga = self.create_component(config.generator,
input=xb_input,
name='a_generator')
gb = self.create_component(config.generator,
input=xa_input,
name='b_generator')
za = ga.controls["z"]
zb = gb.controls["z"]
self.uniform_sample = ga.sample
xba = ga.sample
xab = gb.sample
xa_hat = ga.reuse(gb.sample)
xb_hat = gb.reuse(ga.sample)
z_shape = self.ops.shape(za)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(
config.z_distribution.projections)
ue = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
ue2 = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
ue3 = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
ue4 = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
print('ue', ue.sample)
zua = ue.sample
zub = ue2.sample
ga2 = self.create_component(config.generator,
input=tf.zeros_like(xb_input),
name='ua_generator')
gb2 = self.create_component(config.generator,
input=tf.zeros_like(xb_input),
name='ub_generator')
uga = ga2.reuse(tf.zeros_like(xb_input),
replace_controls={"z": zua})
ugb = gb2.reuse(tf.zeros_like(xb_input),
replace_controls={"z": zub})
ugbprime = gb.reuse(uga)
ugbzb = gb.controls['z']
xa = xa_input
xb = xb_input
t0 = xb
t1 = gb.sample
t2 = ugbprime
f0 = za
f1 = zb
f2 = ugbzb
stack = [t0, t1, t2]
stacked = ops.concat(stack, axis=0)
features = ops.concat([f0, f1, f2], axis=0)
xa_hat = ugbprime
d = self.create_component(config.discriminator,
name='d_ab',
input=stacked,
features=[features])
l = self.create_loss(config.loss, d, xa_input, ga.sample,
len(stack))
loss1 = l
d_loss1 = l.d_loss
g_loss1 = l.g_loss
d_vars1 = d.variables()
g_vars1 = ga2.variables() + gb2.variables() + gb.variables(
) + ga.variables() #gb.variables()# + gb.variables()
d_loss = l.d_loss
g_loss = l.g_loss
metrics = {'g_loss': l.g_loss, 'd_loss': l.d_loss}
g_vars2 = ga.variables()
trainers = []
if config.cyc:
t0 = xa
t1 = ga.sample
f0 = zb
f1 = za
stack = [t0, t1]
stacked = ops.concat(stack, axis=0)
features = ops.concat([f0, f1], axis=0)
d = self.create_component(config.discriminator,
name='d2_ab',
input=stacked,
features=[features])
l = self.create_loss(config.loss, d, xa_input, ga.sample,
len(stack))
d_loss1 += l.d_loss
g_loss1 += l.g_loss
d_vars1 += d.variables()
metrics["gloss2"] = l.g_loss
metrics["dloss2"] = l.d_loss
#loss2=l
#g_loss2 = loss2.g_loss
#d_loss2 = loss2.d_loss
if (config.alpha):
t0 = zub
t1 = zb
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.z_discriminator,
name='z_discriminator',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=ga,
split=2)
d_vars1 += z_d.variables()
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
if (config.ug):
t0 = xb
t1 = ugb
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.discriminator,
name='ug_discriminator',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=ga,
split=2)
d_vars1 += z_d.variables()
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
if (config.alpha2):
t0 = zua
t1 = za
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.z_discriminator,
name='z_discriminator2',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=ga,
split=2)
d_vars1 += z_d.variables()
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
if config.ug2:
t0 = xa
t1 = uga
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.discriminator,
name='ug_discriminator2',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=ga,
split=2)
d_vars1 += z_d.variables()
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
if config.ug3:
t0 = tf.concat(values=[xa, xb], axis=3)
t1 = tf.concat(values=[uga, ugb], axis=3)
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.discriminator,
name='ug_discriminator3',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=ga,
split=2)
d_vars1 += z_d.variables()
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
lossa = hc.Config({
'sample': [d_loss1, g_loss1],
'metrics': metrics
})
#lossb = hc.Config({'sample': [d_loss2, g_loss2], 'metrics': metrics})
trainers += [
ConsensusTrainer(self,
config.trainer,
loss=lossa,
g_vars=g_vars1,
d_vars=d_vars1)
]
#trainers += [ConsensusTrainer(self, config.trainer, loss = lossb, g_vars = g_vars2, d_vars = d_vars2)]
trainer = MultiTrainerTrainer(trainers)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = ga
self.encoder = gb # this is the other gan
self.uniform_distribution = hc.Config({"sample": zb}) #uniform_encoder
self.zb = zb
self.z_hat = gb.sample
self.x_input = xa_input
self.autoencoded_x = xa_hat
self.cyca = xa_hat
self.cycb = xb_hat
self.xba = xba
self.xab = xab
self.uga = uga
self.ugb = ugb
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')
def create(self):
config = self.config
ops = self.ops
with tf.device(self.device):
#x_input = tf.identity(self.inputs.x, name='input')
xa_input = tf.identity(self.inputs.xa, name='xa_i')
xb_input = tf.identity(self.inputs.xb, name='xb_i')
if config.same_g:
ga = self.create_component(config.generator,
input=xb_input,
name='a_generator')
gb = hc.Config({
"sample": ga.reuse(xa_input),
"controls": {
"z": ga.controls['z']
},
"reuse": ga.reuse
})
else:
ga = self.create_component(config.generator,
input=xb_input,
name='a_generator')
gb = self.create_component(config.generator,
input=xa_input,
name='b_generator')
za = ga.controls["z"]
zb = gb.controls["z"]
self.uniform_sample = gb.sample
xba = ga.sample
xab = gb.sample
xa_hat = ga.reuse(gb.sample)
xb_hat = gb.reuse(ga.sample)
xa = xa_input
xb = xb_input
if config.ignore_random:
t0 = xb
t1 = gb.sample
f0 = za
f1 = zb
stack = [t0, t1]
stacked = ops.concat(stack, axis=0)
features = ops.concat([f0, f1], axis=0)
self.inputs.x = xb
ugb = gb.sample
zub = zb
sourcezub = zb
else:
z_shape = self.ops.shape(za)
uz_shape = z_shape
uz_shape[-1] = uz_shape[-1] // len(
config.z_distribution.projections)
ue = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
ue2 = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
ue3 = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
ue4 = UniformDistribution(self,
config.z_distribution,
output_shape=uz_shape)
print('ue', ue.sample)
zua = ue.sample
zub = ue2.sample
ue2 = UniformDistribution(
self,
config.z_distribution,
output_shape=[self.ops.shape(za)[0], config.source_linear])
zub = ue2.sample
uz_to_gz = self.create_component(config.uz_to_gz,
name='uzb_to_gzb',
input=zub)
zub = uz_to_gz.sample
sourcezub = zub
ugb = gb.reuse(tf.zeros_like(xa_input),
replace_controls={"z": zub})
t0 = xb
t1 = gb.sample
t2 = ugb
f0 = za
f1 = zb
f2 = zub
stack = [t0, t1, t2]
stacked = ops.concat(stack, axis=0)
features = ops.concat([f0, f1, f2], axis=0)
d = self.create_component(config.discriminator,
name='d_ab',
input=stacked,
features=[features])
l = self.create_loss(config.loss, d, xa_input, ga.sample,
len(stack))
loss1 = l
d_loss1 = l.d_loss
g_loss1 = l.g_loss
d_vars1 = d.variables()
g_vars1 = gb.variables() + ga.variables()
if not config.ignore_random:
g_vars1 += uz_to_gz.variables(
) #gb.variables()# + gb.variables()
d_loss = l.d_loss
g_loss = l.g_loss
metrics = {'g_loss': l.g_loss, 'd_loss': l.d_loss}
if config.inline_alpha:
t0 = zub
t1 = zb
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.z_discriminator,
name='z_discriminator',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=ga,
split=2)
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
d_vars1 += z_d.variables()
d_loss1 += loss3.d_loss
g_loss1 += loss3.g_loss
trainers = []
if config.separate_alpha:
t0 = zub
t1 = zb
netzd = tf.concat(axis=0, values=[t0, t1])
z_d = self.create_component(config.z_discriminator,
name='z_discriminator',
input=netzd)
loss3 = self.create_component(config.loss,
discriminator=z_d,
x=xa_input,
generator=ga,
split=2)
metrics["za_gloss"] = loss3.g_loss
metrics["za_dloss"] = loss3.d_loss
g_vars1 = gb.variables() + ga.variables(
) #gb.variables()# + gb.variables()
trainers += [
ConsensusTrainer(self,
config.trainer,
loss=loss3,
g_vars=uz_to_gz.variables(),
d_vars=z_d.variables())
]
lossa = hc.Config({
'sample': [d_loss1, g_loss1],
'metrics': metrics
})
#lossb = hc.Config({'sample': [d_loss2, g_loss2], 'metrics': metrics})
trainers += [
ConsensusTrainer(self,
config.trainer,
loss=lossa,
g_vars=g_vars1,
d_vars=d_vars1)
]
#trainers += [ConsensusTrainer(self, config.trainer, loss = lossb, g_vars = g_vars2, d_vars = d_vars2)]
trainer = MultiTrainerTrainer(trainers)
self.session.run(tf.global_variables_initializer())
self.trainer = trainer
self.generator = ga
self.encoder = hc.Config({"sample": ugb}) # this is the other gan
self.uniform_distribution = hc.Config({"sample":
zub}) #uniform_encoder
self.uniform_distribution_source = hc.Config({"sample": sourcezub
}) #uniform_encoder
self.zb = zb
self.z_hat = gb.sample
self.x_input = xa_input
self.autoencoded_x = xa_hat
self.cyca = xa_hat
self.cycb = xb_hat
self.xba = xba
self.xab = xab
self.uga = ugb
self.ugb = ugb
rgb = tf.cast((self.generator.sample + 1) * 127.5, tf.int32)
self.generator_int = tf.bitwise.bitwise_or(rgb,
0xFF000000,
name='generator_int')