├── .spyproject
    ├── codestyle.ini
    ├── encoding.ini
    ├── vcs.ini
    └── workspace.ini
├── AAE.py
├── GAE.py
├── GAE_CFAR.py
├── GAE_GAN.py
├── GAE_image_completion.py
├── README.rst
├── SAAE.py
├── SSAAE.py
├── autoencoder_torch.py
├── dcgan.py
└── helpers.py


/.spyproject/codestyle.ini:
--------------------------------------------------------------------------------
1 | [codestyle]
2 | indentation = True
3 | 
4 | [main]
5 | version = '0.1.0'
6 | 
7 | 


--------------------------------------------------------------------------------
/.spyproject/encoding.ini:
--------------------------------------------------------------------------------
1 | [encoding]
2 | text_encoding = utf-8
3 | 
4 | [main]
5 | version = '0.1.0'
6 | 
7 | 


--------------------------------------------------------------------------------
/.spyproject/vcs.ini:
--------------------------------------------------------------------------------
1 | [vcs]
2 | use_version_control = False
3 | version_control_system = 
4 | 
5 | [main]
6 | version = '0.1.0'
7 | 
8 | 


--------------------------------------------------------------------------------
/.spyproject/workspace.ini:
--------------------------------------------------------------------------------
 1 | [workspace]
 2 | save_data_on_exit = True
 3 | restore_data_on_startup = True
 4 | save_history = True
 5 | save_non_project_files = False
 6 | 
 7 | [main]
 8 | version = '0.1.0'
 9 | recent_files = [u'/home/ali/.config/spyder/temp.py', u'/home/ali/Projects/Mygithub/adverserial-autoencoder-keas/SAAE.py', u'/home/ali/Projects/Mygithub/adverserial-autoencoder-keas/SSAAE.py', u'/home/ali/Projects/Mygithub/adverserial-autoencoder-keas/autoencoder_torch.py', u'/home/ali/Projects/Mygithub/adverserial-autoencoder-keas/dcgan.py', u'/home/ali/Projects/Mygithub/adverserial-autoencoder-keas/GAE_CFAR.py', u'/home/ali/Projects/Mygithub/adverserial-autoencoder-keas/GAE_GAN.py', u'/home/ali/Projects/Mygithub/adverserial-autoencoder-keas/GAE_image_completion.py', u'/home/ali/Projects/Mygithub/adverserial-autoencoder-keas/helpers.py', u'/home/ali/Projects/Mygithub/adverserial-autoencoder-keas/AAE.py']
10 | 
11 | 


--------------------------------------------------------------------------------
/AAE.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # Author : Ali Mirzaei
  3 | # Date : 19/09/2017
  4 | 
  5 | 
  6 | from keras.models import Sequential, Model
  7 | from keras.layers import Dense, Input, Flatten, Reshape
  8 | from keras.datasets import mnist
  9 | from keras.optimizers import Adam,SGD
 10 | from keras.initializers import RandomNormal
 11 | import numpy as np
 12 | import matplotlib
 13 | import helpers
 14 | 
 15 | matplotlib.use('Agg')
 16 | 
 17 | import matplotlib.pyplot as plt
 18 | plt.ioff()
 19 | 
 20 | initializer = RandomNormal(mean=0.0, stddev=0.01, seed=None)
 21 | class AAN():
 22 |     def __init__(self, img_shape=(28, 28), encoded_dim=2):
 23 |         self.encoded_dim = encoded_dim
 24 |         self.optimizer_reconst = Adam(0.01)
 25 |         self.optimizer_discriminator = Adam(0.01)
 26 |         self._initAndCompileFullModel(img_shape, encoded_dim)
 27 | 
 28 |     def _genEncoderModel(self, img_shape, encoded_dim):
 29 |         """ Build Encoder Model Based on Paper Configuration
 30 |         Args:
 31 |             img_shape (tuple) : shape of input image
 32 |             encoded_dim (int) : number of latent variables
 33 |         Return:
 34 |             A sequential keras model
 35 |         """
 36 |         encoder = Sequential()
 37 |         encoder.add(Flatten(input_shape=img_shape))
 38 |         encoder.add(Dense(1000, activation='relu', kernel_initializer=initializer,
 39 |                 bias_initializer=initializer))
 40 |         encoder.add(Dense(1000, activation='relu', kernel_initializer=initializer,
 41 |                 bias_initializer=initializer))
 42 |         encoder.add(Dense(encoded_dim, kernel_initializer=initializer,
 43 |                 bias_initializer=initializer))
 44 |         encoder.summary()
 45 |         return encoder
 46 | 
 47 |     def _getDecoderModel(self, encoded_dim, img_shape):
 48 |         """ Build Decoder Model Based on Paper Configuration
 49 |         Args:
 50 |             encoded_dim (int) : number of latent variables
 51 |             img_shape (tuple) : shape of target images
 52 |         Return:
 53 |             A sequential keras model
 54 |         """
 55 |         decoder = Sequential()
 56 |         decoder.add(Dense(1000, activation='relu', input_dim=encoded_dim, kernel_initializer=initializer,
 57 |                 bias_initializer=initializer))
 58 |         decoder.add(Dense(1000, activation='relu', kernel_initializer=initializer,
 59 |                 bias_initializer=initializer))
 60 |         decoder.add(Dense(np.prod(img_shape), activation='sigmoid', kernel_initializer=initializer,
 61 |                 bias_initializer=initializer))
 62 |         decoder.add(Reshape(img_shape))
 63 |         decoder.summary()
 64 |         return decoder
 65 | 
 66 |     def _getDescriminator(self, encoded_dim):
 67 |         """ Build Descriminator Model Based on Paper Configuration
 68 |         Args:
 69 |             encoded_dim (int) : number of latent variables
 70 |         Return:
 71 |             A sequential keras model
 72 |         """
 73 |         discriminator = Sequential()
 74 |         discriminator.add(Dense(1000, activation='relu',
 75 |                                 input_dim=encoded_dim, kernel_initializer=initializer,
 76 |                 bias_initializer=initializer))
 77 |         discriminator.add(Dense(1000, activation='relu', kernel_initializer=initializer,
 78 |                 bias_initializer=initializer))
 79 |         discriminator.add(Dense(1, activation='sigmoid', kernel_initializer=initializer,
 80 |                 bias_initializer=initializer))
 81 |         discriminator.summary()
 82 |         return discriminator
 83 | 
 84 |     def _initAndCompileFullModel(self, img_shape, encoded_dim):
 85 |         self.encoder = self._genEncoderModel(img_shape, encoded_dim)
 86 |         self.decoder = self._getDecoderModel(encoded_dim, img_shape)
 87 |         self.discriminator = self._getDescriminator(encoded_dim)
 88 |         img = Input(shape=img_shape)
 89 |         encoded_repr = self.encoder(img)
 90 |         gen_img = self.decoder(encoded_repr)
 91 |         self.autoencoder = Model(img, gen_img)
 92 |         valid = self.discriminator(encoded_repr)
 93 |         self.encoder_discriminator = Model(img, valid)
 94 |         self.discriminator.compile(optimizer=self.optimizer_discriminator,
 95 |                                    loss='binary_crossentropy',
 96 |                                    metrics=['accuracy'])
 97 |         self.autoencoder.compile(optimizer=self.optimizer_reconst,
 98 |                                  loss ='mse')
 99 |         for layer in self.discriminator.layers:
100 |             layer.trainable = False
101 |         self.encoder_discriminator.compile(optimizer=self.optimizer_discriminator,
102 |                                            loss='binary_crossentropy',
103 |                                            metrics=['accuracy'])
104 |     def imagegrid(self, epochnumber):
105 |         fig = plt.figure(figsize=[20, 20])
106 |         images = self.generateImages(100)
107 |         for index,img in enumerate(images):
108 |             img = img.reshape((28, 28))
109 |             ax = fig.add_subplot(10, 10, index+1)
110 |             ax.set_axis_off()
111 |             ax.imshow(img, cmap="gray")
112 |         fig.savefig("images/AAE/"+str(epochnumber)+".png")
113 |         plt.show()
114 |         plt.close(fig)
115 |     def generateImages(self, n=100):
116 |         latents = 5*np.random.normal(size=(n, self.encoded_dim))
117 |         imgs = self.decoder.predict(latents)
118 |         return imgs
119 | 
120 |     def train(self, x_train, batch_size=100, epochs=5000, save_interval=500):
121 |         half_batch = int(batch_size / 2)
122 |         for epoch in range(epochs):
123 |             #---------------Train Discriminator -------------
124 |             # Select a random half batch of images
125 |             idx = np.random.randint(0, x_train.shape[0], half_batch)
126 |             imgs = x_train[idx]
127 |             # Generate a half batch of new images
128 |             latent_fake = self.encoder.predict(imgs)
129 |             #gen_imgs = self.decoder.predict(latent_fake)
130 |             latent_real = 5*np.random.normal(size=(half_batch, self.encoded_dim))
131 |             valid = np.ones((half_batch, 1))
132 |             fake = np.zeros((half_batch, 1))
133 |             # Train the discriminator
134 |             d_loss_real = self.discriminator.train_on_batch(latent_real, valid)
135 |             d_loss_fake = self.discriminator.train_on_batch(latent_fake, fake)
136 |             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
137 | 
138 |             idx = np.random.randint(0, x_train.shape[0], batch_size)
139 |             imgs = x_train[idx]
140 |             # Generator wants the discriminator to label the generated representations as valid
141 |             valid_y = np.ones((batch_size, 1))
142 | 
143 |             # Train the autoencode reconstruction
144 |             g_loss_reconstruction = self.autoencoder.train_on_batch(imgs, imgs)
145 | 
146 |             # Train generator
147 |             g_logg_similarity = self.encoder_discriminator.train_on_batch(imgs, valid_y)
148 |             # Plot the progress
149 |             print ("%d [D loss: %f, acc: %.2f%%] [G acc: %f, mse: %f]" % (epoch, d_loss[0], 100*d_loss[1],
150 |                    g_logg_similarity[1], g_loss_reconstruction))
151 |             if(epoch % save_interval == 0):
152 |                 self.imagegrid(epoch)
153 | 
154 | 
155 | if __name__ == '__main__':
156 |     # Load MNIST dataset
157 |     (x_train, y_train), (x_test, y_test) = mnist.load_data()
158 |     x_train = x_train.astype(np.float32) / 255.
159 |     x_test = x_test.astype(np.float32) / 255.
160 |     ann = AAN(encoded_dim=8)
161 |     ann.train(x_train)
162 |     generated = ann.generateImages(10000)
163 |     L= helpers.approximateLogLiklihood(generated, x_test)
164 |     print "Log Likelihood"
165 |     print L
166 | 


