num_hidden_1 = 10
num_hidden_2 = 10
num_hidden_3 = 10
num_hidden_4 = 10
n_epoch = 100 #20000
# ---- train using training data
# The n==0 statement is done because we only want to initialize the network once and then keep training
# as we move through time
if n == 0:
auto1 = Autoencoder(feats_norm_train.shape[1], num_hidden_1)
auto1.fit(feats_norm_train, n_epoch=n_epoch)
inputs = torch.autograd.Variable(
torch.from_numpy(feats_norm_train.astype(np.float32)))
if n == 0:
auto2 = Autoencoder(num_hidden_1, num_hidden_2)
auto1_out = auto1.encoder(inputs).data.numpy()
auto2.fit(auto1_out, n_epoch=n_epoch)
if n == 0:
auto3 = Autoencoder(num_hidden_2, num_hidden_3)
auto1_out = torch.autograd.Variable(
torch.from_numpy(auto1_out.astype(np.float32)))
auto2_out = auto2.encoder(auto1_out).data.numpy()
auto3.fit(auto2_out, n_epoch=n_epoch)
def main():
# Parse arguments
args = get_parser().parse_args()
# Check for GPU
is_gpu = len(tf.config.list_physical_devices("GPU")) > 0
if not is_gpu and not args.allow_cpu:
raise ValueError(
"Cannot run the code on CPU. Please enable GPU support or pass the '--allow-cpu' flag."
)
# Check if dataset should be recreated
if not os.path.exists("cleaned_dataset") or args.force_recreate:
prepare_data()
# ........................................................................
# Let's select the train folds and the holdout fold
# ........................................................................
# Grab folds folders (fold_1, ..., fold_k)
folds_folders = glob.glob("patched_dataset/**")
# Randomly select 1 fold for being the holdout final test
holdout_fold = np.random.choice(folds_folders, 1)[0]
# Keep the rest for training and performing k-fold
# Search for elements of `folds_folders` that are not in `holdout_fold`
train_folds = np.setdiff1d(folds_folders, holdout_fold)
print(f"Train folds: {train_folds}")
print(f"Holdout fold: {holdout_fold}")
for k, fold in enumerate(train_folds):
# Print current fold
print(f"Train Fold {k+1}:")
print_fold_stats(fold)
# Now for the holdout fold
print("Holdout Fold:")
print_fold_stats(holdout_fold)
# Generate the bands to keep
bands_to_keep = np.round(np.linspace(0, 272 - 1, args.bands)).astype(int)
# Load test images and labels
print("Loading holdout fold images")
images, labels = load_fold(holdout_fold, bands_to_keep)
test_data = (images, labels)
# Creat list for holding the training datasets folds
train_data_list = []
for k, fold in enumerate(train_folds):
print(f"Loading images of training fold {k+1}")
# Load the normalized images to list
images, labels = load_fold(fold, bands_to_keep)
# Save images in dict with labels as value
train_data_list.append([images, labels])
# Check if a baseline model should be created
if args.baseline:
# ........................................................................
# Let's now establish a baseline model
# ........................................................................
model = BaselineModel().cross_validate(
train_data_list,
fully_connected_size=128,
add_dropout_layers=True,
)
# How does the model perform on unseen data?
result = model.evaluate(test_data[0], test_data[1], batch_size=64)
result = dict(zip(model.metrics_names, result))
print(result)
# ........................................................................
# Let's now try to use the Autoencoder
# ........................................................................
# Get train data (We only care about the features now)
x_train, _ = build_train_data(train_data_list, range(len(train_data_list)))
x_test = test_data[0]
print("Training an Autoencoder")
# Instantiate autoencoder
autoencoder = Autoencoder(x_train[0].shape, n_bands=args.bands)
# Prepare callbacks
# 1. Reduce learning rate when loss is on plateau
reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor="val_loss",
factor=0.2,
patience=15,
min_lr=9e-4,
verbose=1)
# 2. Early stopping
early_stop = tf.keras.callbacks.EarlyStopping(
monitor="val_loss",
min_delta=0,
patience=20,
mode="auto",
verbose=0,
restore_best_weights=True,
)
# Compile the autoencoder
autoencoder.compile(
optimizer=tf.keras.optimizers.Adam(lr=1e-3),
loss="mse",
)
# Train the model
history = {}
history["autoencoder"] = autoencoder.fit(
x_train,
x_train,
validation_split=0.2,
batch_size=16,
epochs=250,
verbose=1,
callbacks=[reduce_lr, early_stop],
)
# Plot the Autoencoder loss curve
plotter = tfdocs.plots.HistoryPlotter(metric="loss", smoothing_std=10)
plotter.plot(history)
def aae(batch_size=128, dim_list=[100,100],
latent_dim=32, nb_epoch=1, nb_epoch_ae=1,
plt_frq=50, saved_model='',
dataDirName=dataDirName, max_len=20, saved='',
activation=['tanh', 'tanh']):
# get date
now = dt.datetime.now()
date = now.strftime("%d%m_%H%M%S")
# creating file name with parameters in name
interm=''
for i in dim_list:
interm += str(i)
name='e'+str(nb_epoch)+'_a'+str(nb_epoch_ae)+'_l'+str(latent_dim)+'_i'+interm+'_o'+str(max_len)
# import Data
Y_train, Y_test, Y_train, Y_test = importDataSet(dataDirName, max_len)
dof = Y_train.shape[2]
activation_list = activation
dim_list = dim_list
output_length = Y_train.shape[1]
# define different models
encoder = Encoder(latent_dim, output_length, dof, activation_list, dim_list)
decoder = Decoder(latent_dim, output_length, dim_list, activation_list, dof)
autoencoder = Autoencoder(encoder, decoder)
discriminator = Discriminator(latent_dim)
generator = Generator(encoder, discriminator)
# compilating every models necessary
compile(generator, discriminator, autoencoder)
# summary of the different models
encoder.summary()
decoder.summary()
discriminator.summary()
# loading autoencoder if needed
if saved != '':
autoencoder = load_model(saved)
name += '_s'
# Pre-train the AE
print 'pre-training autoencoder'
autoencoder.fit(Y_train, Y_train,
nb_epoch=nb_epoch_ae,
verbose=2,
batch_size=batch_size,
shuffle=True,
validation_data=(Y_test, Y_test))
# Pre-train the discriminator network ...
ntrain = 1000
XT = np.random.permutation(Y_train)
# generating vector (real distribution and encoder output)
zfake = np.random.uniform(low=-1.0, high=1.0, size=[XT.shape[0], latent_dim])
zreal = encoder.predict(XT)
X = np.concatenate((zreal, zfake))
# putting labels on vectors
n = XT.shape[0]
y = np.zeros(2*n)
y[:n] = 1
y = np_utils.to_categorical(y, 2)
# training discriminator
discriminator.fit(X, y, nb_epoch=1, verbose=0, batch_size=batch_size)
y_hat = discriminator.predict(X)
y_hat_idx = np.argmax(y_hat, axis=1)
y_idx = np.argmax(y, axis=1)
diff = y_idx-y_hat_idx
n_tot = y.shape[0]
n_rig = (diff==0).sum()
acc = n_rig*100.0/n_tot
print "Discriminator Accuracy pretrain: %0.02f pct (%d pf %d) right on %d epoch"%(acc, n_rig, n_tot, 1)
# set up loss storage vector
losses = {"discriminator":[], "generator":[]}
# defining function to train aae
def train_for_n(nb_epoch=5, plt_frq=plt_frq, BATCH_SIZE=32):
count = 0
for e in range(nb_epoch):
# Train ae
print "epoch %d"%(e+1)
# first we train the autoencoder
autoencoder_losses = autoencoder.fit(Y_train, Y_train,
shuffle=True,
nb_epoch=1,
batch_size=BATCH_SIZE,
verbose=2,
validation_data=(Y_test, Y_test))
# Make generative latent vectors
music_batch = Y_train[np.random.randint(Y_train.shape[0], size=BATCH_SIZE)]
noise = np.random.uniform(low=-1.0, high=1.0, size=[BATCH_SIZE,latent_dim])
zreal = encoder.predict(music_batch)
# Train discriminator on generated images
nb_misclassified = np.random.randint(BATCH_SIZE)
X0 = np.concatenate((zreal, noise))
y0 = np.zeros(BATCH_SIZE)
y0 = np_utils.to_categorical(y0, 2)
# noising labels
misclass = np.zeros(BATCH_SIZE)
misclass[:nb_misclassified] = 0
misclass = np_utils.to_categorical(misclass, 2)
y0=np.concatenate((misclass, y0))
#in order to shuffle labels
zipped = list(zip(X0, y0))
shuffle(zipped)
X0, y0 = zip(*zipped)
X0 = np.array(X0)
y0 = np.array(y0)
# then training discriminator
#make_trainable(discriminator, True)
# print "Training discriminator"
d_loss, d_lab = discriminator.train_on_batch(X0, y0)
losses["discriminator"].append(float(d_loss))
# train Generator-Discriminator stack on input noise to non-generated output class
y2 = np.ones(BATCH_SIZE)
y2 = np_utils.to_categorical(y2, 2)
#make_trainable(discriminator, False)
# Train generator
# print "Training generator"
g_loss, g_lab = generator.train_on_batch(music_batch, y2)
image_batch = Y_train[np.random.randint(0,Y_train.shape[0],size=BATCH_SIZE)]
g_loss, g_lab = generator.train_on_batch(music_batch, y2 )
losses["generator"].append(float(g_loss))
# Updates plots
d_acc = discriminator.evaluate(X,y, batch_size=BATCH_SIZE, verbose=0)
print "\ndiscriminator loss:", losses["discriminator"][-1]
print "discriminator acc:", d_acc[1]
print "generator loss:", losses["generator"][-1]
#print "autoencoder loss:", autoencoder_losses
count += 1
# launching previous function to train aae
train_for_n(nb_epoch=nb_epoch, plt_frq=plt_frq, BATCH_SIZE=batch_size)
# saving final models
autoencoder.save(name+'_autoencoder.h5')
encoder.save(name+'_encoder_save.h5')
decoder.save(name+'_decoder_save.h5')
#writing losses in a csv to plot them via plot_loss.py
with open('loss.csv', 'w') as csvfile:
fieldnames = ['discriminator', 'generator']
w = csv.DictWriter(csvfile, fieldnames=fieldnames)
w.writeheader()
w.writerow(losses)
# plotting loss
plot_loss('loss.csv')
