def __denoising_autoencoder_mnist__(): X_train, y_train, X_val, y_val, X_test, y_test = load_mnist() X_train = X_train.reshape(X_train.shape[0], -1) X_val = X_val.reshape(X_val.shape[0], -1) X_test = X_test.reshape(X_test.shape[0], -1) print 'Train data shape: ', X_train.shape print 'Train labels shape: ', y_train.shape print 'Test data shape: ', X_test.shape print 'Test labels shape: ', y_test.shape print '' ninput = 28*28 nhidden = 100 net = denoising_autoencoder(layer_units=(ninput, nhidden, ninput), bias=True, act_func = 'sigmoid', loss_type='euclidean', seed=12) tic = time.time() stats = net.train_with_SGD_with_noise(X_train, noise=gaussiannoise(rate=0.3, sd=0.3), learning_rate=0.1, learning_rate_decay=0.95, reg=0.001, num_iters=2000, batchsize=128, mu=0.9) toc = time.time() print toc-tic, 'sec elapsed' print 'overall loss: ', net.loss_with_noise(X_train, X_train, reg=0.01, opt='test') plot_net_output(net, stats, X_train)
def train(args): # load data train_dataloader, test_dataloader = load_mnist() # load model model = CapsuleNet(args).cuda() # define loss and optimizer optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) sched = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=args.lr_decay) # start training for epooch in range(args.epochs): for (i, data) in tqdm(enumerate(train_dataloader), total=len(train_dataloader), smoothing=0.9): img, label = data img, label = img.cuda(), label.cuda() label = F.one_hot(label, num_classes=args.num_class).float() optimizer.zero_grad() pred, reon = model(img, label) loss = margin_loss(label, pred, reon, img, args.lam_recon) loss.backward() optimizer.step() model.eval() correct = 0 for (i, data) in tqdm(enumerate(test_dataloader), total=len(test_dataloader), smoothing=True): img, label = data img, label = img.cuda(), label.cuda() label = F.one_hot(label, num_classes=args.num_class).float() pred, reon = model(img, label) y_pred = pred.data.max(dim=1)[1] y_true = label.data.max(dim=1)[1] correct += (y_pred.eq(y_true).cpu().sum()) print(correct) print(len(test_dataloader.dataset)) OA = correct.data.item() / len(test_dataloader.dataset) print('Test acc:', OA)
if TRAIN_SCRATCH and avg_loss < BEST_VAL: BEST_VAL = avg_loss torch.save(autoencoder.state_dict(), './history/conv_autoencoder.pt') print('Save Best Model in HISTORY\n') if __name__ == '__main__': EPOCHS = 100 BATCH_SIZE = 128 LEARNING_RATE = 1e-3 WEIGHT_DECAY = 1e-5 LOG_INTERVAL = 100 TRAIN_SCRATCH = False # whether to train a model from scratch BEST_VAL = float('inf') # record the best val loss train_loader, test_loader = data_utils.load_mnist(BATCH_SIZE) conv_autoencoder = ConvAutoencoder() if cuda: conv_autoencoder.to(device) if TRAIN_SCRATCH: for epoch in range(EPOCHS): starttime = datetime.datetime.now() model_training(conv_autoencoder, train_loader, epoch) endtime = datetime.datetime.now() print(f'Train a epoch in {(endtime - starttime).seconds} seconds') # evaluate on test set and save best model evaluation(conv_autoencoder, test_loader) print('Trainig Complete with best validation loss {:.4f}'.format( BEST_VAL)) else:
def train(cat_dim, noise_dim, batch_size, n_batch_per_epoch, nb_epoch, dset="mnist"): """ Train model Load the whole train data in memory for faster operations args: **kwargs (dict) keyword arguments that specify the model hyperparameters """ general_utils.setup_logging("IG") # Load and rescale data if dset == "mnist": print("loading mnist data") X_real_train, Y_real_train, X_real_test, Y_real_test = data_utils.load_mnist( ) # pick 1000 sample for testing # X_real_test = X_real_test[-1000:] # Y_real_test = Y_real_test[-1000:] img_dim = X_real_train.shape[-3:] epoch_size = n_batch_per_epoch * batch_size try: # Create optimizers opt_dcgan = Adam(lr=1E-3, beta_1=0.9, beta_2=0.999, epsilon=1e-08) opt_discriminator = Adam(lr=2E-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08) # opt_discriminator = SGD(lr=1E-4, momentum=0.9, nesterov=True) # Load generator model generator_model = models.load("generator_deconv", cat_dim, noise_dim, img_dim, batch_size, dset=dset) # Load discriminator model discriminator_model = models.load("DCGAN_discriminator", cat_dim, noise_dim, img_dim, batch_size, dset=dset) generator_model.compile(loss='mse', optimizer=opt_discriminator) # stop the discriminator to learn while in generator is learning discriminator_model.trainable = False DCGAN_model = models.DCGAN(generator_model, discriminator_model, cat_dim, noise_dim) list_losses = ['binary_crossentropy', 'categorical_crossentropy'] list_weights = [1, 1] DCGAN_model.compile(loss=list_losses, loss_weights=list_weights, optimizer=opt_dcgan) # Multiple discriminator losses # allow the discriminator to learn again discriminator_model.trainable = True discriminator_model.compile(loss=list_losses, loss_weights=list_weights, optimizer=opt_discriminator) # Start training print("Start training") for e in range(nb_epoch + 1): # Initialize progbar and batch counter # progbar = generic_utils.Progbar(epoch_size) batch_counter = 1 start = time.time() print("Epoch: {}".format(e)) for X_real_batch, Y_real_batch in zip( data_utils.gen_batch(X_real_train, batch_size), data_utils.gen_batch(Y_real_train, batch_size)): # Create a batch to feed the discriminator model X_disc_fake, y_disc_fake, noise_sample = data_utils.get_disc_batch( X_real_batch, Y_real_batch, generator_model, batch_size, cat_dim, noise_dim, type="fake") X_disc_real, y_disc_real = data_utils.get_disc_batch( X_real_batch, Y_real_batch, generator_model, batch_size, cat_dim, noise_dim, type="real") # Update the discriminator disc_loss_fake = discriminator_model.train_on_batch( X_disc_fake, [y_disc_fake, Y_real_batch]) disc_loss_real = discriminator_model.train_on_batch( X_disc_real, [y_disc_real, Y_real_batch]) disc_loss = disc_loss_fake + disc_loss_real # Create a batch to feed the generator model # X_noise, y_gen = data_utils.get_gen_batch(batch_size, cat_dim, noise_dim) # Freeze the discriminator discriminator_model.trainable = False gen_loss = DCGAN_model.train_on_batch( [Y_real_batch, noise_sample], [y_disc_real, Y_real_batch]) # Unfreeze the discriminator discriminator_model.trainable = True # training validation p_real_batch, p_Y_batch = discriminator_model.predict( X_real_batch, batch_size=batch_size) acc_train = data_utils.accuracy(p_Y_batch, Y_real_batch) batch_counter += 1 # progbar.add(batch_size, values=[("D tot", disc_loss[0]), # ("D cat", disc_loss[2]), # ("G tot", gen_loss[0]), # ("G cat", gen_loss[2]), # ("P Real:", p_real_batch), # ("Q acc", acc_train)]) # Save images for visualization if batch_counter % (n_batch_per_epoch / 2) == 0 and e % 10 == 0: data_utils.plot_generated_batch(X_real_batch, generator_model, batch_size, cat_dim, noise_dim, e) if batch_counter >= n_batch_per_epoch: break print("") print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start)) _, p_Y_test = discriminator_model.predict( X_real_test, batch_size=X_real_test.shape[0]) acc_test = data_utils.accuracy(p_Y_test, Y_real_test) print("Epoch: {} Accuracy: {}".format(e + 1, acc_test)) if e % 1000 == 0: gen_weights_path = os.path.join( '../../models/IG/gen_weights.h5') generator_model.save_weights(gen_weights_path, overwrite=True) disc_weights_path = os.path.join( '../../models/IG/disc_weights.h5') discriminator_model.save_weights(disc_weights_path, overwrite=True) DCGAN_weights_path = os.path.join( '../../models/IG/DCGAN_weights.h5') DCGAN_model.save_weights(DCGAN_weights_path, overwrite=True) except KeyboardInterrupt: pass
def train(**kwargs): """ Train model Load the whole train data in memory for faster operations args: **kwargs (dict) keyword arguments that specify the model hyperparameters """ # Roll out the parameters batch_size = kwargs["batch_size"] n_batch_per_epoch = kwargs["n_batch_per_epoch"] nb_epoch = kwargs["nb_epoch"] generator = kwargs["generator"] model_name = kwargs["model_name"] image_data_format = kwargs["image_data_format"] img_dim = kwargs["img_dim"] bn_mode = kwargs["bn_mode"] label_smoothing = kwargs["label_smoothing"] label_flipping = kwargs["label_flipping"] noise_scale = kwargs["noise_scale"] dset = kwargs["dset"] use_mbd = kwargs["use_mbd"] epoch_size = n_batch_per_epoch * batch_size # Setup environment (logging directory etc) general_utils.setup_logging(model_name) # Load and rescale data if dset == "celebA": X_real_train = data_utils.load_celebA(img_dim, image_data_format) if dset == "mnist": X_real_train, _, _, _ = data_utils.load_mnist(image_data_format) img_dim = X_real_train.shape[-3:] noise_dim = (100, ) try: # Create optimizers opt_dcgan = Adam(lr=1E-3, beta_1=0.5, beta_2=0.999, epsilon=1e-08) opt_discriminator = SGD(lr=1E-3, momentum=0.9, nesterov=True) # Load generator model generator_model = models.load("generator_%s" % generator, noise_dim, img_dim, bn_mode, batch_size, dset=dset, use_mbd=use_mbd) # Load discriminator model discriminator_model = models.load("DCGAN_discriminator", noise_dim, img_dim, bn_mode, batch_size, dset=dset, use_mbd=use_mbd) generator_model.compile(loss='mse', optimizer=opt_discriminator) discriminator_model.trainable = False DCGAN_model = models.DCGAN(generator_model, discriminator_model, noise_dim, img_dim) loss = ['binary_crossentropy'] loss_weights = [1] DCGAN_model.compile(loss=loss, loss_weights=loss_weights, optimizer=opt_dcgan) discriminator_model.trainable = True discriminator_model.compile(loss='binary_crossentropy', optimizer=opt_discriminator) gen_loss = 100 disc_loss = 100 # Start training print("Start training") for e in range(nb_epoch): # Initialize progbar and batch counter progbar = generic_utils.Progbar(epoch_size) batch_counter = 1 start = time.time() for X_real_batch in data_utils.gen_batch(X_real_train, batch_size): # Create a batch to feed the discriminator model X_disc, y_disc = data_utils.get_disc_batch( X_real_batch, generator_model, batch_counter, batch_size, noise_dim, noise_scale=noise_scale, label_smoothing=label_smoothing, label_flipping=label_flipping) # Update the discriminator disc_loss = discriminator_model.train_on_batch(X_disc, y_disc) # Create a batch to feed the generator model X_gen, y_gen = data_utils.get_gen_batch( batch_size, noise_dim, noise_scale=noise_scale) # Freeze the discriminator discriminator_model.trainable = False gen_loss = DCGAN_model.train_on_batch(X_gen, y_gen) # Unfreeze the discriminator discriminator_model.trainable = True batch_counter += 1 progbar.add(batch_size, values=[("D logloss", disc_loss), ("G logloss", gen_loss)]) # Save images for visualization if batch_counter % 100 == 0: data_utils.plot_generated_batch(X_real_batch, generator_model, batch_size, noise_dim, image_data_format) if batch_counter >= n_batch_per_epoch: break print("") print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start)) if e % 5 == 0: gen_weights_path = os.path.join( '../../models/%s/gen_weights_epoch%s.h5' % (model_name, e)) generator_model.save_weights(gen_weights_path, overwrite=True) disc_weights_path = os.path.join( '../../models/%s/disc_weights_epoch%s.h5' % (model_name, e)) discriminator_model.save_weights(disc_weights_path, overwrite=True) DCGAN_weights_path = os.path.join( '../../models/%s/DCGAN_weights_epoch%s.h5' % (model_name, e)) DCGAN_model.save_weights(DCGAN_weights_path, overwrite=True) except KeyboardInterrupt: pass
import cPickle as pickle import cv2 import matplotlib.pyplot as plt import matplotlib.patches as mpatches import sys sys.path.insert(0, '../mlp_test') from data_utils import load_mnist train_len = 1000 start=0 the_colors = [ 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'darkblue', 'lawngreen', 'orange', 'violet'] showSequence = True data_set = load_mnist()[0] target_values = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) chosens = [(index,data_set[1][index]) for index in range(start, start + train_len) if data_set[1][index] in target_values] sorted_chosens = np.asarray(sorted(chosens, key=lambda target: target[1])) X_data = np.asarray(data_set[0][sorted_chosens[:,0]]) y_data = np.asarray([data_set[1][sorted_chosens[:,0]]])[0] clrs = [the_colors[k] for i in range(train_len) for k in target_values if y_data[i] == k] if not showSequence: params = {'legend.fontsize': 6} plt.rcParams.update(params) patches = []
import urllib.request from urllib.parse import urlparse import sys # Gets your bucket name from command line try: bucket = str(sys.argv[1]) except Exception as error: print("Please pass your bucket name as a commandline argument") sys.exit(1) # Download dataset from pinned commit url = "https://github.com/aws/amazon-sagemaker-examples/raw/af6667bd0be3c9cdec23fecda7f0be6d0e3fa3ea/sagemaker-debugger/xgboost_realtime_analysis/data_utils.py" urllib.request.urlretrieve(url, "data_utils.py") from data_utils import load_mnist, upload_to_s3 prefix = "sagemaker/xgboost" train_file, validation_file = load_mnist() upload_to_s3(train_file, bucket, f"{prefix}/train/mnist.train.libsvm") upload_to_s3(validation_file, bucket, f"{prefix}/validation/mnist.validation.libsvm") # Remove downloaded file import os os.remove("data_utils.py")
from __future__ import division import numpy as np import matplotlib.pyplot as plt import matplotlib.cm as cm import cv2 from cv2 import matchShapes from skimage.measure import compare_ssim import sys sys.path.insert(0, '../mlp_test') from data_utils import load_mnist train_data, verificatio_data, test_data = load_mnist() index_1 = 7 index_2 = 10 img_arr_1 = train_data[0][index_1].reshape((28, 28)) img_val_1 = train_data[1][index_1] img_arr_2 = train_data[0][index_2].reshape((28, 28)) img_val_2 = train_data[1][index_2] import scipy.misc ret, thresh_1 = cv2.threshold(np.uint8(img_arr_1 * 255).copy(), 127, 255, cv2.THRESH_BINARY) ret, thresh2 = cv2.threshold(np.uint8(img_arr_2 * 255).copy(), 127, 255,0) contours,hierarchy = cv2.findContours(thresh_1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnt1 = contours[0] contours,hierarchy = cv2.findContours(thresh2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnt2 = contours[0] formatt = "{:4.2f}" match_I1 = formatt.format(matchShapes(cnt1, cnt2, cv2.cv.CV_CONTOURS_MATCH_I1,0))
def eval(**kwargs): # Roll out the parameters batch_size = kwargs["batch_size"] generator = kwargs["generator"] model_name = kwargs["model_name"] image_data_format = kwargs["image_data_format"] img_dim = kwargs["img_dim"] cont_dim = (kwargs["cont_dim"],) cat_dim = (kwargs["cat_dim"],) noise_dim = (kwargs["noise_dim"],) bn_mode = kwargs["bn_mode"] noise_scale = kwargs["noise_scale"] dset = kwargs["dset"] eval_epoch = kwargs["eval_epoch"] # Setup environment (logging directory etc) general_utils.setup_logging(**kwargs) # Load and rescale data if dset == "RGZ": X_real_train = data_utils.load_RGZ(img_dim, image_data_format) if dset == "mnist": X_real_train, _, _, _ = data_utils.load_mnist(image_data_format) img_dim = X_real_train.shape[-3:] # Load generator model generator_model = models.load("generator_%s" % generator, cat_dim, cont_dim, noise_dim, img_dim, bn_mode, batch_size, dset=dset) # Load colorization model generator_model.load_weights("../../models/%s/gen_weights_epoch%05d.h5" % (model_name, eval_epoch)) X_plot = [] # Vary the categorical variable for i in range(cat_dim[0]): X_noise = data_utils.sample_noise(noise_scale, batch_size, noise_dim) X_cont = data_utils.sample_noise(noise_scale, batch_size, cont_dim) X_cont = np.repeat(X_cont[:1, :], batch_size, axis=0) # fix continuous noise X_cat = np.zeros((batch_size, cat_dim[0]), dtype='float32') X_cat[:, i] = 1 # always the same categorical value X_gen = generator_model.predict([X_cat, X_cont, X_noise]) X_gen = data_utils.inverse_normalization(X_gen) if image_data_format == "channels_first": X_gen = X_gen.transpose(0,2,3,1) X_gen = [X_gen[i] for i in range(len(X_gen))] X_plot.append(np.concatenate(X_gen, axis=1)) X_plot = np.concatenate(X_plot, axis=0) plt.figure(figsize=(8,10)) if X_plot.shape[-1] == 1: plt.imshow(X_plot[:, :, 0], cmap="gray") else: plt.imshow(X_plot) plt.xticks([]) plt.yticks([]) plt.ylabel("Varying categorical factor", fontsize=28, labelpad=60) plt.annotate('', xy=(-0.05, 0), xycoords='axes fraction', xytext=(-0.05, 1), arrowprops=dict(arrowstyle="-|>", color='k', linewidth=4)) plt.tight_layout() plt.savefig(os.path.join("../../figures", model_name, "varying_categorical.png")) plt.clf() plt.close() # Vary the continuous variables X_plot = [] # First get the extent of the noise sampling x = np.ravel(data_utils.sample_noise(noise_scale, batch_size * 20000, cont_dim)) # Define interpolation points x = np.linspace(x.min(), x.max(), num=batch_size) for i in range(batch_size): X_noise = data_utils.sample_noise(noise_scale, batch_size, noise_dim) X_cont = np.concatenate([np.array([x[i], x[j]]).reshape(1, -1) for j in range(batch_size)], axis=0) X_cat = np.zeros((batch_size, cat_dim[0]), dtype='float32') X_cat[:, 1] = 1 # always the same categorical value X_gen = generator_model.predict([X_cat, X_cont, X_noise]) X_gen = data_utils.inverse_normalization(X_gen) if image_data_format == "channels_first": X_gen = X_gen.transpose(0,2,3,1) X_gen = [X_gen[i] for i in range(len(X_gen))] X_plot.append(np.concatenate(X_gen, axis=1)) X_plot = np.concatenate(X_plot, axis=0) plt.figure(figsize=(10,10)) if X_plot.shape[-1] == 1: plt.imshow(X_plot[:, :, 0], cmap="gray") else: plt.imshow(X_plot) plt.xticks([]) plt.yticks([]) plt.ylabel("Varying continuous factor 1", fontsize=28, labelpad=60) plt.annotate('', xy=(-0.05, 0), xycoords='axes fraction', xytext=(-0.05, 1), arrowprops=dict(arrowstyle="-|>", color='k', linewidth=4)) plt.xlabel("Varying continuous factor 2", fontsize=28, labelpad=60) plt.annotate('', xy=(1, -0.05), xycoords='axes fraction', xytext=(0, -0.05), arrowprops=dict(arrowstyle="-|>", color='k', linewidth=4)) plt.tight_layout() plt.savefig(os.path.join("../../figures", model_name, "varying_continuous.png")) plt.clf() plt.close()
def train(**kwargs): """ Train model Load the whole train data in memory for faster operations args: **kwargs (dict) keyword arguments that specify the model hyperparameters """ # Roll out the parameters batch_size = kwargs["batch_size"] n_batch_per_epoch = kwargs["n_batch_per_epoch"] nb_epoch = kwargs["nb_epoch"] generator = kwargs["generator"] model_name = kwargs["model_name"] image_data_format = kwargs["image_data_format"] celebA_img_dim = kwargs["celebA_img_dim"] cont_dim = (kwargs["cont_dim"], ) cat_dim = (kwargs["cat_dim"], ) noise_dim = (kwargs["noise_dim"], ) label_smoothing = kwargs["label_smoothing"] label_flipping = kwargs["label_flipping"] noise_scale = kwargs["noise_scale"] dset = kwargs["dset"] use_mbd = kwargs["use_mbd"] load_from_dir = kwargs["load_from_dir"] target_size = kwargs["target_size"] save_weights_every_n_epochs = kwargs["save_weights_every_n_epochs"] save_only_last_n_weights = kwargs["save_only_last_n_weights"] visualize_images_every_n_epochs = kwargs["visualize_images_every_n_epochs"] epoch_size = n_batch_per_epoch * batch_size # Setup environment (logging directory etc) general_utils.setup_logging(**kwargs) # Load and rescale data if dset == "celebA": X_real_train = data_utils.load_celebA(celebA_img_dim, image_data_format) elif dset == "mnist": X_real_train, _, _, _ = data_utils.load_mnist(image_data_format) else: X_batch_gen = data_utils.data_generator_from_dir( dset, target_size, batch_size) X_real_train = next(X_batch_gen) img_dim = X_real_train.shape[-3:] try: # Create optimizers opt_dcgan = Adam(lr=1E-4, beta_1=0.5, beta_2=0.999, epsilon=1e-08) opt_discriminator = Adam(lr=1E-4, beta_1=0.5, beta_2=0.999, epsilon=1e-08) # opt_discriminator = SGD(lr=1E-4, momentum=0.9, nesterov=True) # Load generator model generator_model = models.load("generator_%s" % generator, cat_dim, cont_dim, noise_dim, img_dim, batch_size, dset=dset, use_mbd=use_mbd) # Load discriminator model discriminator_model = models.load("DCGAN_discriminator", cat_dim, cont_dim, noise_dim, img_dim, batch_size, dset=dset, use_mbd=use_mbd) generator_model.compile(loss='mse', optimizer=opt_discriminator) discriminator_model.trainable = False DCGAN_model = models.DCGAN(generator_model, discriminator_model, cat_dim, cont_dim, noise_dim) list_losses = [ 'binary_crossentropy', 'categorical_crossentropy', gaussian_loss ] list_weights = [1, 1, 1] DCGAN_model.compile(loss=list_losses, loss_weights=list_weights, optimizer=opt_dcgan) # Multiple discriminator losses discriminator_model.trainable = True discriminator_model.compile(loss=list_losses, loss_weights=list_weights, optimizer=opt_discriminator) gen_loss = 100 disc_loss = 100 if not load_from_dir: X_batch_gen = data_utils.gen_batch(X_real_train, batch_size) # Start training print("Start training") disc_total_losses = [] disc_log_losses = [] disc_cat_losses = [] disc_cont_losses = [] gen_total_losses = [] gen_log_losses = [] gen_cat_losses = [] gen_cont_losses = [] start = time.time() for e in range(nb_epoch): print('--------------------------------------------') print('[{0:%Y/%m/%d %H:%M:%S}] Epoch {1:d}/{2:d}\n'.format( datetime.datetime.now(), e + 1, nb_epoch)) # Initialize progbar and batch counter progbar = generic_utils.Progbar(epoch_size) batch_counter = 1 disc_total_loss_batch = 0 disc_log_loss_batch = 0 disc_cat_loss_batch = 0 disc_cont_loss_batch = 0 gen_total_loss_batch = 0 gen_log_loss_batch = 0 gen_cat_loss_batch = 0 gen_cont_loss_batch = 0 for batch_counter in range(n_batch_per_epoch): # Load data X_real_batch = next(X_batch_gen) # Create a batch to feed the discriminator model X_disc, y_disc, y_cat, y_cont = data_utils.get_disc_batch( X_real_batch, generator_model, batch_counter, batch_size, cat_dim, cont_dim, noise_dim, noise_scale=noise_scale, label_smoothing=label_smoothing, label_flipping=label_flipping) # Update the discriminator disc_loss = discriminator_model.train_on_batch( X_disc, [y_disc, y_cat, y_cont]) # Create a batch to feed the generator model X_gen, y_gen, y_cat, y_cont, y_cont_target = data_utils.get_gen_batch( batch_size, cat_dim, cont_dim, noise_dim, noise_scale=noise_scale) # Freeze the discriminator discriminator_model.trainable = False gen_loss = DCGAN_model.train_on_batch( [y_cat, y_cont, X_gen], [y_gen, y_cat, y_cont_target]) # Unfreeze the discriminator discriminator_model.trainable = True progbar.add(batch_size, values=[("D tot", disc_loss[0]), ("D log", disc_loss[1]), ("D cat", disc_loss[2]), ("D cont", disc_loss[3]), ("G tot", gen_loss[0]), ("G log", gen_loss[1]), ("G cat", gen_loss[2]), ("G cont", gen_loss[3])]) disc_total_loss_batch += disc_loss[0] disc_log_loss_batch += disc_loss[1] disc_cat_loss_batch += disc_loss[2] disc_cont_loss_batch += disc_loss[3] gen_total_loss_batch += gen_loss[0] gen_log_loss_batch += gen_loss[1] gen_cat_loss_batch += gen_loss[2] gen_cont_loss_batch += gen_loss[3] # # Save images for visualization # if batch_counter % (n_batch_per_epoch / 2) == 0: # data_utils.plot_generated_batch(X_real_batch, generator_model, e, # batch_size, cat_dim, cont_dim, noise_dim, # image_data_format, model_name) disc_total_losses.append(disc_total_loss_batch / n_batch_per_epoch) disc_log_losses.append(disc_log_loss_batch / n_batch_per_epoch) disc_cat_losses.append(disc_cat_loss_batch / n_batch_per_epoch) disc_cont_losses.append(disc_cont_loss_batch / n_batch_per_epoch) gen_total_losses.append(gen_total_loss_batch / n_batch_per_epoch) gen_log_losses.append(gen_log_loss_batch / n_batch_per_epoch) gen_cat_losses.append(gen_cat_loss_batch / n_batch_per_epoch) gen_cont_losses.append(gen_cont_loss_batch / n_batch_per_epoch) # Save images for visualization if (e + 1) % visualize_images_every_n_epochs == 0: data_utils.plot_generated_batch(X_real_batch, generator_model, e, batch_size, cat_dim, cont_dim, noise_dim, image_data_format, model_name) data_utils.plot_losses(disc_total_losses, disc_log_losses, disc_cat_losses, disc_cont_losses, gen_total_losses, gen_log_losses, gen_cat_losses, gen_cont_losses, model_name) if (e + 1) % save_weights_every_n_epochs == 0: print("Saving weights...") # Delete all but the last n weights general_utils.purge_weights(save_only_last_n_weights, model_name) # Save weights gen_weights_path = os.path.join( '../../models/%s/gen_weights_epoch%05d.h5' % (model_name, e)) generator_model.save_weights(gen_weights_path, overwrite=True) disc_weights_path = os.path.join( '../../models/%s/disc_weights_epoch%05d.h5' % (model_name, e)) discriminator_model.save_weights(disc_weights_path, overwrite=True) DCGAN_weights_path = os.path.join( '../../models/%s/DCGAN_weights_epoch%05d.h5' % (model_name, e)) DCGAN_model.save_weights(DCGAN_weights_path, overwrite=True) end = time.time() print("") print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, end - start)) start = end except KeyboardInterrupt: pass gen_weights_path = '../../models/%s/generator_latest.h5' % (model_name) print("Saving", gen_weights_path) generator_model.save(gen_weights_path, overwrite=True)
import gzip import cPickle import sys sys.path.insert(0, '../mlp_test') from data_utils import load_mnist train_set, valid_set, test_set = load_mnist() chosen_index = 1250 test_x_chosen = test_set[0][chosen_index] test_y_chosen = test_set[1][chosen_index] test_chosen = [test_set[0][chosen_index], test_set[1][chosen_index]] filepath = "../data/savedImage_" + str(test_y_chosen) + ".p" cPickle.dump(test_chosen, open(filepath, "wb" ) ) test_saved = cPickle.load( open(filepath, "rb" ) ) test_x_saved, test_y_saved = test_saved import matplotlib.cm as cm import matplotlib.pyplot as plt plt.title(test_y_saved, fontsize=24) plt.imshow(test_x_saved.reshape((28, 28)), cmap = cm.Greys_r) plt.show()
# Spectral embedding of the digits dataset def cse(X, nr_components=2): print("Computing Spectral embedding") embedder = manifold.SpectralEmbedding(n_components=nr_components, random_state=0, eigen_solver="arpack") return embedder.fit_transform(X) def tsne(X, nr_components=2): print("Computing t-SNE embedding") tsne = manifold.TSNE(n_components=nr_components, init='random', random_state=0) return tsne.fit_transform(X) if __name__ == '__main__': train_data = load_mnist()[0] chosens = [index for index in range(start, start + testlen) if train_data[1][index] in target_values] indexes = np.asarray([i for i in chosens]) X_data = np.asarray([train_data[0][i] for i in chosens]) y_data = np.asarray([train_data[1][i] for i in chosens]) if showAll: t0 = time() plot_embedding(tsne(X_data), y_data, "t-SNE embedding of the digits (time %.2fs)" % (time() - t0)) t0 = time() plot_embedding(cse(X_data), y_data,
import pywt import sys sys.path.insert(0, '../mlp_test') from data_utils import load_mnist mode = 'sym2' level = None direction = ['h', 'v', 'd'] test_data = load_mnist()[2] chosen_index = 7 test_x_chosen = test_data[0][chosen_index] test_y_chosen = test_data[1][chosen_index] pic_arr = test_x_chosen.reshape((28, 28)) pic_wts = pywt.wavedec2(pic_arr, mode, level=level) length = len(pic_wts) import matplotlib.cm as cm import matplotlib.pyplot as plt from matplotlib.ticker import MaxNLocator plt.subplot(length , 3, 2) ax = plt.subplot(length , 3, 2) ax.get_yaxis().set_major_locator(MaxNLocator(integer=True))
def train(**kwargs): """ Train model Load the whole train data in memory for faster operations args: **kwargs (dict) keyword arguments that specify the model hyperparameters """ # Roll out the parameters batch_size = kwargs["batch_size"] n_batch_per_epoch = kwargs["n_batch_per_epoch"] nb_epoch = kwargs["nb_epoch"] generator = kwargs["generator"] model_name = kwargs["model_name"] image_dim_ordering = kwargs["image_dim_ordering"] img_dim = kwargs["img_dim"] bn_mode = kwargs["bn_mode"] label_smoothing = kwargs["label_smoothing"] label_flipping = kwargs["label_flipping"] noise_scale = kwargs["noise_scale"] dset = kwargs["dset"] use_mbd = kwargs["use_mbd"] epoch_size = n_batch_per_epoch * batch_size # Setup environment (logging directory etc) general_utils.setup_logging(model_name) # Load and rescale data if dset == "celebA": X_real_train = data_utils.load_celebA(img_dim, image_dim_ordering) if dset == "mnist": X_real_train, _, _, _ = data_utils.load_mnist(image_dim_ordering) img_dim = X_real_train.shape[-3:] noise_dim = (100,) try: # Create optimizers opt_dcgan = Adam(lr=1E-3, beta_1=0.5, beta_2=0.999, epsilon=1e-08) opt_discriminator = SGD(lr=1E-3, momentum=0.9, nesterov=True) # Load generator model generator_model = models.load("generator_%s" % generator, noise_dim, img_dim, bn_mode, batch_size, dset=dset, use_mbd=use_mbd) # Load discriminator model discriminator_model = models.load("DCGAN_discriminator", noise_dim, img_dim, bn_mode, batch_size, dset=dset, use_mbd=use_mbd) generator_model.compile(loss='mse', optimizer=opt_discriminator) discriminator_model.trainable = False DCGAN_model = models.DCGAN(generator_model, discriminator_model, noise_dim, img_dim) loss = ['binary_crossentropy'] loss_weights = [1] DCGAN_model.compile(loss=loss, loss_weights=loss_weights, optimizer=opt_dcgan) discriminator_model.trainable = True discriminator_model.compile(loss='binary_crossentropy', optimizer=opt_discriminator) gen_loss = 100 disc_loss = 100 # Start training print("Start training") for e in range(nb_epoch): # Initialize progbar and batch counter progbar = generic_utils.Progbar(epoch_size) batch_counter = 1 start = time.time() for X_real_batch in data_utils.gen_batch(X_real_train, batch_size): # Create a batch to feed the discriminator model X_disc, y_disc = data_utils.get_disc_batch(X_real_batch, generator_model, batch_counter, batch_size, noise_dim, noise_scale=noise_scale, label_smoothing=label_smoothing, label_flipping=label_flipping) # Update the discriminator disc_loss = discriminator_model.train_on_batch(X_disc, y_disc) # Create a batch to feed the generator model X_gen, y_gen = data_utils.get_gen_batch(batch_size, noise_dim, noise_scale=noise_scale) # Freeze the discriminator discriminator_model.trainable = False gen_loss = DCGAN_model.train_on_batch(X_gen, y_gen) # Unfreeze the discriminator discriminator_model.trainable = True batch_counter += 1 progbar.add(batch_size, values=[("D logloss", disc_loss), ("G logloss", gen_loss)]) # Save images for visualization if batch_counter % 100 == 0: data_utils.plot_generated_batch(X_real_batch, generator_model, batch_size, noise_dim, image_dim_ordering) if batch_counter >= n_batch_per_epoch: break print("") print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start)) if e % 5 == 0: gen_weights_path = os.path.join('../../models/%s/gen_weights_epoch%s.h5' % (model_name, e)) generator_model.save_weights(gen_weights_path, overwrite=True) disc_weights_path = os.path.join('../../models/%s/disc_weights_epoch%s.h5' % (model_name, e)) discriminator_model.save_weights(disc_weights_path, overwrite=True) DCGAN_weights_path = os.path.join('../../models/%s/DCGAN_weights_epoch%s.h5' % (model_name, e)) DCGAN_model.save_weights(DCGAN_weights_path, overwrite=True) except KeyboardInterrupt: pass
train_len = 2000 start=0 # 'mahalanobis' target_values = np.array([1]) metrics = ['braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'dice', 'euclidean', 'hamming', 'jaccard', 'kulsinski', 'matching', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'] # The metrics 'mahalanobis', 'seuclidean', 'cosine' are not directly usable train_data, validation_data, test_data = load_mnist() chosens = [(index, train_data[1][index]) for index in range(start, start + train_len) if train_data[1][index] in target_values] sorted_chosens = np.asarray(sorted(chosens, key=lambda target: target[1])) X_data = train_data[0][start:start + train_len] y_data = train_data[1][start:start + train_len] X_test = test_data[0] y_test = test_data[1] len_test = len(test_data[1]) from scipy.spatial.distance import cdist def closest_node(node, nodes, distance = 'euclidean'): return cdist([node], nodes, metric = distance).argmin()
def eval(**kwargs): # Roll out the parameters batch_size = kwargs["batch_size"] generator = kwargs["generator"] model_name = kwargs["model_name"] image_dim_ordering = kwargs["image_dim_ordering"] img_dim = kwargs["img_dim"] cont_dim = (kwargs["cont_dim"],) cat_dim = (kwargs["cat_dim"],) noise_dim = (kwargs["noise_dim"],) bn_mode = kwargs["bn_mode"] noise_scale = kwargs["noise_scale"] dset = kwargs["dset"] epoch = kwargs["epoch"] # Setup environment (logging directory etc) general_utils.setup_logging(model_name) # Load and rescale data if dset == "RGZ": X_real_train = data_utils.load_RGZ(img_dim, image_dim_ordering) if dset == "mnist": X_real_train, _, _, _ = data_utils.load_mnist(image_dim_ordering) img_dim = X_real_train.shape[-3:] # Load generator model generator_model = models.load("generator_%s" % generator, cat_dim, cont_dim, noise_dim, img_dim, bn_mode, batch_size, dset=dset) # Load colorization model generator_model.load_weights("../../models/%s/gen_weights_epoch%s.h5" % (model_name, epoch)) X_plot = [] # Vary the categorical variable for i in range(cat_dim[0]): X_noise = data_utils.sample_noise(noise_scale, batch_size, noise_dim) X_cont = data_utils.sample_noise(noise_scale, batch_size, cont_dim) X_cont = np.repeat(X_cont[:1, :], batch_size, axis=0) # fix continuous noise X_cat = np.zeros((batch_size, cat_dim[0]), dtype='float32') X_cat[:, i] = 1 # always the same categorical value X_gen = generator_model.predict([X_cat, X_cont, X_noise]) X_gen = data_utils.inverse_normalization(X_gen) if image_dim_ordering == "th": X_gen = X_gen.transpose(0,2,3,1) X_gen = [X_gen[i] for i in range(len(X_gen))] X_plot.append(np.concatenate(X_gen, axis=1)) X_plot = np.concatenate(X_plot, axis=0) plt.figure(figsize=(8,10)) if X_plot.shape[-1] == 1: plt.imshow(X_plot[:, :, 0], cmap="gray") else: plt.imshow(X_plot) plt.xticks([]) plt.yticks([]) plt.ylabel("Varying categorical factor", fontsize=28, labelpad=60) plt.annotate('', xy=(-0.05, 0), xycoords='axes fraction', xytext=(-0.05, 1), arrowprops=dict(arrowstyle="-|>", color='k', linewidth=4)) plt.tight_layout() plt.savefig("../../figures/varying_categorical.png") plt.clf() plt.close() # Vary the continuous variables X_plot = [] # First get the extent of the noise sampling x = np.ravel(data_utils.sample_noise(noise_scale, batch_size * 20000, cont_dim)) # Define interpolation points x = np.linspace(x.min(), x.max(), num=batch_size) for i in range(batch_size): X_noise = data_utils.sample_noise(noise_scale, batch_size, noise_dim) X_cont = np.concatenate([np.array([x[i], x[j]]).reshape(1, -1) for j in range(batch_size)], axis=0) X_cat = np.zeros((batch_size, cat_dim[0]), dtype='float32') X_cat[:, 1] = 1 # always the same categorical value X_gen = generator_model.predict([X_cat, X_cont, X_noise]) X_gen = data_utils.inverse_normalization(X_gen) if image_dim_ordering == "th": X_gen = X_gen.transpose(0,2,3,1) X_gen = [X_gen[i] for i in range(len(X_gen))] X_plot.append(np.concatenate(X_gen, axis=1)) X_plot = np.concatenate(X_plot, axis=0) plt.figure(figsize=(10,10)) if X_plot.shape[-1] == 1: plt.imshow(X_plot[:, :, 0], cmap="gray") else: plt.imshow(X_plot) plt.xticks([]) plt.yticks([]) plt.ylabel("Varying continuous factor 1", fontsize=28, labelpad=60) plt.annotate('', xy=(-0.05, 0), xycoords='axes fraction', xytext=(-0.05, 1), arrowprops=dict(arrowstyle="-|>", color='k', linewidth=4)) plt.xlabel("Varying continuous factor 2", fontsize=28, labelpad=60) plt.annotate('', xy=(1, -0.05), xycoords='axes fraction', xytext=(0, -0.05), arrowprops=dict(arrowstyle="-|>", color='k', linewidth=4)) plt.tight_layout() plt.savefig("../../figures/varying_continuous.png") plt.clf() plt.close()