--------------------------------------------------------------------------------
/GAE.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | # -*- coding: utf-8 -*-
  4 | # Author : Ali Mirzaei
  5 | # Date : 19/09/2017
  6 | 
  7 | import glob
  8 | from keras.models import Sequential, Model
  9 | from keras.layers import Dense, Input, Flatten, Reshape
 10 | from keras.datasets import mnist, cifar10
 11 | from keras.optimizers import Adam
 12 | import numpy as np
 13 | import matplotlib.pyplot as plt
 14 | from sklearn.neighbors.kde import KernelDensity
 15 | from mpl_toolkits.mplot3d import Axes3D
 16 | import helpers
 17 | from sklearn.model_selection import GridSearchCV
 18 | import keras
 19 | from keras.initializers import RandomNormal
 20 | 
 21 | initializer = RandomNormal(mean=0.0, stddev=0.01, seed=None)
 22 | 
 23 | class GAE():
 24 |     def __init__(self, img_shape=(28, 28), encoded_dim=2):
 25 |         self.encoded_dim = encoded_dim
 26 |         self.optimizer = Adam(0.001)
 27 |         self.optimizer_discriminator = Adam(0.00001)
 28 |         self._initAndCompileFullModel(img_shape, encoded_dim)
 29 |         self.img_shape = img_shape
 30 | 
 31 |     def _genEncoderModel(self, img_shape, encoded_dim):
 32 |         """ Build Encoder Model Based on Paper Configuration
 33 |         Args:
 34 |             img_shape (tuple) : shape of input image
 35 |             encoded_dim (int) : number of latent variables
 36 |         Return:
 37 |             A sequential keras model
 38 |         """
 39 |         encoder = Sequential()
 40 |         encoder.add(Flatten(input_shape=img_shape))
 41 |         encoder.add(Dense(1000, activation='relu'))
 42 |         encoder.add(Dense(1000, activation='relu'))
 43 |         encoder.add(Dense(encoded_dim))
 44 |         encoder.summary()
 45 |         return encoder
 46 | 
 47 |     def _getDecoderModel(self, encoded_dim, img_shape):
 48 |         """ Build Decoder Model Based on Paper Configuration
 49 |         Args:
 50 |             encoded_dim (int) : number of latent variables
 51 |             img_shape (tuple) : shape of target images
 52 |         Return:
 53 |             A sequential keras model
 54 |         """
 55 |         decoder = Sequential()
 56 |         decoder.add(Dense(1000, activation='relu', input_dim=encoded_dim))
 57 |         decoder.add(Dense(1000, activation='relu'))
 58 |         decoder.add(Dense(np.prod(img_shape), activation='sigmoid'))
 59 |         decoder.add(Reshape(img_shape))
 60 |         decoder.summary()
 61 |         return decoder
 62 | 
 63 |     def _getDescriminator(self, img_shape):
 64 |         """ Build Descriminator Model Based on Paper Configuration
 65 |         Args:
 66 |             encoded_dim (int) : number of latent variables
 67 |         Return:
 68 |             A sequential keras model
 69 |         """
 70 |         discriminator = Sequential()
 71 |         discriminator.add(Flatten(input_shape=img_shape))
 72 |         discriminator.add(Dense(1000, activation='relu',
 73 |                                 kernel_initializer=initializer,
 74 |                 bias_initializer=initializer))
 75 |         discriminator.add(Dense(1000, activation='relu', kernel_initializer=initializer,
 76 |                 bias_initializer=initializer))
 77 |         discriminator.add(Dense(1, activation='sigmoid', kernel_initializer=initializer,
 78 |                 bias_initializer=initializer))
 79 |         discriminator.summary()
 80 |         return discriminator
 81 | 
 82 |     def _initAndCompileFullModel(self, img_shape, encoded_dim):
 83 |         self.encoder = self._genEncoderModel(img_shape, encoded_dim)
 84 |         self.decoder = self._getDecoderModel(encoded_dim, img_shape)
 85 |         self.discriminator = self._getDescriminator(img_shape)
 86 |         img = Input(shape=img_shape)
 87 |         encoded_repr = self.encoder(img)
 88 |         gen_img = self.decoder(encoded_repr)
 89 |         self.autoencoder = Model(img, gen_img)
 90 |         self.autoencoder.compile(optimizer=self.optimizer, loss='mse')
 91 |         self.discriminator.compile(optimizer=self.optimizer, 
 92 |                                    loss='binary_crossentropy',
 93 |                                    metrics=['accuracy'])
 94 |         for layer in self.discriminator.layers:
 95 |             layer.trainable = False
 96 |         
 97 |         latent = Input(shape=(encoded_dim,))
 98 |         gen_image_from_latent = self.decoder(latent)
 99 |         is_real = self.discriminator(gen_image_from_latent)
100 |         self.decoder_discriminator = Model(latent, is_real)
101 |         self.decoder_discriminator.compile(optimizer=self.optimizer_discriminator, loss='binary_crossentropy',
102 |                                            metrics=['accuracy'])
103 | 
104 |     def imagegrid(self, epochnumber):
105 |         fig = plt.figure(figsize=[20, 20])
106 |         for i in range(-5, 5):
107 |             for j in range(-5,5):
108 |                 topred = np.array((i*0.5,j*0.5))
109 |                 topred = topred.reshape((1, 2))
110 |                 img = self.decoder.predict(topred)
111 |                 img = img.reshape(self.img_shape)
112 |                 ax = fig.add_subplot(10, 10, (i+5)*10+j+5+1)
113 |                 ax.set_axis_off()
114 |                 ax.imshow(img, cmap="gray")
115 |         fig.savefig(str(epochnumber)+".png")
116 |         plt.show()
117 |         plt.close(fig)
118 | 
119 |     def train(self, x_train, batch_size=32, epochs=5):
120 |         fileNames = glob.glob('models/GAE/weights_mnist_autoencoder.*')
121 |         fileNames.sort()
122 |         if(len(fileNames) != 0):
123 |             savedEpoch = int(fileNames[-1].split('.')[1])
124 |             self.autoencoder.load_weights(fileNames[-1])
125 |         else:
126 |             savedEpoch=-1
127 |         if(savedEpoch<epochs-1):
128 |             self.autoencoder.fit(x_train, x_train, batch_size=batch_size,
129 |                                  epochs=epochs, 
130 |                                  callbacks=[keras.callbacks.ModelCheckpoint('models/GAE/weights_autoencoder.{epoch:02d}.hdf5', 
131 |                                                                            verbose=0, 
132 |                                                                            save_best_only=False, 
133 |                                                                            save_weights_only=False, 
134 |                                                                            mode='auto', 
135 |                                                                            period=1)])
136 |         print "Training KDE"
137 |         codes = self.encoder.predict(x_train)
138 | #        params = {'bandwidth': [3.16]}#np.logspace(0, 2, 5)}
139 | #        grid = GridSearchCV(KernelDensity(), params, n_jobs=4)
140 | #        grid.fit(codes)
141 | #        print grid.best_params_
142 | #        self.kde = grid.best_estimator_
143 |         self.kde = KernelDensity(kernel='gaussian', bandwidth=3.16).fit(codes)
144 |         print "Initial Training of discriminator"
145 |         fileNames = glob.glob('models/GAE/weights_mnist_discriminator.*')
146 |         fileNames.sort()
147 |         if(len(fileNames) != 0):
148 |             savedEpoch = int(fileNames[-1].split('.')[1])
149 |             self.discriminator.load_weights(fileNames[-1])
150 |         else:
151 |             savedEpoch = -1
152 |         if(savedEpoch<epochs-1):
153 |             imgs_fake = self.generate(n = len(x_train))
154 |             #gen_imgs = self.decoder.predict(latent_fake)
155 |             valid = np.ones((len(x_train), 1))
156 |             fake = np.zeros((len(x_train), 1))
157 |             labels = np.vstack([valid, fake])
158 |             images = np.vstack([x_train, imgs_fake])
159 |             # Train the discriminator
160 |             self.discriminator.fit(images, labels, epochs=epochs, batch_size=batch_size, shuffle=True, 
161 |                                    callbacks=[keras.callbacks.ModelCheckpoint('models/GAE/weights_discriminator.{epoch:02d}.hdf5', 
162 |                                                                                verbose=0, 
163 |                                                                                save_best_only=False, 
164 |                                                                                save_weights_only=False, 
165 |                                                                                mode='auto', 
166 |                                                                                period=1)])
167 | 
168 |         print "Training GAN"
169 |         self.generateAndPlot(x_train, fileName="before_gan.png")
170 |         self.trainGAN(x_train, epochs=len(x_train)/batch_size, batch_size= batch_size)
171 |         self.generateAndPlot(x_train, fileName="after_gan.png")
172 |     def trainGAN(self, x_train, epochs =1000, batch_size=32):
173 |         half_batch = batch_size/2
174 |         for epoch in range(epochs):
175 |             #---------------Train Discriminator -------------
176 |             # Select a random half batch of images
177 |             idx = np.random.randint(0, x_train.shape[0], half_batch)
178 |             imgs_real = x_train[idx]
179 |             # Generate a half batch of new images
180 |             imgs_fake = self.generate(n = half_batch)
181 |             #gen_imgs = self.decoder.predict(latent_fake)
182 |             valid = np.ones((half_batch, 1))
183 |             fake = np.zeros((half_batch, 1))
184 |             # Train the discriminator
185 |             d_loss_real = self.discriminator.train_on_batch(imgs_real, valid)
186 |             d_loss_fake = self.discriminator.train_on_batch(imgs_fake, fake)
187 |             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
188 |             #d_loss = (0,0)
189 |             codes = self.kde.sample(batch_size)
190 |             # Generator wants the discriminator to label the generated representations as valid
191 |             valid_y = np.ones((batch_size, 1))
192 |             # Train generator
193 |             g_logg_similarity = self.decoder_discriminator.train_on_batch(codes, valid_y)
194 |             # Plot the progress
195 |             print ("%d [D accuracy: %.2f] [G accuracy: %.2f]" % (epoch, d_loss[1], g_logg_similarity[1]))
196 | #            if(epoch % save_interval == 0):
197 | #                self.imagegrid(epoch)
198 | 
199 |     def generate(self, n = 10000):
200 |         codes = self.kde.sample(n)
201 |         images = self.decoder.predict(codes)
202 |         return images
203 | 
204 |     def generateAndPlot(self, x_train, n = 10, fileName="generated.png"):
205 |         fig = plt.figure(figsize=[20, 20])
206 |         images = self.generate(n*n)
207 |         index = 1
208 |         for image in images:
209 |             image = image.reshape(self.img_shape)
210 |             ax = fig.add_subplot(n, n+1, index)
211 |             index=index+1
212 |             ax.set_axis_off()
213 |             ax.imshow(image, cmap="gray")
214 |             if((index)%(n+1) == 0):
215 |                 nearest = helpers.findNearest(x_train, image)
216 |                 ax = fig.add_subplot(n, n+1, index)
217 |                 index= index+1
218 |                 ax.imshow(nearest, cmap="gray")
219 |         fig.savefig(fileName)
220 |         plt.show()
221 | 
222 |     def meanLogLikelihood(self, x_test):
223 |         KernelDensity(kernel='gaussian', bandwidth=0.2).fit(codes)
224 | if __name__ == '__main__':
225 |     # Load MNIST dataset
226 |     (x_train, y_train), (x_test, y_test) = mnist.load_data()
227 |     x_train = x_train.astype(np.float32) / 255.
228 |     x_test = x_test.astype(np.float32) / 255.
229 |     ann = GAE(img_shape=(28,28), encoded_dim=2)
230 |     ann.train(x_train, epochs=1)
231 |     ann.generateAndPlot(x_train)
232 | #    generated = ann.generate(10000)
233 | #    L = helpers.approximateLogLiklihood(generated, x_test, searchSpace=[.1])
234 | #    print L
235 | #    #codes = ann.kde.sample(1000)
236 | #    #ax = Axes3D(plt.gcf())
237 | #    codes = ann.encoder.predict(x_train)
238 | #    plt.scatter(codes[:,0], codes[:,1], c=y_train)
239 | #    plt.show()
240 | 


