def load_model(self,
vgg_path,
plain_decoder_path,
tune_vgg_path=None,
encrypter_path=None,
decrypter_path=None):
'''
load pretrained vgg and plain decoder
other default is None for cpt training
'''
if encrypter_path is not None:
self.encrypter.load_state_dict(torch.load(encrypter_path))
self.plain_decoder.load_state_dict(torch.load(plain_decoder_path))
vgg = model.VGG().eval()
vgg.load_state_dict(torch.load(vgg_path))
vgg = nn.Sequential(*list(vgg.children())[:31])
self.fixed_feat_extractor = model.Feature_extractor(vgg, False)
self.vgg_tune = model.VGG()
if tune_vgg_path:
self.vgg_tune = nn.Sequential(*list(self.vgg_tune.children())[:31])
self.vgg_tune.load_state_dict(torch.load(tune_vgg_path))
else:
self.vgg_tune.load_state_dict(torch.load(vgg_path))
self.vgg_tune = nn.Sequential(*list(self.vgg_tune.children())[:31])
self.tune_feat_extractor = model.Feature_extractor(self.vgg_tune, True)
if decrypter_path is not None:
decrypter.load_state_dict(torch.load(decrypter_path))
def load_model(self,
vgg_path=None,
decoder_path=None,
message_encoder_path=None,
message_decoder_path=None):
self.vgg = model.VGG()
if vgg_path:
self.vgg.load_state_dict(torch.load(vgg_path))
self.vgg = nn.Sequential(*list(self.vgg.children())[:31])
self.decoder = model.Decoder()
if decoder_path:
self.decoder.load_state_dict(torch.load(decoder_path))
self.message_encoder = model.Message_Encoder()
if message_encoder_path:
self.message_encoder.load_state_dict(
torch.load(message_encoder_path))
self.message_decoder = model.Message_Decoder(
input_width=self.image_size,
content_feat_shape=(self.vgg_relu_4_1_dim,
int(self.image_size / self.down_scale),
int(self.image_size / self.down_scale)))
if message_decoder_path:
self.message_decoder.load_state_dict(
torch.load(message_decoder_path))
def main():
config = Config()
modeler = model.VGG(config)
# read data to train("data/train")
train_reader = read_data.VGGReader(config)
modeler.inference()
loss = modeler.loss
train_op = modeler.train_op(loss)
init = tf.global_variables_initializer()
saver = tf.train.Saver(max_to_keep=100)
sess_config = tf.ConfigProto()
sess_config.gpu_options.allow_growth = True
with tf.Session(config=sess_config) as sess:
sess.run(init)
#saver.restore(sess, config.param_dir + config.load_filename)
#print "restore params" + config.steps
merged = tf.summary.merge_all()
logdir = os.path.join(config.log_dir,
datetime.now().strftime('%Y-%m-%d_%H-%M-%S'))
train_writer = tf.summary.FileWriter(logdir, sess.graph)
#start training
print 'start training'
for step in range(config.max_step):
#start_time = time.time()
with tf.device('/cpu:0'):
images_train, labels_train, filesname_train = train_reader.get_random_batch(
True)
feed_dict = {
modeler.image_holder: images_train,
modeler.label_holder: labels_train,
modeler.is_train: True
}
with tf.device('/gpu:0'):
_, loss_value = sess.run([train_op, loss], feed_dict=feed_dict)
with tf.device('/cpu:0'):
if (step + 1) % config.checkpointer_iter == 0:
modeler.save_npy(
sess, config.param_dir + config.save_filename +
str(modeler.global_step.eval()) + '.npy')
if (step + 1) % config.summary_iter == 0:
summary = sess.run(merged, feed_dict=feed_dict)
train_writer.add_summary(summary,
modeler.global_step.eval())
if step % 10 == 0:
print 'step %d, loss = %.3f' % (step, loss_value)
def load_model(self, vgg_path, decoder_path=None):
self.vgg = model.VGG()
self.vgg.load_state_dict(torch.load(vgg_path))
self.vgg = nn.Sequential(*list(self.vgg.children())[:31])
self.vgg_encoder = model.VGG_Encoder(self.vgg)
self.decoder = model.Decoder()
if decoder_path:
self.decoder.load_state_dict(torch.load(decoder_path))
def build_model(self):
# if self.phase == 'continue_train':
# self.model = util.load_model(self.parent_dir, self.valid_fold)
# else:
# self.model = model.Attention()
self.model = model.VGG()
self.model = self.model.to(self.device)
self.criterion = torch.nn.BCEWithLogitsLoss()
self.optimizer = optim.Adam(self.model.parameters(),
lr=self.lr,
betas=(0.9, 0.999),
weight_decay=1e-5)
def train(opt, images):
gennet_g = model.Generator()
gennet_f = model.Generator()
vgg = model.VGG()
discrinet_c = model.Discriminator(3)
discrinet_t = model.Discriminator(1)
g_optimizer = optimizer.Adam(params=gennet_g.parameters(), lr=opt.lr)
f_optimizer = optimizer.Adam(params=gennet_f.parameters(), lr=opt.lr)
c_optimizer = optimizer.Adam(params=discrinet_c.parameters(), lr=opt.lr)
t_optimizer = optimizer.Adam(params=discrinet_t.parameters(), lr=opt.lr)
optimizers = dict()
optimizers['g'] = g_optimizer
optimizers['f'] = f_optimizer
optimizers['c'] = c_optimizer
optimizers['t'] = t_optimizer
content_criterion = nn.L1Loss()
texture_criterion = model.GANLoss()
color_criterion = model.GANLoss()
tv_criterion = model.TVLoss(1.0)
num_samples = 0
for i in xrange(opt.epoches):
for j in xrange(num_samples / opt.batch_size):
batch = generate_batches(images, opt.batch_size)
loss = train_step(vgg=vgg,
gennet_g=gennet_g,
gennet_f=gennet_f,
discrinet_c=discrinet_c,
discrinet_t=discrinet_t,
content_criterion=content_criterion,
color_criterion=color_criterion,
texture_critetion=texture_criterion,
tv_criterion=tv_criterion,
x=batch['x'],
y=batch['y'],
optimizers=optimizers)
print("\nEpoch: %s\n" % i)
print("Total Loss: %s \n" % loss['total_loss'])
print("Color Loss: %s \n" % loss['color_loss'])
print("Content Loss: %s \n" % loss['content_loss'])
print("TV Loss: %s \n" % loss['tv_loss'])
print("Texture Loss: %s \n" % loss['texture_loss'])
def main():
config = Config()
modeler = model.VGG(config)
#read data to val("data/val")
val_reader = read_data.VGGReader(config)
modeler.inference()
accuracy = modeler.accuracy()
init = tf.global_variables_initializer()
sess_config = tf.ConfigProto()
sess_config.gpu_options.allow_growth = True
with tf.Session(config=sess_config) as sess:
sess.run(init)
#saver.restore(sess, config.param_dir+config.load_filename)
print 'restore params' + config.steps
#testing
confmat = np.zeros((20, 20))
count = 0
num_iter = config.test_size // config.batch_size
for i in range(num_iter):
with tf.device('/cpu:0'):
images_val, labels_val, filenames_val = val_reader.batch()
with tf.device("/gpu:0"):
predict = sess.run(modeler.pred,
feed_dict={
modeler.image_holder: images_val,
modeler.is_train: False
})
#print predict, labels_val
if labels_val[0][predict[0]] > 0:
count += 1
confmat[predict[0]][predict[0]] += 1
else:
for i in range(20):
if labels_val[0][i] > 0:
confmat[i][predict[0]] += 1
confmat = confmat * 20 / 5823
print 'AP: ', count * 1.0 / config.test_size
print 'confusion matrix: '
print confmat
def vgg_graph(sess, phs): VGG = model.VGG() Y_score = VGG.build(phs['batch_images'], N_CLASS, phs['is_training_ph']) Y_hat = tf.nn.softmax(Y_score) Y_pred = tf.argmax(Y_hat, 1) Y_label = tf.to_float(tf.one_hot(phs['batch_labels'], N_CLASS)) cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits = Y_score, labels = Y_label) loss_op = tf.reduce_mean(cross_entropy) correct_prediction = tf.equal(tf.argmax(Y_hat, 1), tf.argmax(Y_label, 1)) acc_op = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) update_op = tf.train.MomentumOptimizer(LR, MOMENTUM).minimize(loss_op, var_list=VGG.vars) return loss_op, acc_op, cross_entropy, Y_hat, update_op, Y_pred, VGG.vars
def main():
config = Config()
modeler = model.VGG(config)
modeler.inference()
# read data to test("data/train")
val_reader = read_data.VGGReader(config)
init = tf.global_variables_initializer()
sess_config = tf.ConfigProto()
sess_config.gpu_options.allow_growth = True
with tf.Session(config=sess_config) as sess:
sess.run(init)
print 'restore params' + config.test_num
print "finding thresholds..."
for step in range(config.max_step):
if step % (config.test_size // 10) == 0:
print 100 * step // config.test_size, "%"
with tf.device("/cpu:0"):
images_val, labels_val, filesname_val = val_reader.batch()
with tf.device("/gpu:0"):
_, probs = sess.run([modeler.pred, modeler.prob],
feed_dict={
modeler.image_holder: images_val,
modeler.is_train: False
})
thresholds, scores = find_threshold1(probs, labels_val)
i = np.argmax(scores)
best_threshold, best_score = thresholds[i], scores[i]
best_thresholds, best_scores = find_threshold2(probs,
labels_val,
num_iters=500,
seed=best_threshold)
with open(
"./thresholds/" + config.net_name + "-thresholds-" +
config.test_num + ".txt", 'w') as fr:
for i in range(len(best_thresholds)):
fr.write(str(best_thresholds[i]) + " ")
def run(
pixelcnn_ckpt,
vgg_ckpt=None,
adversarial_range=0.2,
train_dataset='mnist',
test_dataset='emnist',
img_size=28,
vgg_params={
'batch_size': 16,
'base_f': 16,
'n_layers': 9,
'dropout': 0.8,
'optimizer': 'adam',
'learnrate': 1e-4
},
exp_name='domain-prior',
exp_dir='~/experiments/domain-prior/',
cuda=True,
resume=False):
# Set up experiment directory
exp_name += '_%s-to-%s_vgg%i-%i_adv%.2f' % (
train_dataset, test_dataset, vgg_params['n_layers'],
vgg_params['base_f'], adversarial_range)
exp_dir = os.path.join(os.path.expanduser(exp_dir), exp_name)
if not os.path.isdir(exp_dir):
os.makedirs(exp_dir)
# Train a VGG classifier if not already done
if vgg_ckpt is None:
train_loader, val_loader, n_classes = data.loader(
train_dataset, vgg_params['batch_size'])
if not resume:
with open(os.path.join(exp_dir, 'vgg_params.json'), 'w') as f:
json.dump(vgg_params, f)
vgg = model.VGG(img_size, 1, vgg_params['base_f'],
vgg_params['n_layers'], n_classes,
vgg_params['dropout'])
else:
vgg = torch.load(os.path.join(exp_dir, 'best_checkpoint'))
train.fit(train_loader,
val_loader,
vgg,
exp_dir,
torch.nn.CrossEntropyLoss(),
vgg_params['optimizer'],
vgg_params['learnrate'],
cuda,
resume=resume)
else:
vgg = torch.load(vgg_ckpt)
pixelcnn = torch.load(pixelcnn_ckpt)
pixelcnn_params = os.path.join(os.path.dirname(pixelcnn_ckpt),
'params.json')
with open(pixelcnn_params, 'r') as f:
pixelcnn_params = json.load(f)
n_bins = pixelcnn_params['n_bins']
if cuda:
vgg = vgg.cuda()
pixelcnn = pixelcnn.cuda()
# Run the datasets through the networks and calculate 3 pixelcnn losses:
# 1. Average: mean across the image
# 2. High-pass filtered: weight by difference to upper- and left- neighbors
# 3. Saliency: weight by pixel saliency (vgg backprop-to-input)
_, loader, _ = data.loader(train_dataset, 1)
print('Calculating losses for ' + train_dataset)
dom_avg, dom_hp, dom_sw, dom_sal, dom_var = calc_losses(
vgg, pixelcnn, loader, n_bins, cuda)
print('Calculating losses for adversarial images')
adv_avg, adv_hp, adv_sw, adv_sal, adv_var = adversarial(
vgg, pixelcnn, loader, n_bins, adversarial_range, cuda)
_, loader, _ = data.loader(test_dataset, 1)
print('Calculating losses for ' + test_dataset)
ext_avg, ext_hp, ext_sw, ext_sal, ext_var = calc_losses(
vgg, pixelcnn, loader, n_bins, cuda)
# Loss histograms
n_bins = 100
all_losses = np.concatenate((dom_avg, adv_avg, ext_avg, dom_hp, adv_hp,
ext_hp, dom_sw, adv_sw, ext_sw))
edges = np.linspace(0, np.percentile(all_losses, 95), n_bins + 1)
# average loss
vis.histogram(dom_avg, edges, train_dataset + ' average loss', exp_dir)
vis.histogram(adv_avg, edges, 'adversarial average loss', exp_dir)
vis.histogram(ext_avg, edges, test_dataset + ' average loss', exp_dir)
# high-pass weighted loss
vis.histogram(dom_hp, edges, train_dataset + ' highpass loss', exp_dir)
vis.histogram(adv_hp, edges, 'adversarial highpass loss', exp_dir)
vis.histogram(ext_hp, edges, test_dataset + ' highpass loss', exp_dir)
# saliency weighted loss
vis.histogram(dom_sw, edges, train_dataset + ' saliency loss', exp_dir)
vis.histogram(adv_sw, edges, 'adversarial saliency loss', exp_dir)
vis.histogram(ext_sw, edges, test_dataset + ' saliency loss', exp_dir)
# loss variances
loss_variances = np.concatenate((dom_var, adv_var, ext_var))
edges = np.linspace(0, np.percentile(loss_variances, 95), n_bins + 1)
vis.histogram(dom_var, edges, train_dataset + ' loss variance', exp_dir)
vis.histogram(adv_var, edges, 'adversarial loss variance', exp_dir)
vis.histogram(ext_var, edges, test_dataset + ' loss variance', exp_dir)
# Calculate epistemic uncertainties for each dataset for each model
_, loader, _ = data.loader(train_dataset, 1)
dom_class_epi = epistemic(vgg, loader, cuda)
adv_class_epi = epistemic_adversarial(vgg, adversarial_range, loader, cuda)
_, loader, _ = data.loader(test_dataset, 1)
ext_class_epi = epistemic(vgg, loader, cuda)
# Classifier uncertainty histograms
n_bins = 100
all_class_epi = dom_class_epi + adv_class_epi + ext_class_epi
edges = np.linspace(0, np.percentile(all_class_epi, 95), n_bins + 1)
vis.histogram(dom_class_epi, edges,
train_dataset + ' classifier uncertainty', exp_dir)
vis.histogram(adv_class_epi, edges, 'adversarial classifier uncertainty',
exp_dir)
vis.histogram(ext_class_epi, edges,
test_dataset + ' classifier uncertainty', exp_dir)
# ROC curves
vis.roc(dom_avg, ext_avg, 'out-of-domain: average loss', exp_dir)
vis.roc(dom_hp, ext_hp, 'out-of-domain: high-pass filtered loss', exp_dir)
vis.roc(dom_sw, ext_sw, 'out-of-domain: saliency-weighted loss', exp_dir)
vis.roc(dom_class_epi, ext_class_epi,
'out-of-domain: epistemic uncertainty', exp_dir)
vis.roc(dom_avg, adv_avg, 'adversarial: average loss', exp_dir)
vis.roc(dom_hp, adv_hp, 'adversarial: high-pass filtered loss', exp_dir)
vis.roc(dom_sw, adv_sw, 'adversarial: saliency-weighted loss', exp_dir)
vis.roc(dom_class_epi, adv_class_epi, 'adversarial: epistemic uncertainty',
exp_dir)
#load data
train_data = datasets.TrainData_DIV2K
train_data_loader = torch.utils.data.DataLoader(dataset=train_data,
batch_size=BATCH_SIZE,
shuffle=True)
#load model
models = {}
models['generative'] = model.SRResNet().to(device)
models['upscale'] = {}
for scale in UPSCALE_FACTOR_LIST:
models['upscale'][scale] = model.SubPixelLayer(
models['generative'].output_channel, scale).to(device)
models['extra'] = model.ExtraLayer().SRResNet().to(device)
models['discriminator'] = model.VGG().to(device)
if PRETRAINED == True:
if CONTINUE == True:
for scale in UPSCALE_FACTOR_LIST:
utils.load_model(models, scale, SAVE_PATH, -1)
else:
for key in models.keys():
print(models[key])
else:
if CONTINUE == True:
for scale in UPSCALE_FACTOR_LIST:
utils.load_model(models, scale, SAVE_PATH,
EPOCH_START // len(UPSCALE_FACTOR_LIST))
else:
for scale in UPSCALE_FACTOR_LIST:
utils.load_model(models, scale, SAVE_PATH, -1)
# data
train_dataset = CustomDataset(resps['train'], images['train'])
test_dataset = CustomDataset(resps['test'], images['test'])
dataloader = DataLoader(train_dataset,
batch_size=params.trainBatch,
shuffle=True)
test_loader = DataLoader(test_dataset,
batch_size=params.testBatch,
shuffle=False)
# model
net_g = model.Generator()
net_g.to(device)
net_d = model.Discriminator()
net_d.to(device)
model1 = model.VGG()
model1.load_state_dict(torch.load('models/vgg16.pth'))
model1.to(device)
net_c = model.Comparator(model1, 22)
net_c.to(device)
for param in model1.parameters():
param.requires_grad = False
for param in net_c.parameters():
param.requires_grad = False
# optimizer
if params.optimizer_type == 'Adam':
optimizer_g = optim.Adam(net_g.parameters(),
lr=params.lr,
betas=(params.beta1, params.beta2))
optimizer_d = optim.Adam(net_d.parameters(),
def trainNet(
datapath='.',
nepochs=1,
learning_rate=0.001,
batch_size=64,
cuda=False,
savedir='./',
lossPlotName='loss.png',
num_workers=24,
):
'''
Our basic training file
'''
if "/" not in savedir[-1]:
savedir += "/"
if cuda:
print(f"Running on GPU")
device = torch.device('cuda')
net = model.VGG().to(device)
else:
print(f"Running on CPU")
device = torch.device('cpu')
net = model.VGG()
# Dataset
#imagenet = datasets.ImageNet('/research/imgnet/ILSVRC2013_DET_train/',
# split='train')
t = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
])
train_images = datasets.CIFAR10('.',
train=True,
download=True,
transform=t)
train_data = torch.utils.data.DataLoader(train_images,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
#criterion = nn.MSELoss()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=learning_rate)
epoch_loss_array = torch.zeros(nepochs)
print(f"Train data {len(train_images)}")
for epoch in range(nepochs):
net.train()
epoch_loss = 0
for i, (img, label) in enumerate(train_data):
optimizer.zero_grad()
out = net(img.to(device))
loss = criterion(out.to(device), label.to(device))
epoch_loss += loss.item()
loss.backward()
optimizer.step()
epoch_loss /= (i + 1)
print(f"Epoch {epoch} loss {epoch_loss}")
epoch_loss_array[epoch] = epoch_loss
utils.plot_loss(epoch_loss_array, savedir + lossPlotName)
net.load_state_dict(torch.load('final_model.pt'))
# Testing
with torch.no_grad():
net.eval()
test_loss = 0.
test_images = datasets.CIFAR10('.',
train=False,
download=True,
transform=t)
test_data = torch.utils.data.DataLoader(test_images,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
classes = [
'plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck'
]
corrects = np.zeros(len(classes), dtype=np.int)
totals = np.zeros(len(classes), dtype=np.int)
trues = np.zeros(len(test_images))
preds = np.zeros(len(test_images))
for i, (img, label) in enumerate(test_data):
optimizer.zero_grad()
out = net(img.to(device))
trues[i * batch_size:(i + 1) *
batch_size] = label.to('cpu').numpy()
preds[i * batch_size:(i + 1) *
batch_size] = [np.argmax(o) for o in out.to('cpu').numpy()]
for o, l in zip(out, label):
o = o.to('cpu').numpy()
l = l.to('cpu').numpy()
totals[l] += 1
if np.argmax(o) == l:
corrects[l] += 1
loss = criterion(out.to(device), label.to(device))
test_loss += loss.item()
if i == 0:
utils.plot_examples(img[:9].to('cpu'),
out[:9].to('cpu').numpy(), classes,
label[:9].to('cpu').numpy(),
savedir + "examples.png")
test_loss /= (i + 1)
print(f"Test loss {test_loss}")
utils.confusionMatrix(trues, preds, classes)
torch.save(net.state_dict(), "final_model.pt")
#print(f"Corrects {corrects}")
#print(f"Totals {totals}")
print("Accuracy")
print(f"Name\tCorrects\tAccuracy")
for i in range(len(classes)):
print(f"{classes[i]}\t{corrects[i]}\t\t{corrects[i]/totals[i]}")
print(30 * "-")
print(f"Sum\t{np.sum(corrects)}\t\t{np.sum(corrects)/np.sum(totals)}")
def train(opt, images):
gennet_g = model.Generator()
gennet_f = model.Generator()
vgg = model.VGG()
discrinet_c = model.Discriminator(3)
discrinet_t = model.Discriminator(1)
gray_layer = model.GrayLayer(opt.use_cuda)
gaussian = model.GaussianBlur()
if opt.use_cuda:
gennet_g = gennet_g.cuda()
gennet_f = gennet_f.cuda()
discrinet_c = discrinet_c.cuda()
discrinet_t = discrinet_t.cuda()
gray_layer = gray_layer.cuda()
gaussian = gaussian.cuda()
vgg = vgg.cuda()
g_optimizer = optimizer.Adam(params=gennet_g.parameters(), lr=opt.lr)
f_optimizer = optimizer.Adam(params=gennet_f.parameters(), lr=opt.lr)
c_optimizer = optimizer.Adam(params=discrinet_c.parameters(), lr=opt.lr)
t_optimizer = optimizer.Adam(params=discrinet_t.parameters(), lr=opt.lr)
optimizers = dict()
optimizers['g'] = g_optimizer
optimizers['f'] = f_optimizer
optimizers['c'] = c_optimizer
optimizers['t'] = t_optimizer
dataset = DPEDDataset(opt.data_dir)
dataloader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True)
num_samples = len(dataset)
dataiter = iter(dataloader)
for i in xrange(opt.epoches):
for j in xrange(num_samples / opt.batch_size):
batch_images, batch_target = dataiter.next()
batch_images = Variable(batch_images)
batch_target = Variable(batch_target)
if opt.use_cuda:
batch_target = batch_target.cuda()
batch_images = batch_images.cuda()
loss = train_step(use_cuda=opt.use_cuda,
vgg=vgg,
generator_f=gennet_f,
generator_g=gennet_g,
discriminator_c=discrinet_c,
discriminator_t=discrinet_t,
gray_layer=gray_layer,
blur_layer=gaussian,
input_image=batch_images,
target_image=batch_target,
optimizers=optimizers)
print("\nEpoch: %s Batch: %s" % (i, j))
print("Discriminator:")
print("Color Loss: %s " % loss['discrim_color_loss'])
print("Texture Loss: %s " % loss['discrim_texture_loss'])
print("Generator:")
print("Total Loss: %s " % loss['total_loss'])
print("Content Loss: %s " % loss['content_loss'])
print("Color Loss: %s " % loss['fake_color_loss'])
print("Texture Loss: %s " % loss['fake_texture_loss'])
print("TV Loss: %s " % loss['tv_loss'])
def main():
config = Config()
modeler = model.VGG(config)
#read data to val("data/val")
val_reader = read_data.VGGReader(config)
modeler.inference()
accuracy = modeler.accuracy()
init = tf.global_variables_initializer()
#saver = tf.train.Saver(max_to_keep=200)
sess_config = tf.ConfigProto()
sess_config.gpu_options.allow_growth = True
label_indexs = list()
test_labels = list()
with tf.Session(config=sess_config) as sess:
sess.run(init)
#saver.restore(sess, Config.vgg_path)
print 'restore params' + config.steps
#testing
count = 0
num_iter = config.test_size // config.batch_size
max_false_probs = [0.0] * config.type_size
max_true_probs = [0.0] * config.type_size
pre_prob = [
0.13, 0.13, 0.13, 0.13, 0.13, 0.13, 0.13, 0.6, 0.13, 0.13, 0.13,
0.13, 0.13, 0.13, 0.13, 0.13, 0.13
]
for i in range(num_iter):
label_index = list()
with tf.device('/cpu:0'):
images_val, labels_val, filenames_val = val_reader.batch()
with tf.device("/gpu:0"):
predict, prob = sess.run([modeler.pred, modeler.prob],
feed_dict={
modeler.image_holder: images_val,
modeler.is_train: False
})
if i < 20:
print predict, labels_val
print prob
if i % (num_iter // 10) == 0:
print 100 * i / num_iter, "%"
for j in range(config.type_size):
if (labels_val[0][j] == 1.0
and prob[0][j] > max_true_probs[j]):
max_true_probs[j] = prob[0][j]
if (labels_val[0][j] == 0.0
and prob[0][j] > max_false_probs[j]):
max_false_probs[j] = prob[0][j]
if prob[0][j] > pre_prob[j]:
label_index.append(j)
label_indexs.append(label_index)
is_correct = True
for k in range(len(label_index)):
if labels_val[0][label_index[k]] == 0.0:
is_correct = False
break
count_in = 0
count_in1 = 0
for k in range(len(labels_val[0])):
if labels_val[0][k] > 0.0:
count_in1 += 1
for n in range(len(label_index)):
if label_index[n] == k:
count_in += 1
break
if count_in != count_in1:
is_correct = False
s = filenames_val[0]
for n in range(17):
is_in = False
for m in range(len(label_index)):
if n == label_index[m]:
is_in = True
if is_in:
s += " 1.0"
else:
s += " 0.0"
test_labels.append(s)
if is_correct:
count += 1
with open("./labels/test_labels_pro.csv", 'w') as fr:
fcsv = csv.writer(fr)
for i in range(len(test_labels)):
fcsv.writerow([test_labels[i]])
'''
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
# load the image
dataset = datasets.ImageFolder(root='./images/', transform=transform)
# dataloader
dataloader = torch.utils.data.DataLoader(dataset=dataset,
shuffle=False,
batch_size=1)
# model
my_vgg = model.VGG()
# evaluation mode
my_vgg.eval()
# get the image
img, _ = next(iter(dataloader))
# likelihood distribution
distribution = my_vgg(img)
# should be 386 for the elephant
pred = distribution.argmax(dim=1)
print(pred)
# gradient of the output with respect to the model parameters
distribution[:, 386].backward()
# load image to torchTensor
style_img = ImageProcess.read_image(style_img_path).to(device)
print("style image shape:", style_img.shape)
content_img = ImageProcess.read_image(content_img_path).to(device)
print("content image shape:", content_img.shape)
# paint images
ImageProcess.paint_image(style_img, "style_image")
ImageProcess.paint_image(content_img, "content_image")
# build feature model
vgg16 = tv_models.vgg16(pretrained=True)
# convert into self feature extraction model
vgg16 = model.VGG(
vgg16.features[:23]).to(device).eval() # notify all layers in eval mode
if debug:
print(vgg16)
# get features
style_features = vgg16(style_img)
content_features = vgg16(content_img)
if debug:
print("style feature:")
print([i.shape for i in style_features])
print("content feature:")
print([i.shape for i in content_features])
# calculate Gram matrix according to the extracted feature
style_gram = [gram_matrix(i) for i in style_features]
if debug:
# parameters
batchSize = 128
lr = 1e-4
model_path = 'models/vgg16.pth'
data_dir = 'data/cifar10/'
epochs = [80, 20]
if not os.path.exists(data_dir):
os.makedirs(data_dir)
if not os.path.exists('models'):
os.makedirs('models')
device = torch.device('cuda')
# model and loss
net = model.VGG()
loss_f = nn.CrossEntropyLoss()
net.to(device)
loss_f.to(device)
# data
transform_train = tfs.Compose([
tfs.RandomCrop(32, padding=4),
tfs.RandomHorizontalFlip(),
tfs.ToTensor()
])
data = dst.CIFAR10(data_dir,
download=True,
train=True,
transform=transform_train)
data_test = dst.CIFAR10(data_dir,
