def train(input_dim, z_dim, num_epochs, num_classes, batch_size, learning_rate, shuffle=False, data_dir=None, summary_dir=None):
# Load data
X_train = np.load(os.path.join(data_dir, 'data.npy'))
y_train = np.load(os.path.join(data_dir, 'label.npy'))
y_train = to_categorical(y_train, num_classes + 1)
print('Number of training images: %d' % X_train.shape[0])
with tf.Graph().as_default():
sess = tf.Session()
with sess.as_default():
# Build model
aae = AAE(input_dim, z_dim, num_classes, batch_size, learning_rate)
aae.build(G_type=FLAGS.G_type)
loss_summary_writer = tf.summary.FileWriter(summary_dir, sess.graph)
num_batches_per_epoch = X_train.shape[0] // batch_size
tf.logging.info('Create new session')
sess.run(tf.global_variables_initializer())
for epoch in range(num_epochs):
total_vae_loss, total_gen_loss, total_disc_loss = 0.0, 0.0, 0.0
for i in range(num_batches_per_epoch):
start_index = i * batch_size
end_index = min((i + 1) * batch_size, X_train.shape[0])
X_batch = X_train[start_index:end_index]
y_batch = y_train[start_index:end_index]
vae_loss, gen_loss, disc_loss = train_step(X_batch, y_batch, sess, aae, loss_summary_writer)
total_vae_loss += vae_loss
total_gen_loss += gen_loss
total_disc_loss += disc_loss
print("Epoch %3d ==> vae_loss: %.4f\tgen_loss: %.4f\tdisc_loss: %.4f" % (epoch, total_vae_loss / num_batches_per_epoch, total_gen_loss / num_batches_per_epoch, total_disc_loss / num_batches_per_epoch))
if FLAGS.plot:
indices = np.random.choice(X_train.shape[0], size=batch_size)
X_sample = X_train[indices]
y_sample = y_train[indices]
plot_reconstructed_images(X_sample, y_sample, aae, sess)
plot_generated_images(aae, sess)
indices = np.random.choice(X_train.shape[0], size=5000)
X_sample = X_train[indices]
y_sample = y_train[indices]
X_latent_space = aae.get_latent_space(sess, X_sample)
X_latent_space = X_latent_space.astype('float64')
plot_tsne(X_latent_space, y_sample)
def main(_):
parser = argparse.ArgumentParser()
parser.add_argument('--action',
dest='action',
type=str,
default='train',
help='actions: train, or test')
args = parser.parse_args()
if args.action not in ['train', 'test']:
print('invalid action: ', args.action)
print("Please input a action: train, test")
else:
model = AAE(tf.Session(), configure())
getattr(model, args.action)()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--batch_size', '-bs', type=int, default=64)
parser.add_argument('--nb_epoch', '-e', type=int, default=1000)
parser.add_argument('--latent_dim', '-ld', type=int, default=2)
parser.add_argument('--height', '-ht', type=int, default=32)
parser.add_argument('--width', '-wd', type=int, default=32)
parser.add_argument('--channel', '-ch', type=int, default=1)
parser.add_argument('--save_steps', '-ss', type=int, default=10)
parser.add_argument('--visualize_steps', '-vs', type=int, default=10)
parser.add_argument('--model_dir', '-md', type=str, default="./params")
parser.add_argument('--result_dir', '-rd', type=str, default="./result")
parser.add_argument('--noise_mode', '-nm', type=str, default="normal")
args = parser.parse_args()
os.makedirs(args.result_dir, exist_ok=True)
os.makedirs(args.model_dir, exist_ok=True)
dump_config(os.path.join(args.result_dir, 'config.csv'), args)
input_shape = (args.height, args.width, args.channel)
image_sampler = ImageSampler(
target_size=(args.width, args.height),
color_mode='rgb' if args.channel == 3 else 'gray',
is_training=True)
noise_sampler = NoiseSampler(args.noise_mode)
autoencoder = AutoEncoder(
input_shape,
args.latent_dim,
is_training=True,
color_mode='rgb' if args.channel == 3 else 'gray')
discriminator = Discriminator(is_training=True)
aae = AAE(autoencoder, discriminator, is_training=True)
train_x, _ = load_mnist(mode='training')
aae.fit_generator(image_sampler.flow(train_x, batch_size=args.batch_size),
noise_sampler,
nb_epoch=args.nb_epoch,
save_steps=args.save_steps,
visualize_steps=args.visualize_steps,
result_dir=args.result_dir,
model_dir=args.model_dir)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--batch_size', '-bs', type=int, default=64)
parser.add_argument('--latent_dim', '-ld', type=int, default=2)
parser.add_argument('--height', '-ht', type=int, default=32)
parser.add_argument('--width', '-wd', type=int, default=32)
parser.add_argument('--channel', '-ch', type=int, default=1)
parser.add_argument('--model_path', '-mp', type=str, default="./params")
parser.add_argument('--result_dir', '-rd', type=str, default="./result")
args = parser.parse_args()
os.makedirs(args.result_dir, exist_ok=True)
input_shape = (args.height, args.width, args.channel)
autoencoder = AutoEncoder(
input_shape,
args.latent_dim,
is_training=False,
color_mode='rgb' if args.channel == 3 else 'gray')
discriminator = Discriminator(is_training=False)
aae = AAE(autoencoder, discriminator, is_training=False)
aae.restore(args.model_path)
test_x, test_y = load_mnist(mode='test')
image_sampler = ImageSampler(
target_size=(args.width, args.height),
color_mode='rgb' if args.channel == 3 else 'gray',
is_training=False)
encoded = aae.predict_latent_vectors_generator(
image_sampler.flow(test_x, shuffle=False))
df = pd.DataFrame({
'z_1': encoded[:, 0],
'z_2': encoded[:, 1],
'label': test_y
})
df.plot(kind='scatter', x='z_1', y='z_2', c='label', cmap='Set1', s=10)
plt.savefig(os.path.join(args.result_dir, 'scatter.png'))
flags.DEFINE_integer("batch_size", 128, "batch size")
flags.DEFINE_integer("updates_per_epoch", 300, "number of updates per epoch")
flags.DEFINE_integer("max_epoch", 5000, "max epoch")
flags.DEFINE_float("learning_rate", 1e-1, "learning rate")
flags.DEFINE_string("working_directory", "./", "wd")
flags.DEFINE_string("log_directory", "./log", "wd")
flags.DEFINE_integer("hidden_size", 2, "size of the hidden unit")
FLAGS = flags.FLAGS
if __name__ == "__main__":
data_directory = os.path.join(FLAGS.working_directory, "MNIST")
if not os.path.exists(data_directory):
os.makedirs(data_directory)
mnist = input_data.read_data_sets(data_directory, one_hot=False)
model = AAE(FLAGS.hidden_size, FLAGS.batch_size, FLAGS.learning_rate,
FLAGS.log_directory)
for epoch in range(FLAGS.max_epoch):
recons_loss_train, classify_loss_train = 0., 0.
for i in range(FLAGS.updates_per_epoch):
images, _ = mnist.train.next_batch(FLAGS.batch_size)
recons_loss_value, classify_loss_value, summary = \
model.update_params(images)
recons_loss_train += recons_loss_value
classify_loss_train += classify_loss_value
# write summary
if epoch % 10 == 9:
model.train_writer.add_summary(summary, epoch)
recons_loss_train = recons_loss_train / \
(FLAGS.updates_per_epoch * FLAGS.batch_size)
classify_loss_train = classify_loss_train / \
def main():
parser = argparse.ArgumentParser()
parser.add_argument('ok_image_dir', type=str)
parser.add_argument('ng_image_dir', type=str)
parser.add_argument('--ok_nb_sample', '-ons', type=int, default=47736)
parser.add_argument('--ng_nb_sample', '-nns', type=int, default=450)
parser.add_argument('--batch_size', '-bs', type=int, default=234)
parser.add_argument('--nb_epoch', '-e', type=int, default=200)
parser.add_argument('--latent_dim', '-ld', type=int, default=16)
parser.add_argument('--height', '-ht', type=int, default=64)
parser.add_argument('--width', '-wd', type=int, default=64)
parser.add_argument('--channel', '-ch', type=int, default=8)
parser.add_argument('--save_steps', '-ss', type=int, default=1)
parser.add_argument('--visualize_steps', '-vs', type=int, default=1)
parser.add_argument('--model_dir', '-md', type=str, default="./params")
parser.add_argument('--result_dir', '-rd', type=str, default="./result")
parser.add_argument('--noise_mode', '-nm', type=str, default="normal")
parser.add_argument('--select_gpu', '-sg', type=str, default="0")
args = parser.parse_args()
config = tf.ConfigProto(
gpu_options=tf.GPUOptions(
visible_device_list=args.select_gpu, # specify GPU number
allow_growth=True)
)
os.makedirs(args.result_dir, exist_ok=True)
os.makedirs(args.model_dir, exist_ok=True)
dump_config(os.path.join(args.result_dir, 'config.csv'), args)
ok_paths = [os.path.join(args.ok_image_dir, f)
for f in os.listdir(args.ok_image_dir)]
random.shuffle(ok_paths)
ng_paths = [os.path.join(args.ng_image_dir, f)
for f in os.listdir(args.ng_image_dir)]
random.shuffle(ng_paths)
if args.nb_inliers is not None:
ok_paths = ok_paths[:args.ok_nb_sample]
else :
args.nb_inliers = len(ok_paths)
if args.nb_outliers is not None:
ng_paths = ng_paths[:args.ng_nb_sample]
image_paths = ok_paths + ng_paths
input_shape = (args.height, args.width, args.channel)
image_sampler = ImageSampler(target_size=(args.width, args.height),
color_mode='rgb' if args.channel == 3 else 'gray',
is_training=True)
noise_sampler = NoiseSampler(args.noise_mode)
autoencoder = AutoEncoder(input_shape, args.latent_dim,
is_training=True,
channel=args.channel)
discriminator = Discriminator(is_training=True)
aae = AAE(autoencoder, discriminator, is_training=True, kld_weight=args.kld_weight, config=config)
aae.fit_generator(image_sampler.flow_from_path(image_paths, args.batch_size),
noise_sampler, nb_epoch=args.nb_epoch,
save_steps=args.save_steps, visualize_steps=args.visualize_steps,
result_dir=args.result_dir, model_dir=args.model_dir)
conf.gpu_enabled = True if args.gpu_enabled == 1 else False conf.learning_rate = 0.0001 conf.gradient_momentum = 0.1 conf.gradient_clipping = 5.0 conf.ndim_z = 2 conf.ndim_y = 10 conf.batchnorm_before_activation = True conf.generator_hidden_units = [600, 600] conf.generator_activation_function = "elu" conf.generator_apply_dropout = False conf.generator_apply_batchnorm = False conf.generator_apply_batchnorm_to_input = False conf.decoder_hidden_units = [600, 600] conf.decoder_activation_function = "elu" conf.decoder_apply_dropout = False conf.decoder_apply_batchnorm = False conf.decoder_apply_batchnorm_to_input = False conf.discriminator_z_hidden_units = [600, 600] conf.discriminator_z_activation_function = "elu" conf.discriminator_z_apply_dropout = False conf.discriminator_z_apply_batchnorm = False conf.discriminator_z_apply_batchnorm_to_input = False conf.q_z_x_type = aae.Q_Z_X_TYPE_DETERMINISTIC aae = AAE(conf, name="aae") aae.load(args.model_dir)
from glob import glob
import cv2
file_list = glob('./anime/*.jpg')
num_training_examples = 50000
num_testing_examples = 1000
train_images = [
cv2.cvtColor(cv2.resize(cv2.imread(path), (64, 64)), cv2.COLOR_BGR2RGB)
for path in file_list[:num_training_examples]
]
test_images = [
cv2.cvtColor(cv2.resize(cv2.imread(path), (64, 64)), cv2.COLOR_BGR2RGB)
for path in file_list[-num_testing_examples:]
]
print(np.array(train_images).shape)
print(np.array(test_images).shape)
return np.array(train_images), np.array(test_images)
if __name__ == '__main__':
model = AAE('anime_aae', load_anime_data, 64, 64, 3)
model.train(epochs=10000, batch_size=32, sample_interval=100)
model = AAE('fashion_aae', load_fashion_data, 64, 64, 3)
model.train(epochs=10000, batch_size=32, sample_interval=100)
model = AAE('humanface_aae', load_face_data, 64, 64, 3)
model.train(epochs=10000, batch_size=32, sample_interval=100)
model.hide_message('anime_aae')
model.hide_message('fashion_aae')
def main():
parser = argparse.ArgumentParser()
parser.add_argument('ok_image_dir', type=str)
parser.add_argument('ng_image_dir', type=str)
parser.add_argument('--batch_size', '-bs', type=int, default=234)
parser.add_argument('--latent_dim', '-ld', type=int, default=16)
parser.add_argument('--height', '-ht', type=int, default=64)
parser.add_argument('--width', '-wd', type=int, default=64)
parser.add_argument('--channel', '-ch', type=int, default=8)
parser.add_argument('--model_path',
'-mp',
type=str,
default="./params/epoch_200/model.ckpt")
parser.add_argument('--result_dir', '-rd', type=str, default="./result")
parser.add_argument('--nb_visualize_batch', '-nvb', type=int, default=1)
parser.add_argument('--select_gpu', '-sg', type=str, default="0")
args = parser.parse_args()
os.makedirs(args.result_dir, exist_ok=True)
config = tf.ConfigProto(gpu_options=tf.GPUOptions(
visible_device_list=args.select_gpu, # specify GPU number
allow_growth=True))
input_shape = (args.height, args.width, args.channel)
autoencoder = AutoEncoder(input_shape,
args.latent_dim,
is_training=False,
channel=args.channel)
discriminator = Discriminator(is_training=False)
aae = AAE(autoencoder, discriminator, is_training=False)
aae.restore(args.model_path)
result_dir_inlier = os.path.join(args.result_dir, "decoded/inlier")
result_dir_outlier = os.path.join(args.result_dir, "decoded/outlier")
image_sampler = ImageSampler(
target_size=(args.width, args.height),
color_mode='rgb' if args.channel == 3 else 'gray',
is_training=False)
data_generator_inlier = image_sampler.flow_from_directory(args.inlier_dir,
args.batch_size,
shuffle=False)
df_inlier = get_encoded_save_decoded(aae,
data_generator_inlier,
args.latent_dim,
result_dir_inlier,
label='inlier',
nb_visualize=args.nb_visualize_batch)
data_generator_outlier = image_sampler.flow_from_directory(
args.outlier_dir, args.batch_size, shuffle=False)
df_outlier = get_encoded_save_decoded(aae,
data_generator_outlier,
args.latent_dim,
result_dir_outlier,
label='outlier',
nb_visualize=args.nb_visualize_batch)
df = pd.concat([df_inlier, df_outlier], ignore_index=True)
os.makedirs(args.result_dir, exist_ok=True)
df.to_csv(os.path.join(args.result_dir, "output.csv"), index=False)
flags.LEARNING_RATE = 1e-3
else:
flags.LEARNING_RATE = 2e-4 # follow radford
flags.EXPONENTIAL_DECAY = True
noise_dist = UniformNoise(flags.NOISE_DIM)
input_noise_dist = UniformNoise(1)
from veegan import VEEGAN
model = VEEGAN(data_dist, noise_dist, input_noise_dist, flags, args)
elif METHOD == 'wgan':
noise_dist = NormalNoise(flags.NOISE_DIM)
eps_dist = UniformNoise(1)
from wgan import WGANGP
model = WGANGP(data_dist, noise_dist, eps_dist, flags, args)
elif METHOD == 'vae':
from vae import VAE
noise_dist = NormalNoise(flags.NOISE_DIM)
model = VAE(data_dist, noise_dist, flags, args)
elif METHOD == 'aae':
from aae import AAE
model = AAE(data_dist, noise_dist, flags, args)
elif METHOD == 'avbac':
from avbac import *
noise_dist = NormalNoise(flags.NOISE_DIM)
single_noise_dist = NormalNoise(PERTURB)
model = AVB_AC(data_dist, noise_dist, single_noise_dist, flags, args)
model.create_model()
evaluator = Evaluator(model)
evaluator.run(os.path.join(args.working_dir, 'model'), args.ckpt_id)