--------------------------------------------------------------------------------
/GAE_CFAR.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | # -*- coding: utf-8 -*-
  4 | # Author : Ali Mirzaei
  5 | # Date : 19/09/2017
  6 | 
  7 | 
  8 | from keras.models import Sequential, Model
  9 | from keras.layers import Dense, Input, Flatten, Reshape, Conv2D, Conv2DTranspose
 10 | from keras.datasets import mnist, cifar10
 11 | from keras.optimizers import Adam
 12 | import numpy as np
 13 | import matplotlib.pyplot as plt
 14 | from sklearn.neighbors.kde import KernelDensity
 15 | from mpl_toolkits.mplot3d import Axes3D
 16 | import helpers
 17 | from sklearn.model_selection import GridSearchCV
 18 | import keras
 19 | from tqdm import tqdm
 20 | 
 21 | class GAE():
 22 |     def __init__(self, img_shape=(28, 28), encoded_dim=2):
 23 |         self.encoded_dim = encoded_dim
 24 |         self.optimizer = Adam(0.001)
 25 |         self._initAndCompileFullModel(img_shape, encoded_dim)
 26 |         self.img_shape = img_shape
 27 | 
 28 |     def _genEncoderModel(self, img_shape, encoded_dim):
 29 |         """ Build Encoder Model Based on Paper Configuration
 30 |         Args:
 31 |             img_shape (tuple) : shape of input image
 32 |             encoded_dim (int) : number of latent variables
 33 |         Return:
 34 |             A sequential keras model
 35 |         """
 36 |         encoder = Sequential()
 37 |         #encoder.add(Flatten(input_shape=img_shape))
 38 |         encoder.add(Conv2D(32, (5, 5), activation='tanh', input_shape=img_shape))
 39 |         encoder.add(Flatten())
 40 |         #encoder.add(Dense(100, activation='tanh'))
 41 |         encoder.add(Dense(encoded_dim, activation='tanh'))
 42 |         encoder.summary()
 43 |         return encoder
 44 | 
 45 |     def _getDecoderModel(self, encoded_dim, img_shape):
 46 |         """ Build Decoder Model Based on Paper Configuration
 47 |         Args:
 48 |             encoded_dim (int) : number of latent variables
 49 |             img_shape (tuple) : shape of target images
 50 |         Return:
 51 |             A sequential keras model
 52 |         """
 53 |         decoder = Sequential()
 54 |         #decoder.add(Dense(100, activation='tanh', input_dim=encoded_dim))
 55 |         decoder.add(Dense((img_shape[0] - 2) * (img_shape[1] - 2) * 3, activation='tanh', input_dim=encoded_dim))
 56 |         decoder.add(Reshape(((img_shape[0] - 2), (img_shape[1] - 2), 3)))
 57 |         decoder.add(Conv2DTranspose(3, (3,3), activation='sigmoid'))
 58 |         decoder.add(Reshape(img_shape))
 59 |         decoder.summary()
 60 |         return decoder
 61 | 
 62 | 
 63 |     def _initAndCompileFullModel(self, img_shape, encoded_dim):
 64 |         self.encoder = self._genEncoderModel(img_shape, encoded_dim)
 65 |         self.decoder = self._getDecoderModel(encoded_dim, img_shape)
 66 |         img = Input(shape=img_shape)
 67 |         encoded_repr = self.encoder(img)
 68 |         gen_img = self.decoder(encoded_repr)
 69 |         self.autoencoder = Model(img, gen_img)
 70 |         self.autoencoder.compile(optimizer=self.optimizer, loss='mse')
 71 |     def imagegrid(self, epochnumber):
 72 |         fig = plt.figure(figsize=[20, 20])
 73 |         for i in range(-5, 5):
 74 |             for j in range(-5,5):
 75 |                 topred = np.array((i*0.5,j*0.5))
 76 |                 topred = topred.reshape((1, 2))
 77 |                 img = self.decoder.predict(topred)
 78 |                 img = img.reshape((28, 28))
 79 |                 ax = fig.add_subplot(10, 10, (i+5)*10+j+5+1)
 80 |                 ax.set_axis_off()
 81 |                 ax.imshow(img, cmap="gray")
 82 |         fig.savefig(str(epochnumber)+".png")
 83 |         plt.show()
 84 |         plt.close(fig)
 85 | 
 86 |     def train(self, x_train, batch_size=32, epochs=5):
 87 |         self.autoencoder.load_weights('15619.hdf5')
 88 |         l=0
 89 |         tq = tqdm(range(len(x_train)*epochs/batch_size))
 90 |         for i in tq:
 91 |             tq.set_description("MSE Loss (%f)" % l)
 92 |             idx= np.random.randint(0, len(x_train), batch_size)
 93 |             x_batch = x_train[idx]
 94 |             x_out = copy.copy(x_batch)
 95 |             mask = np.random.choice([0, 1], size=(batch_size, 32, 32, 1), p=[1./10, 9./10])
 96 |             mask = np.repeat(mask, 3, 3)
 97 |             mm = np.ma.masked_array(x_batch, mask= mask)
 98 |             x_batch[mm.mask]=0
 99 |             l = self.autoencoder.train_on_batch(x_batch, x_out)
100 |             if(i%(len(x_train)/batch_size)==(len(x_train)/batch_size)-1):
101 |                 self.autoencoder.save_weights(str(i)+'.hdf5')
102 | #                                 callbacks=[keras.callbacks.ModelCheckpoint('weights_cifar.{epoch:02d}.hdf5', 
103 | #                                                                           verbose=0, 
104 | #                                                                           save_best_only=False, 
105 | #                                                                           save_weights_only=False, 
106 | #                                                                           mode='auto', 
107 | #                                                                           period=1)])
108 | #        codes = self.encoder.predict(x_train)
109 | #        params = {'bandwidth': [3.16]}#np.logspace(0, 2, 5)}
110 | #        grid = GridSearchCV(KernelDensity(), params, n_jobs=4)
111 | #        grid.fit(codes)
112 | #        print grid.best_params_
113 | #        self.kde = grid.best_estimator_
114 | #        self.kde = KernelDensity(kernel='gaussian', bandwidth=.2).fit(codes)
115 | 
116 |     def generate(self, n = 10000):
117 |         codes = self.kde.sample(n)
118 |         images = self.decoder.predict(codes)
119 |         return images
120 | 
121 |     def generateAndPlot(self, x_test):
122 |         fig = plt.figure(figsize=[20, 20])
123 |         images = x_test
124 |         index = 1
125 |         reconstructed_image = self.autoencoder.predict(x_test)
126 |         for image,r in zip(images, reconstructed_image):
127 |             image = image.reshape(self.img_shape)
128 |             ax = fig.add_subplot(len(x_test), 2, index)
129 |             index=index+1
130 |             ax.set_axis_off()
131 |             ax.imshow(image, cmap="gray")
132 |             ax = fig.add_subplot(len(x_test), 2, index)
133 |             index=index+1
134 |             ax.set_axis_off()
135 |             ax.imshow(r, cmap="gray")
136 |             
137 |         fig.savefig("cfar10_generated.png")
138 |         plt.show()
139 | 
140 |     def meanLogLikelihood(self, x_test):
141 |         KernelDensity(kernel='gaussian', bandwidth=0.2).fit(codes)
142 | 
143 | 
144 | def plotResults(ann, x_test, key_numbers = 10):
145 |     fig = plt.figure(figsize=(10, 10*len(x_test)/4))
146 |     for index, x in enumerate(x_test):
147 |         print('Processing Image ', index)
148 |         selected_pixels = []
149 |         best_partial_x = np.zeros(x.shape)
150 |         for p in range(key_numbers):
151 |             errors = []
152 |             partial_images = []
153 |             for pixel in range(32*32):
154 |                 partial_x = copy.copy(best_partial_x)
155 |                 partial_x[pixel/32, pixel%32,:] = x[pixel/32, pixel%32,:]
156 |                 partial_images.append(copy.copy(partial_x))
157 |             partial_images= np.array(partial_images)
158 |             y = ann.autoencoder.predict(partial_images)
159 |             errors = np.sum(np.abs(y-x), axis=(1,2,3))
160 |             best_pixel = np.argmin(errors)
161 |             best_partial_x[best_pixel/32, best_pixel%32,:] = x[best_pixel/32, best_pixel%32,:]
162 |             selected_pixels.append(best_pixel)
163 |         partial_x = np.zeros(x.shape)
164 |         mask = np.zeros(x.shape)
165 |         for pixel in selected_pixels:
166 |             partial_x[pixel/32, pixel%32,:] = x[pixel/32, pixel%32,:]
167 |             mask[pixel/32, pixel%32] = 1
168 |         y = ann.autoencoder.predict(partial_x.reshape(1,32,32,3))
169 |         ax = fig.add_subplot(len(x_test),4,index*4+1)
170 |         ax.imshow(x)
171 |         ax = fig.add_subplot(len(x_test),4,index*4+2)
172 |         ax.imshow(mask)
173 |         ax = fig.add_subplot(len(x_test),4,index*4+3)
174 |         ax.imshow(partial_x)
175 |         ax = fig.add_subplot(len(x_test),4,index*4+4)
176 |         ax.imshow(y[0])
177 |         plt.show()
178 |     fig.savefig(str(key_numbers)+'cifar3.jpg')
179 | 
180 | 
181 | if __name__ == '__main__':
182 |     # Load MNIST dataset
183 |     import copy
184 |     (x_train, y_train), (x_test, y_test) = cifar10.load_data()
185 |     x_train = x_train.astype(np.float32) / 255.
186 |     x_test = x_test.astype(np.float32) / 255.
187 | #    x_out = copy.copy(x_train)
188 | #    x_in = []
189 | #    for x in x_train:
190 | #        mask = np.random.choice([0, 1], size=(32, 32), p=[1./10, 9./10])
191 | #        mask = np.dstack([mask, mask, mask])
192 | #        mm = np.ma.masked_array(x, mask= mask)
193 | #        x[mm.mask]=0
194 | #        x_in.append(x)
195 | #    x_in = np.array(x_in)
196 |     ann = GAE(img_shape = x_train[0].shape, encoded_dim=100)
197 |     #ann.autoencoder.load_weights('weights.03.hdf5')
198 |     ann.train(x_train, epochs=0)
199 |     #ann.generateAndPlot(x_in[0:10])
200 |     plotResults(ann, x_test[np.random.randint(0, len(x_test), 5)],100)
201 |     #generated = ann.generate(10000)
202 |     #L = helpers.approximateLogLiklihood(generated, x_test, searchSpace=[.1])
203 |     #print L
204 |     #codes = ann.kde.sample(1000)
205 |     #ax = Axes3D(plt.gcf())
206 |     #codes = ann.encoder.predict(x_train)
207 |     #plt.scatter(codes[:,0], codes[:,1], c=y_train)
208 |     #plt.show()
209 | 


