def main(_):
model = DSN(mode=FLAGS.mode, learning_rate=0.0003)
solver = Solver(model, svhn_dir='svhn', mnist_dir='mnist', model_save_path=FLAGS.model_save_path, sample_save_path=FLAGS.sample_save_path)
# create directories if not exist
if not tf.gfile.Exists(FLAGS.model_save_path):
tf.gfile.MakeDirs(FLAGS.model_save_path)
if not tf.gfile.Exists(FLAGS.sample_save_path):
tf.gfile.MakeDirs(FLAGS.sample_save_path)
if FLAGS.mode == 'pretrain':
solver.pretrain()
elif FLAGS.mode == 'train_sampler':
solver.train_sampler()
elif FLAGS.mode == 'train_dsn':
solver.train_dsn()
elif FLAGS.mode == 'eval_dsn':
solver.eval_dsn()
elif FLAGS.mode == 'test':
solver.test()
elif FLAGS.mode == 'train_convdeconv':
solver.train_convdeconv()
elif FLAGS.mode == 'train_gen_images':
solver.train_gen_images()
elif FLAGS.mode == 'end_to_end':
solver.train_end_to_end()
elif FLAGS.mode == 'train_all':
start_img = 1600
end_img = 3200
for start,end,name in zip([3200,4800,6400,8000,9600],[4800,6400,8000,9600,11200],['Exp3','Exp4','Exp5','Exp6','Exp7']):
model = DSN(mode='train_dsn', learning_rate=0.0001)
solver = Solver(model, svhn_dir='svhn', mnist_dir='mnist', model_save_path=FLAGS.model_save_path, sample_save_path=FLAGS.sample_save_path, start_img = start_img, end_img = end_img)
solver.train_dsn()
model = DSN(mode='eval_dsn')
solver = Solver(model, svhn_dir='svhn', mnist_dir='mnist', model_save_path=FLAGS.model_save_path, sample_save_path=FLAGS.sample_save_path)
solver.eval_dsn(name=name)
tf.reset_default_graph()
else:
print 'Unrecognized mode.'
def main(_):
with tf.device('/gpu:' + FLAGS.gpu):
model = DSN(mode=FLAGS.mode, learning_rate=0.001)
src_split, trg_split = FLAGS.splits.split('2')[0], FLAGS.splits.split(
'2')[1]
solver = Solver(model,
batch_size=64,
src_dir=src_split,
trg_dir=trg_split)
if FLAGS.mode == 'pretrain':
solver.pretrain()
elif FLAGS.mode == 'train_sampler':
solver.train_sampler()
elif FLAGS.mode == 'train_dsn':
solver.train_dsn()
elif FLAGS.mode == 'eval_dsn':
solver.eval_dsn()
elif FLAGS.mode == 'test':
solver.test()
elif FLAGS.mode == 'features':
solver.features()
elif FLAGS.mode == 'test_ensemble':
solver.test_ensemble()
elif FLAGS.mode == 'train_adda_shared' or FLAGS.mode == 'train_adda':
solver.train_adda_shared()
else:
print 'Unrecognized mode.'
def main(config):
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
model = DSN().cuda()
state = torch.load(config.ckp_path)
model.load_state_dict(state['state_dict'])
filenames = glob.glob(os.path.join(config.img_dir, '*.png'))
filenames = sorted(filenames)
out_filename = config.save_path
os.makedirs(os.path.dirname(config.save_path), exist_ok=True)
model.eval()
with open(out_filename, 'w') as out_file:
out_file.write('image_name,label\n')
with torch.no_grad():
for fn in filenames:
data = Image.open(fn).convert('RGB')
data = transform(data)
data = torch.unsqueeze(data, 0)
data = data.cuda()
output, _, _, _, _ = model(data, mode=config.mode)
pred = output.max(1, keepdim=True)[
1] # get the index of the max log-probability
out_file.write(
fn.split('/')[-1] + ',' + str(pred.item()) + '\n')
def build_model(self):
self.model = DSN().to(self.device)
self.model.apply(xavier_weights_init)
self.optimizer = torch.optim.Adam(self.model.parameters(),
lr=self.lr,
betas=[self.beta1, self.beta2],
weight_decay=self.weight_decay)
def main(_):
model = DSN(mode=FLAGS.mode, learning_rate=0.0001)
src_split, trg_split = FLAGS.splits.split('2')[0], FLAGS.splits.split(
'2')[1]
solver = Solver(model,
batch_size=128,
src_dir=src_split,
trg_dir=trg_split)
if FLAGS.mode == 'pretrain':
solver.pretrain()
elif FLAGS.mode == 'train_sampler':
solver.train_sampler()
elif FLAGS.mode == 'train_dsn':
solver.train_dsn()
elif FLAGS.mode == 'eval_dsn':
solver.eval_dsn()
elif FLAGS.mode == 'test':
solver.test()
elif FLAGS.mode == 'test_ensemble':
solver.test_ensemble()
else:
print 'Unrecognized mode.'
def main(_):
src_split, trg_split = FLAGS.splits.split('2')[0], FLAGS.splits.split(
'2')[1]
from model import DSN
model = DSN(mode='eval_dsn', learning_rate=0.0003)
solver = Solver(model, src_dir=src_split, trg_dir=trg_split)
solver.check_TSNE()
def main(_):
model = DSN(mode=FLAGS.mode, learning_rate=0.00001)
solver = Solver(model, batch_size=32)
if FLAGS.mode == 'pretrain':
solver.pretrain()
elif FLAGS.mode == 'train_sampler':
solver.train_sampler()
elif FLAGS.mode == 'train_dsn':
solver.train_dsn()
elif FLAGS.mode == 'eval_dsn':
solver.eval_dsn()
elif FLAGS.mode == 'test':
solver.test()
elif FLAGS.mode == 'features':
solver.features()
elif FLAGS.mode == 'test_ensemble':
solver.test_ensemble()
elif FLAGS.mode == 'train_adda_shared' or FLAGS.mode == 'train_adda':
solver.train_adda_shared()
else:
print 'Unrecognized mode.'
def main(_):
npr.seed(291)
GPU_ID = 3
os.environ[
"CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # see issue #152 on stackoverflow
os.environ["CUDA_VISIBLE_DEVICES"] = str(GPU_ID)
model = DSN(mode=FLAGS.mode, learning_rate=0.0003)
solver = Solver(model,
svhn_dir='/data/svhn',
syn_dir='/data/syn',
model_save_path=FLAGS.model_save_path,
sample_save_path=FLAGS.sample_save_path)
# create directories if not exist
if not tf.gfile.Exists(FLAGS.model_save_path):
tf.gfile.MakeDirs(FLAGS.model_save_path)
if not tf.gfile.Exists(FLAGS.sample_save_path):
tf.gfile.MakeDirs(FLAGS.sample_save_path)
if FLAGS.mode == 'pretrain':
solver.pretrain()
elif FLAGS.mode == 'train_sampler':
solver.train_sampler()
elif FLAGS.mode == 'train_dsn':
solver.train_dsn()
elif FLAGS.mode == 'eval_dsn':
solver.eval_dsn()
elif FLAGS.mode == 'test':
solver.test()
elif FLAGS.mode == 'train_convdeconv':
solver.train_convdeconv()
elif FLAGS.mode == 'train_gen_images':
solver.train_gen_images()
elif FLAGS.mode == 'train_all':
start_img = 1600
end_img = 3200
for start, end, name in zip([3200, 4800, 6400, 8000, 9600],
[4800, 6400, 8000, 9600, 11200],
['Exp3', 'Exp4', 'Exp5', 'Exp6', 'Exp7']):
model = DSN(mode='train_dsn', learning_rate=0.0001)
solver = Solver(model,
svhn_dir='svhn',
mnist_dir='mnist',
model_save_path=FLAGS.model_save_path,
sample_save_path=FLAGS.sample_save_path,
start_img=start_img,
end_img=end_img)
solver.train_dsn()
model = DSN(mode='eval_dsn')
solver = Solver(model,
svhn_dir='svhn',
mnist_dir='mnist',
model_save_path=FLAGS.model_save_path,
sample_save_path=FLAGS.sample_save_path)
solver.eval_dsn(name=name)
tf.reset_default_graph()
else:
print 'Unrecognized mode.'
print ('Step: [%d/%d] test acc [%.3f]' \
%(t+1, self.pretrain_iter, test_trg_acc))
print confusion_matrix(test_labels, trg_pred)
acc.append(test_trg_acc)
with open('test_acc.pkl', 'wb') as f:
cPickle.dump(acc, f, cPickle.HIGHEST_PROTOCOL)
#~ gen_acc = sess.run(fetches=[model.trg_accuracy, model.trg_pred],
#~ feed_dict={model.src_images: gen_images,
#~ model.src_labels: gen_labels,
#~ model.trg_images: gen_images,
#~ model.trg_labels: gen_labels})
#~ print ('Step: [%d/%d] src train acc [%.2f] src test acc [%.2f] trg test acc [%.2f]' \
#~ %(t+1, self.pretrain_iter, gen_acc))
time.sleep(10.1)
if __name__ == '__main__':
from model import DSN
model = DSN(mode='eval_dsn', learning_rate=0.0003)
solver = Solver(model)
#~ solver.find_closest_samples()
solver.check_TSNE()
})
src_acc = sess.run(model.src_accuracy,
feed_dict={
model.src_images:
src_images[:20000],
model.src_labels:
src_labels[:20000],
model.trg_images:
trg_test_images[trg_rand_idxs],
model.trg_labels:
trg_test_labels[trg_rand_idxs]
})
print ('Step: [%d/%d] src train acc [%.3f] src test acc [%.3f] trg test acc [%.3f]' \
%(t+1, self.pretrain_iter, src_acc, test_src_acc, test_trg_acc))
print confusion_matrix(trg_test_labels[trg_rand_idxs],
trg_pred)
acc.append(test_trg_acc)
with open(self.protocol + '_' + algorithm + '.pkl', 'wb') as f:
cPickle.dump(acc, f, cPickle.HIGHEST_PROTOCOL)
if __name__ == '__main__':
from model import DSN
model = DSN(mode='eval_dsn')
solver = Solver(model)
solver.check_TSNE()
shuffle=True,
num_workers=8)
dataset_target = datasets.MNIST(
root=target_dataset,
train=True,
transform=img_tgt_transform,
)
datasetloader_target = torch.utils.data.DataLoader(dataset=dataset_target,
batch_size=batch_size,
shuffle=True,
num_workers=8)
# load models
my_net = DSN(n_class=10, code_size=3072, channels=n_channels)
my_net.apply(weights_init)
# setup optimizer
optimizer = optim.Adam(my_net.parameters(), lr=lr, weight_decay=weight_decay)
loss_class = nn.CrossEntropyLoss()
loss_rec = func.mean_pairwise_square_loss()
loss_diff = func.difference_loss()
if cuda:
my_net = my_net.cuda()
loss_class = loss_class.cuda()
loss_rec = loss_rec.cuda()
loss_diff = loss_diff.cuda()
#loss coefficients
