def get_FullCifar10Datapool(batch_size, shift):
imgs, labels = load_full_cifar_10(shift)
imgs = np.reshape(imgs, [len(imgs), 3, 32, 32])
imgs = imgs.transpose([0, 2, 3, 1])
data_pool = utils.MemoryData({'img': imgs, 'label': labels},
batch_size)
return data_pool
def getFashion_MNISTDatapool(batch_size, shift, keep=None):
if keep is None:
imgs, y, num_train_data = data.mnist_load('fmnist',shift=shift)
else:
imgs, y, num_train_data = data.mnist_load('fmnist', keep=keep, shift=shift)
print "Total number of training dataset: " + str(num_train_data)
imgs.shape = imgs.shape + (1,)
data_pool = utils.MemoryData({'img': imgs, 'label':y}, batch_size)
return data_pool
def getMNISTDatapool(batch_size, keep=None, shift=True):
if keep is None:
imgs, _, num_train_data = data.mnist_load('MNIST_data', shift=shift)
else:
imgs, _, num_train_data = data.mnist_load('MNIST_data',
keep=keep,
shift=shift)
print "Total number of training data: " + str(num_train_data)
imgs.shape = imgs.shape + (1, )
data_pool = utils.MemoryData({'img': imgs}, batch_size)
return data_pool
def getFullFashion_MNISTDatapool(batch_size, shift,keep=None):
if keep is None:
imgs, y, num_train_data = data.mnist_load('fmnist',shift=shift)
imgs_t, y_t, num_train_data_t = data.mnist_load('fmnist',dataset='test',shift=shift)
else:
imgs, y, num_train_data = data.mnist_load('fmnist', keep=keep, shift=shift)
imgs_t, y_t, num_train_data_t = data.mnist_load('fmnist', keep=keep,dataset='test',shift = shift)
print "Total number of training dataset: " + str(num_train_data + num_train_data_t)
imgs.shape = imgs.shape + (1,)
imgs_t.shape = imgs_t.shape + (1,)
data_pool = utils.MemoryData({'img': np.concatenate((imgs,imgs_t)), 'label':np.concatenate((y,y_t))}, batch_size)
return data_pool
def getToyDatapool(batch_size, mus, cov, numberPerCluster):
X = getToyDataset(mus, cov, numberPerCluster)
print "Total number of training dataset: " + str(len(X))
data_pool = utils.MemoryData({'point':X}, batch_size)
return data_pool
def experiment(name, data_func, init_w):
""" param """
epoch = 80
batch_size = 64
n_centroid = 10
gan_type = name
dir = "results/" + gan_type + "-" + datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S")
''' dataset '''
X, Y = data_func()
import utils
data_pool = utils.MemoryData({'img': X, 'label': Y}, batch_size)
""" graphs """
# heads =1
# generator = partial(models.mgan_gen, heads=1)
# discriminator = partial(models.mgan_dis, name='d_2')
# generator_ = partial(models.generator_m2_32X32, heads=1)
def generator(z, training=True, reuse=True, heads=10):
imgs = []
for i in range(heads):
imgs += models.generator_m2_32X32(z=z,
training=training,
reuse=reuse,
name='generator' + str(i),
heads=1)
return imgs
discriminator = partial(models.discriminator2, name='d_2')
# encoder = partial(models.cnn_discriminator, out_dim = 10)
# from cnn_classifier import cnn_classifier
encoder = partial(models.cnn_classifier2, keep_prob=1., name='classifier')
# encoder = partial(vat.forward, is_training=False, update_batch_stats=False)
optimizer = tf.train.AdamOptimizer
#==============================
# inputs
real = tf.placeholder(tf.float32, shape=[batch_size, 32, 32, 3])
real2 = tf.placeholder(tf.float32, shape=[None, 32, 32, 3])
# with tf.variable_scope("CNN") as scope:
r_mean = encoder(real2, reuse=False)
r_p = tf.nn.softmax(r_mean)
# r_p = r_mean
predicts = tf.argmax(r_p, axis=1)
#=====================
z = tf.random_normal(shape=(batch_size, 100),
mean=0,
stddev=1,
dtype=tf.float32)
# z = tf.placeholder(tf.float32, shape=[None, z_dim])
fake_set = generator(z, reuse=False)
fake = tf.concat(fake_set, 0)
# print(fake.shape)
r_logit = discriminator(real, reuse=False)
f_logit = discriminator(fake)
d_loss_real = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=r_logit,
labels=tf.ones_like(r_logit)))
d_loss_fake = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=f_logit,
labels=tf.zeros_like(f_logit)))
d_loss = d_loss_real + 1. * d_loss_fake
g_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=f_logit,
labels=tf.ones_like(f_logit)))
g_loss_ori = tf.identity(g_loss)
g_loss = 1. * g_loss #weight down real loss
for i in range(len(fake_set)):
onehot_labels = tf.one_hot(indices=tf.cast(
tf.scalar_mul(i, tf.ones(batch_size)), tf.int32),
depth=n_centroid)
f_mean = encoder(fake_set[i])
f_p = tf.nn.softmax(f_mean)
g_loss += 3. * tf.reduce_mean(
objectives.categorical_crossentropy(onehot_labels, f_p))
# trainable variables for each network
T_vars = tf.trainable_variables()
en_var = [var for var in T_vars if var.name.startswith('classifier')]
g_var = [var for var in T_vars if var.name.startswith('generator')]
dis_var = [var for var in T_vars if var.name.startswith('d_2')]
#optimizer
# global_step = tf.Variable(0, name='global_step',trainable=False)
d_step = optimizer(learning_rate=0.0002,
beta1=0.5).minimize(d_loss, var_list=dis_var)
g_step = optimizer(learning_rate=0.0002,
beta1=0.5).minimize(g_loss, var_list=g_var)
g_step2 = optimizer(learning_rate=0.0002,
beta1=0.5).minimize(g_loss_ori, var_list=g_var)
""" train """
''' init '''
# session
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# saver
saver = tf.train.Saver(max_to_keep=5)
# summary writer
# Send summary statistics to TensorBoard
tf.summary.scalar('d_loss', d_loss)
tf.summary.scalar('g_loss', g_loss)
image_sets = generator(z, training=False)
for img_set in image_sets:
tf.summary.image('G_images', img_set, 12)
merged = tf.summary.merge_all()
logdir = dir + "/tensorboard"
writer = tf.summary.FileWriter(logdir, sess.graph)
print('Tensorboard dir: ' + logdir)
# ''' initialization '''
sess.run(tf.global_variables_initializer())
''' train '''
batch_epoch = len(data_pool) // (batch_size)
max_it = epoch * batch_epoch
def cluster_acc(Y_pred, Y):
from sklearn.utils.linear_assignment_ import linear_assignment
assert Y_pred.size == Y.size
D = max(Y_pred.max(), Y.max()) + 1
w = np.zeros((D, D), dtype=np.int64)
for i in range(Y_pred.size):
w[Y_pred[i], Y[i]] += 1
ind = linear_assignment(w.max() - w)
return sum([w[i, j] for i, j in ind]) * 1.0 / Y_pred.size, w
def gan_train(max_it, it_offset):
print("GAN iteration: " + str(max_it))
# total_it = it_offset + max_it
for it in range(it_offset, it_offset + max_it):
real_ipt, y = data_pool.batch(['img', 'label'])
if it > 30000:
_, _ = sess.run([d_step, g_step], feed_dict={real: real_ipt})
else:
_, _ = sess.run([d_step, g_step2],
feed_dict={real: real_ipt}) #ori g loss
if it % 10 == 0:
summary = sess.run(merged, feed_dict={real: real_ipt})
writer.add_summary(summary, it)
if it % 1000 == 0:
i = 0
for f in fake_set:
sample_imgs = sess.run(f)
# if normalize:
# for i in range(len(sample_imgs)):
sample_imgs = sample_imgs * 2. - 1.
save_dir = dir + "/sample_imgs"
utils.mkdir(save_dir + '/')
# for imgs, name in zip(sample_imgs, list_of_names):
my_utils.saveSampleImgs(imgs=sample_imgs,
full_path=save_dir + "/" +
'sample-%d-%d.jpg' % (i, it),
row=8,
column=8)
i += 1
total_it = 0
try:
ae_saver = tf.train.Saver(var_list=en_var)
ae_saver.restore(sess, init_w) #0.86 cifar
# dist = [0]*10
predict_y = sess.run(predicts, feed_dict={real2: X[:1000]})
acc = cluster_acc(predict_y, Y[:1000])
print('Accuracy of clustering model: ', acc[0])
gan_train(max_it, 0)
except Exception, e:
traceback.print_exc()
import models_mnist as models
""" param """
epoch = 50
batch_size = 64
lr = 0.0002
z_dim = 100
gpu_id = 3
''' data '''
utils.mkdir('./data/mnist/')
data.mnist_download('./data/mnist')
imgs, _, _ = data.mnist_load('./data/mnist')
imgs.shape = imgs.shape + (1,)
data_pool = utils.MemoryData({'img': imgs}, batch_size)
""" graphs """
with tf.device('/gpu:%d' % gpu_id):
''' models '''
generator = models.generator
discriminator = models.discriminator
''' graph '''
# inputs
real = tf.placeholder(tf.float32, shape=[None, 28, 28, 1])
z = tf.placeholder(tf.float32, shape=[None, z_dim])
# generate
fake = generator(z, reuse=False)
batch_size = 64
n_centroid = 10
gan_type = "gan-svhn"
dir = "results/" + gan_type + "-" + datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S")
''' data '''
#===========svhn=================
import scipy.io as sio
train_data = sio.loadmat('../train_32x32.mat')
X = train_data['X'] / 255.
Y = train_data['y']
X = X.transpose([3, 0, 1, 2])
# data_pool = my_utils.getFullMNISTDatapool(batch_size, shift=False) #range 0 ~ 1
import utils
data_pool = utils.MemoryData({'img': X, 'label': Y}, batch_size)
# data_pool = my_utils.getFullFashion_MNISTDatapool(batch_size, shift=False)
# X,Y = my_utils.loadFullFashion_MNSIT(shift=False)
# # X, Y = my_utils.load_data('mnist')
# X = np.reshape(X, [70000,28,28,1])
# num_data = 70000
# plt.ion() # enables interactive mode
# test_data_list, numPerClass = my_utils.getTest_data(numPerClass=100)
# colors = ['blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'black', 'purple', 'pink', 'brown']
# # 0 1 2 3 4 5 6 7 8 9
""" graphs """
heads = 1
# generator = partial(models.generator_m2_32X32, heads=1)
# discriminator = partial(models.discriminator2, name='d_2')
generator = partial(models.generator_m2_32X32, heads=2)
def experiment():
epoch = 40
batch_size = 100
lr = 2e-4
beta1 = 0.5
z_dim = 128
n_critic = 1 #
n_generator = 1
model_name = "modified_CatGAN"
dir = "results/" + model_name + "-" + datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S")
''' dataset '''
from data import load_fmnist
X, Y = load_fmnist()
num_data = len(X)
import utils
data_pool = utils.MemoryData({'img': X, 'label': Y}, batch_size)
""" graphs """
generator = models.generator
encoder = partial(models.cnn_discriminator, name='encoder', out_dim=10)
optimizer = tf.train.AdamOptimizer
# inputs
real = tf.placeholder(tf.float32, shape=[None, 28, 28, 1])
random_z = tf.random_normal(shape=(batch_size, z_dim),
mean=0,
stddev=1,
dtype=tf.float32)
random_z2 = tf.random_normal(shape=(10000, z_dim),
mean=0,
stddev=1,
dtype=tf.float32)
#marginal entropy
def mar_entropy(y):
y1 = tf.reduce_mean(y, axis=0)
y2 = tf.reduce_sum(-y1 * tf.log(y1))
return y2
#conditional entropy
def cond_entropy(y):
y1 = -y * tf.log(y)
y2 = tf.reduce_sum(y1) / batch_size
return y2
fake = generator(random_z, reuse=False)
# print('fake shape ',fake.shape)
r_mean = encoder(real, reuse=False)
f_mean = encoder(fake)
r_p = tf.nn.softmax(r_mean)
f_p = tf.nn.softmax(f_mean)
# weight = tf.placeholder(tf.float32, shape=[])
# init_weight = 1.
#discriminator loss
d_loss = -1 * (mar_entropy(r_p) - cond_entropy(r_p) + cond_entropy(f_p)
) # Equation (7) upper
#generator loss
g_loss = -mar_entropy(f_p) + cond_entropy(f_p) # Equation (7) lower
# trainable variables for each network
T_vars = tf.trainable_variables()
d_var = [var for var in T_vars if var.name.startswith('encoder')]
g_var = [var for var in T_vars if var.name.startswith('generator')]
# optimize
global_step = tf.Variable(0, name='global_step', trainable=False)
d_step = optimizer(learning_rate=lr,
beta1=beta1).minimize(d_loss,
var_list=d_var,
global_step=global_step)
g_step = optimizer(learning_rate=lr, beta1=beta1).minimize(g_loss,
var_list=g_var)
d_reg_loss = d_loss + 0.001 * tf.add_n([tf.nn.l2_loss(v) for v in d_var])
d_reg_step = optimizer(learning_rate=lr,
beta1=beta1).minimize(d_reg_loss, var_list=d_var)
""" train """
''' init '''
# session
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1)
sess = tf.InteractiveSession(config=tf.ConfigProto(
gpu_options=gpu_options))
# saver
saver = tf.train.Saver(max_to_keep=5)
# summary writer
# Send summary statistics to TensorBoard
tf.summary.scalar('d_loss', d_loss)
tf.summary.scalar('g_loss', g_loss)
images_from_g = generator(random_z, training=False)
images_from_g2 = generator(random_z2, training=False)
tf.summary.image('Generator_image', images_from_g, 12)
#predict
embed_mean = encoder(real)
y = tf.nn.softmax(embed_mean)
predicts = tf.argmax(y, axis=1)
merged = tf.summary.merge_all()
logdir = dir + "/tensorboard"
writer = tf.summary.FileWriter(logdir, sess.graph)
print('Tensorboard dir: ' + logdir)
''' initialization '''
sess.run(tf.global_variables_initializer())
''' train '''
batch_epoch = len(data_pool) // (batch_size * n_critic)
max_it = epoch * batch_epoch
def sample_once(it):
rows = 10
columns = 10
feed = {random_z: np.random.normal(size=[rows * columns, z_dim])}
list_of_generators = [images_from_g] # used for sampling images
list_of_names = ['it%d-g.jpg' % it]
save_dir = dir + "/sample_imgs"
my_utils.sample_and_save(sess=sess,
list_of_generators=list_of_generators,
feed_dict=feed,
list_of_names=list_of_names,
save_dir=save_dir)
def cluster_acc(Y_pred, Y):
from sklearn.utils.linear_assignment_ import linear_assignment
assert Y_pred.size == Y.size
D = max(Y_pred.max(), Y.max()) + 1
w = np.zeros((D, D), dtype=np.int64)
for i in range(Y_pred.size):
w[Y_pred[i], Y[i]] += 1
ind = linear_assignment(w.max() - w)
return sum([w[i, j] for i, j in ind]) * 1.0 / Y_pred.size, w
def training(max_it, it_offset):
print("Modified CatGAN iteration: " + str(max_it))
for it in range(it_offset, it_offset + max_it):
real_ipt, y = data_pool.batch(['img', 'label'])
if it // batch_epoch > 25:
#print('stop G')
_ = sess.run([d_reg_step], feed_dict={real: real_ipt})
else:
_, _ = sess.run([d_step, g_step], feed_dict={real: real_ipt})
if it % 10 == 0:
summary = sess.run(merged, feed_dict={real: real_ipt})
writer.add_summary(summary, it)
#
if it % (batch_epoch) == 0:
predict_y = sess.run(predicts,
feed_dict={real: X[60000:62000]})
acc = cluster_acc(predict_y, Y[60000:62000])
print('Epoch', (it // (batch_epoch)),
'Accuracy of clustering model: ', acc[0])
try:
training(max_it, 0)
total_it = sess.run(global_step)
print("Total iterations: " + str(total_it))
except Exception, e:
traceback.print_exc()
def experiment():
""" param """
epoch = 80
batch_size = 64
n_centroid = 10
gan_type = "LearningByAssociation+GAN+VAEGAN+SVHN"
dir = "results/" + gan_type + "-" + datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S")
''' dataset '''
X, Y = load_svhn_code()
import utils
data_pool = utils.MemoryData({'img': X, 'label': Y}, batch_size)
""" graphs """
# heads =1
# generator = partial(models.mgan_gen, heads=1)
# discriminator = partial(models.mgan_dis, name='d_2')
# generator = partial(models.ss_generator2, heads=10) #for aegan
# generator = partial(models.ss_generator3, heads=10) #for vaegan
#no weight sharing
def G(z,
reuse=True,
name="generator",
training=True,
heads=10,
model=None):
out = []
with tf.variable_scope(name, reuse=reuse):
for i in range(heads):
out += model(z,
reuse=reuse,
training=training,
name=name + str(i))
return out
generator = partial(G,
heads=10,
model=partial(models.ss_generator3,
heads=1)) # for vaegan
# generator = partial(G, heads=10, model = partial(models.ss_generator2, heads=1)) # for ae,aegan
import models_32x32
discriminator = partial(models.ss_discriminator2, name='d_2')
decoder = partial(models_32x32.decoder, name='decoder')
# encoder = partial(models.cnn_discriminator, out_dim = 10)
# from cnn_classifier import cnn_classifier
encoder = partial(models.ss_classifier, keep_prob=1., name='classifier')
# encoder = partial(vat.forward, is_training=False, update_batch_stats=False)
optimizer = tf.train.AdamOptimizer
#==============================
# inputs
real = tf.placeholder(tf.float32, shape=[batch_size, 100])
real2 = tf.placeholder(tf.float32, shape=[None, 100])
# with tf.variable_scope("CNN") as scope:
r_mean = encoder(real2, reuse=False)
r_p = tf.nn.softmax(r_mean)
# r_p = r_mean
predicts = tf.argmax(r_p, axis=1)
#=====================
z = tf.random_normal(shape=(batch_size, 100),
mean=0,
stddev=1,
dtype=tf.float32)
# z = tf.placeholder(tf.float32, shape=[None, z_dim])
fake_set = generator(z, reuse=False)
fake = tf.concat(fake_set, 0)
# print(fake.shape)
r_logit = discriminator(real, reuse=False)
f_logit = discriminator(fake)
d_loss_real = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=r_logit,
labels=tf.ones_like(r_logit)))
d_loss_fake = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=f_logit,
labels=tf.zeros_like(f_logit)))
d_loss = d_loss_real + 1. * d_loss_fake
g_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=f_logit,
labels=tf.ones_like(f_logit)))
g_loss_ori = tf.identity(g_loss)
g_loss = 1. * g_loss #weight down real loss
for i in range(len(fake_set)):
onehot_labels = tf.one_hot(indices=tf.cast(
tf.scalar_mul(i, tf.ones(batch_size)), tf.int32),
depth=n_centroid)
# if i == 0:
# f_mean = encoder(fake_set[i],reuse=False)
# else:
# with tf.variable_scope("CNN") as scope:
# scope.reuse_variables()
f_mean = encoder(fake_set[i])
f_p = tf.nn.softmax(f_mean)
# f_p = f_mean
# g_loss += .5*cond_entropy(f_p)
g_loss += 2. * tf.reduce_mean(
objectives.categorical_crossentropy(onehot_labels, f_p))
# g_loss += cat_weight*tf.reduce_mean(tf.losses.softmax_cross_entropy(logits=f_l, onehot_labels=onehot_labels))
# trainable variables for each network
T_vars = tf.trainable_variables()
# en_var = [var for var in T_vars if var.name.startswith('discriminator')]
# en_var = [var for var in T_vars if var.name.startswith('CNN')]
en_var = [var for var in T_vars if var.name.startswith('classifier')]
g_var = [var for var in T_vars if var.name.startswith('generator')]
dis_var = [var for var in T_vars if var.name.startswith('d_2')]
#optimizer
global_step = tf.Variable(0, name='global_step', trainable=False)
d_step = optimizer(learning_rate=0.0002,
beta1=0.5).minimize(d_loss, var_list=dis_var)
g_step = optimizer(learning_rate=0.0002,
beta1=0.5).minimize(g_loss, var_list=g_var)
g_step2 = optimizer(learning_rate=0.0002,
beta1=0.5).minimize(g_loss_ori, var_list=g_var)
""" train """
''' init '''
# session
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# saver
saver = tf.train.Saver(max_to_keep=5)
# summary writer
# Send summary statistics to TensorBoard
tf.summary.scalar('d_loss', d_loss)
tf.summary.scalar('g_loss', g_loss)
image_sets_ = generator(z, training=False)
image_sets = []
for i in range(len(image_sets_)):
if i == 0:
image_sets.append(decoder(image_sets_[i], reuse=False))
else:
image_sets.append(decoder(image_sets_[i]))
#todo
for img_set in image_sets:
tf.summary.image('G_images', img_set, 12)
merged = tf.summary.merge_all()
logdir = dir + "/tensorboard"
writer = tf.summary.FileWriter(logdir, sess.graph)
print('Tensorboard dir: ' + logdir)
# ''' initialization '''
sess.run(tf.global_variables_initializer())
''' train '''
batch_epoch = len(data_pool) // (batch_size)
max_it = epoch * batch_epoch
def cluster_acc(Y_pred, Y):
from sklearn.utils.linear_assignment_ import linear_assignment
assert Y_pred.size == Y.size
D = max(Y_pred.max(), Y.max()) + 1
w = np.zeros((D, D), dtype=np.int64)
for i in range(Y_pred.size):
w[Y_pred[i], Y[i]] += 1
ind = linear_assignment(w.max() - w)
return sum([w[i, j] for i, j in ind]) * 1.0 / Y_pred.size, w
def gan_train(max_it, it_offset):
print("GAN iteration: " + str(max_it))
# total_it = it_offset + max_it
for it in range(it_offset, it_offset + max_it):
real_ipt, y = data_pool.batch(['img', 'label'])
if it > 30000:
_, _ = sess.run([d_step, g_step], feed_dict={real: real_ipt})
else:
_, _ = sess.run([d_step, g_step2], feed_dict={real: real_ipt})
if it % 10 == 0:
summary = sess.run(merged, feed_dict={real: real_ipt})
writer.add_summary(summary, it)
if it % 1000 == 0:
i = 0
# todo
for f in image_sets:
sample_imgs = sess.run(f)
# if normalize:
# for i in range(len(sample_imgs)):
sample_imgs = sample_imgs * 2. - 1.
save_dir = dir + "/sample_imgs"
utils.mkdir(save_dir + '/')
# for imgs, name in zip(sample_imgs, list_of_names):
my_utils.saveSampleImgs(imgs=sample_imgs,
full_path=save_dir + "/" +
'sample-%d-%d.jpg' % (i, it),
row=8,
column=8)
i += 1
total_it = 0
try:
ae_saver = tf.train.Saver(var_list=en_var)
de_var = [
var for var in tf.trainable_variables()
if var.name.startswith('decoder')
]
de_saver = tf.train.Saver(var_list=de_var)
# ckpt = tf.train.get_checkpoint_state('../vat_tf/log/svhnaug/')
# print("Checkpoints:", ckpt)
# if ckpt and ckpt.model_checkpoint_path:
# ae_saver.restore(sess, ckpt.model_checkpoint_path)
# sess.run(tf.local_variables_initializer())
# ae_saver.restore(sess, 'results/cnn-classifier-model.ckpt') # 0.49
# ae_saver.restore(sess, 'results/cnn-classifier-noshift-model.ckpt')
# ae_saver.restore(sess, 'results/svhn-encoder-classifier-model.ckpt')#0.89 ae
# ae_saver.restore(sess, 'results/svhn-encoder-2-classifier-model.ckpt')#0.81 aegan weight 1
# ae_saver.restore(sess, 'results/svhn-encoder-3-classifier-model.ckpt') # 0.85 aegan weight 0.5
# ae_saver.restore(sess, 'results/svhn-encoder-4-classifier-model.ckpt') # 0.8134 vaegan weight 0.5
# ae_saver.restore(sess, 'results/svhn-encoder-5-classifier-model.ckpt') # 0.9 vaegan weight 0.5->mean embed
# ae_saver.restore(sess, 'results/svhn-encoder-6-classifier-model.ckpt') # 0.84 aegan weight 0.2
ae_saver.restore(
sess, 'weights/lba-svhn-code/svhn-encoder-7-classifier-model.ckpt'
) # 0.92 vaegan weight 0.5->reduce KL->mean embed
# ae_saver.restore(sess, 'results/cifar-encode-2-classifier-model.ckpt') # 0.87 vaegan weight 1->mean embed
# de_saver.restore(sess, 'results/dcgan-ae-20180813-193414/checkpoint/model.ckpt')#ae encoder 1
# de_saver.restore(sess, 'results/aegan-20180815-185953/checkpoint/model.ckpt')#aegan weight 1->encode2
# de_saver.restore(sess, 'results/aegan-20180816-094249/checkpoint/model.ckpt')#aeganweight 0.5->encode 3
# de_saver.restore(sess, 'results/vaegan-20180816-141528/checkpoint/model.ckpt') #vaeganweight 0.5->encode 4
# de_saver.restore(sess, 'results/aegan-20180823-105228/checkpoint/model.ckpt') # aeganweight 0.2->encode 6
de_saver.restore(sess, 'weights/vaegan-svhn/model.ckpt'
) # vaeganweight 0.5->reduce KL->mean embed->encode 7
# de_saver.restore(sess, 'results/vaegan-20180827-154620/checkpoint/model.ckpt')#cifar
# de_saver.restore(sess, 'results/vaegan-20180827-171731/checkpoint/model.ckpt') #cifar good
# dist = [0]*10
predict_y = sess.run(predicts, feed_dict={real2: X[:1000]})
acc = cluster_acc(predict_y, Y[:1000])
print('Accuracy of clustering model: ', acc[0])
gan_train(max_it, 0)
except Exception, e:
traceback.print_exc()
gan_type = "apx-gist"
dir = "results/" + gan_type + "-" + datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S")
''' data '''
import utils
#svhn
# X , _ = my_utils.get_svhn()
import scipy.io as sio
train_data = sio.loadmat('../train_32x32.mat')
X = train_data['X'] / 255.
# X = X/255.
X = X.transpose([3, 0, 1, 2])
# X = np.array(X)/float(255.)
gist_feature = np.load('svhn-gist.npy')
# Y = train_data['y']
data_pool = utils.MemoryData({'img': X, 'label': gist_feature}, batch_size)
# inputs
real = tf.placeholder(tf.float32, shape=[None, 32, 32, 3])
target_gist = tf.placeholder(tf.float32, shape=[None, 960])
""" graphs """
import models_mnist as models
encoder = Encoder
optimizer = tf.train.MomentumOptimizer
#encoder
real_logits = encoder(real, reuse=False)
# gist_fit = tf.nn.sigmoid(real_logits)
gist_fit = tf.nn.relu(real_logits)
#variables
with tf.Session() as sess:
import scipy.io as sio
import numpy as np
train_data = sio.loadmat('../train_32x32.mat')
X = train_data['X'] / 255.
y = train_data['y'] - 1
# Y = train_data['y']
pseudo_y = np.load('svhn-peusdo-label-0.47.npy')
pseudo_y_onehot = tf.keras.utils.to_categorical(pseudo_y,
num_classes=10)
X = X.transpose([3, 0, 1, 2])
# data_pool = my_utils.getFullMNISTDatapool(batch_size, shift=False) #range 0 ~ 1
import utils
data_pool = utils.MemoryData({'img': X, 'label': pseudo_y_onehot}, 50)
saver = tf.train.Saver(max_to_keep=5)
sess.run(tf.initialize_all_variables())
max_steps = 5000
for step in range(max_steps):
batch_xs, batch_ys = data_pool.batch()
if (step % 100) == 0:
print(
step,
sess.run(accuracy,
feed_dict={
x: X[:1000],
y_: pseudo_y_onehot[:1000],
k_prob: 1.0
}))
def experiment(init_w):
""" param """
epoch = 40
batch_size = 64
n_centroid = 10
gan_type = "ModifiedCatGAN+GAN+FMNIST"
dir = "results/" + gan_type + "-" + datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S")
''' dataset '''
# data_pool = my_utils.getFullMNISTDatapool(batch_size, shift=False) #range 0 ~ 1
# data_pool = my_utils.getFullFashion_MNISTDatapool(batch_size, shift=False)
X, Y = load_fmnist()
num_data = len(X)
import utils
data_pool = utils.MemoryData({'img': X, 'label': Y}, batch_size)
""" graphs """
generator = partial(models.generator_m2, heads=10)
discriminator = partial(models.discriminator2, name='d_2')
encoder = partial(models.cnn_discriminator, out_dim=10)
optimizer = tf.train.AdamOptimizer
# inputs
real = tf.placeholder(tf.float32, shape=[batch_size, 28, 28, 1])
real2 = tf.placeholder(tf.float32, shape=[None, 28, 28, 1])
r_mean = encoder(real2, reuse=False)
r_p = tf.nn.softmax(r_mean)
predicts = tf.argmax(r_p, axis=1)
#=====================
z = tf.random_normal(shape=(batch_size, 62),
mean=0,
stddev=1,
dtype=tf.float32)
# z = tf.placeholder(tf.float32, shape=[None, z_dim])
fake_set = generator(z, reuse=False)
fake = tf.concat(fake_set, 0)
r_logit = discriminator(real, reuse=False)
f_logit = discriminator(fake)
d_loss_real = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=r_logit,
labels=tf.ones_like(r_logit)))
d_loss_fake = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=f_logit,
labels=tf.zeros_like(f_logit)))
d_loss = d_loss_real + 0.1 * d_loss_fake
g_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=f_logit,
labels=tf.ones_like(f_logit)))
g_loss = 10. * g_loss #weight down real loss
for i in range(len(fake_set)):
onehot_labels = tf.one_hot(indices=tf.cast(
tf.scalar_mul(i, tf.ones(batch_size)), tf.int32),
depth=n_centroid)
f_mean = encoder(fake_set[i])
f_p = tf.nn.softmax(f_mean)
# g_loss += .5*cond_entropy(f_p)
g_loss += tf.reduce_mean(
objectives.categorical_crossentropy(onehot_labels, f_p))
# g_loss += cat_weight*tf.reduce_mean(tf.losses.softmax_cross_entropy(logits=f_l, onehot_labels=onehot_labels))
# trainable variables for each network
T_vars = tf.trainable_variables()
en_var = [var for var in T_vars if var.name.startswith('discriminator')]
# en_var = [var for var in T_vars if var.name.startswith('encoder')]
g_var = [var for var in T_vars if var.name.startswith('generator')]
dis_var = [var for var in T_vars if var.name.startswith('d_2')]
#optimizer
global_step = tf.Variable(0, name='global_step', trainable=False)
d_step = optimizer(learning_rate=0.0002,
beta1=0.5).minimize(d_loss, var_list=dis_var)
g_step = optimizer(learning_rate=5 * 0.0002,
beta1=0.5).minimize(g_loss, var_list=g_var)
""" train """
''' init '''
# session
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# saver
saver = tf.train.Saver(max_to_keep=5)
# summary writer
# Send summary statistics to TensorBoard
tf.summary.scalar('d_loss', d_loss)
tf.summary.scalar('g_loss', g_loss)
image_sets = generator(z, training=False)
for img_set in image_sets:
tf.summary.image('G_images', img_set, 12)
merged = tf.summary.merge_all()
logdir = dir + "/tensorboard"
writer = tf.summary.FileWriter(logdir, sess.graph)
print('Tensorboard dir: ' + logdir)
# ''' initialization '''
sess.run(tf.global_variables_initializer())
''' train '''
batch_epoch = len(data_pool) // (batch_size)
max_it = epoch * batch_epoch
def cluster_acc(Y_pred, Y):
from sklearn.utils.linear_assignment_ import linear_assignment
assert Y_pred.size == Y.size
D = max(Y_pred.max(), Y.max()) + 1
w = np.zeros((D, D), dtype=np.int64)
for i in range(Y_pred.size):
w[Y_pred[i], Y[i]] += 1
ind = linear_assignment(w.max() - w)
return sum([w[i, j] for i, j in ind]) * 1.0 / Y_pred.size, w
def gan_train(max_it, it_offset):
print("GAN iteration: " + str(max_it))
# total_it = it_offset + max_it
for it in range(it_offset, it_offset + max_it):
real_ipt, y = data_pool.batch(['img', 'label'])
# z_ipt = np.random.normal(size=[batch_size, z_dim])
# z_ipt = np.random.normal(size=[batch_size, z_dim])
# if it%700 ==0 and it >0:
# global cat_weight_init
# cat_weight_init = min(0.7, 1.3*cat_weight_init)
# print('cat weight', cat_weight_init)
_, _ = sess.run([d_step, g_step], feed_dict={real: real_ipt})
if it % 10 == 0:
summary = sess.run(merged, feed_dict={real: real_ipt})
writer.add_summary(summary, it)
if it % 1000 == 0:
import utils
i = 0
for f in fake_set:
sample_imgs = sess.run(f)
# if normalize:
# for i in range(len(sample_imgs)):
sample_imgs = sample_imgs * 2. - 1.
save_dir = dir + "/sample_imgs"
utils.mkdir(save_dir + '/')
# for imgs, name in zip(sample_imgs, list_of_names):
my_utils.saveSampleImgs(imgs=sample_imgs,
full_path=save_dir + "/" +
'sample-%d-%d.jpg' % (i, it),
row=8,
column=8)
i += 1
total_it = 0
try:
ae_saver = tf.train.Saver(var_list=en_var)
ae_saver.restore(sess, init_w) # 0.73
# dist = [0]*10
predict_y = sess.run(predicts, feed_dict={real2: X[:2000]})
acc = cluster_acc(predict_y, Y[:2000])
print('Accuracy of clustering model: ', acc[0])
# for i in predict_y:
# dist[i] += 1
# print(np.array(dist)/float(2000))
gan_train(max_it, 0)
except Exception, e:
traceback.print_exc()
train_data = sio.loadmat('../train_32x32.mat')
# access to the dict
x_train = train_data['X']
y_train = train_data['y']
x_train = x_train / 255.
x_train = x_train.transpose([3, 0, 1, 2])
# show sample
# print len(y_train)
# for i in range(10):
# plt.imshow(x_train[i])
# plt.show()
# print y_train[i]
# data_pool = my_utils.getFullMNISTDatapool(batch_size, shift=False) #range 0 ~ 1
import utils
data_pool = utils.MemoryData({'img': x_train, 'label': y_train}, batch_size)
# data_pool = my_utils.getFullFashion_MNISTDatapool(batch_size, shift=False)
# X,Y = my_utils.loadFullFashion_MNSIT(shift=False)
# X, Y = my_utils.load_data('mnist')
# X = np.reshape(X, [70000,28,28,1])
# num_data = 70000
# test_data = [[], [], [], [], [], [], [], [], [], []]
# colors = ['blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'black', 'purple', 'pink', 'brown']
# plt.ion() # enables interactive mode
# for i, j in zip(X, Y):
# if len(test_data[j]) < 100:
# test_data[j].append(i)
# test_data_list = test_data[0]
# for i in range(1,10):
# test_data_list = np.concatenate((test_data_list, test_data[i]))
def experiment(dec_init):
""" param """
epoch = 40
batch_size = 64
lr_dec = 0.002
lr_gan = 0.0002
beta1 = 0.5
z_dim = 10
n_centroid = 10
original_dim =784
# n_critic = 1 #
# n_generator = 1
gan_type="DEC+GAN+MNIST"
dir="results/"+gan_type+"-"+datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
''' dataset '''
X, y = load_mnist()
import utils
data_pool = utils.MemoryData({'img': X, 'label':y}, batch_size)
""" graphs """
encoder = partial(models.encoder, z_dim = z_dim)
decoder = models.decoder
num_heads = 10
generator = partial(models.generator_m2, heads=num_heads)
discriminator = models.discriminator2
# sampleing = models.sampleing
optimizer = tf.train.AdamOptimizer
with tf.variable_scope('kmean', reuse=False):
tf.get_variable("u_p", [n_centroid, z_dim], dtype=tf.float32)
# inputs
real = tf.placeholder(tf.float32, shape=[batch_size, 28, 28, 1])
real2 = tf.placeholder(tf.float32, shape=[None, 28, 28, 1])
# encoder
z_mean, _ = encoder(real, reuse=False)
z_mean2, _ = encoder(real2)
#=====================
z = tf.random_normal(shape=(batch_size, z_dim),
mean=0, stddev=1, dtype=tf.float32)
fake_set = generator(z, reuse=False)
fake = tf.concat(fake_set, 0)
r_logit = discriminator(real,reuse=False)
f_logit = discriminator(fake)
d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=r_logit, labels=tf.ones_like(r_logit)))
d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=f_logit, labels=tf.zeros_like(f_logit)))
d_loss = d_loss_real + (1./num_heads)*d_loss_fake
g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=f_logit, labels=tf.ones_like(f_logit)))
def compute_soft_assign(z):
with tf.variable_scope('kmean', reuse=True):
theta_p = tf.get_variable('u_p')
q = 1.0 / (1.0 + (K.sum(K.square(K.expand_dims(z,dim=1) - theta_p), axis=2) / 1.))
q **= (1. + 1.0) / 2.0
q = K.transpose(K.transpose(q) / K.sum(q, axis=1))
return q
def target_distribution2(q):
weight = q ** 1.5 / tf.reduce_sum(q, axis=0)
return tf.transpose(tf.transpose(weight)/ tf.reduce_sum(q, axis=1))
def KL(P,Q):
return tf.reduce_sum(P * tf.log(P/Q), [0,1])
q = compute_soft_assign(z_mean)
# predicts = tf.argmax(q, axis=1)
predicts2 = tf.argmax(compute_soft_assign(z_mean2), axis=1)
# print('soft dist: ',q.shape)
t = target_distribution2(q)
# print('target dist: ',t.shape)
KL_loss = KL(t, q)
# beta = 0.01
# KL_recon_loss = beta*KL_loss + recon_loss
f_logit_set = []
real_weight = tf.placeholder(tf.float32, shape=[])
real_weight_init = 1.
g_loss = 1.*g_loss #weight down real loss
diversity_weight = tf.get_variable("diversity_term", [10], dtype=tf.float32)
for i in range(len(fake_set)):
onehot_labels = tf.one_hot(indices=tf.cast(tf.scalar_mul(i, tf.ones(batch_size)), tf.int32), depth=n_centroid)
f_m, _ = encoder(fake_set[i])
f_l = compute_soft_assign(f_m)
g_loss += 1.*tf.reduce_mean(objectives.categorical_crossentropy(onehot_labels,f_l))
# trainable variables for each network
T_vars = tf.trainable_variables()
en_var = [var for var in T_vars if var.name.startswith('encoder')]
de_var = [var for var in T_vars if var.name.startswith('decoder')]
kmean_var = [var for var in T_vars if var.name.startswith('kmean')]
g_var = [var for var in T_vars if var.name.startswith('generator')]
dis_var = [var for var in T_vars if var.name.startswith('discriminator')]
#optimizer
learning_rate = tf.placeholder(tf.float32, shape=[])
global_step = tf.Variable(0, name='global_step',trainable=False)
# ae_step = optimizer(learning_rate=learning_rate).minimize(recon_loss, var_list=en_var+de_var, global_step=global_step)
kl_step = tf.train.MomentumOptimizer(learning_rate=lr_dec, momentum=0.9).minimize(KL_loss, var_list=kmean_var+en_var)
d_step = optimizer(learning_rate=lr_gan, beta1=beta1).minimize(d_loss, var_list=dis_var)
g_step = optimizer(learning_rate=lr_gan, beta1=beta1).minimize(g_loss, var_list=g_var)
""" train """
''' init '''
# session
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# saver
saver = tf.train.Saver(max_to_keep=5)
# summary writer
# Send summary statistics to TensorBoard
tf.summary.scalar('d_loss', d_loss)
tf.summary.scalar('g_loss', g_loss)
tf.summary.image('Real', real, 12)
# tf.summary.image('Recon', x_hat, 12)
image_sets = generator(z, training= False)
for img_set in image_sets:
tf.summary.image('G_images', img_set, 12)
merged = tf.summary.merge_all()
logdir = dir+"/tensorboard"
writer = tf.summary.FileWriter(logdir, sess.graph)
print('Tensorboard dir: '+logdir)
# ''' initialization '''
sess.run(tf.global_variables_initializer())
def kmean_init():
from sklearn.cluster import KMeans
sample = sess.run(z_mean2, feed_dict={real2:X})
kmeans = KMeans(n_clusters=n_centroid, n_init=20).fit(sample)
with tf.variable_scope('kmean', reuse=True):
u_p = tf.get_variable('u_p')
return u_p.assign(kmeans.cluster_centers_)
def training(max_it, it_offset):
print("DEC iteration: " + str(max_it))
for it in range(it_offset, it_offset + max_it):
real_ipt, y = data_pool.batch(['img','label'])
_ = sess.run([kl_step], feed_dict={real: real_ipt})
def gan_train(max_it, it_offset):
print("GAN iteration: " + str(max_it))
for it in range(it_offset, it_offset + max_it):
real_ipt, y = data_pool.batch(['img', 'label'])
_, _ = sess.run([d_step,g_step], feed_dict={real: real_ipt, real_weight: real_weight_init})
if it % 10 == 0:
summary = sess.run(merged, feed_dict={real: real_ipt, real_weight: real_weight_init})
writer.add_summary(summary, it)
if it%1000 == 0:
i = 0
for f in fake_set:
sample_imgs = sess.run(f)
sample_imgs = sample_imgs * 2. - 1.
save_dir = dir + "/sample_imgs"
utils.mkdir(save_dir + '/')
my_utils.saveSampleImgs(imgs=sample_imgs, full_path=save_dir + "/" + 'sample-%d-%d.jpg' % (i,it), row=8,
column=8)
i += 1
total_it = 0
try:
batch_epoch = len(data_pool) // (batch_size)
max_it = epoch * batch_epoch
ae_saver = tf.train.Saver(var_list=en_var+de_var)
# ae_saver.restore(sess, 'results/ae-20180411-193032/checkpoint/model.ckpt')
ae_saver.restore(sess, dec_init) #ep100 SGD Momentum 0.94
# ae_saver.restore(sess, 'results/ae-20180412-134727/checkpoint/model.ckpt') # ep100 0.824
#ae_saver.restore(sess,'results/ae-20180427-210832/checkpoint/model.ckpt') #0.62
#dec training
load_kmean = kmean_init()
sess.run(load_kmean)
#train 2 epochs
training(2*batch_epoch,0)
#measure dist
predict_y = sess.run(predicts2, feed_dict={real2: X})
acc = my_utils.cluster_acc(predict_y, y)
print('Accuracy of clustering model: ', acc[0])
#GAN training
gan_train(max_it, 2*batch_epoch)
except Exception, e:
traceback.print_exc()