--------------------------------------------------------------------------------
/GAE_GAN.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | # -*- coding: utf-8 -*-
  4 | # Author : Ali Mirzaei
  5 | # Date : 19/09/2017
  6 | 
  7 | import glob
  8 | from keras.models import Sequential, Model
  9 | from keras.layers import Dense, Input, Flatten, Reshape
 10 | from keras.datasets import mnist, cifar10
 11 | from keras.optimizers import Adam, SGD
 12 | import numpy as np
 13 | import matplotlib
 14 | matplotlib.use('Agg')
 15 | import matplotlib.pyplot as plt
 16 | from sklearn.neighbors.kde import KernelDensity
 17 | from mpl_toolkits.mplot3d import Axes3D
 18 | import helpers
 19 | from sklearn.model_selection import GridSearchCV
 20 | import keras
 21 | from keras.initializers import RandomNormal
 22 | 
 23 | initializer = RandomNormal(mean=0.0, stddev=0.01, seed=None)
 24 | 
 25 | class GAE():
 26 |     def __init__(self, img_shape=(28, 28), encoded_dim=2):
 27 |         self.encoded_dim = encoded_dim
 28 |         self.optimizer = SGD(0.001, momentum=.9)
 29 |         self.optimizer_discriminator = SGD(0.0001, momentum=.9)
 30 |         self.optimizer_autoencoder = Adam(0.0001)
 31 |         self._initAndCompileFullModel(img_shape, encoded_dim)
 32 |         self.img_shape = img_shape
 33 | 
 34 |     def _genEncoderModel(self, img_shape, encoded_dim):
 35 |         """ Build Encoder Model Based on Paper Configuration
 36 |         Args:
 37 |             img_shape (tuple) : shape of input image
 38 |             encoded_dim (int) : number of latent variables
 39 |         Return:
 40 |             A sequential keras model
 41 |         """
 42 |         encoder = Sequential()
 43 |         encoder.add(Flatten(input_shape=img_shape))
 44 |         encoder.add(Dense(1000, activation='relu'))
 45 |         encoder.add(Dense(1000, activation='relu'))
 46 |         encoder.add(Dense(encoded_dim))
 47 |         encoder.summary()
 48 |         return encoder
 49 | 
 50 |     def _getDecoderModel(self, encoded_dim, img_shape):
 51 |         """ Build Decoder Model Based on Paper Configuration
 52 |         Args:
 53 |             encoded_dim (int) : number of latent variables
 54 |             img_shape (tuple) : shape of target images
 55 |         Return:
 56 |             A sequential keras model
 57 |         """
 58 |         decoder = Sequential()
 59 |         decoder.add(Dense(1000, activation='relu', input_dim=encoded_dim))
 60 |         decoder.add(Dense(1000, activation='relu'))
 61 |         decoder.add(Dense(np.prod(img_shape), activation='sigmoid'))
 62 |         decoder.add(Reshape(img_shape))
 63 |         decoder.summary()
 64 |         return decoder
 65 | 
 66 |     def _getDescriminator(self, img_shape):
 67 |         """ Build Descriminator Model Based on Paper Configuration
 68 |         Args:
 69 |             encoded_dim (int) : number of latent variables
 70 |         Return:
 71 |             A sequential keras model
 72 |         """
 73 |         discriminator = Sequential()
 74 |         discriminator.add(Flatten(input_shape=img_shape))
 75 |         discriminator.add(Dense(1000, activation='relu',
 76 |                                 kernel_initializer=initializer,
 77 |                 bias_initializer=initializer))
 78 |         discriminator.add(Dense(1000, activation='relu', kernel_initializer=initializer,
 79 |                 bias_initializer=initializer))
 80 |         discriminator.add(Dense(1, activation='sigmoid', kernel_initializer=initializer,
 81 |                 bias_initializer=initializer))
 82 |         discriminator.summary()
 83 |         return discriminator
 84 | 
 85 |     def _initAndCompileFullModel(self, img_shape, encoded_dim):
 86 |         self.encoder = self._genEncoderModel(img_shape, encoded_dim)
 87 |         self.decoder = self._getDecoderModel(encoded_dim, img_shape)
 88 |         self.discriminator = self._getDescriminator(img_shape)
 89 |         img = Input(shape=img_shape)
 90 |         encoded_repr = self.encoder(img)
 91 |         gen_img = self.decoder(encoded_repr)
 92 |         self.autoencoder = Model(img, gen_img)
 93 |         self.autoencoder.compile(optimizer=self.optimizer_autoencoder, loss='mse')
 94 |         self.discriminator.compile(optimizer=self.optimizer_discriminator, 
 95 |                                    loss='binary_crossentropy',
 96 |                                    metrics=['accuracy'])
 97 |         for layer in self.discriminator.layers:
 98 |             layer.trainable = False
 99 | 
100 |         is_real = self.discriminator(gen_img)
101 |         self.autoencoder_discriminator = Model(img, is_real)
102 |         self.autoencoder_discriminator.compile(optimizer=self.optimizer, loss='binary_crossentropy',
103 |                                            metrics=['accuracy'])
104 | 
105 |     def imagegrid(self, epochnumber):
106 |         fig = plt.figure(figsize=[20, 20])
107 |         for i in range(-5, 5):
108 |             for j in range(-5,5):
109 |                 topred = np.array((i*0.5,j*0.5))
110 |                 topred = topred.reshape((1, 2))
111 |                 img = self.decoder.predict(topred)
112 |                 img = img.reshape(self.img_shape)
113 |                 ax = fig.add_subplot(10, 10, (i+5)*10+j+5+1)
114 |                 ax.set_axis_off()
115 |                 ax.imshow(img, cmap="gray")
116 |         fig.savefig(str(epochnumber)+".png")
117 |         plt.show()
118 |         plt.close(fig)
119 | 
120 |     def train(self, x_train, batch_size=32, epochs=5):
121 |         self.autoencoder.fit(x_train, x_train, epochs=1)
122 |         for epoch in range(epochs):
123 |             #---------------Train Discriminator -------------
124 |             # Select a random half batch of images
125 |             idx = np.random.randint(0, x_train.shape[0], batch_size)
126 |             imgs_real = x_train[idx]
127 |             idx = np.random.randint(0, x_train.shape[0], batch_size)
128 |             imgs_real2 = x_train[idx]
129 |             # Generate a half batch of new images
130 |             #gen_imgs = self.decoder.predict(latent_fake)
131 |             imgs_fake = self.autoencoder.predict(imgs_real2)
132 |             valid = np.ones((batch_size, 1))
133 |             fake = np.zeros((batch_size, 1))
134 |             # Train the discriminator
135 |             d_loss_real = self.discriminator.train_on_batch(imgs_real, valid)
136 |             d_loss_fake = self.discriminator.train_on_batch(imgs_fake, fake)
137 |             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
138 |             #d_loss = (0,0)
139 |             idx = np.random.randint(0, x_train.shape[0], batch_size)
140 |             imgs_real = x_train[idx]
141 |             # Generator wants the discriminator to label the generated representations as valid
142 |             valid_y = np.ones((batch_size, 1))
143 |             # Train generator
144 |             g_logg_similarity = self.autoencoder_discriminator.train_on_batch(imgs_real, valid_y)
145 |             # Plot the progress
146 |             print ("%d [D loss = %.2f, accuracy: %.2f] [G loss = %f, accuracy: %.2f]" % (epoch,d_loss[0], d_loss[1], g_logg_similarity[0], g_logg_similarity[1]))
147 | #            if(epoch % save_interval == 0):
148 | #                self.imagegrid(epoch)
149 |         codes = self.encoder.predict(x_train)
150 | #        params = {'bandwidth': [3.16]}#np.logspace(0, 2, 5)}
151 | #        grid = GridSearchCV(KernelDensity(), params, n_jobs=4)
152 | #        grid.fit(codes)
153 | #        print grid.best_params_
154 | #        self.kde = grid.best_estimator_
155 |         self.kde = KernelDensity(kernel='gaussian', bandwidth=3.16).fit(codes)
156 | 
157 | 
158 |     def generate(self, n = 10000):
159 |         codes = self.kde.sample(n)
160 |         images = self.decoder.predict(codes)
161 |         return images
162 | 
163 |     def generateAndPlot(self, x_train, n = 10, fileName="generated.png"):
164 |         fig = plt.figure(figsize=[20, 20])
165 |         images = self.generate(n*n)
166 |         index = 1
167 |         for image in images:
168 |             image = image.reshape(self.img_shape)
169 |             ax = fig.add_subplot(n, n+1, index)
170 |             index=index+1
171 |             ax.set_axis_off()
172 |             ax.imshow(image, cmap="gray")
173 |             if((index)%(n+1) == 0):
174 |                 nearest = helpers.findNearest(x_train, image)
175 |                 ax = fig.add_subplot(n, n+1, index)
176 |                 index= index+1
177 |                 ax.imshow(nearest, cmap="gray")
178 |         fig.savefig(fileName)
179 |         plt.show()
180 | 
181 |     def meanLogLikelihood(self, x_test):
182 |         KernelDensity(kernel='gaussian', bandwidth=0.2).fit(codes)
183 | if __name__ == '__main__':
184 |     # Load MNIST dataset
185 |     (x_train, y_train), (x_test, y_test) = mnist.load_data()
186 |     x_train = x_train.astype(np.float32) / 255.
187 |     x_test = x_test.astype(np.float32) / 255.
188 |     ann = GAE(img_shape=(28,28), encoded_dim=2)
189 |     ann.train(x_train, epochs=1000)
190 |     ann.generateAndPlot(x_train)
191 | #    generated = ann.generate(10000)
192 | #    L = helpers.approximateLogLiklihood(generated, x_test, searchSpace=[.1])
193 | #    print L
194 | #    #codes = ann.kde.sample(1000)
195 | #    #ax = Axes3D(plt.gcf())
196 | #    codes = ann.encoder.predict(x_train)
197 | #    plt.scatter(codes[:,0], codes[:,1], c=y_train)
198 | #    plt.show()
199 | 


