Updates for class 2

Author: vanpelt

keras-autoencoder/autoencoder.py

@@ -43,9 +43,7 @@ def on_epoch_end(self, epoch, logs):
 decoder.add(Dense(28*28, activation="sigmoid"))
 decoder.add(Reshape((28,28)))
 
-model = Sequential()
-model.add(encoder)
-model.add(decoder)
+model = Model(encoder, decoder)
 
 model.compile(optimizer='adam', loss='mse')
 

keras-autoencoder/wandb/settings

@@ -1,4 +1,4 @@
 [default]
 entity: qualcomm
-project: encoding-july27
+project: encoding-aug22
 base_url: https://api.wandb.ai

keras-cifar/cifar-cnn.py

@@ -8,63 +8,58 @@
 
 import os
 import wandb
-from wandb.wandb_keras import WandbKerasCallback
+from wandb.keras import WandbCallback
 
 run = wandb.init()
 config = run.config
+config.dropout = 0.25
+config.dense_layer_nodes = 100
+config.learn_rate = 0.01
+config.batch_size = 32
+config.epochs = 50
+
 class_names = ['airplane','automobile','bird','cat','deer',
                'dog','frog','horse','ship','truck']
-num_classes = 10
-
+num_classes = len(class_names)
 
-save_dir = os.path.join(os.getcwd(), 'saved_models')
-model_name = 'keras_cifar10_trained_model.h5'
-
-(x_train, y_train), (x_test, y_test) = cifar10.load_data()
+(X_train, y_train), (X_test, y_test) = cifar10.load_data()
 
 # Convert class vectors to binary class matrices.
 y_train = keras.utils.to_categorical(y_train, num_classes)
 y_test = keras.utils.to_categorical(y_test, num_classes)
 
 model = Sequential()
 model.add(Conv2D(32, (3, 3), padding='same',
-                 input_shape=x_train.shape[1:], activation='relu'))
+                 input_shape=X_train.shape[1:], activation='relu'))
 model.add(MaxPooling2D(pool_size=(2, 2)))
-model.add(Dropout(0.25))
+model.add(Dropout(config.dropout))
 
 model.add(Flatten())
 model.add(Dense(config.dense_layer_nodes, activation='relu'))
-model.add(Dropout(0.5))
+model.add(Dropout(config.dropout))
 model.add(Dense(num_classes, activation='softmax'))
 
-
 opt = keras.optimizers.SGD(lr=config.learn_rate)
 
 # Let's train the model using RMSprop
 model.compile(loss='categorical_crossentropy',
               optimizer=opt,
               metrics=['accuracy'])
 
-x_train = x_train.astype('float32')
-x_test = x_test.astype('float32')
-x_train /= 255
-x_test /= 255
-
-
-datagen = ImageDataGenerator(
-        width_shift_range=0.1)
-
+X_train = X_train.astype('float32') / 255.
+X_test = X_test.astype('float32') / 255.
 
-datagen.fit(x_train)
+datagen = ImageDataGenerator(width_shift_range=0.1)
+datagen.fit(X_train)
 
-    # Fit the model on the batches generated by datagen.flow().
-model.fit_generator(datagen.flow(x_train, y_train,
+# Fit the model on the batches generated by datagen.flow().
+model.fit_generator(datagen.flow(X_train, y_train,
                                      batch_size=config.batch_size),
-                        steps_per_epoch=x_train.shape[0] // config.batch_size,
+                        steps_per_epoch=X_train.shape[0] // config.batch_size,
                         epochs=config.epochs,
-                        validation_data=(x_test, y_test),
+                        validation_data=(X_test, y_test),
                         workers=4,
                         callbacks=[WandbKerasCallback(data_type="image", labels=class_names)]
-   )
+)
 
 

keras-fashion/nn.py

@@ -36,23 +36,14 @@
 # create model
 model=Sequential()
 #model.add(Reshape((img_width, img_height, 1), input_shape=(img_width,img_height)))
-#model.add(Dropout(0.4))
-#model.add(Conv2D(32, (3,3), activation='relu'))
-#model.add(MaxPooling2D(2,2))
-#model.add(Dropout(0.4))
-#model.add(Conv2D(32, (3,3), activation='relu'))
-#model.add(MaxPooling2D(2,2))
 model.add(Flatten(input_shape=(img_width,img_height)))
 model.add(Dropout(0.4))
 model.add(Dense(100, activation='relu'))
 model.add(Dropout(0.4))
 model.add(Dense(num_classes, activation='softmax'))
 model.compile(loss='categorical_crossentropy', optimizer='adam',
                 metrics=['accuracy'])
-model.summary()
 # Fit the model
 model.fit(X_train, y_train, epochs=config.epochs, validation_data=(X_test, y_test),
-                    callbacks=[WandbCallback(validation_data=X_test, labels=labels)])
+                    callbacks=[WandbCallback(data_type="image", labels=labels)])
 
-#print("Predictions", model.predict(X_train[:50]))
-#print("Truth", y_train[:50])

keras-fashion/wandb/settings

@@ -1,4 +1,4 @@
 [default]
 entity: qualcomm
-project: fashion-july27
+project: fashion-aug22
 base_url: https://api.wandb.ai

keras-gan/gan-simple.py

