Clean up in training loop

Author: eriklindernoren

README.md

@@ -254,20 +254,6 @@ $ python3 gan.py
     <img src="http://eriklindernoren.se/images/gan_mnist5.gif" width="640"\>
 </p>
 
-GAN on RGB face images
-[Code](gan/gan_rgb.py)
-
-#### Example
-```
-$ cd gan/
-<follow steps at the top of gan_rgb.py>
-$ python3 gan_rgb.py
-```
-
-<p align="center">
-    <img src="gan/etc/adam.gif" width="640"\>
-</p>
-
 ### InfoGAN
 Implementation of _InfoGAN: Interpretable Representation Learning by Information Maximizing Generative Adversarial Nets_.
 

aae/aae.py

@@ -74,20 +74,20 @@ def build_encoder(self):
         return Model(img, latent_repr)
 
     def build_decoder(self):
-        # Decoder
-        decoder = Sequential()
 
-        decoder.add(Dense(512, input_dim=self.latent_dim))
-        decoder.add(LeakyReLU(alpha=0.2))
-        decoder.add(Dense(512))
-        decoder.add(LeakyReLU(alpha=0.2))
-        decoder.add(Dense(np.prod(self.img_shape), activation='tanh'))
-        decoder.add(Reshape(self.img_shape))
+        model = Sequential()
+
+        model.add(Dense(512, input_dim=self.latent_dim))
+        model.add(LeakyReLU(alpha=0.2))
+        model.add(Dense(512))
+        model.add(LeakyReLU(alpha=0.2))
+        model.add(Dense(np.prod(self.img_shape), activation='tanh'))
+        model.add(Reshape(self.img_shape))
 
-        decoder.summary()
+        model.summary()
 
         z = Input(shape=(self.latent_dim,))
-        img = decoder(z)
+        img = model(z)
 
         return Model(z, img)
 
@@ -116,38 +116,34 @@ def train(self, epochs, batch_size=128, sample_interval=50):
         X_train = (X_train.astype(np.float32) - 127.5) / 127.5
         X_train = np.expand_dims(X_train, axis=3)
 
-        half_batch = int(batch_size / 2)
+        # Adversarial ground truths
+        valid = np.ones((batch_size, 1))
+        fake = np.zeros((batch_size, 1))
 
         for epoch in range(epochs):
 
-
             # ---------------------
             #  Train Discriminator
             # ---------------------
 
-            # Select a random half batch of images
-            idx = np.random.randint(0, X_train.shape[0], half_batch)
+            # Select a random batch of images
+            idx = np.random.randint(0, X_train.shape[0], batch_size)
             imgs = X_train[idx]
 
             latent_fake = self.encoder.predict(imgs)
-            latent_real = np.random.normal(size=(half_batch, self.latent_dim))
+            latent_real = np.random.normal(size=(batch_size, self.latent_dim))
 
             # Train the discriminator
-            d_loss_real = self.discriminator.train_on_batch(latent_real, np.ones((half_batch, 1)))
-            d_loss_fake = self.discriminator.train_on_batch(latent_fake, np.zeros((half_batch, 1)))
+            d_loss_real = self.discriminator.train_on_batch(latent_real, valid)
+            d_loss_fake = self.discriminator.train_on_batch(latent_fake, fake)
             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
 
-
             # ---------------------
             #  Train Generator
             # ---------------------
 
-            # Select a random half batch of images
-            idx = np.random.randint(0, X_train.shape[0], batch_size)
-            imgs = X_train[idx]
-
             # Train the generator