--------------------------------------------------------------------------------
/GAE_image_completion.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | # -*- coding: utf-8 -*-
  4 | # Author : Ali Mirzaei
  5 | # Date : 19/09/2017
  6 | 
  7 | import glob
  8 | from keras.models import Sequential, Model
  9 | from keras.layers import Dense, Input, Flatten, Reshape, Lambda
 10 | from keras.datasets import mnist, cifar10
 11 | from keras.optimizers import Adam
 12 | import numpy as np
 13 | import matplotlib.pyplot as plt
 14 | from sklearn.neighbors.kde import KernelDensity
 15 | from mpl_toolkits.mplot3d import Axes3D
 16 | import helpers
 17 | from sklearn.model_selection import GridSearchCV
 18 | import keras
 19 | from keras.initializers import RandomNormal
 20 | import keras.backend as K
 21 | 
 22 | initializer = RandomNormal(mean=0.0, stddev=0.01, seed=None)
 23 | 
 24 | def selector(args):
 25 |     xs, ys, image = args
 26 |     xs = K.cast(xs, K.tf.int32)
 27 |     ys = K.cast(ys, K.tf.int32)
 28 |     image = Reshape((28,28))(image)
 29 | #    x = xy_s[0:100]
 30 | #    y = xy_s[100:200]
 31 |     img = K.zeros((28,28))
 32 |     #tt=image[xs[0,:],ys[0,:]]
 33 |     return image
 34 | 
 35 | class GAE():
 36 |     def __init__(self, img_shape=(28, 28), encoded_dim=2):
 37 |         self.encoded_dim = encoded_dim
 38 |         self.optimizer = Adam(0.001)
 39 |         self.optimizer_discriminator = Adam(0.00001)
 40 |         self._initAndCompileFullModel(img_shape, encoded_dim)
 41 |         self.img_shape = img_shape
 42 | 
 43 |     def _genEncoderModel(self, img_shape, encoded_dim):
 44 |         """ Build Encoder Model Based on Paper Configuration
 45 |         Args:
 46 |             img_shape (tuple) : shape of input image
 47 |             encoded_dim (int) : number of latent variables
 48 |         Return:
 49 |             A sequential keras model
 50 |         """
 51 |         encoder = Sequential()
 52 |         encoder.add(Flatten(input_shape=img_shape))
 53 |         encoder.add(Dense(1000, activation='relu'))
 54 |         encoder.add(Dense(1000, activation='relu'))
 55 |         encoder.add(Dense(encoded_dim))
 56 |         encoder.summary()
 57 |         return encoder
 58 | 
 59 |     def _getDecoderModel(self, encoded_dim, img_shape):
 60 |         """ Build Decoder Model Based on Paper Configuration
 61 |         Args:
 62 |             encoded_dim (int) : number of latent variables
 63 |             img_shape (tuple) : shape of target images
 64 |         Return:
 65 |             A sequential keras model
 66 |         """
 67 |         decoder = Sequential()
 68 |         decoder.add(Dense(1000, activation='relu', input_dim=encoded_dim))
 69 |         decoder.add(Dense(1000, activation='relu'))
 70 |         decoder.add(Dense(np.prod(img_shape), activation='sigmoid'))
 71 |         decoder.add(Reshape(img_shape))
 72 |         decoder.summary()
 73 |         return decoder
 74 | 
 75 |     def _getLocationNetwork(self, img_shape):
 76 |         """ Build Descriminator Model Based on Paper Configuration
 77 |         Args:
 78 |             encoded_dim (int) : number of latent variables
 79 |         Return:
 80 |             A sequential keras model
 81 |         """
 82 |         locationNetwork = Sequential()
 83 |         locationNetwork.add(Flatten(input_shape=img_shape))
 84 |         locationNetwork.add(Dense(1000, activation='relu',
 85 |                                 kernel_initializer=initializer,
 86 |                 bias_initializer=initializer))
 87 |         locationNetwork.add(Dense(1000, activation='relu', kernel_initializer=initializer,
 88 |                 bias_initializer=initializer))
 89 |         locationNetwork.add(Dense(100, activation='sigmoid', kernel_initializer=initializer,
 90 |                 bias_initializer=initializer))
 91 |         locationNetwork.summary()
 92 |         img = Input(shape=img_shape)
 93 |         xs = locationNetwork(img)
 94 |         ys = locationNetwork(img)
 95 |         #img_xys = K.concatenate([xys, Flatten()(img)])
 96 |         out = Lambda(selector,output_shape=img_shape)([xs, ys,img])
 97 |         return Model(img,out)
 98 | 
 99 |     def _initAndCompileFullModel(self, img_shape, encoded_dim):
100 |         self.encoder = self._genEncoderModel(img_shape, encoded_dim)
101 |         self.decoder = self._getDecoderModel(encoded_dim, img_shape)
102 |         img = Input(shape=img_shape)
103 |         encoded_repr = self.encoder(img)
104 |         gen_img = self.decoder(encoded_repr)
105 |         self.autoencoder = Model(img, gen_img)
106 |         self.autoencoder.compile(optimizer=self.optimizer, loss='mse')
107 |         #self.locator = self._getLocationNetwork(img_shape)
108 |         #self.locator.compile(optimizer=self.optimizer, loss='mse')
109 | 
110 |     def imagegrid(self, epochnumber):
111 |         fig = plt.figure(figsize=[20, 20])
112 |         for i in range(-5, 5):
113 |             for j in range(-5,5):
114 |                 topred = np.array((i*0.5,j*0.5))
115 |                 topred = topred.reshape((1, 2))
116 |                 img = self.decoder.predict(topred)
117 |                 img = img.reshape(self.img_shape)
118 |                 ax = fig.add_subplot(10, 10, (i+5)*10+j+5+1)
119 |                 ax.set_axis_off()
120 |                 ax.imshow(img, cmap="gray")
121 |         fig.savefig(str(epochnumber)+".png")
122 |         plt.show()
123 |         plt.close(fig)
124 | 
125 |     def train(self, x_in, x_out, batch_size=32, epochs=5):
126 |         self.autoencoder.load_weights('weights.04.hdf5')
127 |         self.autoencoder.fit(x_in, x_out, epochs=epochs, batch_size=batch_size,
128 |                               callbacks=[keras.callbacks.ModelCheckpoint('weights.{epoch:02d}.hdf5', 
129 |                                            verbose=0, 
130 |                                            save_best_only=False, 
131 |                                            save_weights_only=False, 
132 |                                            mode='auto', 
133 |                                            period=1),
134 |     keras.callbacks.TensorBoard(log_dir='./logs', 
135 |                                 histogram_freq=0, 
136 |                                 batch_size=batch_size, write_graph=True,
137 |                                 write_grads=False,
138 |                                 write_images=False,
139 |                                 embeddings_freq=0,
140 |                                 embeddings_layer_names=None,
141 |                                 embeddings_metadata=None)])
142 | 
143 |     def trainGAN(self, x_train, epochs =1000, batch_size=32):
144 |         half_batch = batch_size/2
145 |         for epoch in range(epochs):
146 |             #---------------Train Discriminator -------------
147 |             # Select a random half batch of images
148 |             idx = np.random.randint(0, x_train.shape[0], half_batch)
149 |             imgs_real = x_train[idx]
150 |             # Generate a half batch of new images
151 |             imgs_fake = self.generate(n = half_batch)
152 |             #gen_imgs = self.decoder.predict(latent_fake)
153 |             valid = np.ones((half_batch, 1))
154 |             fake = np.zeros((half_batch, 1))
155 |             # Train the discriminator
156 |             d_loss_real = self.discriminator.train_on_batch(imgs_real, valid)
157 |             d_loss_fake = self.discriminator.train_on_batch(imgs_fake, fake)
158 |             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
159 |             #d_loss = (0,0)
160 |             codes = self.kde.sample(batch_size)
161 |             # Generator wants the discriminator to label the generated representations as valid
162 |             valid_y = np.ones((batch_size, 1))
163 |             # Train generator
164 |             g_logg_similarity = self.decoder_discriminator.train_on_batch(codes, valid_y)
165 |             # Plot the progress
166 |             print ("%d [D accuracy: %.2f] [G accuracy: %.2f]" % (epoch, d_loss[1], g_logg_similarity[1]))
167 | #            if(epoch % save_interval == 0):
168 | #                self.imagegrid(epoch)
169 | 
170 |     def generate(self, n = 10000):
171 |         codes = self.kde.sample(n)
172 |         images = self.decoder.predict(codes)
173 |         return images
174 | 
175 |     def generateAndPlot(self, x_test, n = 10, fileName="generated.png"):
176 |         fig = plt.figure(figsize=[20, 20*n/3])
177 |         for i in range(n):
178 |             x_in = x_test[np.random.randint(len(x_test))]
179 |             x=copy.copy(x_in)
180 |             mask = np.random.choice([0, 1], size=(28, 28), p=[1./10, 9./10])
181 |             mm = np.ma.masked_array(x, mask= mask)
182 |             x[mm.mask]=0
183 |             y = self.autoencoder.predict(x.reshape(1, 28, 28))
184 |             ax = fig.add_subplot(n, 3, i*3+1)
185 |             ax.set_axis_off()
186 |             ax.imshow(x)
187 |             ax = fig.add_subplot(n, 3, i*3+2)
188 |             ax.set_axis_off()
189 |             ax.imshow(y[0])
190 |             ax = fig.add_subplot(n, 3, i*3+3)
191 |             ax.set_axis_off()
192 |             ax.imshow(x_in)
193 |         fig.savefig(fileName)
194 |         plt.show()
195 | 
196 |     def meanLogLikelihood(self, x_test):
197 |         KernelDensity(kernel='gaussian', bandwidth=0.2).fit(codes)
198 | 
199 | def plotResults(ann, x_test, key_numbers = 10):
200 |     fig = plt.figure(figsize=(10, 10*len(x_test)/4))
201 |     for index, x in enumerate(x_test):
202 |         errors = []
203 |         for pixel in range(28*28):
204 |             partial_x = np.zeros(x.shape)
205 |             partial_x[pixel/28, pixel%28] = x[pixel/28, pixel%28]
206 |             y = ann.autoencoder.predict(partial_x.reshape(1,28,28))
207 |             error = np.sum(np.abs(y-x))
208 |             errors.append(error)
209 |         pixels = np.argsort(errors)
210 |         selected_pixels = pixels[0:key_numbers]
211 |         partial_x = np.zeros(x.shape)
212 |         mask = np.zeros(x.shape)
213 |         for pixel in selected_pixels:
214 |             partial_x[pixel/28, pixel%28] = x[pixel/28, pixel%28]
215 |             mask[pixel/28, pixel%28] = 1
216 |         y = ann.autoencoder.predict(partial_x.reshape(1,28,28))
217 |         ax = fig.add_subplot(len(x_test),4,index*4+1)
218 |         ax.imshow(x)
219 |         ax = fig.add_subplot(len(x_test),4,index*4+2)
220 |         ax.imshow(mask)
221 |         ax = fig.add_subplot(len(x_test),4,index*4+3)
222 |         ax.imshow(partial_x)
223 |         ax = fig.add_subplot(len(x_test),4,index*4+4)
224 |         ax.imshow(y[0])
225 |         plt.show()
226 |     fig.savefig(str(key_numbers)+'.jpg')
227 | 
228 | import copy
229 | if __name__ == '__main__':
230 |     # Load MNIST dataset
231 |     (x_train, y_train), (x_test, y_test) = mnist.load_data()
232 |     x_train = x_train.astype(np.float32) / 255.
233 |     x_test = x_test.astype(np.float32) / 255.
234 |     x_out = copy.copy(x_train)
235 |     x_in = []
236 |     for x in x_train:
237 |         mask = np.random.choice([0, 1], size=(28, 28), p=[1./10, 9./10])
238 |         mm = np.ma.masked_array(x, mask= mask)
239 |         x[mm.mask]=0
240 |         x_in.append(x)
241 |     x_in = np.array(x_in)
242 |     ann = GAE(img_shape=(28,28), encoded_dim=8)
243 |     ann.train(x_in,x_out, epochs=0)
244 |     plotResults(ann, x_test[0:10], key_numbers=1)
245 |     plotResults(ann, x_test[0:10], key_numbers=5)
246 |     plotResults(ann, x_test[0:10], key_numbers=10)
247 |     plotResults(ann, x_test[0:10], key_numbers=25)
248 |     plotResults(ann, x_test[0:10], key_numbers=50)
249 |     plotResults(ann, x_test[0:10], key_numbers=100)
250 |     plotResults(ann, x_test[0:10], key_numbers=400)
251 | 
252 | 
253 |     #ann.generateAndPlot(x_test,50)
254 | #    ann.generateAndPlot(x_train)
255 | #    generated = ann.generate(10000)
256 | #    L = helpers.approximateLogLiklihood(generated, x_test, searchSpace=[.1])
257 | #    print L
258 | #    #codes = ann.kde.sample(1000)
259 | #    #ax = Axes3D(plt.gcf())
260 | #    codes = ann.encoder.predict(x_train)
261 | #    plt.scatter(codes[:,0], codes[:,1], c=y_train)
262 | #    plt.show()
263 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
1 | Adverserail Autoencoder in Keras
2 | ================================
3 | 
4 | 
5 | Generation of data in MNIST dataset
6 | 
7 | Description can be found here:
8 | https://medium.com/@a.mirzaei69/adversarial-autoencoders-on-mnist-dataset-python-keras-implementation-5eeafd52ab21
9 | 


