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