-            g_loss = self.adversarial_autoencoder.train_on_batch(imgs, [imgs, np.ones((batch_size, 1))])
+            g_loss = self.adversarial_autoencoder.train_on_batch(imgs, [imgs, valid])
 
             # Plot the progress
             print ("%d [D loss: %f, acc: %.2f%%] [G loss: %f, mse: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss[0], g_loss[1]))

acgan/acgan.py

@@ -47,8 +47,8 @@ def __init__(self):
         # and the label of that image
         valid, target_label = self.discriminator(img)
 
-        # The combined model  (stacked generator and discriminator) takes
-        # noise as input => generates images => determines validity
+        # The combined model  (stacked generator and discriminator)
+        # Trains the generator to fool the discriminator
         self.combined = Model([noise, label], [valid, target_label])
         self.combined.compile(loss=losses,
             optimizer=optimizer)
@@ -75,11 +75,9 @@ def build_generator(self):
 
         noise = Input(shape=(self.latent_dim,))
         label = Input(shape=(1,), dtype='int32')
-
         label_embedding = Flatten()(Embedding(self.num_classes, 100)(label))
 
         model_input = multiply([noise, label_embedding])
-
         img = model(model_input)
 
         return Model([noise, label], img)
@@ -123,38 +121,38 @@ def train(self, epochs, batch_size=128, sample_interval=50):
         # Load the dataset
         (X_train, y_train), (_, _) = mnist.load_data()
 
-        # Rescale -1 to 1
+        # Configure inputs
         X_train = (X_train.astype(np.float32) - 127.5) / 127.5
         X_train = np.expand_dims(X_train, axis=3)
         y_train = y_train.reshape(-1, 1)
 
-        half_batch = int(batch_size / 2)
+        # Adversarial ground truths
+        valid = np.ones((batch_size, 1))
+        fake = np.zeros((batch_size, 1))
 
         for epoch in range(epochs):
 
             # ---------------------
             #  Train Discriminator
             # ---------------------
 
-            # Select a random half batch of images
-            idx = np.random.randint(0, X_train.shape[0], half_batch)
+            # Select a random batch of images
+            idx = np.random.randint(0, X_train.shape[0], batch_size)
             imgs = X_train[idx]
 
-            noise = np.random.normal(0, 1, (half_batch, 100))
+            # Sample noise as generator input
+            noise = np.random.normal(0, 1, (batch_size, 100))
 
             # The labels of the digits that the generator tries to create an
             # image representation of
-            sampled_labels = np.random.randint(0, 10, half_batch).reshape(-1, 1)
+            sampled_labels = np.random.randint(0, 10, (batch_size, 1))
 
             # Generate a half batch of new images
             gen_imgs = self.generator.predict([noise, sampled_labels])
 
-            valid = np.ones((half_batch, 1))
-            fake = np.zeros((half_batch, 1))
-
             # Image labels. 0-9 if image is valid or 10 if it is generated (fake)
             img_labels = y_train[idx]
-            fake_labels = 10 * np.ones(half_batch).reshape(-1, 1)
+            fake_labels = 10 * np.ones(img_labels.shape)
 
             # Train the discriminator
             d_loss_real = self.discriminator.train_on_batch(imgs, [valid, img_labels])
@@ -165,14 +163,6 @@ def train(self, epochs, batch_size=128, sample_interval=50):
             #  Train Generator
             # ---------------------
 
-            # Sample generator input
-            noise = np.random.normal(0, 1, (batch_size, 100))
-
-            valid = np.ones((batch_size, 1))
-            # Generator wants discriminator to label the generated images as the intended
-            # digits
-            sampled_labels = np.random.randint(0, 10, batch_size).reshape(-1, 1)
-
             # Train the generator
             g_loss = self.combined.train_on_batch([noise, sampled_labels], [valid, sampled_labels])
 
@@ -188,9 +178,7 @@ def sample_images(self, epoch):
         r, c = 10, 10
         noise = np.random.normal(0, 1, (r * c, 100))
         sampled_labels = np.array([num for _ in range(r) for num in range(c)])
-
         gen_imgs = self.generator.predict([noise, sampled_labels])
-
         # Rescale images 0 - 1
         gen_imgs = 0.5 * gen_imgs + 0.5
 
@@ -215,9 +203,8 @@ def save(model, model_name):
             open(options['file_arch'], 'w').write(json_string)
             model.save_weights(options['file_weight'])
 
-        save(self.generator, "mnist_acgan_generator")
-        save(self.discriminator, "mnist_acgan_discriminator")
-        save(self.combined, "mnist_acgan_adversarial")
+        save(self.generator, "generator")
+        save(self.discriminator, "discriminator")
 
 
 if __name__ == '__main__':

bgan/bgan.py

@@ -45,8 +45,8 @@ def __init__(self):
         # The valid takes generated images as input and determines validity
         valid = self.discriminator(img)
 
-        # The combined model  (stacked generator and discriminator) takes
-        # noise as input => generates images => determines validity
+        # The combined model  (stacked generator and discriminator)
+        # Trains the generator to fool the discriminator
         self.combined = Model(z, valid)
         self.combined.compile(loss=self.boundary_loss, optimizer=optimizer)
 
@@ -103,44 +103,39 @@ def train(self, epochs, batch_size=128, sample_interval=50):
         (X_train, _), (_, _) = mnist.load_data()
 
         # Rescale -1 to 1
-        X_train = (X_train.astype(np.float32) - 127.5) / 127.5
+        X_train = X_train / 127.5 - 1.
         X_train = np.expand_dims(X_train, axis=3)
 
-        half_batch = int(batch_size / 2)
+        # Adversarial ground truths
+        valid = np.ones((batch_size, 1))
+        fake = np.zeros((batch_size, 1))
 
         for epoch in range(epochs):
 
             # ---------------------
             #  Train Discriminator
             # ---------------------
 
-            # Select a random half batch of images
-            idx = np.random.randint(0, X_train.shape[0], half_batch)
+            # Select a random batch of images
+            idx = np.random.randint(0, X_train.shape[0], batch_size)
             imgs = X_train[idx]
 
-            noise = np.random.normal(0, 1, (half_batch, self.latent_dim))
+            noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
 
-            # Generate a half batch of new images
+            # Generate a batch of new images
             gen_imgs = self.generator.predict(noise)
 
             # Train the discriminator
-            d_loss_real = self.discriminator.train_on_batch(imgs, np.ones((half_batch, 1)))
-            d_loss_fake = self.discriminator.train_on_batch(gen_imgs, np.zeros((half_batch, 1)))
+            d_loss_real = self.discriminator.train_on_batch(imgs, valid)
+            d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
 
 
             # ---------------------
             #  Train Generator
             # ---------------------
 
-            noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
-
-            # The generator wants the discriminator to label the generated samples
-            # as valid (ones)
-            valid_y = np.array([1] * batch_size)
-
-            # Train the generator
-            g_loss = self.combined.train_on_batch(noise, valid_y)
+            g_loss = self.combined.train_on_batch(noise, valid)
 
             # Plot the progress
             print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))