--------------------------------------------------------------------------------
/SAAE.py:
--------------------------------------------------------------------------------
  1 | s# -*- coding: utf-8 -*-
  2 | # Author : Ali Mirzaei
  3 | # Date : 06/10/2017
  4 | 
  5 | # Supervised Adverserial Autoencoder Fig 6
  6 | 
  7 | from keras.models import Sequential, Model
  8 | from keras.layers import Dense, Input, Flatten, Reshape, concatenate
  9 | from keras.datasets import mnist
 10 | from keras.optimizers import Adam
 11 | import numpy as np
 12 | import matplotlib.pyplot as plt
 13 | 
 14 | 
 15 | class SAAE():
 16 |     def __init__(self, img_shape=(28, 28), encoded_dim=2):
 17 |         self.encoded_dim = encoded_dim
 18 |         self.optimizer_reconst = Adam(0.001)
 19 |         self.optimizer_discriminator = Adam(0.0001)
 20 |         self._initAndCompileFullModel(img_shape, encoded_dim)
 21 | 
 22 |     def _genEncoderModel(self, img_shape, encoded_dim):
 23 |         """ Build Encoder Model Based on Paper Configuration
 24 |         Args:
 25 |             img_shape (tuple) : shape of input image
 26 |             encoded_dim (int) : number of latent variables
 27 |         Return:
 28 |             A sequential keras model
 29 |         """
 30 |         encoder = Sequential()
 31 |         encoder.add(Flatten(input_shape=img_shape))
 32 |         encoder.add(Dense(1000, activation='relu'))
 33 |         encoder.add(Dense(1000, activation='relu'))
 34 |         encoder.add(Dense(encoded_dim))
 35 |         encoder.summary()
 36 |         return encoder
 37 | 
 38 |     def _getDecoderModel(self, encoded_dim, img_shape):
 39 |         """ Build Decoder Model Based on Paper Configuration
 40 |         Args:
 41 |             encoded_dim (int) : number of latent variables
 42 |             img_shape (tuple) : shape of target images
 43 |         Return:
 44 |             A sequential keras model
 45 |         """
 46 |         latent_input = Input(shape=(encoded_dim,))
 47 |         labels_input = Input(shape=(10,))
 48 |         concated = concatenate([latent_input, labels_input])
 49 |         decoder = Sequential()
 50 |         decoder.add(Dense(1000, activation='relu', input_dim=encoded_dim+10))
 51 |         decoder.add(Dense(1000, activation='relu'))
 52 |         decoder.add(Dense(np.prod(img_shape), activation='sigmoid'))
 53 |         decoder.add(Reshape(img_shape))
 54 |         out = decoder(concated)
 55 |         decoder_model = Model([latent_input, labels_input], out)
 56 |         decoder_model.summary()
 57 |         return decoder_model
 58 | 
 59 |     def _getDescriminator(self, encoded_dim):
 60 |         """ Build Descriminator Model Based on Paper Configuration
 61 |         Args:
 62 |             encoded_dim (int) : number of latent variables
 63 |         Return:
 64 |             A sequential keras model
 65 |         """
 66 |         discriminator = Sequential()
 67 |         discriminator.add(Dense(1000, activation='relu',
 68 |                                 input_dim=encoded_dim))
 69 |         discriminator.add(Dense(1000, activation='relu'))
 70 |         discriminator.add(Dense(1, activation='sigmoid'))
 71 |         discriminator.summary()
 72 |         return discriminator
 73 | 
 74 |     def _initAndCompileFullModel(self, img_shape, encoded_dim):
 75 |         self.encoder = self._genEncoderModel(img_shape, encoded_dim)
 76 |         self.decoder = self._getDecoderModel(encoded_dim, img_shape)
 77 |         self.discriminator = self._getDescriminator(encoded_dim)
 78 |         img = Input(shape=img_shape)
 79 |         label = Input(shape=(10,))
 80 |         encoded_repr = self.encoder(img)
 81 |         gen_img = self.decoder([encoded_repr, label])
 82 |         self.autoencoder = Model([img, label], gen_img)
 83 |         valid = self.discriminator(encoded_repr)
 84 |         self.encoder_discriminator = Model(img, valid)
 85 |         self.discriminator.compile(optimizer=self.optimizer_discriminator,
 86 |                                    loss='binary_crossentropy',
 87 |                                    metrics=['accuracy'])
 88 |         self.autoencoder.compile(optimizer=self.optimizer_reconst,
 89 |                                  loss ='mse')
 90 |         for layer in self.discriminator.layers:
 91 |             layer.trainable = False
 92 |         self.encoder_discriminator.compile(optimizer=self.optimizer_discriminator,
 93 |                                            loss='binary_crossentropy',
 94 |                                            metrics=['accuracy'])
 95 |     def imagegrid(self, epochnumber):
 96 |         fig = plt.figure(figsize=[20, 20])
 97 |         labels = self.getOneHotCodes(range(10))
 98 |         styles = np.random.normal(size=(10, self.encoded_dim))
 99 |         k=0
100 |         for label in labels:
101 |             for style in styles:
102 |                 img = self.decoder.predict([style.reshape(-1,self.encoded_dim), label.reshape(-1,10)])
103 |                 img = img.reshape((28, 28))
104 |                 k = k + 1
105 |                 ax = fig.add_subplot(10, 10, k)
106 |                 ax.set_axis_off()
107 |                 ax.imshow(img, cmap="gray")
108 |         fig.savefig("images/SAAE/" + str(epochnumber) + ".png")
109 |         plt.show()
110 |         plt.close(fig)
111 | 
112 |     def getOneHotCodes(self, y_train):
113 |         labels = np.zeros((len(y_train), 10))
114 |         labels[range(len(y_train)), np.array(y_train).astype(int)] = 1
115 |         return labels
116 | 
117 |     def train(self, x_train, y_train, batch_size=32, epochs=5000, save_image_interval=50):
118 |         labels = self.getOneHotCodes(y_train)
119 |         save_interval = 50
120 |         for epoch in range(epochs):
121 |             #---------------Train Discriminator -------------
122 |             # Select a random half batch of images
123 |             idx = np.random.randint(0, x_train.shape[0], batch_size)
124 |             imgs = x_train[idx]
125 |             labels_batch = labels[idx, :]
126 |             # Generate a half batch of new images
127 |             latent_fake = self.encoder.predict(imgs)
128 |             #gen_imgs = self.decoder.predict(latent_fake)
129 |             latent_real = np.random.normal(size=(batch_size, self.encoded_dim))
130 |             valid = np.ones((batch_size, 1))
131 |             fake = np.zeros((batch_size, 1))
132 |             # Train the discriminator
133 |             d_loss_real = self.discriminator.train_on_batch(latent_real, valid)
134 |             d_loss_fake = self.discriminator.train_on_batch(latent_fake, fake)
135 |             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
136 | 
137 |             #idx = np.random.randint(0, x_train.shape[0], batch_size)
138 |             #imgs = x_train[idx]
139 |             # Generator wants the discriminator to label the generated representations as valid
140 |             valid_y = np.ones((batch_size, 1))
141 | 
142 |             # Train the autoencode reconstruction
143 |             g_loss_reconstruction = self.autoencoder.train_on_batch([imgs, labels_batch], imgs)
144 | 
145 |             # Train generator
146 |             g_logg_similarity = self.encoder_discriminator.train_on_batch(imgs, valid_y)
147 |             # Plot the progress
148 |             print ("%d [D loss: %f, acc: %.2f%%] [G acc: %f, mse: %f]" % (epoch, d_loss[0], 100*d_loss[1],
149 |                    g_logg_similarity[1], g_loss_reconstruction))
150 |             if(epoch % save_interval == 0):
151 |                 self.imagegrid(epoch)
152 | 
153 | 
154 | if __name__ == '__main__':
155 |     # Load MNIST dataset
156 |     (x_train, y_train), (x_test, y_test) = mnist.load_data()
157 |     x_train = x_train.astype(np.float32) / 255.
158 |     x_test = x_test.astype(np.float32) / 255.
159 |     ann = SAAE()
160 |     ann.train(x_train, y_train)
161 | 


--------------------------------------------------------------------------------
/SSAAE.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # Author : Ali Mirzaei
  3 | # Date : 05/10/2017
  4 | # Semi-Supervised Adverserial Autoencoder Fig III in paper
  5 | 
  6 | from keras.models import Sequential, Model
  7 | from keras.layers import Dense, Input, Flatten, Reshape, concatenate
  8 | from keras.datasets import mnist
  9 | from keras.optimizers import Adam, SGD
 10 | import numpy as np
 11 | import matplotlib
 12 | import helpers
 13 | 
 14 | matplotlib.use('Agg')
 15 | 
 16 | import matplotlib.pyplot as plt
 17 | plt.ioff()
 18 | class SSAAE():
 19 |     def __init__(self, img_shape=(28, 28), encoded_dim=2):
 20 |         self.encoded_dim = encoded_dim
 21 |         self.optimizer_reconst = Adam(0.0001)
 22 |         self.optimizer_discriminator = Adam(0.0001)
 23 |         self._initAndCompileFullModel(img_shape, encoded_dim)
 24 | 
 25 |     def _genEncoderModel(self, img_shape, encoded_dim):
 26 |         """ Build Encoder Model Based on Paper Configuration
 27 |         Args:
 28 |             img_shape (tuple) : shape of input image
 29 |             encoded_dim (int) : number of latent variables
 30 |         Return:
 31 |             A sequential keras model
 32 |         """
 33 |         encoder = Sequential()
 34 |         encoder.add(Flatten(input_shape=img_shape))
 35 |         encoder.add(Dense(1000, activation='relu'))
 36 |         encoder.add(Dense(1000, activation='relu'))
 37 |         encoder.add(Dense(encoded_dim))
 38 |         encoder.summary()
 39 |         return encoder
 40 | 
 41 |     def _getDecoderModel(self, encoded_dim, img_shape):
 42 |         """ Build Decoder Model Based on Paper Configuration
 43 |         Args:
 44 |             encoded_dim (int) : number of latent variables
 45 |             img_shape (tuple) : shape of target images
 46 |         Return:
 47 |             A sequential keras model
 48 |         """
 49 |         decoder = Sequential()
 50 |         decoder.add(Dense(1000, activation='relu', input_dim=encoded_dim))
 51 |         decoder.add(Dense(1000, activation='relu'))
 52 |         decoder.add(Dense(np.prod(img_shape), activation='sigmoid'))
 53 |         decoder.add(Reshape(img_shape))
 54 |         decoder.summary()
 55 |         return decoder
 56 | 
 57 |     def _getDescriminator(self, input_dim):
 58 |         """ Build Descriminator Model Based on Paper Configuration
 59 |         Args:
 60 |             input_dim (int) : number of latent variables
 61 |         Return:
 62 |             A sequential keras model
 63 |         """
 64 |         latent_input = Input(shape=(input_dim,))
 65 |         labels_input = Input(shape=(11,))
 66 |         concated = concatenate([latent_input, labels_input])
 67 |         discriminator = Sequential()
 68 |         discriminator.add(Dense(1000, activation='relu',
 69 |                                 input_dim=input_dim+11))
 70 |         discriminator.add(Dense(1000, activation='relu'))
 71 |         discriminator.add(Dense(1, activation='sigmoid'))
 72 |         out = discriminator(concated)
 73 |         discriminator_model = Model([latent_input, labels_input], out)
 74 |         discriminator_model.summary()
 75 |         return discriminator_model
 76 | 
 77 |     def _initAndCompileFullModel(self, img_shape, encoded_dim):
 78 |         self.encoder = self._genEncoderModel(img_shape, encoded_dim)
 79 |         self.decoder = self._getDecoderModel(encoded_dim, img_shape)
 80 |         self.discriminator = self._getDescriminator(encoded_dim)
 81 |         img = Input(shape=img_shape)
 82 |         label_code = Input(shape=(11,))
 83 |         encoded_repr = self.encoder(img)
 84 |         gen_img = self.decoder(encoded_repr)
 85 |         self.autoencoder = Model(img, gen_img)
 86 |         valid = self.discriminator([encoded_repr, label_code])
 87 |         self.encoder_discriminator = Model([img, label_code], valid)
 88 |         self.discriminator.compile(optimizer=self.optimizer_discriminator,
 89 |                                    loss='binary_crossentropy',
 90 |                                    metrics=['accuracy'])
 91 |         self.autoencoder.compile(optimizer=self.optimizer_reconst,
 92 |                                  loss ='mse')
 93 |         for layer in self.discriminator.layers:
 94 |             layer.trainable = False
 95 |         self.encoder_discriminator.compile(optimizer=self.optimizer_discriminator,
 96 |                                            loss='binary_crossentropy',
 97 |                                            metrics=['accuracy'])
 98 | 
 99 |     def imagegrid(self, epochnumber):
