def train_feature_generator(self):
print 'Training sampler.'
images, labels = self.load_mnist(self.mnist_dir, split='train')
labels = utils.one_hot(labels, 10)
# build a graph
model = self.model
model.build_model()
batch_size = self.batch_size
noise_dim = 100
epochs = 5000
with tf.Session(config=self.config) as sess:
# initialize variables
tf.global_variables_initializer().run()
# restore feature extractor trained on Step 0
print ('Loading pretrained feature extractor.')
variables_to_restore = slim.get_model_variables(scope='feature_extractor')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_feature_extractor)
print 'Loaded'
summary_writer = tf.summary.FileWriter(logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
t = 0
while(t <= self.train_feature_generator_iter):
for start, end in zip(range(0, len(images), batch_size), range(batch_size, len(images), batch_size)):
t += 1
Z_samples = utils.sample_Z(batch_size, noise_dim, 'uniform')
feed_dict = {model.noise: Z_samples, model.images: images[start:end], model.labels: labels[start:end]}
avg_D_fake = sess.run(model.logits_fake, feed_dict)
avg_D_real = sess.run(model.logits_real, feed_dict)
sess.run(model.d_train_op, feed_dict)
sess.run(model.g_train_op, feed_dict)
if (t+1) % 50 == 0:
summary, dl, gl = sess.run([model.summary_op, model.d_loss, model.g_loss], feed_dict)
summary_writer.add_summary(summary, t)
print ('Step: [%d/%d] d_loss: %.6f g_loss: %.6f avg_D_fake: %.2f avg_D_real: %.2f ' \
%(t+1, int(epochs*len(images) /batch_size), dl, gl, avg_D_fake.mean(), avg_D_real.mean()))
if (t+1) % 5000 == 0:
saver.save(sess, self.pretrained_feature_generator)
def eval_dsn(self):
# build model
model = self.model
model.build_model()
# load svhn dataset
source_images, source_labels = self.load_svhn(self.src_dir)
source_labels[:] = 2
with tf.Session(config=self.config) as sess:
print('Loading pretrained G.')
variables_to_restore = slim.get_model_variables(scope='generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
print('Loading sample generator.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
# train model for source domain S
src_labels = utils.one_hot(source_labels[:1000], 10)
src_noise = utils.sample_Z(1000, 100, 'uniform')
feed_dict = {
model.src_noise: src_noise,
model.src_labels: src_labels
}
samples = sess.run(model.sampled_images, feed_dict)
for i in range(1000):
print str(i) + '/' + str(len(samples)), np.argmax(
src_labels[i])
plt.imshow(np.squeeze(samples[i]), cmap='gray')
plt.imsave('./sample/' + str(np.argmax(src_labels[i])) + '/' +
str(i) + '_' + str(np.argmax(src_labels[i])),
np.squeeze(samples[i]),
cmap='gray')
def features_to_pkl(self, seq_2_names=['...'], train_stage='dsn'):
source_images, _ = load_synthia(self.seq_name, no_elements=900)
source_features = self.extract_VGG16_features(source_images,
train_stage=train_stage)
tf.reset_default_graph()
target_features = dict()
for s in seq_2_names:
target_images, _ = load_synthia(s, no_elements=900)
target_features[s] = self.extract_VGG16_features(
target_images, train_stage=train_stage)
tf.reset_default_graph()
self.build_model(mode='train_feature_generator')
with tf.Session() as sess:
# initialize G and D
tf.global_variables_initializer().run()
print('Loading feature generator.')
variables_to_restore = slim.get_model_variables(
scope='feature_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.exp_dir + '/model/sampler')
n_samples = 900
noise = utils.sample_Z(n_samples, 100, 'uniform')
feed_dict = {self.noise: noise, self.fx: source_features[1:2]}
fzy = sess.run([self.fzy], feed_dict)
with open(self.exp_dir + '/features_' + train_stage + '.pkl',
'w') as f:
cPickle.dump((source_features, target_features, fzy), f,
cPickle.HIGHEST_PROTOCOL)
def train(args, model, sess):
summary_writer = tf.summary.FileWriter(model.log_dir, sess.graph)
# load data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
# load previous model
model.load(sess, args.model_dir)
steps_per_epoch = mnist.train.labels.shape[0] // args.batch_size
for epoch in range(args.epoch):
epoch_loss_d = []
epoch_loss_g = []
for step in range(steps_per_epoch):
# train discriminator for d_iters times first
d_iters = 5
for _ in range(0, d_iters):
bx, _ = mnist.train.next_batch(args.batch_size)
bx = np.reshape(bx, [-1, img['w'], img['h'], img['c']])
bz = sample_Z(args.batch_size, args.z_dim, args.sampler, args.num_classes, args.n_cat)
sess.run(model.d_train_op, feed_dict={model.x: bx, model.z: bz})
# train generator
bz = sample_Z(args.batch_size, args.z_dim, args.sampler, args.num_classes, args.n_cat)
sess.run(model.g_train_op, feed_dict={model.x: bx, model.z: bz})
# for tensorboard
summary, global_step = sess.run([model.summary_op, model.global_step],
feed_dict={model.x: bx,
model.z: bz})
if step % 100 == 0:
bx, _ = mnist.train.next_batch(args.batch_size)
bx = np.reshape(bx, [-1, img['w'], img['h'], img['c']])
bz = sample_Z(args.batch_size, args.z_dim, args.sampler, args.num_classes, args.n_cat)
d_loss = sess.run(
model.d_loss, feed_dict={model.x: bx, model.z: bz}
)
g_loss = sess.run(
model.g_loss, feed_dict={model.z: bz}
)
print('Epoch[{}/{}] Step[{}/{}] g_loss:{:.4f}, d_loss:{:.4f}'.format(epoch, args.epoch, step,
steps_per_epoch, g_loss,
d_loss))
summary_writer.add_summary(summary, global_step)
epoch_loss_d.append(d_loss)
epoch_loss_g.append(g_loss)
mean_loss_d = sum(epoch_loss_d)/len(epoch_loss_d)
mean_loss_g = sum(epoch_loss_g)/len(epoch_loss_g)
print('Epoch:', '%04d' % epoch,
'G loss: {:.4}'.format(mean_loss_g),
'D loss: {:.4}'.format(mean_loss_d))
with open(model.log_dir + "/training_loss.txt", "a+") as file:
file.write("Epoch: %d\t LossD: %f\t LossG: %f\n" % (epoch, mean_loss_d, mean_loss_g))
if(epoch % args.saving_cycle == 0):
model.save(sess, args.model_dir, global_step)
def features(self):
# load whatevere dataset
split='source'
#~ images, _ = self.load_NYUD(split=split)
# build a graph
model = self.model
model.build_model()
with tf.Session(config=self.config) as sess:
tf.global_variables_initializer().run()
#~ # Load pretrained or final model
print ('Loading pretrained model.')
variables_to_restore = slim.get_model_variables(scope='vgg_16')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
# Load pretrained or final model
print ('Loading pretrained sampler.')
variables_to_restore = slim.get_model_variables(scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
#~ print ('Loading test model.')
#~ variables_to_restore = slim.get_model_variables(scope='vgg_16')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.test_model)
no_items=1000000
features = np.zeros((no_items, model.hidden_repr_size), dtype=np.float)
inf_labels = np.zeros((no_items,))
noise = utils.sample_Z(no_items, 100, 'uniform')
labels = utils.one_hot(npr.randint(19,size=no_items), 19)
i=0
#~ # Eval on source
#~ for im in np.array_split(images, 40):
#~ _feat_ = sess.run(fetches=model.fx, feed_dict={model.images: im})
#~ print _feat_
#~ features[i:i+len(im)]= np.squeeze(_feat_)
#~ i+=len(im)
#~ print(i)
#~ with open('features.pkl','w') as f:
#~ cPickle.dump(features, f, cPickle.HIGHEST_PROTOCOL)
#~ # Eval on source
for n, l in zip(np.array_split(noise, 100), np.array_split(labels, 100)):
_feat_, inferred_labels = sess.run(fetches=[model.fzy, model.inferred_labels], feed_dict={model.noise: n, model.labels: l})
features[i:i+len(n)]= np.squeeze(_feat_)
inf_labels[i:i+len(n)] = inferred_labels
i+=len(n)
#~ #print(i)
#with open('features_noise.pkl','w') as f:
#cPickle.dump(features, f, cPickle.HIGHEST_PROTOCOL)
#~ with open('features.pkl','r') as f:
#~ features = cPickle.load(f)
features[features > 0] = 1
features[features < 0] = -1
tmpUnique = np.unique(features.view(np.dtype((np.void, features.dtype.itemsize*features.shape[1]))), return_counts = True)
uniques=tmpUnique[0].view(features.dtype).reshape(-1, features.shape[1])
print uniques.shape
print len(np.where(inf_labels==np.argmax(labels,1))[0])
print 'break'
def train_feature_generator(self):
epochs = 10000
batch_size = 64
noise_dim = 100
summary_string_writer = tf.summary.FileWriter(self.log_dir)
config = tf.ConfigProto(device_count={'GPU': 0})
source_images, source_annotations = load_synthia(self.seq_name,
no_elements=900)
source_features = self.extract_VGG16_features(source_images)
self.build_model(mode='train_feature_generator')
with tf.Session() as sess:
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver(
slim.get_model_variables(scope='feature_generator'))
tf.global_variables_initializer().run()
t = 0
for i in range(epochs):
#~ print 'Epoch',str(i), '.....................................................................'
for start, end in zip(
range(0, len(source_images), batch_size),
range(batch_size, len(source_images), batch_size)):
if t % 5000 == 0:
saver.save(sess,
os.path.join(self.exp_dir, 'model/sampler'))
t += 1
Z_samples = utils.sample_Z(batch_size, noise_dim,
'uniform')
feed_dict = {
self.noise: Z_samples,
self.fx: source_features[start:end]
}
avg_D_fake = sess.run(self.logits_fake, feed_dict)
avg_D_real = sess.run(self.logits_real, feed_dict)
sess.run(self.d_train_op, feed_dict)
sess.run(self.g_train_op, feed_dict)
if (t + 1) % 200 == 0:
summary, dl, gl = sess.run(
[self.summary_op, self.d_loss, self.g_loss],
feed_dict)
summary_writer.add_summary(summary, t)
print ('Step: [%d/%d] d_loss: [%.6f] g_loss: [%.6f]' \
%(t+1, int(epochs*len(source_images) /batch_size), dl, gl))
print 'avg_D_fake', str(
avg_D_fake.mean()), 'avg_D_real', str(
avg_D_real.mean())
def train_sampler(self):
print 'Training sampler.'
source_images, source_labels = self.load_office(split=self.src_dir)
source_labels = utils.one_hot(source_labels.astype(int), 31)
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
batch_size = self.batch_size
noise_dim = 100
epochs = 500000
with tf.Session(config=tf.ConfigProto(
device_count={'GPU': 0})) as sess:
# initialize G and D
tf.global_variables_initializer().run()
# restore variables of F
print('Computing latent representation.')
# Do not change next two lines. Necessary because slim.get_model_variables(scope='blablabla') works only for model built with slim.
variables_to_restore = tf.global_variables()
variables_to_restore = [
v for v in variables_to_restore if np.all([
s not in str(v.name) for s in [
'encoder', 'sampler_generator', 'disc_e',
'source_train_op'
]
])
]
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
feed_dict = {
model.noise: utils.sample_Z(1, noise_dim, 'uniform'),
model.images: source_images,
model.labels: source_labels,
model.fx: np.ones((1, 128))
}
source_fx = sess.run(model.dummy_fx, feed_dict)
with tf.Session(config=self.config) as sess:
# initialize G and D
tf.global_variables_initializer().run()
# restore variables of F
print('Loading pretrained model.')
# Do not change next two lines. Necessary because slim.get_model_variables(scope='blablabla') works only for model built with slim.
variables_to_restore = tf.global_variables()
variables_to_restore = [
v for v in variables_to_restore if np.all([
s not in str(v.name) for s in [
'encoder', 'sampler_generator', 'disc_e',
'source_train_op'
]
])
]
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
#~ print ('Loading pretrained encoder disc.')
#~ variables_to_restore = slim.get_model_variables(scope='disc_e')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.pretrained_sampler)
#~ print ('Loading sample generator.')
#~ variables_to_restore = slim.get_model_variables(scope='sampler_generator')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.pretrained_sampler)
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
#~ feed_dict = {model.images: source_images[:10000]}
#~ fx = sess.run(model.fx, feed_dict)
t = 0
for i in range(epochs):
#~ print 'Epoch',str(i)
for start, end in zip(
range(0, len(source_images), batch_size),
range(batch_size, len(source_images), batch_size)):
t += 1
Z_samples = utils.sample_Z(batch_size, noise_dim,
'uniform')
feed_dict = {
model.noise: Z_samples,
model.images: source_images[0:1],
model.labels: source_labels[start:end],
model.fx: source_fx[start:end]
}
avg_D_fake = sess.run(model.logits_fake, feed_dict)
avg_D_real = sess.run(model.logits_real, feed_dict)
sess.run(model.d_train_op, feed_dict)
sess.run(model.g_train_op, feed_dict)
if (t + 1) % 250 == 0:
summary, dl, gl = sess.run(
[model.summary_op, model.d_loss, model.g_loss],
feed_dict)
summary_writer.add_summary(summary, t)
print ('Step: [%d/%d] d_loss: [%.6f] g_loss: [%.6f]' \
%(t+1, int(epochs*len(source_images) /batch_size), dl, gl))
print 'avg_D_fake', str(
avg_D_fake.mean()), 'avg_D_real', str(
avg_D_real.mean())
if (t + 1) % 1000 == 0:
saver.save(
sess, os.path.join(self.model_save_path,
'sampler'))
def train_end_to_end(self):
print 'Training sampler.'
images, labels = self.load_mnist(self.mnist_dir, split='train')
images_test, labels_test = self.load_mnist(self.mnist_dir,
split='test')
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
batch_size = self.batch_size
noise_dim = 100
epochs = 5000
with tf.Session(config=self.config) as sess:
tf.global_variables_initializer().run()
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
t = 0
print('Loading pretrained model.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
print('Loading sampler - generator.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
print('Loading sampler - discriminator.')
variables_to_restore = slim.get_model_variables(scope='disc_e')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
balanced_labels = np.repeat(
np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 6)
for i in range(epochs):
print 'Epoch', str(i)
for start, end in zip(
range(0, len(images), batch_size),
range(batch_size, len(images), batch_size)):
t += 1
Z_samples = utils.sample_Z(batch_size, noise_dim,
'uniform')
feed_dict = {
model.noise: Z_samples,
model.balanced_labels: balanced_labels,
model.images: images[start:end],
model.labels: labels[start:end]
}
avg_D_fake = sess.run(model.logits_fake, feed_dict)
avg_D_real = sess.run(model.logits_real, feed_dict)
#~ sess.run(model.train_op_images, feed_dict)
sess.run(model.train_op_features, feed_dict)
#~ sess.run(model.train_op_d, feed_dict)
#~ sess.run(model.train_op_g, feed_dict)
if (t + 1) % 100 == 0:
summary, loss_d, loss_g, loss_images, loss_features = sess.run(
[
model.summary_op, model.d_loss, model.g_loss,
model.loss_images, model.loss_features
], feed_dict)
feed_dict[model.images] = images_test[:2000]
feed_dict[model.labels] = labels_test[:2000]
test_acc = sess.run([model.accuracy_images], feed_dict)
summary_writer.add_summary(summary, t)
print ('Step: [%d/%d] img_loss: %.3f feat_loss: %.3f d_loss: %.3f g_loss: %.3f avg_D_fake: %.2f avg_D_real: %.2f accuracy: %.6f ' \
%(t+1, int(epochs*len(images) /batch_size), loss_images, loss_features, loss_d, loss_g, avg_D_fake.mean(), avg_D_real.mean(), test_acc[0]))
if (t + 1) % 1000 == 0:
saver.save(
sess,
os.path.join(self.model_save_path, 'end_to_end'))
def check_TSNE(self):
target_images, target_labels = self.load_mnist(self.mnist_dir,
split='train')
#~ usps_images, usps_labels = self.load_usps(self.usps_dir)
source_images, source_labels = self.load_svhn(self.svhn_dir,
split='train')
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
self.config = tf.ConfigProto(device_count={'GPU': 0})
with tf.Session(config=self.config) as sess:
# initialize G and D
tf.global_variables_initializer().run()
if sys.argv[1] == 'test':
print('Loading test model.')
variables_to_restore = slim.get_model_variables(
scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
elif sys.argv[1] == 'pretrain':
print('Loading pretrained model.')
variables_to_restore = slim.get_model_variables(
scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
elif sys.argv[1] == 'convdeconv':
print('Loading convdeconv model.')
variables_to_restore = slim.get_model_variables(
scope='conv_deconv')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.convdeconv_model)
else:
raise NameError('Unrecognized mode.')
n_samples = 2000
src_labels = utils.one_hot(source_labels[:n_samples], 10)
trg_labels = utils.one_hot(target_labels[:n_samples], 10)
src_noise = utils.sample_Z(n_samples, 100, 'uniform')
if sys.argv[1] == 'convdeconv':
feed_dict = {
model.src_noise: src_noise,
model.src_labels: src_labels,
model.src_images: source_images,
model.trg_images: target_images[:n_samples]
}
h_repr = sess.run(model.h_repr, feed_dict)
else:
print('Loading sampler.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
feed_dict = {
model.src_noise: src_noise,
model.src_labels: src_labels,
model.src_images: source_images[:n_samples],
model.trg_images: target_images[:n_samples]
}
fzy, fx_src, fx_trg = sess.run(
[model.fzy, model.fx_src, model.fx_trg], feed_dict)
src_labels = np.argmax(src_labels, 1)
trg_labels = np.argmax(trg_labels, 1)
print 'Computing T-SNE.'
model = TSNE(n_components=2, random_state=0)
if sys.argv[2] == '1':
TSNE_hA = model.fit_transform(np.vstack((fx_src)))
plt.figure(2)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((np.ones((n_samples)))),
s=3,
cmap=mpl.cm.jet)
plt.figure(3)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((src_labels)),
s=3,
cmap=mpl.cm.jet)
elif sys.argv[2] == '2':
TSNE_hA = model.fit_transform(np.vstack((fzy, fx_src)))
plt.figure(2)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((np.ones((n_samples, )), 2 * np.ones(
(n_samples, )))),
s=3,
cmap=mpl.cm.jet)
plt.figure(3)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((src_labels, src_labels)),
s=3,
cmap=mpl.cm.jet)
elif sys.argv[2] == '3':
TSNE_hA = model.fit_transform(np.vstack((fzy, fx_src, fx_trg)))
plt.figure(2)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((
src_labels,
src_labels,
trg_labels,
)),
s=5,
cmap=mpl.cm.jet)
plt.figure(3)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((np.ones((n_samples, )), 2 * np.ones(
(n_samples, )), 3 * np.ones((n_samples, )))),
s=5,
cmap=mpl.cm.jet)
elif sys.argv[2] == '4':
TSNE_hA = model.fit_transform(h_repr)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.argmax(trg_labels, 1),
s=3,
cmap=mpl.cm.jet)
plt.legend()
plt.show()
def eval_dsn(self):
# build model
model = self.model
model.build_model()
self.config = tf.ConfigProto(device_count={'GPU': 0})
with tf.Session(config=self.config) as sess:
#~ print ('Loading pretrained G.')
#~ variables_to_restore = slim.get_model_variables(scope='generator')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.test_model)
print('Loading pretrained E.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
print('Loading sample generator.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
#~ source_images, source_labels = self.load_mnist(self.mnist_dir, split='train')
#~ source_images = source_images[:2000]
#~ source_labels = source_labels[:2000]
source_images, source_labels = self.load_usps(self.usps_dir)
source_images = source_images[:1800]
source_labels = source_labels[:1800]
source_images = np.repeat(source_images, 50, 0)
source_labels = np.repeat(source_labels, 50, 0)
#~ for n in range(0,10):
#~ print n
#~ no_gen = 10000
#~ source_labels = n * np.ones((no_gen,),dtype=int)
#~ # train model for source domain S
#~ src_labels = utils.one_hot(source_labels[:no_gen],10)
#~ src_noise = utils.sample_Z(no_gen,100,'uniform')
#~ feed_dict = {model.src_noise: src_noise, model.src_labels: src_labels}
#~ samples, samples_logits = sess.run([model.sampled_images, model.sampled_images_logits], feed_dict)
#~ samples_logits = samples_logits[:,n]
#~ samples = samples[samples_logits>8.]
#~ samples_logits = samples_logits[samples_logits>8.]
#~ for i in range(len(samples_logits)):
## print str(i)+'/'+str(len(samples_logits))-
#~ plt.imshow(np.squeeze(samples[i]), cmap='gray')
#~ plt.imsave('./sample/'+str(np.argmax(src_labels[i]))+'/'+str(i)+'_'+str(np.argmax(src_labels[i]))+'_'+str(samples_logits[i]),np.squeeze(samples[i]), cmap='gray')
#~ print str(i)+'/'+str(len(samples)), np.argmax(src_labels[i])
no_gen = len(source_images)
print 'Number of samples:', no_gen
# train model for source domain S
src_images = source_images[:2]
src_labels = utils.one_hot(source_labels[:no_gen], 10)
src_noise = utils.sample_Z(no_gen, 100, 'uniform')
feed_dict = {
model.src_noise: src_noise,
model.src_labels: src_labels,
model.src_images: src_images
}
fzy, fx_src, fzy_labels = sess.run(
[model.fzy, model.fx_src, model.fzy_labels], feed_dict)
fzy_states = (fzy > 0.).astype(int)
fx_src_states = (fx_src > 0.).astype(int)
tmpUnique = np.unique(fzy_states.view(
np.dtype((np.void,
fzy_states.dtype.itemsize * fzy_states.shape[1]))),
return_counts=True)
fzy_states_unique = tmpUnique[0].view(fzy_states.dtype).reshape(
-1, fzy_states.shape[1])
print 'fzy:', fzy_states_unique.shape
tmpUnique = np.unique(fx_src_states.view(
np.dtype(
(np.void,
fx_src_states.dtype.itemsize * fx_src_states.shape[1]))),
return_counts=True)
fx_src_states_unique = tmpUnique[0].view(
fx_src_states.dtype).reshape(-1, fx_src_states.shape[1])
print 'fx_src:', fx_src_states_unique.shape
print(np.argmax(src_labels, 1) == fzy_labels).astype(int).mean()
while (True):
src_images = source_images[:2]
src_labels = utils.one_hot(source_labels[:no_gen], 10)
src_noise = utils.sample_Z(no_gen, 100, 'uniform')
feed_dict = {
model.src_noise: src_noise,
model.src_labels: src_labels,
model.src_images: src_images
}
fzy, fx_src = sess.run([model.fzy, model.fx_src], feed_dict)
fzy_states = (fzy > 0.).astype(int)
fx_src_states = (fx_src > 0.).astype(int)
fzy_states = np.vstack((fzy_states, fzy_states_unique))
fx_src_states = np.vstack(
(fx_src_states, fx_src_states_unique))
tmpUnique = np.unique(fzy_states.view(
np.dtype(
(np.void,
fzy_states.dtype.itemsize * fzy_states.shape[1]))),
return_counts=True)
fzy_states_unique = tmpUnique[0].view(
fzy_states.dtype).reshape(-1, fzy_states.shape[1])
print 'fzy:', fzy_states_unique.shape
print 'break'
def train_dsn(self):
print 'Training DSN.'
if self.protocol == 'svhn_mnist':
source_images, source_labels = self.load_svhn(self.svhn_dir,
split='train')
target_images, target_labels = self.load_mnist(self.mnist_dir,
split='train')
if self.protocol == 'mnist_mnist_m':
source_images, source_labels = self.load_mnist(self.mnist_dir,
split='train')
target_images, target_labels = self.load_mnist_m(self.mnist_m_dir,
split='train')
elif self.protocol == 'syn_svhn':
source_images, source_labels = self.load_syn(self.syn_dir,
split='train')
target_images, target_labels = self.load_svhn(self.svhn_dir,
split='train')
elif self.protocol == 'mnist_usps':
source_images, source_labels = self.load_mnist(self.mnist_dir,
split='train')
target_images, target_labels = self.load_usps(self.usps_dir)
elif self.protocol == 'usps_mnist':
target_images, target_labels = self.load_mnist(self.mnist_dir,
split='train')
source_images, source_labels = self.load_usps(self.usps_dir)
elif self.protocol == 'amazon_reviews':
source_images, source_labels, target_images, target_labels, _, _ = self.load_amazon_reviews(
self.amazon_dir)
algorithm = str(sys.argv[1])
# build a graph
model = self.model
model.build_model(algorithm)
label_gen = utils.one_hot(
np.array([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3,
3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 0, 0,
0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7,
7, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9
]), 10)
label_gen = np.matlib.repmat(label_gen, 5, 1)
self.config = tf.ConfigProto(device_count={'GPU': 0})
with tf.Session(config=self.config) as sess:
tf.global_variables_initializer().run()
print('Loading pretrained encoder.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
print 'Extracting source features'
source_features = sess.run(model.orig_src_fx,
feed_dict={
model.src_features:
np.zeros((1, 128)),
model.src_images:
source_images,
model.src_noise:
np.zeros((1, 100)),
model.src_labels:
utils.one_hot(source_labels, 10),
model.trg_images:
target_images[0:1],
model.labels_gen:
label_gen
})
tf.reset_default_graph()
# build a graph
model = self.model
model.build_model(algorithm)
with tf.Session() as sess:
# initialize G and D
tf.global_variables_initializer().run()
# restore variables of F
print('Loading pretrained encoder.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
#~ print ('Loading pretrained discriminator.')
#~ variables_to_restore = slim.get_model_variables(scope='disc_e')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.test_model)
print('Loading sample generator.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
print('Start training.')
trg_count = 0
t = 0
context = zmq.Context()
socket = context.socket(zmq.DEALER)
socket.connect('tcp://localhost:5560')
for step in range(40001):
trg_count += 1
t += 1
i = step % int(source_images.shape[0] / self.batch_size)
j = step % int(target_images.shape[0] / self.batch_size)
src_images = source_images[i * self.batch_size:(i + 1) *
self.batch_size]
src_labels = utils.one_hot(
source_labels[i * self.batch_size:(i + 1) *
self.batch_size], 10)
src_labels_int = source_labels[i * self.batch_size:(i + 1) *
self.batch_size]
src_noise = utils.sample_Z(self.batch_size, 100, 'uniform')
trg_images = target_images[j * self.batch_size:(j + 1) *
self.batch_size]
src_features = source_features[i * self.batch_size:(i + 1) *
self.batch_size]
feed_dict = {
model.src_features: src_features,
model.src_images: src_images,
model.src_noise: src_noise,
model.src_labels: src_labels,
model.trg_images: trg_images,
model.labels_gen: label_gen
}
sess.run(model.E_train_op, feed_dict)
sess.run(model.DE_train_op, feed_dict)
#~ if step%1==0:
#~ sess.run(model.G_train_op, feed_dict)
#~ sess.run(model.DG_train_op, feed_dict)
#~ sess.run(model.const_train_op, feed_dict)
logits_E_real, logits_E_fake, logits_G_real, logits_G_fake = sess.run(
[
model.logits_E_real, model.logits_E_fake,
model.logits_G_real, model.logits_G_fake
], feed_dict)
if (step) % 1000 == 0:
summary, E, DE, G, DG, cnst = sess.run([
model.summary_op, model.E_loss, model.DE_loss,
model.G_loss, model.DG_loss, model.const_loss
], feed_dict)
summary_writer.add_summary(summary, step)
print ('Step: [%d/%d] E: [%.6f] DE: [%.6f] G: [%.6f] DG: [%.6f] Const: [%.6f] E_real: [%.2f] E_fake: [%.2f] G_real: [%.2f] G_fake: [%.2f]' \
%(step+1, self.train_iter, E, DE, G, DG, cnst,logits_E_real.mean(),logits_E_fake.mean(),logits_G_real.mean(),logits_G_fake.mean()))
if (step) % 1000 == 0:
saver.save(sess, os.path.join(self.model_save_path, 'dtn'))
print 'Sending...'
socket.send_string(algorithm)
def train_dsn(self):
print 'Training DSN.'
if self.protocol == 'svhn_mnist':
source_images, source_labels = self.load_svhn(self.svhn_dir,
split='train')
target_images, target_labels = self.load_mnist(self.mnist_dir,
split='train')
algorithm = str(sys.argv[1])
# build a graph
model = self.model
model.build_model(algorithm)
source_features = np.zeros((len(source_images), 128))
#~ self.config = tf.ConfigProto(device_count = {'GPU': 0})
with tf.Session(config=self.config) as sess:
tf.global_variables_initializer().run()
print('Loading pretrained encoder.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
print 'Extracting source features'
for indices, source_images_batch in zip(
np.array_split(np.arange(len(source_images)), 20),
np.array_split(source_images, 20)):
print indices[0]
source_features[indices] = sess.run(model.orig_src_fx,
feed_dict={
model.src_features:
np.zeros((1, 128)),
model.src_images:
source_images_batch,
model.src_noise:
np.zeros((1, 100)),
model.src_labels:
utils.one_hot(
source_labels, 10),
model.trg_images:
target_images[0:1]
})
tf.reset_default_graph()
# build a graph
model = self.model
model.build_model(algorithm)
with tf.Session(config=self.config) as sess:
# initialize G and D
tf.global_variables_initializer().run()
# restore variables of F
print('Loading pretrained encoder.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
#~ print ('Loading pretrained discriminator.')
#~ variables_to_restore = slim.get_model_variables(scope='disc_e')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.test_model)
print('Loading sample generator.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
print('Start training.')
trg_count = 0
t = 0
context = zmq.Context()
socket = context.socket(zmq.DEALER)
if sys.argv[1] == 'adda':
socket.connect('tcp://localhost:5560')
elif sys.argv[1] == 'adda_di':
socket.connect('tcp://localhost:5660')
if sys.argv[1] == 'fa':
socket.connect('tcp://localhost:5760')
for step in range(40001):
trg_count += 1
t += 1
i = step % int(source_images.shape[0] / self.batch_size)
j = step % int(target_images.shape[0] / self.batch_size)
src_images = source_images[i * self.batch_size:(i + 1) *
self.batch_size]
src_labels = utils.one_hot(
source_labels[i * self.batch_size:(i + 1) *
self.batch_size], 10)
src_labels_int = source_labels[i * self.batch_size:(i + 1) *
self.batch_size]
src_noise = utils.sample_Z(self.batch_size, 100, 'uniform')
trg_images = target_images[j * self.batch_size:(j + 1) *
self.batch_size]
src_features = source_features[i * self.batch_size:(i + 1) *
self.batch_size]
feed_dict = {
model.src_features: src_features,
model.src_images: src_images,
model.src_noise: src_noise,
model.src_labels: src_labels,
model.trg_images: trg_images
}
sess.run(model.E_train_op, feed_dict)
sess.run(model.DE_train_op, feed_dict)
logits_E_real, logits_E_fake = sess.run(
[model.logits_E_real, model.logits_E_fake], feed_dict)
if (step) % 1000 == 0:
summary, E, DE = sess.run(
[model.summary_op, model.E_loss, model.DE_loss],
feed_dict)
summary_writer.add_summary(summary, step)
print ('Step: [%d/%d] E: [%.6f] DE: [%.6f] E_real: [%.2f] E_fake: [%.2f]' \
%(step+1, self.train_iter, E, DE, logits_E_real.mean(),logits_E_fake.mean()))
if (step) % 1000 == 0:
print 'Saving...'
saver.save(sess, self.test_model)
print 'Sending...'
socket.send_string(algorithm)
def train_DIFA(self):
print 'Adapt with DIFA'
# build a graph
model = self.model
model.build_model()
source_images, source_labels = self.load_svhn(self.svhn_dir,
split='train')
target_images, _ = self.load_mnist(self.mnist_dir, split='train')
target_test_images, target_test_labels = self.load_mnist(
self.mnist_dir, split='test')
with tf.Session(config=self.config) as sess:
# Initialize weights
tf.global_variables_initializer().run()
print('Loading pretrained encoder.')
variables_to_restore = slim.get_model_variables(
scope='feature_extractor')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_feature_extractor)
print('Loading pretrained S.')
variables_to_restore = slim.get_model_variables(
scope='feature_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_feature_generator)
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
print('Start training.')
for step in range(self.train_DIFA_iters):
i = step % int(source_images.shape[0] / self.batch_size)
j = step % int(target_images.shape[0] / self.batch_size)
source_images_batch = source_images[i *
self.batch_size:(i + 1) *
self.batch_size]
target_images_batch = target_images[j *
self.batch_size:(j + 1) *
self.batch_size]
labels_batch = utils.one_hot(
source_labels[i * self.batch_size:(i + 1) *
self.batch_size], 10)
noise = utils.sample_Z(self.batch_size, 100, 'uniform')
feed_dict = {
model.src_images: source_images_batch,
model.trg_images: target_images_batch,
model.noise: noise,
model.labels: labels_batch
}
sess.run(model.e_train_op, feed_dict)
sess.run(model.d_train_op, feed_dict)
if (step + 1) % 50 == 0:
logits_real, logits_fake = sess.run(
[model.logits_real, model.logits_fake], feed_dict)
summary, e_loss, d_loss = sess.run(
[model.summary_op, model.e_loss, model.d_loss],
feed_dict)
summary_writer.add_summary(summary, step)
print ('Step: [%d/%d] e_loss: [%.6f] d_loss: [%.6f] e_real: [%.2f] e_fake: [%.2f]' \
%(step+1, self.train_DIFA_iters, e_loss, d_loss, logits_real.mean(),logits_fake.mean()))
print 'Evaluating.'
target_test_acc = 0.
for target_test_labels_batch, target_test_images_batch in zip(
np.array_split(target_test_labels, 100),
np.array_split(target_test_images, 100)):
feed_dict[
self.model.trg_images] = target_test_images_batch
feed_dict[self.model.
trg_labels_gt] = target_test_labels_batch
target_test_acc_tmp = sess.run(model.trg_accuracy,
feed_dict)
target_test_acc += target_test_acc_tmp / 100.
print 'target test accuracy: [%.3f]' % (target_test_acc)
print 'Saving.'
saver.save(sess, self.DIFA_feature_extractor)
def train_domain_invariant_encoder(self, seq_2_name):
print 'Adapting from ' + self.seq_name + ' to ' + seq_2_name
epochs = 1000000
batch_size = 8
noise_dim = 100
self.build_model('train_domain_invariant_encoder')
summary_string_writer = tf.summary.FileWriter(self.log_dir)
config = tf.ConfigProto(device_count={'GPU': 0})
with tf.Session() as sess:
print 'Loading weights.'
# Run the initializers.
sess.run(tf.global_variables_initializer())
self.read_vgg_weights_except_fc8_func(sess)
sess.run(self.vgg_fc8_weights_initializer)
variables_to_restore = [
i for i in slim.get_model_variables()
if ('fc6' in i.name) or ('fc7' in i.name)
]
restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, os.path.join(self.exp_dir,'model/segm_model'))
restorer.restore(sess, self.exp_dir + '/model/segm_model')
variables_to_restore = slim.get_model_variables(
scope='feature_generator')
restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, os.path.join(self.exp_dir+'model/sampler'))
restorer.restore(sess, self.exp_dir + '/model/sampler')
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver(self.E_vars)
source_images, source_annotations = load_synthia(self.seq_name,
no_elements=900)
target_images, target_annotations = load_synthia(seq_2_name,
no_elements=900)
print('Start training.')
trg_count = 0
t = 0
for step in range(100000):
#~ if t % 1000 == 0:
#~ print 'Saving model.'
#~ saver.save(sess, self.exp_dir+'/model/di_encoder_new')
trg_count += 1
t += 1
i = step % int(source_images.shape[0] / batch_size)
j = step % int(target_images.shape[0] / batch_size)
src_images = source_images[i * batch_size:(i + 1) * batch_size]
trg_images = target_images[j * batch_size:(j + 1) * batch_size]
noise = utils.sample_Z(batch_size, 100, 'uniform')
feed_dict = {
self.src_images: src_images,
self.trg_images: trg_images,
self.noise: noise,
self.is_training: True
}
sess.run(self.E_train_op, feed_dict)
sess.run(self.DE_train_op, feed_dict)
logits_E_real, logits_E_fake = sess.run(
[self.logits_E_real, self.logits_E_fake], feed_dict)
if (step + 1) % 100 == 0:
summary, E, DE = sess.run(
[self.summary_op, self.E_loss, self.DE_loss],
feed_dict)
summary_writer.add_summary(summary, step)
print ('Step: [%d] E: [%.3f] DE: [%.3f] E_real: [%.2f] E_fake: [%.2f]' \
%(step+1, E, DE, logits_E_real.mean(),logits_E_fake.mean()))
def train_dsn(self):
source_images, source_labels = self.load_svhn(self.svhn_dir,
split='train')
target_images, target_labels = self.load_mnist(self.mnist_dir,
split='train')
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
with tf.Session(config=self.config) as sess:
# initialize G and D
tf.global_variables_initializer().run()
# restore variables of F
print('Loading pretrained encoder.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
#~ print ('Loading pretrained encoder disc.')
#~ variables_to_restore = slim.get_model_variables(scope='disc_e')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.pretrained_sampler)
#~ print ('Loading pretrained G.')
#~ variables_to_restore = slim.get_model_variables(scope='generator')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.test_model)
#~ print ('Loading pretrained D_g.')
#~ variables_to_restore = slim.get_model_variables(scope='disc_g')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.test_model)
print('Loading sample generator.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
print('Start training.')
trg_count = 0
t = 0
self.batch_size = 64
label_gen = utils.one_hot(
np.array([
0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6,
6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3,
3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9,
9, 9, 9, 9
]), 10)
for step in range(10000000):
trg_count += 1
t += 1
i = step % int(source_images.shape[0] / self.batch_size)
j = step % int(target_images.shape[0] / self.batch_size)
src_images = source_images[i * self.batch_size:(i + 1) *
self.batch_size]
src_labels = utils.one_hot(
source_labels[i * self.batch_size:(i + 1) *
self.batch_size], 10)
src_labels_int = source_labels[i * self.batch_size:(i + 1) *
self.batch_size]
src_noise = utils.sample_Z(self.batch_size, 100, 'uniform')
trg_images = target_images[j * self.batch_size:(j + 1) *
self.batch_size]
feed_dict = {
model.src_images: src_images,
model.src_noise: src_noise,
model.src_labels: src_labels,
model.trg_images: trg_images,
model.labels_gen: label_gen
}
#~ sess.run(model.E_train_op, feed_dict)
#~ sess.run(model.DE_train_op, feed_dict)
sess.run(model.G_train_op, feed_dict)
if step % 15 == 0:
sess.run(model.DG_train_op, feed_dict)
sess.run(model.const_train_op, feed_dict)
sess.run(model.const_train_op, feed_dict)
sess.run(model.const_train_op, feed_dict)
logits_E_real, logits_E_fake, logits_G_real, logits_G_fake = sess.run(
[
model.logits_E_real, model.logits_E_fake,
model.logits_G_real, model.logits_G_fake
], feed_dict)
if (step + 1) % 10 == 0:
summary, E, DE, G, DG, cnst = sess.run([
model.summary_op, model.E_loss, model.DE_loss,
model.G_loss, model.DG_loss, model.const_loss
], feed_dict)
summary_writer.add_summary(summary, step)
print ('Step: [%d/%d] E: [%.6f] DE: [%.6f] G: [%.6f] DG: [%.6f] Const: [%.6f] E_real: [%.2f] E_fake: [%.2f] G_real: [%.2f] G_fake: [%.2f]' \
%(step+1, self.train_iter, E, DE, G, DG, cnst,logits_E_real.mean(),logits_E_fake.mean(),logits_G_real.mean(),logits_G_fake.mean()))
if (step + 1) % 500 == 0:
saver.save(sess, os.path.join(self.model_save_path, 'dtn'))
def train_feature_generator(self):
print 'Training sampler.'
# images, labels = self.load_svhn(self.svhn_dir, split='train')
classes, images, Xs_test, labels, Ys_test = self.getprotocol(Xs)
labels = utils.one_hot(labels, 11)
# build a graph
model = self.model
model.build_model()
noise_dim = 100
epochs = 5000
with tf.Session(config=self.config) as sess:
# initialize variables
tf.global_variables_initializer().run()
# restore feature extractor trained on Step 0
print('Loading pretrained feature extractor.')
variables_to_restore = slim.get_model_variables(
scope='feature_extractor')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_feature_extractor)
print 'Loaded'
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
for step in range(self.train_feature_generator_iters):
i = step % int(images.shape[0] / self.batch_size)
images_batch = images[i * self.batch_size:(i + 1) *
self.batch_size]
labels_batch = labels[i * self.batch_size:(i + 1) *
self.batch_size]
# noise = utils.sample_Z(self.batch_size, noise_dim, 'uniform')
noise = utils.sample_Z(self.batch_size, noise_dim, 'gaussian')
feed_dict = {
model.noise: noise,
model.images: images_batch,
model.labels: labels_batch
}
avg_D_fake = sess.run(model.logits_fake, feed_dict)
avg_D_real = sess.run(model.logits_real, feed_dict)
sess.run(model.d_train_op, feed_dict)
sess.run(model.g_train_op, feed_dict)
if (step + 1) % 1000 == 0:
summary, dl, gl = sess.run(
[model.summary_op, model.d_loss, model.g_loss],
feed_dict)
summary_writer.add_summary(summary, step)
print ('Step: [%d/%d] d_loss: %.6f g_loss: %.6f avg_d_fake: %.2f avg_d_real: %.2f ' \
% (
step + 1, self.train_feature_generator_iters, dl, gl, avg_D_fake.mean(), avg_D_real.mean()))
print 'Saving.'
saver.save(sess, self.pretrained_feature_generator)
def eval_dsn(self, name='Exp2'):
# build model
model = self.model
model.build_model()
self.config = tf.ConfigProto(device_count={'GPU': 0})
with tf.Session(config=self.config) as sess:
print('Loading pretrained G.')
variables_to_restore = slim.get_model_variables(scope='generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
print('Loading pretrained E.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
print('Loading sample generator.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
source_images, source_labels = self.load_svhn(self.svhn_dir)
npr.seed(190)
for n in range(10):
print n
no_gen = 5000
source_labels = n * np.ones((no_gen, ), dtype=int)
# train model for source domain S
src_labels = utils.one_hot(source_labels[:no_gen], 10)
src_noise = utils.sample_Z(no_gen, 100, 'uniform')
feed_dict = {
model.src_noise: src_noise,
model.src_labels: src_labels
}
samples, samples_logits = sess.run(
[model.sampled_images, model.sampled_images_logits],
feed_dict)
samples_logits = samples_logits[:, n]
samples = samples[samples_logits > 8.]
samples_logits = samples_logits[samples_logits > 8.]
for i in range(len(samples_logits)):
#~ try:
#~ imsave('./sample/'+str(np.argmax(src_labels[i]))+'/'+name+'/'+str(i)+'_'+str(np.argmax(src_labels[i]))+'_'+str(samples_logits[i])+'.png',np.squeeze(samples[i]))
#~ except:
#~ os.mkdir('./sample/'+str(np.argmax(src_labels[i]))+'/'+name+'/')
imsave(
'./sample/' + str(np.argmax(src_labels[i])) + '/' +
name + '_' + str(i) + '_' +
str(np.argmax(src_labels[i])) +
'_' + str(samples_logits[i]) + '.png',
np.squeeze(samples[i]))
print str(i) + '/' + str(len(samples)), np.argmax(
src_labels[i])
def train_DIFA(self):
print 'Adapt with DIFA'
# build a graph
model = self.model
model.build_model()
# source_images, source_labels = self.load_svhn(self.svhn_dir, split='train')
# target_images, _ = self.load_mnist(self.mnist_dir, split='train') #无需训练label
# target_test_images, target_test_labels = self.load_mnist(self.mnist_dir, split='test')
###########协议数据
# Xs = cPickle.load(open("protocal18m.dat", 'rb'))
classes_s, source_images, Xs_test, source_labels, Ys_test = self.getprotocol(
Xs)
classes_t, target_images, target_test_images, Yt_train, target_test_labels = self.getprotocol(
Xt)
with tf.Session(config=self.config) as sess:
# Initialize weights
tf.global_variables_initializer().run()
print('Loading pretrained encoder.')
variables_to_restore = slim.get_model_variables(
scope='feature_extractor')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_feature_extractor)
print('Loading pretrained S.')
variables_to_restore = slim.get_model_variables(
scope='feature_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_feature_generator)
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
print('Start training.')
#先评估目标域
print 'Evaluating.'
target_test_acc = 0.
source_test_acc = 0.
# 评估源域数据
# for source_test_labels_batch, source_test_images_batch in zip(
# np.array_split(Ys_test, 5), np.array_split(Xs_test, 5)):
# source_test_acc_tmp = sess.run(model.trg_accuracy,
# feed_dict={model.trg_images: source_test_images_batch,
# model.trg_labels_gt: source_test_labels_batch})
# source_test_acc += source_test_acc_tmp / 5.
source_test_acc = sess.run(model.trg_accuracy,
feed_dict={
model.trg_images: Xs_test[::4],
model.trg_labels_gt: Ys_test[::4]
})
print 'source test accuracy: [%.3f]' % (source_test_acc)
# for target_test_labels_batch, target_test_images_batch in zip(
# np.array_split(target_test_labels, 5), np.array_split(target_test_images, 5)):
# target_test_acc_tmp = sess.run(model.trg_accuracy,
# feed_dict={model.trg_images: target_test_images_batch,
# model.trg_labels_gt: target_test_labels_batch})
# target_test_acc += target_test_acc_tmp / 5.
target_test_acc = sess.run(model.trg_accuracy,
feed_dict={
model.trg_images:
target_test_images[::3],
model.trg_labels_gt:
target_test_labels[::3]
})
print 'target test accuracy: [%.3f]' % (target_test_acc)
#画混淆矩阵
pred_t = sess.run(model.trg_labels,
feed_dict={
model.trg_images:
target_test_images[1000:3000],
model.trg_labels_gt:
target_test_labels[1000:3000]
})
y_true = utils.one_hot(target_test_labels[1000:3000], 11)
confusion(classes_t, pred_t, y_true)
plt.savefig("noadapta.png")
plt.close('all')
# plt.show()
noise_dim = 100
p = 0
test_acc = []
for step in range(self.train_DIFA_iters):
i = step % int(source_images.shape[0] / self.batch_size)
j = step % int(target_images.shape[0] / self.batch_size)
source_images_batch = source_images[i *
self.batch_size:(i + 1) *
self.batch_size]
target_images_batch = target_images[j *
self.batch_size:(j + 1) *
self.batch_size]
labels_batch = utils.one_hot(
source_labels[i * self.batch_size:(i + 1) *
self.batch_size], 11)
# noise = utils.sample_Z(self.batch_size, noise_dim, 'uniform')
noise = utils.sample_Z(self.batch_size, noise_dim, 'gaussian')
feed_dict = {
model.src_images: source_images_batch,
model.trg_images: target_images_batch,
model.noise: noise,
model.labels: labels_batch
}
sess.run(model.e_train_op, feed_dict)
sess.run(model.d_train_op, feed_dict)
logits_real, logits_fake = sess.run(
[model.logits_real, model.logits_fake], feed_dict)
if (step + 1) % 800 == 0:
summary, e_loss, d_loss = sess.run(
[model.summary_op, model.e_loss, model.d_loss],
feed_dict)
summary_writer.add_summary(summary, step)
print ('Step: [%d/%d] e_loss: [%.6f] d_loss: [%.6f] e_real: [%.2f] e_fake: [%.2f]' \
% (step + 1, self.train_DIFA_iters, e_loss, d_loss, logits_real.mean(), logits_fake.mean()))
print 'Evaluating.'
target_test_acc = 0.
# for target_test_labels_batch, target_test_images_batch in zip(
# np.array_split(target_test_labels, 10), np.array_split(target_test_images, 10)):
# feed_dict[self.model.trg_images] = target_test_images_batch
# feed_dict[self.model.trg_labels_gt] = target_test_labels_batch
# target_test_acc_tmp = sess.run(model.trg_accuracy, feed_dict)
# target_test_acc += target_test_acc_tmp / 10.
target_test_acc = sess.run(model.trg_accuracy,
feed_dict={
model.trg_images:
target_test_images[::3],
model.trg_labels_gt:
target_test_labels[::3]
})
source_test_acc = sess.run(model.trg_accuracy,
feed_dict={
model.trg_images:
Xs_test[::4],
model.trg_labels_gt:
Ys_test[::4]
})
print 'source test accuracy: [%.3f]' % (source_test_acc)
pred_t = sess.run(model.trg_labels,
feed_dict={
model.trg_images:
target_test_images[1000:3000],
model.trg_labels_gt:
target_test_labels[1000:3000]
})
y_true = utils.one_hot(target_test_labels[1000:3000], 11)
confusion(classes_t, pred_t, y_true)
p = p + 1
plt.savefig("pics/adapta" + str(p) + ".png")
plt.close('all')
print 'target test accuracy: [%.3f]' % (target_test_acc)
test_acc.append(target_test_acc)
np.savetxt("resultacc.txt", np.array(test_acc))
print 'Saving.'
saver.save(sess, self.DIFA_feature_extractor)
def train_sampler(self):
print 'Training sampler.'
images, labels = self.load_mnist(self.mnist_dir, split='train')
labels = utils.one_hot(labels, 10)
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
batch_size = self.batch_size
noise_dim = 100
epochs = 5000
with tf.Session(config=self.config) as sess:
# initialize G and D
tf.global_variables_initializer().run()
# restore variables of F
print('Loading pretrained model.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
# restore variables of F
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
#~ feed_dict = {model.images: source_images[:10000]}
#~ fx = sess.run(model.fx, feed_dict)
t = 0
for i in range(epochs):
#~ print 'Epoch',str(i)
for start, end in zip(
range(0, len(images), batch_size),
range(batch_size, len(images), batch_size)):
t += 1
Z_samples = utils.sample_Z(batch_size, noise_dim,
'uniform')
feed_dict = {
model.noise: Z_samples,
model.images: images[start:end],
model.labels: labels[start:end]
}
avg_D_fake = sess.run(model.logits_fake, feed_dict)
avg_D_real = sess.run(model.logits_real, feed_dict)
sess.run(model.d_train_op, feed_dict)
sess.run(model.g_train_op, feed_dict)
if (t + 1) % 100 == 0:
summary, dl, gl = sess.run(
[model.summary_op, model.d_loss, model.g_loss],
feed_dict)
summary_writer.add_summary(summary, t)
print ('Step: [%d/%d] d_loss: %.6f g_loss: %.6f avg_D_fake: %.2f avg_D_real: %.2f ' \
%(t+1, int(epochs*len(images) /batch_size), dl, gl, avg_D_fake.mean(), avg_D_real.mean()))
if (t + 1) % 1000 == 0:
saver.save(
sess, os.path.join(self.model_save_path,
'sampler'))
def train_sampler(self):
print 'Training sampler.'
source_images, source_labels = self.load_NYUD(split='source')
source_labels = utils.one_hot(source_labels.astype(int), self.no_classes )
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
batch_size = self.batch_size
noise_dim = model.noise_dim
epochs = 500000
## Computing latent representation for the source split
#~ with tf.Session(config=tf.ConfigProto(device_count = {'GPU': 0})) as sess:
with tf.Session(config=self.config) as sess:
print ('Computing latent representation.')
tf.global_variables_initializer().run()
variables_to_restore = slim.get_model_variables(scope='vgg_16')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
## Must do it batchwise
source_fx = np.empty((0, model.hidden_repr_size))
#~ counter = 0
for spl_im, spl_lab in zip(np.array_split(source_images, 40), np.array_split(source_labels, 40)):
feed_dict = {model.noise: utils.sample_Z(1, noise_dim, 'uniform'),
model.images: spl_im,
model.labels: spl_lab,
model.fx: np.ones((1,model.hidden_repr_size))}
s_fx = sess.run(model.dummy_fx, feed_dict)
source_fx = np.vstack((source_fx, np.squeeze(s_fx)))
#~ print(counter)
#~ counter+=1
assert source_fx.shape == (source_images.shape[0], model.hidden_repr_size)
with tf.Session(config=self.config) as sess:
# initialize G and D
tf.global_variables_initializer().run()
print ('Loading pretrained model.')
variables_to_restore = slim.get_model_variables(scope='vgg_16')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
summary_writer = tf.summary.FileWriter(logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
#~ feed_dict = {model.images: source_images[:10000]}
#~ fx = sess.run(model.fx, feed_dict)
t = 0
for i in range(epochs):
#~ print 'Epoch',str(i)
src_rand = np.random.permutation(source_images.shape[0])
source_labels, source_fx = source_labels[src_rand], source_fx[src_rand]
for start, end in zip(range(0, len(source_images), batch_size), range(batch_size, len(source_images), batch_size)):
t += 1
Z_samples = utils.sample_Z(batch_size, noise_dim, 'uniform')
feed_dict = {model.noise: Z_samples, model.images: source_images[0:1], model.labels: source_labels[start:end], model.fx: source_fx[start:end]}
avg_D_fake = sess.run(model.logits_fake, feed_dict)
avg_D_real = sess.run(model.logits_real, feed_dict)
sess.run(model.d_train_op, feed_dict)
sess.run(model.g_train_op, feed_dict)
if (t+1) % 250 == 0:
summary, dl, gl = sess.run([model.summary_op, model.d_loss, model.g_loss], feed_dict)
summary_writer.add_summary(summary, t)
print ('Step: [%d/%d] g_loss: [%.6f] d_loss: [%.6f]' \
%(t+1, int(epochs*len(source_images) /batch_size), gl, dl))
print '\t avg_D_fake',str(avg_D_fake.mean()),'avg_D_real',str(avg_D_real.mean())
if (t+1) % 5000 == 0:
saver.save(sess, os.path.join(self.model_save_path, 'sampler'))
def check_TSNE(self):
images, labels = self.load_mnist(self.mnist_dir, split='train')
# build a graph
model = self.model
model.build_model()
self.config = tf.ConfigProto(device_count={'GPU': 0})
with tf.Session(config=self.config) as sess:
# initialize G and D
tf.global_variables_initializer().run()
if sys.argv[1] == 'test':
print('Loading test model.')
variables_to_restore = slim.get_model_variables(
scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
elif sys.argv[1] == 'pretrain':
print('Loading pretrained model.')
variables_to_restore = slim.get_model_variables(
scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
else:
raise NameError('Unrecognized mode.')
n_samples = 2000
labels = utils.one_hot(labels[:n_samples], 10)
noise = utils.sample_Z(n_samples, 100, 'uniform')
print('Loading sampler.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
feed_dict = {
model.noise: noise,
model.labels: labels,
model.images: images[:n_samples]
}
fzy, fx = sess.run([model.fzy, model.fx], feed_dict)
labels = np.argmax(labels, 1)
print 'Computing T-SNE.'
model = TSNE(n_components=2, random_state=0)
if sys.argv[2] == '1':
TSNE_hA = model.fit_transform(fx)
f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)
ax1.set_facecolor('white')
ax2.set_facecolor('white')
ax1.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.ones((n_samples)),
s=3,
cmap=mpl.cm.jet,
alpha=0.5)
ax2.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=labels,
s=3,
cmap=mpl.cm.jet,
alpha=0.5)
elif sys.argv[2] == '2':
TSNE_hA = model.fit_transform(np.vstack((fzy, fx)))
f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)
ax1.set_facecolor('white')
ax2.set_facecolor('white')
ax1.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((np.ones((n_samples, )), 2 * np.ones(
(n_samples, )))),
s=3,
cmap=mpl.cm.jet,
alpha=0.5)
ax2.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((labels, labels)),
s=3,
cmap=mpl.cm.jet,
alpha=0.5)
plt.legend()
plt.show()
def train_dsn(self):
source_images, source_labels = self.load_NYUD(split='source')
target_images, target_labels = self.load_NYUD(split='target')
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
# initialize G and D
tf.global_variables_initializer().run()
# restore variables of F
print ('Loading Encoder.')
variables_to_restore = slim.get_model_variables(scope='vgg_16')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
print ('Loading sample generator.')
variables_to_restore = slim.get_model_variables(scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
summary_writer = tf.summary.FileWriter(logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
print ('Start training.')
trg_count = 0
t = 0
accTeSet = []
noise_dim = model.noise_dim
for step in range(10000000):
trg_count += 1
t+=1
i = step % int(source_images.shape[0] / self.batch_size)
j = step % int(target_images.shape[0] / self.batch_size)
src_images = source_images[i*self.batch_size:(i+1)*self.batch_size]
src_labels = utils.one_hot(source_labels[i*self.batch_size:(i+1)*self.batch_size].astype(int),model.no_classes)
src_noise = utils.sample_Z(self.batch_size,noise_dim,'uniform')
trg_images = target_images[j*self.batch_size:(j+1)*self.batch_size]
feed_dict = {model.src_images: src_images, model.src_noise: src_noise, model.src_labels: src_labels, model.trg_images: trg_images}
sess.run(model.E_train_op, feed_dict)
sess.run(model.DE_train_op, feed_dict)
if (step+1) % 10 == 0:
logits_E_real,logits_E_fake = sess.run([model.logits_E_real,model.logits_E_fake],feed_dict)
summary, E, DE = sess.run([model.summary_op, model.E_loss, model.DE_loss], feed_dict)
summary_writer.add_summary(summary, step)
print ('Step: [%d/%d] E: [%.6f] DE: [%.6f] E_real: [%.2f] E_fake: [%.2f]' \
%(step+1, self.train_iter, E, DE,logits_E_real.mean(),logits_E_fake.mean()))
if (step+1) % 20 == 0:
trg_acc = 0.
for trg_im, trg_lab, in zip(np.array_split(target_images, 40),
np.array_split(target_labels, 40),
):
feed_dict = {model.src_images: src_images[0:2], #dummy
model.src_labels: src_labels[0:2], #dummy
model.trg_images: trg_im,
model.target_labels: trg_lab}
trg_acc_ = sess.run(fetches=model.trg_accuracy, feed_dict=feed_dict)
trg_acc += (trg_acc_*len(trg_lab)) # must be a weighted average since last split is smaller
print ('trg acc [%.4f]' %(trg_acc/len(target_labels)))
accTeSet.append(trg_acc/len(target_labels))
with file(model.mode + '_test_accuracies.pkl', 'w') as f:
cPickle.dump(accTeSet, f, protocol=cPickle.HIGHEST_PROTOCOL)
saver.save(sess, os.path.join(self.model_save_path, 'dtn'))
def train_dsn(self):
source_images, source_labels = self.load_office(split=self.src_dir)
target_images, target_labels = self.load_office(split=self.trg_dir)
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=True)) as sess:
with tf.device('/gpu:1'):
# initialize G and D
tf.global_variables_initializer().run()
# restore variables of F
print('Loading pretrained model.')
# Do not change next two lines. Necessary because slim.get_model_variables(scope='blablabla') works only for model built with slim.
variables_to_restore = tf.global_variables()
#~ variables_to_restore = [v for v in variables_to_restore if 'encoder' in v.name]
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
#~ print ('Loading pretrained encoder disc.')
#~ variables_to_restore = slim.get_model_variables(scope='disc_e')
#~ restorer = tf.train.Saver(variables_to_restore)
#~ restorer.restore(sess, self.pretrained_sampler)
print('Loading sample generator.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
summary_writer = tf.summary.FileWriter(
logdir=self.log_dir, graph=tf.get_default_graph())
saver = tf.train.Saver()
print('Start training.')
trg_count = 0
t = 0
G_loss = 1.
DG_loss = 1.
noise_dim = 100
for step in range(10000000):
trg_count += 1
t += 1
i = step % int(source_images.shape[0] / self.batch_size)
j = step % int(target_images.shape[0] / self.batch_size)
src_images = source_images[i * self.batch_size:(i + 1) *
self.batch_size]
src_labels = utils.one_hot(
source_labels[i * self.batch_size:(i + 1) *
self.batch_size].astype(int), 31)
src_noise = utils.sample_Z(self.batch_size, 100, 'uniform')
trg_images = target_images[j * self.batch_size:(j + 1) *
self.batch_size]
feed_dict = {
model.src_images: src_images,
model.src_noise: src_noise,
model.src_labels: src_labels,
model.trg_images: trg_images
}
sess.run(model.E_train_op, feed_dict)
sess.run(model.DE_train_op, feed_dict)
if (step + 1) % 10 == 0:
logits_E_real, logits_E_fake = sess.run(
[model.logits_E_real, model.logits_E_fake],
feed_dict)
summary, E, DE = sess.run(
[model.summary_op, model.E_loss, model.DE_loss],
feed_dict)
summary_writer.add_summary(summary, step)
print ('Step: [%d/%d] E: [%.6f] DE: [%.6f] E_real: [%.2f] E_fake: [%.2f]' \
%(step+1, self.train_iter, E, DE,logits_E_real.mean(),logits_E_fake.mean()))
if (step + 1) % 20 == 0:
saver.save(sess,
os.path.join(self.model_save_path, 'dtn'))
def check_TSNE(self):
source_images, source_labels = self.load_NYUD(split='source')
target_images, target_labels = self.load_NYUD(split='target')
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
#~ self.config = tf.ConfigProto(device_count = {'GPU': 0})
with tf.Session(config=self.config) as sess:
# initialize G and D
tf.global_variables_initializer().run()
if sys.argv[2] in ['2', '3']:
print ('Loading sampler.')
variables_to_restore = slim.get_model_variables(scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
if sys.argv[1] == 'test':
print ('Loading test model.')
variables_to_restore = tf.global_variables()
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
elif sys.argv[1] == 'pretrain':
print ('Loading pretrained model.')
variables_to_restore = slim.get_model_variables(scope='vgg_16')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
else:
raise NameError('Unrecognized mode.')
n_samples = len(source_labels)# Some trg samples are discarded
target_images = target_images[:n_samples]
target_labels = target_labels[:n_samples]
assert len(target_labels) == len(source_labels)
src_labels = utils.one_hot(source_labels.astype(int),self.no_classes )
trg_labels = utils.one_hot(target_labels.astype(int),self.no_classes )
src_noise = utils.sample_Z(n_samples,model.noise_dim,'uniform')
fzy = np.empty((0,model.hidden_repr_size))
fx_src = np.empty((0,model.hidden_repr_size))
fx_trg = np.empty((0,model.hidden_repr_size))
for src_im, src_lab, trg_im, trg_lab, src_n in zip(np.array_split(source_images, 40),
np.array_split(src_labels, 40),
np.array_split(target_images, 40),
np.array_split(trg_labels, 40),
np.array_split(src_noise, 40),
):
feed_dict = {model.src_noise: src_n, model.src_labels: src_lab, model.src_images: src_im, model.trg_images: trg_im}
fzy_, fx_src_, fx_trg_ = sess.run([model.fzy, model.fx_src, model.fx_trg], feed_dict)
fzy = np.vstack((fzy, fzy_))
fx_src = np.vstack((fx_src, np.squeeze(fx_src_)) )
fx_trg = np.vstack((fx_trg, np.squeeze(fx_trg_)) )
src_labels = np.argmax(src_labels,1)
trg_labels = np.argmax(trg_labels[:n_samples],1)
assert len(src_labels) == len(fx_src)
assert len(trg_labels) == len(fx_trg)
print 'Computing T-SNE.'
model = TSNE(n_components=2, random_state=0)
if sys.argv[2] == '1':
TSNE_hA = model.fit_transform(np.squeeze(fx_src))
plt.figure(2)
plt.scatter(TSNE_hA[:,0], TSNE_hA[:,1], c = np.hstack((np.ones((n_samples)))), s=3, cmap = mpl.cm.jet)
plt.figure(3)
plt.scatter(TSNE_hA[:,0], TSNE_hA[:,1], c = np.hstack((src_labels)), s=3, cmap = mpl.cm.jet)
elif sys.argv[2] == '2':
TSNE_hA = model.fit_transform(np.vstack((fzy,fx_src)))
plt.figure(2)
plt.scatter(TSNE_hA[:,0], TSNE_hA[:,1], c = np.hstack((np.ones((n_samples,)), 2 * np.ones((n_samples,)))), s=3, cmap = mpl.cm.jet)
plt.figure(3)
plt.scatter(TSNE_hA[:,0], TSNE_hA[:,1], c = np.hstack((src_labels,src_labels)), s=3, cmap = mpl.cm.jet)
elif sys.argv[2] == '3':
TSNE_hA = model.fit_transform(np.vstack((fzy,fx_src,fx_trg)))
plt.figure(2)
plt.scatter(TSNE_hA[:,0], TSNE_hA[:,1], c = np.hstack((src_labels, src_labels, trg_labels, )), s=3, cmap = mpl.cm.jet)
plt.figure(3)
plt.scatter(TSNE_hA[:,0], TSNE_hA[:,1], c = np.hstack((np.ones((n_samples,)), 2 * np.ones((n_samples,)), 3 * np.ones((n_samples,)))), s=3, cmap = mpl.cm.jet)
plt.show()
def check_TSNE(self):
source_images, source_labels = self.load_office(split=self.src_dir)
target_images, target_labels = self.load_office(split=self.trg_dir)
# build a graph
model = self.model
model.build_model()
# make directory if not exists
if tf.gfile.Exists(self.log_dir):
tf.gfile.DeleteRecursively(self.log_dir)
tf.gfile.MakeDirs(self.log_dir)
#~ self.config = tf.ConfigProto(device_count = {'GPU': 0})
with tf.Session(config=self.config) as sess:
# initialize G and D
tf.global_variables_initializer().run()
if sys.argv[1] == 'test':
print('Loading test model.')
# Do not change next two lines. Necessary because slim.get_model_variables(scope='blablabla') works only for model built with slim.
variables_to_restore = tf.global_variables()
variables_to_restore = [
v for v in variables_to_restore if np.all([
s not in str(v.name) for s in [
'encoder', 'sampler_generator', 'disc_e',
'source_train_op'
]
])
]
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
elif sys.argv[1] == 'pretrain':
print('Loading pretrained model.')
# Do not change next two lines. Necessary because slim.get_model_variables(scope='blablabla') works only for model built with slim.
variables_to_restore = tf.global_variables()
variables_to_restore = [
v for v in variables_to_restore if np.all([
s not in str(v.name) for s in [
'encoder', 'sampler_generator', 'disc_e',
'source_train_op'
]
])
]
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
elif sys.argv[1] == 'convdeconv':
print('Loading convdeconv model.')
variables_to_restore = slim.get_model_variables(
scope='conv_deconv')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.convdeconv_model)
else:
raise NameError('Unrecognized mode.')
n_samples = 400
src_labels = utils.one_hot(source_labels[:n_samples].astype(int),
31)
trg_labels = utils.one_hot(target_labels[:n_samples].astype(int),
31)
src_noise = utils.sample_Z(n_samples, 100, 'uniform')
if sys.argv[1] == 'convdeconv':
feed_dict = {
model.src_noise: src_noise,
model.src_labels: src_labels,
model.src_images: source_images,
model.trg_images: target_images[:n_samples]
}
h_repr = sess.run(model.h_repr, feed_dict)
else:
print('Loading sampler.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
feed_dict = {
model.src_noise: src_noise,
model.src_labels: src_labels,
model.src_images: source_images[:n_samples],
model.trg_images: target_images[:n_samples]
}
fzy, fx_src, fx_trg = sess.run(
[model.fzy, model.fx_src, model.fx_trg], feed_dict)
src_labels = np.argmax(src_labels, 1)
trg_labels = np.argmax(trg_labels, 1)
print 'Computing T-SNE.'
model = TSNE(n_components=2, random_state=0)
if sys.argv[2] == '1':
TSNE_hA = model.fit_transform(np.vstack((fx_src)))
plt.figure(2)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((np.ones((n_samples)))),
s=3,
cmap=mpl.cm.jet)
plt.figure(3)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((src_labels)),
s=3,
cmap=mpl.cm.jet)
elif sys.argv[2] == '2':
TSNE_hA = model.fit_transform(np.vstack((fzy, fx_src)))
plt.figure(2)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((np.ones((n_samples, )), 2 * np.ones(
(n_samples, )))),
s=3,
cmap=mpl.cm.jet)
plt.figure(3)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((src_labels, src_labels)),
s=3,
cmap=mpl.cm.jet)
elif sys.argv[2] == '3':
TSNE_hA = model.fit_transform(np.vstack((fzy, fx_src, fx_trg)))
plt.figure(2)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((
src_labels,
src_labels,
trg_labels,
)),
s=3,
cmap=mpl.cm.jet)
plt.figure(3)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.hstack((np.ones((n_samples, )), 2 * np.ones(
(n_samples, )), 3 * np.ones((n_samples, )))),
s=3,
cmap=mpl.cm.jet)
elif sys.argv[2] == '4':
TSNE_hA = model.fit_transform(h_repr)
plt.scatter(TSNE_hA[:, 0],
TSNE_hA[:, 1],
c=np.argmax(trg_labels, 1),
s=3,
cmap=mpl.cm.jet)
plt.show()
def eval_dsn(self):
# build model
model = self.model
model.build_model()
self.config = tf.ConfigProto(device_count={'GPU': 0})
with tf.Session(config=self.config) as sess:
print('Loading pretrained G.')
variables_to_restore = slim.get_model_variables(scope='generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
print('Loading pretrained E.')
variables_to_restore = slim.get_model_variables(scope='encoder')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.test_model)
print('Loading sample generator.')
variables_to_restore = slim.get_model_variables(
scope='sampler_generator')
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_sampler)
if self.protocol == 'svhn_mnist':
source_images, source_labels = self.load_svhn(self.svhn_dir)
elif self.protocol == 'mnist_usps':
source_images, source_labels = self.load_mnist(self.mnist_dir)
for n in range(10):
print n
no_gen = 5000
source_labels = n * np.ones((no_gen, ), dtype=int)
# train model for source domain S
src_labels = utils.one_hot(source_labels[:no_gen], 10)
src_noise = utils.sample_Z(no_gen, 100, 'uniform')
feed_dict = {
model.src_noise: src_noise,
model.src_labels: src_labels
}
samples, samples_logits = sess.run(
[model.sampled_images, model.sampled_images_logits],
feed_dict)
samples_logits = samples_logits[:, n]
samples = samples[samples_logits > 8.]
samples_logits = samples_logits[samples_logits > 8.]
for i in range(len(samples_logits)):
#~ print str(i)+'/'+str(len(samples_logits))-
plt.imshow(np.squeeze(samples[i]), cmap='gray')
plt.imsave('./sample/' + str(np.argmax(src_labels[i])) +
'/' + str(i) + '_' +
str(np.argmax(src_labels[i])) + '_' +
str(samples_logits[i]),
np.squeeze(samples[i]),
cmap='gray')
print str(i) + '/' + str(len(samples)), np.argmax(
src_labels[i])