@@ -153,7 +148,6 @@ def sample_images(self, epoch):
         r, c = 5, 5
         noise = np.random.normal(0, 1, (r * c, self.latent_dim))
         gen_imgs = self.generator.predict(noise)
-
         # Rescale images 0 - 1
         gen_imgs = 0.5 * gen_imgs + 0.5
 

bigan/bigan.py

@@ -34,7 +34,7 @@ def __init__(self):
 
         # Build the generator
         self.generator = self.build_generator()
-        
+
         # Build the encoder
         self.encoder = self.build_encoder()
 
@@ -54,6 +54,7 @@ def __init__(self):
         valid = self.discriminator([z_, img])
 
         # Set up and compile the combined model
+        # Trains generator to fool the discriminator
         self.bigan_generator = Model([z, img], [fake, valid])
         self.bigan_generator.compile(loss=['binary_crossentropy', 'binary_crossentropy'],
             optimizer=optimizer)
@@ -125,7 +126,9 @@ def train(self, epochs, batch_size=128, sample_interval=50):
         X_train = (X_train.astype(np.float32) - 127.5) / 127.5
         X_train = np.expand_dims(X_train, axis=3)
 
-        half_batch = int(batch_size / 2)
+        # Adversarial ground truths
+        valid = np.ones((batch_size, 1))
+        fake = np.zeros((batch_size, 1))
 
         for epoch in range(epochs):
 
@@ -135,17 +138,14 @@ def train(self, epochs, batch_size=128, sample_interval=50):
             # ---------------------
 
             # Sample noise and generate img
-            z = np.random.normal(size=(half_batch, self.latent_dim))
+            z = np.random.normal(size=(batch_size, self.latent_dim))
             imgs_ = self.generator.predict(z)
 
-            # Select a random half batch of images and encode
-            idx = np.random.randint(0, X_train.shape[0], half_batch)
+            # Select a random batch of images and encode
+            idx = np.random.randint(0, X_train.shape[0], batch_size)
             imgs = X_train[idx]
             z_ = self.encoder.predict(imgs)
 
-            valid = np.ones((half_batch, 1))
-            fake = np.zeros((half_batch, 1))
-
             # Train the discriminator (img -> z is valid, z -> img is fake)
             d_loss_real = self.discriminator.train_on_batch([z_, imgs], valid)
             d_loss_fake = self.discriminator.train_on_batch([z, imgs_], fake)
@@ -155,16 +155,6 @@ def train(self, epochs, batch_size=128, sample_interval=50):
             #  Train Generator
             # ---------------------
 
-            # Sample gaussian noise
-            z = np.random.normal(size=(batch_size, self.latent_dim))
-
-            # Select a random half batch of images
-            idx = np.random.randint(0, X_train.shape[0], batch_size)
-            imgs = X_train[idx]
-
-            valid = np.ones((batch_size, 1))
-            fake = np.zeros((batch_size, 1))
-
             # Train the generator (z -> img is valid and img -> z is is invalid)
             g_loss = self.bigan_generator.train_on_batch([z, imgs], [valid, fake])
 
@@ -173,7 +163,6 @@ def train(self, epochs, batch_size=128, sample_interval=50):
 
             # If at save interval => save generated image samples
             if epoch % sample_interval == 0:
-                # Select a random half batch of images
                 self.sample_interval(epoch)
 
     def sample_interval(self, epoch):