100 |         fig = plt.figure(figsize=[20, 20])
101 |         (latent, labels) = self.generateRandomVectors(range(10))
102 |         imgs = self.decoder.predict(latent)
103 |         for index, img in enumerate(imgs):
104 |             img = img.reshape((28, 28))
105 |             ax = fig.add_subplot(1, 10, index+1)
106 |             ax.set_axis_off()
107 |             ax.imshow(img, cmap="gray")
108 |         fig.savefig("images/SSAAE/" + str(epochnumber)+".png")
109 |         plt.show()
110 |         plt.close(fig)
111 |         
112 |     def saveLatentMap(self,epochnumber, x_test, y_test):
113 |         fig = plt.figure(figsize=[20, 20])
114 |         lat = self.encoder.predict(x_test)
115 |         ax = fig.add_subplot(1, 1, 1)
116 |         ax.scatter(lat[:,0], lat[:,1], c=y_test)
117 |         fig.savefig("images/SSAAE/map_"+ str(epochnumber)+".png")
118 | 
119 | 
120 | 
121 |     def train(self, x_train, y_train, x_test, y_test, batch_size=32, epochs=10000, save_interval=500):
122 |         for epoch in range(epochs):
123 |             #---------------Train Discriminator -------------
124 |             # Select a random half batch of images
125 |             idx = np.random.randint(0, x_train.shape[0], batch_size)
126 |             imgs = x_train[idx]
127 |             y_batch = y_train[idx]
128 |             # Generate a half batch of new images
129 |             latent_fake = self.encoder.predict(imgs)
130 |             #gen_imgs = self.decoder.predict(latent_fake)
131 |             #latent_real = np.random.normal(size=(half_batch, self.encoded_dim))
132 |             (latent_real, labels) = self.generateRandomVectors(y_batch)
133 |             valid = np.ones((batch_size, 1))
134 |             fake = np.zeros((batch_size, 1))
135 |             # Train the discriminator
136 |             d_loss_real = self.discriminator.train_on_batch([latent_real, labels], valid)
137 |             d_loss_fake = self.discriminator.train_on_batch([latent_fake, labels], fake)
138 |             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
139 | 
140 |             #idx = np.random.randint(0, x_train.shape[0], batch_size)
141 |             #imgs = x_train[idx]
142 |             #y_batch = y_train[idx]
143 |             #(_, labels) = self.generateRandomVectors(y_batch)
144 |             # Generator wants the discriminator to label the generated representations as valid
145 |             valid_y = np.ones((batch_size, 1))
146 | 
147 |             # Train the autoencode reconstruction
148 |             g_loss_reconstruction = self.autoencoder.train_on_batch(imgs, imgs)
149 | 
150 |             # Train generator
151 |             g_logg_similarity = self.encoder_discriminator.train_on_batch([imgs, labels], valid_y)
152 |             # Plot the progress
153 |             print ("%d [D loss: %f, acc: %.2f%%] [G acc: %f, mse: %f]" % (epoch, d_loss[0], 100*d_loss[1],
154 |                    g_logg_similarity[1], g_loss_reconstruction))
155 |             if(epoch % save_interval == 0):
156 |                 self.imagegrid(epoch)
157 |                 self.saveLatentMap(epoch, x_test, y_test)
158 | 
159 |     def generateRandomVectors(self, y_train):
160 |         vectors = []
161 |         labels = np.zeros((len(y_train), 11))
162 |         labels[range(len(y_train)), np.array(y_train).astype(int)] = 1
163 |         for index,y in enumerate(y_train):
164 |             if y == 10:
165 |                 l = np.random.randint(0, 10)
166 |             else:
167 |                 l = y
168 |             mean = [10*np.cos((l*2*np.pi)/10), 10*np.sin((l*2*np.pi)/10)]
169 |             v1 = [np.cos((l*2*np.pi)/10), np.sin((l*2*np.pi)/10)]
170 |             v2 = [-np.sin((l*2*np.pi)/10), np.cos((l*2*np.pi)/10)]
171 |             a1 = 8
172 |             a2 = .4
173 |             M =np.vstack((v1,v2)).T
174 |             S = np.array([[a1, 0], [0, a2]])
175 |             cov = np.dot(np.dot(M, S), np.linalg.inv(M))
176 |             #cov = cov*cov.T
177 |             vec = np.random.multivariate_normal(mean=mean, cov=cov,
178 |                                                 size=1)
179 |             vectors.append(vec)
180 |         return (np.array(vectors).reshape(-1, 2), labels)
181 | 
182 | if __name__ == '__main__':
183 |     # Load MNIST dataset
184 |     (x_train, y_train), (x_test, y_test) = mnist.load_data()
185 |     idx_unlabel = np.random.randint(0, x_train.shape[0], 20000)
186 |     y_train[idx_unlabel] = 10
187 |     x_train = x_train.astype(np.float32) / 255.
188 |     x_test = x_test.astype(np.float32) / 255.
189 |     ann = SSAAE()
190 |     #vecs,b = ann.generateRandomVectors(1000*range(10))
191 |     #plt.scatter(vecs[:,0], vecs[:,1])
192 |     ann.train(x_train, y_train, x_test, y_test, epochs=1)
193 |     vecs,b = ann.generateRandomVectors(1000*range(10))
194 |     generated=ann.decoder.predict(vecs)
195 |     print generated.shape
196 |     L= helpers.approximateLogLiklihood(generated, x_test)
197 |     print "Log Likelihood"
198 |     print L


--------------------------------------------------------------------------------
/autoencoder_torch.py:
--------------------------------------------------------------------------------
  1 | import torch
  2 | from torch import nn
  3 | from torch.autograd import Variable
  4 | from torch.nn import functional as F
  5 | import numpy as np
  6 | from torchvision import datasets, transforms
  7 | from torch import optim
  8 | import matplotlib.pyplot as plt
  9 | 
 10 | kwargs =  {}
 11 | train_loader = torch.utils.data.DataLoader(
 12 |     datasets.MNIST('mnist', train=True, download=True,
 13 |                    transform= transforms.ToTensor()),
 14 |     batch_size=32, shuffle=True, **kwargs)
 15 | 
 16 | class AE(nn.Module):
 17 |     """Autoencoder
 18 |     autoencoder to generate image   
 19 |     """
 20 |     def __init__(self, input_shape=(28, 28), latent_dim=2):
 21 |         super(GAE, self).__init__()
 22 |         self.input_shape = input_shape
 23 |         self.fc1 = nn.Linear(np.prod(input_shape), 1000)
 24 |         self.fc2 = nn.Linear(1000, 1000)
 25 |         self.fc3 = nn.Linear(1000, latent_dim)
 26 |         self.fc4 = nn.Linear(latent_dim, 1000)
 27 |         self.fc5 = nn.Linear(1000, 1000)
 28 |         self.fc6 = nn.Linear(1000, np.prod(input_shape))
 29 |     def forward(self, x):
 30 |         x = x.view((-1, 1, np.prod(self.input_shape)))
 31 |         x = F.relu(self.fc1(x))
 32 |         x = F.relu(self.fc2(x))
 33 |         x = self.fc3(x)
 34 |         x = F.relu(self.fc4(x))
 35 |         x = F.relu(self.fc5(x))
 36 |         x = F.sigmoid(self.fc6(x))
 37 |         x = x.view((-1, 1)+self.input_shape)
 38 |         return x
 39 |     def generateAndPlot(self, x_test, n = 10, fileName="generated.png"):
 40 |         fig = plt.figure(figsize=[20, 20*n/3])
 41 |         for i in range(n):
 42 |             x_in = x_test[np.random.randint(len(x_test))]
 43 |             x=copy.copy(x_in)
 44 |             mask = np.random.choice([0, 1], size=(28, 28), p=[1./10, 9./10])
 45 |             mm = np.ma.masked_array(x, mask= mask)
 46 |             x[mm.mask]=0
 47 |             y = self.forward(Variable(torch.from_numpy(x.reshape(1, 1, 28, 28))))
 48 |             ax = fig.add_subplot(n, 3, i*3+1)
 49 |             ax.set_axis_off()
 50 |             ax.imshow(x)
 51 |             ax = fig.add_subplot(n, 3, i*3+2)
 52 |             ax.set_axis_off()
 53 |             ax.imshow(y[0][0].data.numpy())
 54 |             ax = fig.add_subplot(n, 3, i*3+3)
 55 |             ax.set_axis_off()
 56 |             ax.imshow(x_in)
 57 |         fig.savefig(fileName)
 58 |         plt.show()
 59 | 
 60 | class KeyPointNetwork(nn.Module):
 61 |     def __init__(self, input_shape=(28, 28)):
 62 |         super(KeyPointNetwork, self).__init__()
 63 |         self.fc1 = nn.Linear(np.prod(input_shape), 100)
 64 |         self.fc2 = nn.Linear(100, 100)
 65 |         self.fc3 = nn.Linear(100, 100)
 66 |         self.input_shape = input_shape
 67 |     def forward(self, x):
 68 |         x = x.view(-1, 1, np.prod(self.input_shape))
 69 |         x = F.relu(self.fc1(x))
 70 |         x = F.relu(self.fc2(x))
 71 |         x = F.sigmoid(self.fc3(x))*np.prod(self.input_shape)
 72 |         return x
 73 | 
 74 | class ImageCompletion(nn.Module):
 75 |     def __init__(self, input_shape=(28,28), generatorModel = 'gae.model'):
 76 |         super(ImageCompletion, self).__init__()
 77 |         self.gae = GAE(input_shape=input_shape)
 78 |         self.gae = torch.load(generatorModel)
 79 |         # for p in self.gae.parameters():
 80 |         #     p.require_grad=False
 81 |         self.kpn = KeyPointNetwork(input_shape=input_shape)
 82 |         self.input_shape = input_shape
 83 |     def forward(self, x):
 84 |         keys = self.kpn(x)
 85 |         in_images = torch.zeros(x.size())
 86 |         for i in range(x.size()[0]):
 87 |             im = x[i, :, :]
 88 |             for key in keys[i,0].data.numpy():
 89 |                 key = int(key)
 90 |                 a=in_images[i,key%28, key/28]
 91 |                 b=im[key%28, key/28].data
 92 |                 a=b
 93 |                 #plt.imshow(in_images[i,:,:].numpy())
 94 |                 #a=1
 95 |                 
 96 |                 #            sel_key  = keys.view(32, 1, 2, -1)[i, 0, :, :]
 97 | #            sel_key = sel_key.type(torch.LongTensor)
 98 | #            sel_image = in_images[i, 0, :, :]
 99 | #            sel_image[sel_key.data.numpy()] = im.data.index(sel_key.data.numpy())
