def testModel():
# Create models
print("Creating Autoencoder, Encoder and Generator...")
autoencoder, encoder, decoder = getModels()
# Load Autoencoder weights
print("Loading weights...")
autoencoder.load_weights(modelsPath + modelName)
# Load dataset to test
print("Loading dataset...")
X_train, X_test = loadDataset()
# Visualization functions
visualizeReconstructedImages(X_train[:16],
X_test[:16],
autoencoder,
save=True)
def testModel():
# Create models
print("Creating Autoencoder, Encoder and Generator...")
autoencoder, encoder, decoder = getModels()
# Load Autoencoder weights
print("Loading weights...")
autoencoder.load_weights(modelsPath+modelName)
# Load dataset to test
print("Loading dataset...")
X_train, X_test = loadDataset()
# Visualization functions
#visualizeReconstructedImages(X_train[:16],X_test[:16], autoencoder)
# computeTSNEProjectionOfPixelSpace(X_test[:1000], display=True)
# computeTSNEProjectionOfLatentSpace(X_test[:1000], encoder, display=True)
# while 1: visualizeInterpolation(X_test[randint(0,X_test.shape[0])], X_test[randint(0,X_test.shape[0])], encoder, decoder, save=False, nbSteps=5)
while 1 :visualizeArithmetics(X_test[randint(0,X_test.shape[0])], X_test[randint(0,X_test.shape[0])], X_test[randint(0,X_test.shape[0])], encoder, decoder)
hashName = ''.join(random.choice(string.lowercase) for i in range(3))
for i in range(len(reconstructions)):
interpolatedImage = normalImages[i]*255
interpolatedImage = cv2.resize(interpolatedImage,(50,50))
interpolatedImage = interpolatedImage.astype(np.uint8)
resultImage = interpolatedImage if resultImage is None else np.hstack([resultImage,interpolatedImage])
reconstructedImage = reconstructions[i]*255.
reconstructedImage = reconstructedImage.reshape([28,28])
reconstructedImage = cv2.resize(reconstructedImage,(50,50))
reconstructedImage = reconstructedImage.astype(np.uint8)
resultLatent = reconstructedImage if resultLatent is None else np.hstack([resultLatent,reconstructedImage])
if save:
cv2.imwrite(visualsPath+"{}_{}.png".format(hashName,i),np.hstack([interpolatedImage,reconstructedImage]))
result = np.vstack([resultImage,resultLatent])
if not save:
cv2.imshow("Interpolation in Image Space vs Latent Space",result)
cv2.waitKey()
cv2.destroyAllWindows()
if __name__ == "__main__":
# Load dataset to test
print("Loading dataset...")
X_train, X_test = loadDataset()
visualizeDataset(X_test[:100])
def trainModel(startEpoch=0):
# Create models
print("Creating Autoencoder...")
autoencoder, _, _ = getModels()
autoencoder.compile(optimizer=RMSprop(lr=0.00025), loss="mse")
# From which we start
if startEpoch > 0:
# Load Autoencoder weights
print("Loading weights...")
autoencoder.load_weights(modelsPath + modelName)
print("Loading dataset...")
X_train, X_test = loadDataset()
# Compute number of batches
nbBatch = int(X_train.shape[0] / batchSize)
# Train the Autoencoder on dataset
print(
"Training Autoencoder for {} epochs with {} batches per epoch and {} samples per batch."
.format(nbEpoch, nbBatch, batchSize))
print("Run id: {}".format(runID))
# Debug utils writer
writer = tf.summary.FileWriter("/tmp/logs/" + runID)
batchTimes = [0. for i in range(5)]
# For each epoch
for epoch in range(startEpoch, nbEpoch):
# For each batch
for batchIndex in range(nbBatch):
batchStartTime = time.time()
# Get batch
X = X_train[batchIndex * batchSize:(batchIndex + 1) * batchSize]
# Train on batch
autoencoderLoss = autoencoder.train_on_batch(X, X)
trainingSummary = tf.Summary.Value(
tag="Loss", simple_value=float(autoencoderLoss))
# Compute ETA
batchTime = time.time() - batchStartTime
batchTimes = batchTimes[1:] + [batchTime]
eta = getETA(
sum(batchTimes) / len(batchTimes), nbBatch, batchIndex,
nbEpoch, epoch)
# Save reconstructions on train/test samples
if batchIndex % 2 == 0:
visualizeReconstructedImages(X_train[:16],
X_test[:16],
autoencoder,
save=True,
label="{}_{}".format(
epoch, batchIndex))
# Validation & Tensorboard Debug
if batchIndex % 20 == 0:
validationLoss = autoencoder.evaluate(X_test[:512],
X_test[:512],
batch_size=256,
verbose=0)
validationSummary = tf.Summary.Value(
tag="Validation Loss", simple_value=float(validationLoss))
summary = tf.Summary(
value=[trainingSummary, validationSummary])
print(
"Epoch {}/{} - Batch {}/{} - Loss: {:.3f}/{:.3f} - ETA:".
format(epoch + 1, nbEpoch, batchIndex + 1, nbBatch,
autoencoderLoss, validationLoss), eta)
else:
print(
"Epoch {}/{} - Batch {}/{} - Loss: {:.3f} - ETA:".format(
epoch + 1, nbEpoch, batchIndex + 1, nbBatch,
autoencoderLoss), eta)
summary = tf.Summary(value=[
trainingSummary,
])
writer.add_summary(summary, epoch * nbBatch + batchIndex)
#Save model every epoch
print("Saving autoencoder...")
autoencoder.save_weights(modelsPath + modelName, overwrite=True)
def train():
#======== Parameters ========#
# Gan hacks tricks
softLabels = True
flipLabels = False #Max(log(D)) instead of min(log(1-D))
addNoiseToDiscriminator = True
useDropout = False
# Torch heuristic for training
useTorchHeuristic = True
lossMargin = 0.25
# Classic training parameters
epochNb = 3
batchSize = 128
# Display parameters
displayImageNb = 64
# Optimizers for generator and discriminator
d_optim = SGD(lr=0.00025, momentum=0.9, nesterov=True)
g_optim = Adam(lr=0.00025, beta_1=0.5)
#============================#
# Load data
X_train, X_test = loadDataset()
# Create models
discriminator = getDiscriminator(useDropout)
generator = getGenerator(useDropout)
discriminator_on_generator = getGeneratorContainingDiscriminator(generator, discriminator)
# Compile models with optimizers
generator.compile(loss='binary_crossentropy', optimizer="SGD")
discriminator_on_generator.compile(loss='binary_crossentropy', optimizer=g_optim)
discriminator.trainable = True
discriminator.compile(loss='binary_crossentropy', optimizer=d_optim)
# Prepare 100D noise matrix for each batch
# We keep the same noise to follow the generation
displayNoise = np.random.normal(0., 1., (displayImageNb, 100))
# Torch.ch heuristic for training
discriminator.trainable = True
generator.trainable = True
# Compute number of batches
batchNb = int(X_train.shape[0]/batchSize)
print("Starting training for {} epochs with {} batches of size {}".format(epochNb, batchNb, batchSize))
# For each epoch
for epoch in range(epochNb):
# For each batch
for batchIndex in range(batchNb):
# Save generated images to disk every batch
generated_images = generator.predict(displayNoise, verbose=0)
saveGeneratedImages(generated_images, "{}_{}".format(epoch, batchIndex))
#==== TRAINING THE DISCRIMINATOR ====#
# Get real image batch from data
real_images = X_train[batchIndex*batchSize:(batchIndex+1)*batchSize]
# Add noise to make it harder for discriminator
X = addNoise(real_images) if addNoiseToDiscriminator else real_images
y = getTrueLabels(batchSize, soft=softLabels)
# Train on real images, or just compute loss if not trainable
d_loss_real = discriminator.train_on_batch(X, y)
# Generate a batch of fake images
noise = np.random.normal(0., 1., (batchSize, 100))
generated_images = generator.predict(noise, verbose=0)
# Add noise to make it harder for discriminator
X = addNoise(generated_images) if addNoiseToDiscriminator else generated_images
y = getFakeLabels(batchSize, soft=softLabels)
# Train on fake images, or just compute loss if not trainable
d_loss_fake = discriminator.train_on_batch(X, y)
#==== TRAINING THE GENERATOR ====#
for i in range(2):
# Generator is trained twice on a batch because the discriminator is too
shouldDiscriminatorBeTrained = discriminator.trainable
# Always put as not trainable first
discriminator.trainable = False
# Train generator, or just compute loss if not trainable
noise = np.random.normal(0., 1., (batchSize, 100))
y = getTrueLabels(batchSize, soft=softLabels, flipped=flipLabels)
g_loss = discriminator_on_generator.train_on_batch(noise, y)
# Restore true value of trainable
discriminator.trainable = shouldDiscriminatorBeTrained
print("Epoch {}/{} - Batch {}/{} - (G: {:.3f}) - (D_true: {:.3f}, D_fake: {:.3f})".format(epoch+1, epochNb, batchIndex+1, batchNb, g_loss, d_loss_real, d_loss_fake))
if useTorchHeuristic:
# Assume both should be trained
discriminator.trainable = True
generator.trainable = True
# Discriminator too powerful
if d_loss_fake < lossMargin or d_loss_real < lossMargin:
print "Stopping D for next update"
discriminator.trainable = False
# Discriminator too weak
if d_loss_fake > (1.0-lossMargin) or d_loss_real > (1.0-lossMargin):
print "Stopping G for next update"
generator.trainable = False
# Both are good, train both
if not discriminator.trainable and not generator.trainable:
print "Starting G and D"
discriminator.trainable = True
generator.trainable = True
#Save model every N batches
if batchIndex%40 == 0:
print "Saving models..."
generator.save_weights('Models/generator', True)
discriminator.save_weights('Models/discriminator', True)