@@ -0,0 +1,152 @@
+import os
+import numpy as np
+
+from keras.layers import Input
+from keras.models import Model, Sequential
+from keras.layers.core import Reshape, Dense, Dropout, Flatten
+from keras.layers.advanced_activations import LeakyReLU
+from keras.layers.convolutional import Convolution2D, UpSampling2D
+from keras.layers.normalization import BatchNormalization
+from keras.datasets import mnist
+from keras.optimizers import Adam
+from keras import backend as K
+from keras import initializers
+from PIL import Image
+from keras.callbacks import LambdaCallback
+import wandb
+
+# Find more tricks here: https://github.com/soumith/ganhacks
+
+run = wandb.init()
+config = wandb.config
+
+# The results are a little better when the dimensionality of the random vector is only 10.
+# The dimensionality has been left at 100 for consistency with other GAN implementations.
+randomDim = 10
+
+# Load MNIST data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+X_train = (X_train.astype(np.float32) - 127.5)/127.5
+X_train = X_train.reshape(60000, 784)
+
+config.lr=0.0002
+config.beta_1=0.5
+config.batch_size=128
+config.epochs=10
+
+# Optimizer
+adam = Adam(config.lr, beta_1=config.beta_1)
+
+generator = Sequential()
+generator.add(Dense(256, input_dim=randomDim, kernel_initializer=initializers.RandomNormal(stddev=0.02)))
+generator.add(LeakyReLU(0.2))
+generator.add(Dense(512))
+generator.add(LeakyReLU(0.2))
+generator.add(Dense(1024))
+generator.add(LeakyReLU(0.2))
+generator.add(Dense(784, activation='tanh'))
+generator.compile(loss='binary_crossentropy', optimizer=adam, metrics=['acc'])
+
+discriminator = Sequential()
+discriminator.add(Dense(1024, input_dim=784, kernel_initializer=initializers.RandomNormal(stddev=0.02)))
+discriminator.add(LeakyReLU(0.2))
+discriminator.add(Dropout(0.3))
+discriminator.add(Dense(512))
+discriminator.add(LeakyReLU(0.2))
+discriminator.add(Dropout(0.3))
+discriminator.add(Dense(256))
+discriminator.add(LeakyReLU(0.2))
+discriminator.add(Dropout(0.3))
+discriminator.add(Dense(1, activation='sigmoid'))
+discriminator.compile(loss='binary_crossentropy', optimizer=adam, metrics=['binary_accuracy'])
+
+# Combined network
+discriminator.trainable = False
+ganInput = Input(shape=(randomDim,))
+x = generator(ganInput)
+ganOutput = discriminator(x)
+gan = Model(inputs=ganInput, outputs=ganOutput)
+gan.compile(loss='binary_crossentropy', optimizer=adam, metrics = ['binary_accuracy'])
+
+iter = 0
+# Write out generated MNIST images
+def writeGeneratedImages(epoch, examples=100, dim=(10, 10), figsize=(10, 10)):
+    noise = np.random.normal(0, 1, size=[examples, randomDim])
+    generatedImages = generator.predict(noise)
+    generatedImages = generatedImages.reshape(examples, 28, 28)
+    
+    for i in range(10):
+        img = Image.fromarray((generatedImages[0] + 1.)* (255/2.))
+        img = img.convert('RGB')
+        img.save(str(i) + ".jpg")
+
+
+# Save the generator and discriminator networks (and weights) for later use
+def saveModels(epoch):
+    generator.save('models/gan_generator_epoch_%d.h5' % epoch)
+    discriminator.save('models/gan_discriminator_epoch_%d.h5' % epoch)
+
+
+def log_generator(epoch, logs):
+    global iter
+    iter += 1
+    if iter % 500 == 0:
+        wandb.log({'generator_loss': logs['loss'],
+                     'generator_acc': logs['binary_accuracy'],
+                     'discriminator_loss': 0.0,
+                     'discriminator_acc': (1-logs['binary_accuracy'])})
+
+def log_discriminator(epoch, logs):
+    global iter
+    if iter % 500 == 250:
+        wandb.log({
+            'generator_loss': 0.0,
+            'generator_acc': logs['binary_accuracy'],
+            'discriminator_loss': logs['loss'],
+            'discriminator_acc': logs['binary_accuracy']})
+
+def train(epochs=config.epochs, batchSize=config.batch_size):
+    batchCount = int(X_train.shape[0] / config.batch_size)
+    print('Epochs:', epochs)
+    print('Batch size:', batchSize)
+    print('Batches per epoch:', batchCount)
+
+    wandb_logging_callback_d = LambdaCallback(on_epoch_end=log_discriminator)
+    wandb_logging_callback_g = LambdaCallback(on_epoch_end=log_generator)
+
+
+    for e in range(1, epochs+1):
+        print("Epoch {}:".format(e))
+        for i in range(batchCount):
+            # Get a random set of input noise and images
+            noise = np.random.normal(0, 1, size=[batchSize, randomDim])
+            imageBatch = X_train[np.random.randint(0, X_train.shape[0], size=batchSize)]
+
+            # Generate fake MNIST images
+            generatedImages = generator.predict(noise)
+            # print np.shape(imageBatch), np.shape(generatedImages)
+            X = np.concatenate([imageBatch, generatedImages])
+
+            # Labels for generated and real data
+            yDis = np.zeros(2*batchSize)
+            # One-sided label smoothing
+            yDis[:batchSize] = 0.9
+
+            # Train discriminator
+            discriminator.trainable = True
+            dloss = discriminator.fit(X, yDis, verbose=0, callbacks=[wandb_logging_callback_d])
+
+            # Train generator
+            noise = np.random.normal(0, 1, size=[batchSize, randomDim])
+            yGen = np.ones(batchSize)
+            discriminator.trainable = False
+            gloss = gan.fit(noise, yGen, verbose=0, callbacks=[wandb_logging_callback_g])
+
+            writeGeneratedImages(i)
+
+        print("Discriminator loss: {}, acc: {}".format(dloss.history["loss"][-1], dloss.history["binary_accuracy"][-1]))
+        print("Generator loss: {}, acc: {}".format(gloss.history["loss"][-1], 1-gloss.history["binary_accuracy"][-1]))
+
+
+if __name__ == '__main__':
+    train(200, 128)