100 |         # in_images[keys.int().data.numpy()] = x.data.index(keys.int().data.numpy())
101 |         # in_images[keys] = x[keys]
102 |         y = self.gae(Variable(in_images))
103 |         return y
104 |     def showResults(self, x_test, n=10, fileName ="Keys.jpg"):
105 |         import copy
106 |         fig = plt.figure(figsize=[20, 20*n/3])
107 |         for i in range(n):
108 |             x_in = x_test[np.random.randint(len(x_test))]
109 |             x=copy.copy(x_in)
110 |             mask = self.kpn.forward(Variable(torch.from_numpy(x.reshape((1,1)+self.input_shape))))
111 |             mm = np.zeros(self.input_shape)
112 |             for element in mask[0,0].data.numpy():
113 |                 xx=int(element%self.input_shape[0])
114 |                 yy=int(element/self.input_shape[0])
115 |                 mm[xx,yy]=x[xx,yy]
116 |             ax = fig.add_subplot(n, 4, i*4+1)
117 |             ax.set_axis_off()
118 |             ax.imshow(x)
119 |             ax = fig.add_subplot(n, 4, i*4+2)
120 |             ax.set_axis_off()
121 |             ax.imshow(mm)
122 |             y = self.gae.forward(Variable(torch.from_numpy(mm.reshape((1,1)+self.input_shape))))
123 |             ax = fig.add_subplot(n, 4, i*4+3)
124 |             ax.set_axis_off()
125 |             ax.imshow(y[0,0].data.numpy())
126 |             ax = fig.add_subplot(n, 4, i*4+4)
127 |             ax.set_axis_off()
128 |             ax.imshow(x_in)
129 |         fig.savefig(fileName)
130 |         plt.show()
131 | 
132 | def trainGAE():
133 |     import copy
134 |     from keras.datasets import mnist
135 |     # Load MNIST dataset
136 |     (x_train, y_train), (x_test, y_test) = mnist.load_data()
137 |     x_train = x_train.astype(np.float32) / 255.
138 |     x_test = x_test.astype(np.float32) / 255.
139 |     x_out = copy.copy(x_train)
140 |     x_in = []
141 |     for x in x_train:
142 |         mask = np.random.choice([0, 1], size=(28, 28), p=[1./10, 9./10])
143 |         mm = np.ma.masked_array(x, mask=mask)
144 |         x[mm.mask] = 0
145 |         x_in.append(x)
146 |     x_in = np.array(x_in)
147 |     model = GAE(latent_dim=6)
148 |     optimizer = optim.Adam(model.parameters(), lr=1e-3)
149 |     loss = nn.MSELoss()
150 |     model.train()
151 |     batch_size = 32
152 |     epochs = 1000
153 |     torch.load('gae.model')
154 |     for epoch in range(epochs):
155 |         idx = np.random.randint(0, x_in.shape[0], batch_size)
156 |         input_images = x_in[idx]
157 |         output_images = x_out[idx]
158 |         input_images, output_images = Variable(torch.from_numpy(input_images)), Variable(torch.from_numpy(output_images))
159 |         optimizer.zero_grad()
160 |         output = model.forward(input_images)
161 |         l = loss(output, output_images)
162 |         l.backward()
163 |         optimizer.step()
164 |         print(l.data.numpy()[0], epoch*100/epochs)
165 |     model.generateAndPlot(x_test)
166 |     torch.save(model, 'gae.model')
167 | 
168 | def trainKeyPoint():
169 |     from keras.datasets import mnist
170 |     # Load MNIST dataset
171 |     (x_train, y_train), (x_test, y_test) = mnist.load_data()
172 |     x_train = x_train.astype(np.float32) / 255.
173 |     x_test = x_test.astype(np.float32) / 255.
174 | 
175 |     model = ImageCompletion()
176 |     optimizer = optim.SGD(model.parameters(), lr=1e-3)
177 |     loss = nn.MSELoss()
178 |     model.train()
179 |     batch_size = 32
180 |     epochs = 100
181 |     model = torch.load('keypoint.model')
182 |     for epoch in range(epochs):
183 |         idx = np.random.randint(0, x_train.shape[0], batch_size)
184 |         input_images = x_train[idx]
185 |         input_images = Variable(torch.from_numpy(input_images))
186 |         optimizer.zero_grad()
187 |         output = model.forward(input_images)
188 |         l = loss(output, input_images)
189 |         l.backward()
190 |         optimizer.step()
191 |         print(l.data.numpy()[0], epoch*100/epochs)
192 |     model.showResults(x_test)
193 |     torch.save(model, 'keypoint.model')
194 |     
195 | if __name__ == '__main__':
196 |     trainKeyPoint()
197 | 


--------------------------------------------------------------------------------
/dcgan.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python2
 2 | # -*- coding: utf-8 -*-
 3 | """
 4 | Created on Thu Oct 19 22:03:44 2017
 5 | 
 6 | @author: ali
 7 | """
 8 | from keras.layers import Dense, Activation, BatchNormalization, Reshape, Conv2D, UpSampling2D, MaxPooling2D, Input, Flatten
 9 | from keras.models import Sequential, Model
10 | from keras.losses import mse, binary_crossentropy
11 | from keras.datasets import mnist, cifar10
12 | from keras.callbacks import ModelCheckpoint
13 | import numpy as np
14 | 
15 | def decoder_model():
16 |     model = Sequential()
17 | #    model.add(Dense(input_dim=100, output_dim=1024))
18 | #    model.add(Activation('tanh'))
19 |     model.add(Dense(1024*4*4,  input_dim=20))
20 |     model.add(BatchNormalization())
21 |     model.add(Activation('tanh'))
22 |     model.add(Reshape((4, 4, 1024), input_shape=(1024*4*4,)))
23 |     model.add(UpSampling2D(size=(2, 2)))
24 |     model.add(Conv2D(512, (5, 5), padding='same'))
25 |     model.add(Activation('tanh'))
26 |     model.add(UpSampling2D(size=(2, 2)))
27 |     model.add(Conv2D(256, (5, 5), padding='same'))
28 |     model.add(Activation('tanh'))
29 |     model.add(UpSampling2D(size=(2, 2)))
30 |     model.add(Conv2D(128, (3, 3), padding='same'))
31 |     model.add(Activation('tanh'))
32 |     model.add(Conv2D(3, (5, 5), padding='same'))
33 |     model.add(Activation('tanh'))
34 |     return model
35 | 
36 | def encoder_model():
37 |     model = Sequential()
38 |     model.add(Conv2D(128, (3,3),padding='same', input_shape=(32,32,3), activation='tanh'))
39 |     model.add(MaxPooling2D(pool_size=(2, 2)))
40 |     model.add(Conv2D(256,(5,5), padding='same', activation='tanh'))
41 |     model.add(MaxPooling2D(pool_size=(2, 2)))
42 |     model.add(Conv2D(512,(5,5), padding='same', activation='tanh'))
43 |     model.add(MaxPooling2D(pool_size=(2, 2)))
44 |     model.add(Conv2D(1024,(4,4), padding='same', activation='tanh'))
45 |     model.add(MaxPooling2D(pool_size=(2, 2)))
46 |     model.add(Flatten())
47 |     model.add(Dense(20))
48 |     model.add(BatchNormalization())
49 |     model.add(Activation('tanh'))
50 |     return model
51 | 
52 | 
53 | if __name__ == "__main__":
54 |     (x_train, y_train), (x_test, y_test) = cifar10.load_data()
55 |     x_train = (x_train.astype(np.float32)-128) / 255.
56 |     x_test = (x_test.astype(np.float32)-128) / 255.
57 | 
58 |     img = Input(shape=(32,32,3))
59 |     encoder = encoder_model()
60 |     encoder.summary()
61 |     decoder = decoder_model()
62 |     decoder.summary()
63 |     code = encoder(img)
64 |     img_reconst = decoder(code)
65 |     autoencoder = Model(img, img_reconst)
66 |     autoencoder.summary()
67 | #    autoencoder.load_weights('weights.00.hdf5')
68 |     autoencoder.compile(optimizer='sgd',loss='mse')
69 |     autoencoder.fit(x_train, x_train, batch_size=10, epochs=1, callbacks=[ModelCheckpoint('weights.{epoch:02d}.hdf5', 
70 |                                                                        verbose=0, 
71 |                                                                        save_best_only=False, 
72 |                                                                        save_weights_only=False, 
73 |                                                                        mode='auto', 
74 |                                                                        period=1)])
75 | 


--------------------------------------------------------------------------------
/helpers.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | from sklearn.neighbors.kde import KernelDensity
 3 | import numpy as np
 4 | from sklearn.model_selection import GridSearchCV
 5 | 
 6 | 
 7 | def approximateLogLiklihood(x_generated, x_test, searchSpace = np.logspace(-4, 0, 5)):
 8 |     x_generated = np.array(x_generated).reshape((len(x_generated),-1))
 9 |     x_test = np.array(x_test).reshape((len(x_test),-1))
10 |     # use grid search cross-validation to optimize the bandwidth
11 |     print "new"
12 |     params = {'bandwidth': searchSpace}
13 |     grid = GridSearchCV(KernelDensity(), params, n_jobs=4)
14 |     grid.fit(x_generated)
15 |     print grid.best_params_
16 |     kde = grid.best_estimator_
17 |     scores = kde.score_samples(x_test)
18 |     return np.sum(scores)/len(scores)
19 | 
20 | def findNearest(x_train, x_test):
21 |     diff  = np.square(x_train-x_test)
22 |     mse = [np.sum(x) for x in diff]
23 |     return x_train[np.argmin(mse)]


--------------------------------------------------------------------------------