def test_validate(self):
with self.assertRaises(ValidationException):
config = {
"projections": [hg.encoders.uniform_encoder.identity],
"z": 3,
"min": 0,
"max": 1
}
UniformEncoder(gan, config)
def ec(zt, cp,reuse=True):
if config.noise:
randt = random_like(cp)
if config.proxy:
dist3 = UniformEncoder(self, config.z_distribution)
proxy_c = self.create_component(config.proxy_c, name='rand_ct', input=dist3.sample, reuse=reuse)
randt = proxy_c.sample
print("CC", zt, randt)
c = self.create_component(config.ec, name='ec', input=zt, features={'ct-1':cp, 'n':randt}, reuse=reuse)
else:
c = self.create_component(config.ec, name='ec', input=zt, features=[cp], reuse=reuse)
if not reuse:
if config.proxy:
self.g_vars += proxy_c.variables()
self.g_vars += c.variables()
return c.sample
def random_t(shape):
shape[-1] //= len(config.z_distribution.projections)
return UniformEncoder(self, config.z_distribution, output_shape=shape).sample
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 UniformEncoder(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 = UniformEncoder(self, config.z_distribution)
dist2 = UniformEncoder(self, config.z_distribution)
dist3 = UniformEncoder(self, config.z_distribution)
dist4 = UniformEncoder(self, config.z_distribution)
dist5 = UniformEncoder(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 = UniformEncoder(self, config.z_distribution)
proxy_c = self.create_component(config.proxy_c, name='rand_ct', input=dist3.sample, reuse=reuse)
randt = proxy_c.sample
print("CC", zt, randt)
c = self.create_component(config.ec, name='ec', input=zt, features={'ct-1':cp, 'n':randt}, reuse=reuse)
else:
c = self.create_component(config.ec, name='ec', input=zt, features=[cp], reuse=reuse)
if not reuse:
if config.proxy:
self.g_vars += proxy_c.variables()
self.g_vars += c.variables()
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)
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
#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, uc2.sample, uz2.sample, reuse=False)
self.zs = zs
self.cs = cs
ugs, ucs, uzs = build_sim(uz.sample, uc.sample, len(self.frames))
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:], ucs_next[0], uzs_next[0])
gs_next, cs_next, zs_next = build_sim(zs[-1], cs[-1], len(self.frames))
#gs_next_next, cs_next_next, zs_next_next = build_sim(zs[-1], cs[-1], 21)
re_ucs, re_uzs, ugs_hat = encode_frames(ugs[1:], ucs[0], uzs[0])
re_cs_next, re_zs_next, re_gs_next = encode_frames(gs_next[1:], cs_next[0], zs_next[0])
self.x_hats = x_hats
t0 = tf.concat(zs[1:], axis=3)
t1 = tf.concat(re_uzs[:-1], axis=3)
t2 = tf.concat(re_zs_next[:-1], axis=3)
t3 = tf.concat(re_uzs_next[:-1], axis=3)
t4 = tf.concat(re_uzs[:-1], axis=3)
f0 = tf.concat(cs[1:], axis=3)
f1 = tf.concat(re_ucs[:-1], axis=3)
f2 = tf.concat(re_cs_next[:-1], axis=3)
f3 = tf.concat(re_ucs_next[:-1], axis=3)
stack = [t0,t1, t2]#, t4, t5]
stacked = ops.concat(stack, axis=0)
features =ops.concat([f0,f1,f2], axis=0)
d = self.create_component(config.z_discriminator, name='d_img', input=stacked, features=[features])
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
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
gen = hc.Config({"sample":ugs[0]})
if config.use_x:
def rotate(first, second, offset=None):
rotations = [tf.concat(first[:offset], axis=3)]
elem = first
for e in second:
elem = elem[1:]+[e]
rotations.append(tf.concat(elem[:offset], axis=3))
return rotations
t0 = tf.concat(self.frames[1:], axis=3)
f0 = tf.concat(cs[1:-1], axis=3)
stack = [t0]
features = [f0]
if config.encode_forward:
stack += rotate(self.frames[2:]+[gs_next[0]], gs_next[1:])
features += rotate(cs[2:], cs_next[1:])
#stack += [gs_next_next[-frames:]]
if config.encode_ug:
stack += rotate(ugs[:-2], ugs[-2:]+ugs_next[1:])
features += rotate(ucs[:-2], ucs[-2:]+ucs_next[1:])
stacked = ops.concat(stack, axis=0)
features = tf.concat(features, axis=0)
d = self.create_component(config.discriminator, name='d_manifold', input=stacked, features=[features])
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
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)
metrics = {
'g_loss': g_loss,
'd_loss': d_loss
}
trainers = []
lossa = hc.Config({'sample': [d_loss, g_loss], 'metrics': metrics, 'd_fake': l.d_fake, 'd_real': l.d_real, 'config': l.config})
self.loss = lossa
self._g_vars = self.g_vars
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_encoder = dist
def test_validate_z_must_be_multiple_of_two(self):
with self.assertRaises(ValidationException):
UniformEncoder(gan, {})
import tensorflow as tf
import hyperchamber as hc
import numpy as np
import hypergan as hg
from hypergan.encoders.uniform_encoder import UniformEncoder
from hypergan.gan_component import ValidationException
from hypergan.ops import TensorflowOps
from unittest.mock import MagicMock
from tests.mocks import MockDiscriminator, mock_gan
gan = mock_gan()
encoder = UniformEncoder(gan, {'test': True, "z": 2, "min": 0, "max": 1})
class UniformEncoderTest(tf.test.TestCase):
def test_config(self):
with self.test_session():
self.assertEqual(encoder.config.test, True)
def test_projection(self):
config = {
"projections": [hg.encoders.uniform_encoder.identity],
"z": 2,
"min": 0,
"max": 1
}
subject = UniformEncoder(gan, config)
with self.test_session():
projections = subject.create()
self.assertEqual(subject.ops.shape(projections)[1], 2)
def create(self):
BaseGAN.create(self)
if self.session is None:
self.session = self.ops.new_session(self.ops_config)
with tf.device(self.device):
config = self.config
ops = self.ops
g_encoder = dict(config.g_encoder or config.discriminator)
encoder = self.create_component(g_encoder)
encoder.ops.describe("g_encoder")
encoder.create(self.inputs.x)
encoder.z = tf.zeros(0)
if (len(encoder.sample.get_shape()) == 2):
s = ops.shape(encoder.sample)
encoder.sample = tf.reshape(encoder.sample, [s[0], s[1], 1, 1])
z_discriminator = dict(config.z_discriminator
or config.discriminator)
z_discriminator['layer_filter'] = None
encoder_discriminator = self.create_component(z_discriminator)
encoder_discriminator.ops.describe("z_discriminator")
standard_discriminator = self.create_component(
config.discriminator)
standard_discriminator.ops.describe("discriminator")
#encoder.sample = ops.reshape(encoder.sample, [ops.shape(encoder.sample)[0], -1])
uniform_encoder_config = config.encoder
z_size = 1
for size in ops.shape(encoder.sample)[1:]:
z_size *= size
uniform_encoder_config.z = z_size
uniform_encoder = UniformEncoder(self, uniform_encoder_config)
uniform_encoder.create()
self.generator = self.create_component(config.generator)
z = uniform_encoder.sample
x = self.inputs.x
# project the output of the autoencoder
projection_input = ops.reshape(encoder.sample,
[ops.shape(encoder.sample)[0], -1])
projections = []
for projection in uniform_encoder.config.projections:
projection = uniform_encoder.lookup(projection)(
uniform_encoder.config, self.gan, projection_input)
projection = ops.reshape(projection, ops.shape(encoder.sample))
projections.append(projection)
z_hat = tf.concat(axis=3, values=projections)
z = ops.reshape(z, ops.shape(z_hat))
# end encoding
g = self.generator.create(z)
sample = self.generator.sample
self.uniform_sample = self.generator.sample
x_hat = self.generator.reuse(z_hat)
encoder_discriminator.create(x=z, g=z_hat)
eloss = dict(config.loss)
eloss['gradient_penalty'] = False
encoder_loss = self.create_component(
eloss, discriminator=encoder_discriminator)
encoder_loss.create()
stacked_xg = ops.concat([x, x_hat, g], axis=0)
standard_discriminator.create(stacked_xg)
standard_loss = self.create_component(
config.loss, discriminator=standard_discriminator)
standard_loss.create(split=3)
self.trainer = self.create_component(config.trainer)
#loss terms
distance = config.distance or ops.lookup('l1_distance')
cycloss = tf.reduce_mean(distance(self.inputs.x, x_hat))
cycloss_lambda = config.cycloss_lambda
if cycloss_lambda is None:
cycloss_lambda = 10
cycloss *= cycloss_lambda
loss1 = ('generator', cycloss + encoder_loss.g_loss)
loss2 = ('generator', cycloss + standard_loss.g_loss)
loss3 = ('discriminator', standard_loss.d_loss)
loss4 = ('discriminator', encoder_loss.d_loss)
var_lists = []
var_lists.append(encoder.variables())
var_lists.append(self.generator.variables())
var_lists.append(standard_discriminator.variables())
var_lists.append(encoder_discriminator.variables())
metrics = []
metrics.append(encoder_loss.metrics)
metrics.append(standard_loss.metrics)
metrics.append(None)
metrics.append(None)
# trainer
self.trainer = MultiStepTrainer(self,
self.config.trainer,
[loss1, loss2, loss3, loss4],
var_lists=var_lists,
metrics=metrics)
self.trainer.create()
self.session.run(tf.global_variables_initializer())
self.encoder = encoder
self.uniform_encoder = uniform_encoder