def test(threshold, model_name='model'):
print("Loading data...")
test_data = utils.load_test_data(test_file, me, ms, mr)
test_example_num = len(test_data["input_ids"])
print("Done.")
with tf.Session() as sess:
model = Model(
max_entity_num=me,
max_sentence_num=ms,
max_relation_num=mr,
max_seq_length=FLAGS.max_seq_length,
class_num=len(rel2id),
entity_types=len(ner2id),
bert_config=bert_config,
hidden_size=FLAGS.hidden_size,
hidden_layers=FLAGS.hidden_layers,
attention_heads=FLAGS.attention_heads,
intermediate_size=FLAGS.intermediate_size,
hidden_dropout_prob=bert_config.hidden_dropout_prob,
attention_probs_dropout_prob=bert_config.
attention_probs_dropout_prob,
graph_hidden_dropout_prob=FLAGS.graph_hidden_dropout_prob,
graph_attention_probs_dropout_prob=FLAGS.
graph_attention_probs_dropout_prob,
)
saver = tf.train.Saver()
checkpoint = os.path.join(checkpoint_dir, model_name)
saver.restore(sess, checkpoint)
test_logits = []
test_index = []
for batch_index in tqdm(
utils.batch_iter(test_example_num, FLAGS.batch_size, False)):
feed_dict = {
model.input_ids: test_data["input_ids"][batch_index],
model.input_mask: test_data["input_mask"][batch_index],
model.segment_ids: test_data["segment_ids"][batch_index],
model.entity_mask: test_data["entity_mask"][batch_index],
model.entity_types: test_data["entity_types"][batch_index],
model.sentence_mask: test_data["sentence_mask"][batch_index],
model.attention_mask: test_data["attention_mask"][batch_index],
model.relation_mask: test_data["relation_mask"][batch_index],
model.head_mask: test_data["head_mask"][batch_index],
model.tail_mask: test_data["tail_mask"][batch_index],
model.is_training: False
}
logit = sess.run(model.sigmoid, feed_dict)
test_logits.append(logit)
test_index += batch_index
test_logits = np.concatenate(test_logits, axis=0)
utils.inference(test_logits, test_data, test_index, threshold)
def get_actions(ball_location, last_ball_location, left_location, left_model, right_location, right_model):
left_action = get_random_action(ALL_ACTIONS)
right_action = get_random_action(ALL_ACTIONS)
if last_ball_location is None:
last_ball_location = ball_location
if ball_location is not None:
if left_location is not None:
# here we are flipping X
left_ball_loc = [ball_location[0], GAME_WIDTH - ball_location[1]]
left_last_ball_loc = [last_ball_location[0], GAME_WIDTH - last_ball_location[1]]
left_action = inference(left_ball_loc, left_last_ball_loc, left_location, right_location, left_model)
if right_location is not None:
right_action = inference(ball_location, last_ball_location, right_location, left_location, right_model)
else:
left_action = [0, 0]
right_action = [0, 0]
return left_action, right_action
def car_recognize():
try:
data = json.loads(request.data)
preds = utils.inference(model, data['content'])
response = {'probabilities': preds}
return jsonify(response)
except BaseException as err:
print(err)
raise (err)
def single_demo(self):
self.net.eval()
current_dir = os.path.dirname(os.path.realpath(__file__))
image_list = os.listdir(self.args.image_path)
image_list.sort()
start_time = time.time()
inference(self.input_transform,
self.net,
image_list,
self.args.image_path,
save_dir=self.args.output_bin)
duration = time.time() - start_time
print('{}s used to make predictions.\n'.format(duration))
conf_m, IOU = calculate_iou(self.args.nb_classes, self.args.output_bin,
self.args.label_path, self.args.image_path,
image_list)
print('IOU: ')
print(IOU)
print('meanIOU: %f' % np.mean(IOU))
print('pixel acc: %f' % (np.sum(np.diag(conf_m)) / np.sum(conf_m)))
def reconstruction_creation(index, dataset):
'''create reconstructed image and calculate loss between original and reconstructed image'''
image, name = dataset[index]
reconstruct_image = inference(device, image.unsqueeze(0), model) # create reconstructed image using model
recon_detach = reconstruct_image.detach()
recon_cpu = recon_detach.cpu() # send to cpu
recon_numpy = recon_cpu.numpy() # convert image to numpy array for easier calculations
recon_numpy = np.squeeze(recon_numpy, axis=0)
criterion = nn.MSELoss()
loss = str(criterion(image.unsqueeze(0).cpu(), reconstruct_image.cpu()).item()) # calculate loss
return recon_numpy, loss
def main():
fmoment = int(time.time())
args = parse_args()
norm = args.norm
backbone = args.backbone
pretrained = args.pretrained
lossfunc = args.loss
size = args.size
pk = args.pk
nk = args.nk
n_epoch = args.n_epoch
gpu = args.gpu
test_every = args.test_every
ckpt = args.ckpt
print(
'norm=%s backbone=%s pretrained=%s lossfunc=%s size=%s pk=%d nk=%d epoch=%d gpu=%d test_every=%d ckpt=%s'
% (norm, backbone, pretrained, lossfunc, size, pk, nk, n_epoch, gpu,
test_every, ckpt))
if backbone == 'resnet18':
model = resnet18.resnet18(norm=norm).cuda(device=gpu)
if pretrained == 'pretrained':
ckpt_dict = torch.load('resnet18-pretrained.pth')
model_dict = model.state_dict()
ckpt_dict = {k: v for k, v in ckpt_dict.items() if k in model_dict}
model_dict.update(ckpt_dict)
model.load_state_dict(model_dict)
if lossfunc == 'CE':
criterion = nn.CrossEntropyLoss().cuda(device=gpu)
elif lossfunc == 'Focal':
criterion = FocalLoss(class_num=2, gpu=gpu).cuda(device=gpu)
for m in model.modules():
if isinstance(m, nn.Linear):
nn.init.constant_(m.bias, -math.log(99))
elif lossfunc == 'BCE':
criterion = BCE(class_num=2, gpu=gpu).cuda(device=gpu)
optimizer = optim.Adam(model.parameters(), lr=1e-4, weight_decay=1e-4)
cudnn.benchmark = True
train_trans = transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomVerticalFlip(p=0.5),
transforms.ToTensor(),
transforms.Normalize(mean=[0.2005, 0.1490, 0.1486],
std=[0.1445, 0.1511, 0.0967])
])
infer_trans = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.2005, 0.1490, 0.1486],
std=[0.1445, 0.1511, 0.0967])
])
train_dset = XDataset('train-%s.lib' % size,
train_trans=train_trans,
infer_trans=infer_trans)
train_loader = torch.utils.data.DataLoader(train_dset,
batch_size=64,
shuffle=False,
pin_memory=True)
test_dset = XDataset('test-%s.lib' % size,
train_trans=train_trans,
infer_trans=infer_trans)
test_loader = torch.utils.data.DataLoader(test_dset,
batch_size=128,
shuffle=False,
pin_memory=True)
if ckpt != 'none':
checkpoint = torch.load(ckpt)
start = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
best_f1 = checkpoint['best_f1']
optimizer.load_state_dict(checkpoint['optimizer'])
if not os.path.exists(
'logs/Training_%s_%s_%s_%s_%s_%d_%d_%d.csv' %
(norm, backbone, pretrained, lossfunc, size, pk, nk, fmoment)):
fconv = open(
'logs/Training_%s_%s_%s_%s_%s_%d_%d_%d.csv' %
(norm, backbone, pretrained, lossfunc, size, pk, nk, fmoment),
'w')
fconv.write('time,epoch,loss,error\n')
fconv.write('%d,0,0,0\n' % fmoment)
fconv.close()
if not os.path.exists(
'logs/Testing_%s_%s_%s_%s_%s_%d_%d_%d.csv' %
(norm, backbone, pretrained, lossfunc, size, pk, nk, fmoment)):
fconv = open(
'logs/Testing_%s_%s_%s_%s_%s_%d_%d_%d.csv' %
(norm, backbone, pretrained, lossfunc, size, pk, nk, fmoment),
'w')
fconv.write('time,epoch,loss,error,tp,tn,fp,fn,f1,S\n')
fconv.write('%d,0,0,0\n' % fmoment)
fconv.close()
else:
start = 0
best_f1 = 0
fconv = open(
'logs/Training_%s_%s_%s_%s_%s_%d_%d_%d.csv' %
(norm, backbone, pretrained, lossfunc, size, pk, nk, fmoment), 'w')
fconv.write('time,epoch,loss,error\n')
fconv.write('%d,0,0,0\n' % fmoment)
fconv.close()
fconv = open(
'logs/Testing_%s_%s_%s_%s_%s_%d_%d_%d.csv' %
(norm, backbone, pretrained, lossfunc, size, pk, nk, fmoment), 'w')
fconv.write('time,epoch,loss,error,tp,tn,fp,fn,f1,S\n')
fconv.write('%d,0,0,0\n' % fmoment)
fconv.close()
for epoch in range(start, n_epoch):
train_dset.setmode(1)
_, probs = inference(epoch, train_loader, model, criterion, gpu)
# torch.save(probs,'probs/train-%d.pth'%(epoch+1))
probs1 = probs[:train_dset.plen]
probs0 = probs[train_dset.plen:]
topk1 = np.array(
group_argtopk(np.array(train_dset.slideIDX[:train_dset.plen]),
probs1, pk))
topk0 = np.array(
group_argtopk(np.array(train_dset.slideIDX[train_dset.plen:]),
probs0, nk)) + train_dset.plen
topk = np.append(topk1, topk0).tolist()
# torch.save(topk,'topk/train-%d.pth'%(epoch+1))
# maxs = group_max(np.array(train_dset.slideIDX), probs, len(train_dset.targets))
# torch.save(maxs, 'maxs/%d.pth'%(epoch+1))
sf(topk)
train_dset.maketraindata(topk)
train_dset.setmode(2)
loss, err = train(train_loader, model, criterion, optimizer, gpu)
moment = time.time()
writecsv([moment, epoch + 1, loss, err],
'logs/Training_%s_%s_%s_%s_%s_%d_%d_%d.csv' %
(norm, backbone, pretrained, lossfunc, size, pk, nk, fmoment))
print('Training epoch=%d, loss=%.5f, error=%.5f' %
(epoch + 1, loss, err))
if (epoch + 1) % test_every == 0:
test_dset.setmode(1)
loss, probs = inference(epoch, test_loader, model, criterion, gpu)
# torch.save(probs,'probs/test-%d.pth'%(epoch+1))
# topk = group_argtopk(np.array(test_dset.slideIDX), probs, pk)
# torch.save(topk, 'topk/test-%d.pth'%(epoch+1))
maxs = group_max(
np.array(test_dset.slideIDX), probs,
len(test_dset.targets)) #è¿åæ¯ä¸ªåççæ大æ?ç
# torch.save(maxs, 'maxs/test-%d.pth'%(epoch+1))
pred = [1 if x >= 0.5 else 0 for x in maxs]
tp, tn, fp, fn = tfpn(pred, test_dset.targets)
err = calc_err(pred, test_dset.targets)
S, f1 = score(tp, tn, fp, fn)
moment = time.time()
writecsv(
[moment, epoch + 1, loss, err, tp, tn, fp, fn, f1, S],
'logs/Testing_%s_%s_%s_%s_%s_%d_%d_%d.csv' %
(norm, backbone, pretrained, lossfunc, size, pk, nk, fmoment))
print('Testing epoch=%d, loss=%.5f, error=%.5f' %
(epoch + 1, loss, err))
#Save best model
if f1 >= best_f1:
best_f1 = f1
obj = {
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_f1': best_f1,
'optimizer': optimizer.state_dict()
}
torch.save(
obj, 'ckpt_%s_%s_%s_%s_%s_%d_%d_%d.pth' %
(norm, backbone, pretrained, lossfunc, size, pk, nk,
fmoment))
def train_srgans(train_loader, val_loader, generator, discriminator, device,
args):
# Loss Function #
criterion_Perceptual = PerceptualLoss(args.model).to(device)
# For SRGAN #
criterion_MSE = nn.MSELoss()
criterion_TV = TVLoss()
# For ESRGAN #
criterion_BCE = nn.BCEWithLogitsLoss()
criterion_Content = nn.L1Loss()
# Optimizers #
D_optim = torch.optim.Adam(discriminator.parameters(),
lr=args.lr,
betas=(0.9, 0.999))
G_optim = torch.optim.Adam(generator.parameters(),
lr=args.lr,
betas=(0.9, 0.999))
D_optim_scheduler = get_lr_scheduler(D_optim, args)
G_optim_scheduler = get_lr_scheduler(G_optim, args)
# Lists #
D_losses, G_losses = list(), list()
# Train #
print("Training {} started with total epoch of {}.".format(
str(args.model).upper(), args.num_epochs))
for epoch in range(args.num_epochs):
for i, (high, low) in enumerate(train_loader):
discriminator.train()
if args.model == "srgan":
generator.train()
# Data Preparation #
high = high.to(device)
low = low.to(device)
# Initialize Optimizers #
D_optim.zero_grad()
G_optim.zero_grad()
#######################
# Train Discriminator #
#######################
set_requires_grad(discriminator, requires_grad=True)
# Generate Fake HR Images #
fake_high = generator(low)
if args.model == 'srgan':
# Forward Data #
prob_real = discriminator(high)
prob_fake = discriminator(fake_high.detach())
# Calculate Total Discriminator Loss #
D_loss = 1 - prob_real.mean() + prob_fake.mean()
elif args.model == 'esrgan':
# Forward Data #
prob_real = discriminator(high)
prob_fake = discriminator(fake_high.detach())
# Relativistic Discriminator #
diff_r2f = prob_real - prob_fake.mean()
diff_f2r = prob_fake - prob_real.mean()
# Labels #
real_labels = torch.ones(diff_r2f.size()).to(device)
fake_labels = torch.zeros(diff_f2r.size()).to(device)
# Adversarial Loss #
D_loss_real = criterion_BCE(diff_r2f, real_labels)
D_loss_fake = criterion_BCE(diff_f2r, fake_labels)
# Calculate Total Discriminator Loss #
D_loss = (D_loss_real + D_loss_fake).mean()
# Back Propagation and Update #
D_loss.backward()
D_optim.step()
###################
# Train Generator #
###################
set_requires_grad(discriminator, requires_grad=False)
if args.model == 'srgan':
# Adversarial Loss #
prob_fake = discriminator(fake_high).mean()
G_loss_adversarial = torch.mean(1 - prob_fake)
G_loss_mse = criterion_MSE(fake_high, high)
# Perceptual Loss #
lambda_perceptual = 6e-3
G_loss_perceptual = criterion_Perceptual(fake_high, high)
# Total Variation Loss #
G_loss_tv = criterion_TV(fake_high)
# Calculate Total Generator Loss #
G_loss = args.lambda_adversarial * G_loss_adversarial + G_loss_mse + lambda_perceptual * G_loss_perceptual + args.lambda_tv * G_loss_tv
elif args.model == 'esrgan':
# Forward Data #
prob_real = discriminator(high)
prob_fake = discriminator(fake_high)
# Relativistic Discriminator #
diff_r2f = prob_real - prob_fake.mean()
diff_f2r = prob_fake - prob_real.mean()
# Labels #
real_labels = torch.ones(diff_r2f.size()).to(device)
fake_labels = torch.zeros(diff_f2r.size()).to(device)
# Adversarial Loss #
G_loss_bce_real = criterion_BCE(diff_f2r, real_labels)
G_loss_bce_fake = criterion_BCE(diff_r2f, fake_labels)
G_loss_bce = (G_loss_bce_real + G_loss_bce_fake).mean()
# Perceptual Loss #
lambda_perceptual = 1e-2
G_loss_perceptual = criterion_Perceptual(fake_high, high)
# Content Loss #
G_loss_content = criterion_Content(fake_high, high)
# Calculate Total Generator Loss #
G_loss = args.lambda_bce * G_loss_bce + lambda_perceptual * G_loss_perceptual + args.lambda_content * G_loss_content
# Back Propagation and Update #
G_loss.backward()
G_optim.step()
# Add items to Lists #
D_losses.append(D_loss.item())
G_losses.append(G_loss.item())
####################
# Print Statistics #
####################
if (i + 1) % args.print_every == 0:
print(
"{} | Epoch [{}/{}] | Iterations [{}/{}] | D Loss {:.4f} | G Loss {:.4f}"
.format(
str(args.model).upper(), epoch + 1, args.num_epochs,
i + 1, len(train_loader), np.average(D_losses),
np.average(G_losses)))
# Save Sample Images #
sample_images(val_loader, args.batch_size, args.scale_factor,
generator, epoch, args.samples_path, device)
# Adjust Learning Rate #
D_optim_scheduler.step()
G_optim_scheduler.step()
# Save Model Weights and Inference #
if (epoch + 1) % args.save_every == 0:
torch.save(
generator.state_dict(),
os.path.join(
args.weights_path,
'{}_Epoch_{}.pkl'.format(generator.__class__.__name__,
epoch + 1)))
inference(val_loader, generator, args.upscale_factor, epoch,
args.inference_path, device)
print('Finished Training')
torch.save(net.state_dict(), 'model/poisoned_nontarget_pytorch.pth')
# %%
# train clean
x_train_clean, y_train_clean = x_train.copy(), y_train.copy()
y_train_clean = np.argmax(y_train_clean, 1)
trainset_clean = torch.utils.data.TensorDataset(
torch.tensor(x_train_clean),
torch.tensor(y_train_clean))
trainloader_clean = torch.utils.data.DataLoader(trainset_clean, batch_size=8,
shuffle=False, num_workers=2)
print('\ntrainloader_clean')
preds_train_clean = inference(trainloader_clean, net, device)
MyConfMat(y_train_clean.tolist(), preds_train_clean)
# train poison
trainset_poison = torch.utils.data.TensorDataset(
torch.tensor(x_train_poison),
torch.tensor(y_train_clean))
trainloader_poison = torch.utils.data.DataLoader(trainset_poison, batch_size=8,
shuffle=False, num_workers=2)
print('\ntrainloader_poison')
preds_train_poison = inference(trainloader_poison, net, device)
MyConfMat(y_train_clean.tolist(), preds_train_poison)
# train all poison
x_train_allpoison, y_train_allpoison = x_train.copy(), y_train.copy()
x_train_allpoison, y_train_allpoison = poison(x_train_allpoison,
# pickle_path
pickle_path = osp.join('pickles', 'latest.pickle')
# discretized state value
min_state_val = 0
max_state_val = 40
# random seed
seed = 42
# learning mode "Q-learning", "SARSA" or "Expected-SARSA"
learning_mode = "Q-learning"
# save path
save_path = None # 'results'
if save_path is not None and not osp.exists(save_path):
os.makedirs(save_path)
if __name__ == "__main__":
score = inference(pickle_path=pickle_path,
env_name=env_name,
epsilon=epsilon,
min_state_val=min_state_val,
max_state_val=max_state_val,
seed=seed,
save_path=save_path,
learning_mode=learning_mode)
print("Score: {} (Model: {}; Env: {}) ".format(score, pickle_path,
env_name))
def main():
args = Args()
logger = get_logger('main')
EXP_NAME = 'multihead 4 layer with mask'
assert EXP_NAME is not None, '이거슨 무슨 실험이냐!!'
print(EXP_NAME)
kaggle = KaggleData(args.train_path, args.test_path)
kaggle.build_field(args.max_len, include_lengths=args.lengths)
kaggle.build_dataset(split_ratio=0.9,
stratified=False,
strata_field='target')
kaggle.build_vocab('question',
args.max_vocab,
min_freq=args.min_freq,
pretrained_vectors=args.embedding,
cache=args.cache)
kaggle.build_iterator(batch_sizes=[args.batch_size] * 3,
device=args.device)
kaggle.summary()
logger.info('building model...')
model = build_model(kaggle, args)
#TODO: hyperparam pos_wieght is to be tuned
criterion = nn.BCEWithLogitsLoss(
reduction='sum',
pos_weight=torch.tensor([args.pos_weight], device=args.device))
optimizer, scheduler = build_optimizer_scheduler(
'Adam',
lr=0.001,
parameters=model.parameters(),
factor=0.5,
patience=args.scheduler_patience,
verbose=True)
logger.info('start training...')
early_stopping = EarlyStoppingCriterion(patience=args.early_stop_patience)
for epoch in range(args.epoch):
loss = run_epoch(model, kaggle.train_iter, criterion, optimizer)
f1_score, accuracy = evaluate(model,
kaggle.valid_iter,
threshold=args.threshold,
vocab=kaggle.vocab,
verbose=False)
scheduler.step(f1_score)
print('loss at epoch {}: {:.5}'.format(epoch + 1, loss))
print('f1 score / accuracy on valid: {:.4} / {:.4}'.format(
f1_score, accuracy))
if early_stopping(epoch, f1_score):
if early_stopping.is_improved:
logger.info('best model achieved in this epoch')
# TODO: path name!!
torch.save(model.state_dict(), 'best_model.pt')
else:
logger.info('early stopping...')
break
print()
logger.info('best model is from epoch {} (f1: {:.4})'.format(
early_stopping.best_epoch, early_stopping.best_score))
model.load_state_dict(torch.load('best_model.pt'))
logger.info('selecting threshold...')
best = 0
best_threshold = 0
for th in np.arange(0.2, 0.6, 0.05):
# FIXME: verbose
f1_score, accuracy = evaluate(model,
kaggle.valid_iter,
threshold=float(th),
vocab=kaggle.vocab,
verbose=False)
if f1_score > best:
best = f1_score
best_threshold = th
print('best f1_score with threshold {}: {:.4} '.format(
best_threshold, float(best)))
pred_total, qid_total = inference(model, kaggle.test_iterator,
best_threshold)
write_to_csv(pred_total, qid_total, path='submission.csv')
model.train()
img1, anno1, img2, anno2 = img1.to('cuda'), anno1.to('cuda'), img2.to(
'cuda'), anno2.to('cuda')
loss = model.calc_loss(img1, anno1, img2, anno2, K,
utils.get_max_label(video))
optim.zero_grad()
loss.backward()
optim.step()
print(
'{}/100000. {:.02f} seconds passed. current loss {:.05f}, lr {}, video {}'
.format(ix + 1,
time.time() - st, loss.data, lr, video),
flush=True)
if ix % ckpt_iter == 0:
#checkpoint
utils.save_to_checkpoint(model, ix, DEBUG)
if (ix + 1) % lr_update_iter == 0:
#adjust learning rate
lr_before = lr
lr = lr * lr_factor
print('adjust learning rate .. form {} to {}'.format(lr_before, lr))
optim = factory.make_optim(model, lr, momentum, weight_decay)
if (DEBUG and ix % 50 == 0) or ix % 500 == 0 or (ix < 500
and ix % 100 == 0):
model.eval()
print('inference started.')
utils.inference(model, K, ix, DEBUG)
print('inference finished.')
# ---------------------------------------------------------------------
# Inference
# ---------------------------------------------------------------------
if args.inference:
num_correct = [0]
def collector(outputs, targets):
pred = outputs.cpu().max(1)[1]
num_correct[0] += pred.eq(targets.cpu().view_as(pred)).sum().item()
inference(model,
test_loader,
criterion,
collector,
args)
num_correct = num_correct[0]
test_accuracy = 100. * (num_correct / len(test_loader.dataset))
print('Test set: Accuracy: {}/{} ({:.0f}%)\n'.format(
num_correct,
len(test_loader.dataset),
test_accuracy
))
# ---------------------------------------------------------------------
# Model saving
# ---------------------------------------------------------------------
# -------------------------------------------------------------------------
# Inference
# -------------------------------------------------------------------------
if args.inference:
loss = F.binary_cross_entropy_with_logits
preds = []
def collector(outputs, targets):
preds.append(outputs.detach().cpu().numpy())
inference(model,
seq_dataloader,
loss,
collector,
args)
# ---------------------------------------------------------------------
# Validation
# ---------------------------------------------------------------------
if args.validate:
preds = np.vstack(preds)
assert isinstance(preds, np.ndarray)
assert preds.shape[0] == len(X_train)
assert preds.shape[1] == n_toks
X_valid = np.load('%s_valid.npy' % args.cache_path, allow_pickle=True)
print(model)
# Quit here if dry run
if args.dry:
exit(0)
# Training
if args.training:
utils.train(model, trainloader, optimizer, loss_func, args)
# Inference
if args.inference:
num_correct = [0]
def collector(outputs, targets):
pred = outputs.cpu().max(1)[1]
num_correct[0] += pred.eq(targets.cpu().view_as(pred)).sum().item()
utils.inference(model, testloader, loss_func, collector, args)
num_correct = num_correct[0]
test_accuracy = 100. * (num_correct / len(testloader.dataset))
print('Test set: Accuracy: {}/{} ({:.0f}%)\n'.format(
num_correct, len(testloader.dataset), test_accuracy))
# Save model
if args.save_model:
utils.save_model(model, args.model_filename)
print('flattened input size:', input_size)
# instantiate and load model
if style == 'conv':
model = ConvAutoencoder()
elif style == 'dense':
model = DenseAutoencoder(input_size, feature_size)
# if there are multiple GPUs, split the batch to different GPUs
if torch.cuda.device_count() > 1:
print("Using " + str(torch.cuda.device_count()) + " GPUs...")
model = nn.DataParallel(model)
model.load_state_dict(torch.load(model_file))
# get the reconstructed image
reconstruct_image = inference(device, image.unsqueeze(0), model)
print('shape of reconstructed image:', reconstruct_image.shape)
#print(reconstruct_image)
# measure the loss between the 2 images
criterion = nn.MSELoss()
loss = criterion(image.unsqueeze(0).cpu(), reconstruct_image.cpu())
print('loss between before and after:', loss)
# plot images before and after reconstruction
fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(14, 7))
ax1.imshow(np.transpose(image.numpy(), (1, 2, 0)))
ax1.set_title('Original Image')
ax2.imshow(
np.transpose(reconstruct_image.squeeze().detach().cpu().numpy(),
(1, 2, 0)))
image_dir=hp.image_dir,
label_dir=hp.label_dir,
subset='valid')
for q_name, attribute in q_valid.get_queries().items():
start = time.time()
bbox, class_idx = attribute[0], attribute[1]
# create image tensor
query_img = image_preprocessing(hp.image_dir + q_name)
query_tensor = torch.FloatTensor(
np.transpose(np.expand_dims(query_img, axis=0), axes=[0, 3, 1, 2]))
# get embedding vector
if use_gpu:
query_tensor = query_tensor.cuda()
cs_func = cs_func.cuda()
query_embedding = inference(model, query_tensor)
similarity = cs_func(query_embedding, db_embeddings).topk(
len(q_valid.get_groundtruth()[class_idx]))
prediction = [maps[idx] for idx in similarity[1].cpu().numpy()]
end = time.time()
score = similarity[0].cpu().numpy()
AP = calculate_AP(prediction=prediction,
score=score,
groundtruth=q_valid.get_groundtruth()[class_idx])
mAP.append(AP)
time_running.append(end - start)
# visualization
# visualize(q_name, prediction, score)
# break
def infer(data_path, **kwargs):
return inference(model, data_path)
def train_srcnns(train_loader, val_loader, model, device, args):
# Loss Function #
criterion = nn.L1Loss()
# Optimizers #
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
betas=(0.5, 0.999))
optimizer_scheduler = get_lr_scheduler(optimizer=optimizer, args=args)
# Lists #
losses = list()
# Train #
print("Training {} started with total epoch of {}.".format(
str(args.model).upper(), args.num_epochs))
for epoch in range(args.num_epochs):
for i, (high, low) in enumerate(train_loader):
# Data Preparation #
high = high.to(device)
low = low.to(device)
# Forward Data #
generated = model(low)
# Calculate Loss #
loss = criterion(generated, high)
# Initialize Optimizer #
optimizer.zero_grad()
# Back Propagation and Update #
loss.backward()
optimizer.step()
# Add items to Lists #
losses.append(loss.item())
# Print Statistics #
if (i + 1) % args.print_every == 0:
print("{} | Epoch [{}/{}] | Iterations [{}/{}] | Loss {:.4f}".
format(
str(args.model).upper(), epoch + 1, args.num_epochs,
i + 1, len(train_loader), np.average(losses)))
# Save Sample Images #
sample_images(val_loader, args.batch_size, args.upscale_factor,
model, epoch, args.samples_path, device)
# Adjust Learning Rate #
optimizer_scheduler.step()
# Save Model Weights and Inference #
if (epoch + 1) % args.save_every == 0:
torch.save(
model.state_dict(),
os.path.join(
args.weights_path,
'{}_Epoch_{}.pkl'.format(model.__class__.__name__,
epoch + 1)))
inference(val_loader, model, args.upscale_factor, epoch,
args.inference_path, device)
def main():
# Configurations
lr = 0.00000001 # learning rate
batch_size = 64 # batch_size
last_epoch = 1 # the last training epoch. (defulat: 1)
max_epoch = 553 # maximum epoch for the training.
num_boxes = 2 # the number of boxes for each grid in Yolo v1.
num_classes = 20 # the number of classes in Pascal VOC Detection.
grid_size = 7 # 3x224x224 image is reduced to (5*num_boxes+num_classes)x7x7.
lambda_coord = 7 # weight for coordinate regression loss.
lambda_noobj = 0.5 # weight for no-objectness confidence loss.
""" dataset load """
train_dset = VOCDetection(root=data_root, split='train')
train_dloader = DataLoader(train_dset,
batch_size=batch_size,
shuffle=True,
drop_last=True,
num_workers=8)
#drop_last 마지막 애매하게 남는 데이터들은 버림
test_dset = VOCDetection(root=data_root, split='test')
test_dloader = DataLoader(test_dset,
batch_size=batch_size,
shuffle=False,
drop_last=False,
num_workers=8)
""" model load """
model = Yolo(grid_size, num_boxes, num_classes)
#model = nn.DataParallel(model, device_ids = [5,6,7])
model = model.to(DEVICE)
#pretrained_weights = torch.load(pretrained_backbone_path)
#model.load_state_dict(pretrained_weights)
""" optimizer / loss """
model.features.requires_grad_(False)
model_params = [v for v in model.parameters() if v.requires_grad is True]
optimizer = optim.Adam(model_params, lr=lr, betas=[0.9, 0.999])
# Load the last checkpoint if exits.
ckpt_path = os.path.join(ckpt_dir, 'last_best.pth')
if os.path.exists(ckpt_path):
ckpt = torch.load(ckpt_path, map_location='cuda:3')
model.load_state_dict(ckpt['model'])
optimizer.load_state_dict(ckpt['optimizer'])
last_epoch = ckpt['epoch'] + 1
print('Last checkpoint is loaded. start_epoch:', last_epoch)
else:
print('No checkpoint is found.')
Yolov1Loss = Loss(7, 2, 20)
#ckpt_path = os.path.join(ckpt_dir, 'last_best.pth')
""" training """
# Training & Testing.
model = model.to(DEVICE)
best_loss = 1
for epoch in range(1, max_epoch):
step = 0
# Learning rate scheduling
if epoch in [50, 150, 550, 600]:
lr *= 0.1
for param_group in optimizer.param_groups:
param_group['lr'] = lr
if epoch < last_epoch:
continue
model.train()
for x, y in train_dloader:
step += 1
imgs = Variable(x)
gt_outs = Variable(y)
imgs, gt_outs = imgs.to(DEVICE), gt_outs.to(DEVICE)
model_outs = model(imgs)
loss = Yolov1Loss(model_outs, gt_outs)
if loss < best_loss:
best_loss = loss
ckpt = {
'model': model.state_dict(),
'optimizer': optimizer.state_dict(),
'epoch': epoch
}
torch.save(ckpt, ckpt_path)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('step:{}/{} | loss:{:.8f}'.format(step, len(train_dloader),
loss.item()))
model.eval()
val_loss = 0.0
with torch.no_grad():
for x, y in test_dloader:
imgs = Variable(x)
gt_outs = Variable(y)
imgs, gt_outs = imgs.to(DEVICE), gt_outs.to(DEVICE)
model_outs = model(imgs)
loss = Yolov1Loss(model_outs, gt_outs)
loss_iter = loss.item()
print('Epoch [%d/%d], Val Loss: %.4f' %
(epoch, max_epoch, loss_iter))
ckpt = {
'model': model.state_dict(),
'optimizer': optimizer.state_dict(),
'epoch': epoch
}
torch.save(ckpt, ckpt_path)
''' test '''
test_image_dir = os.path.join(root, 'test_images')
image_path_list = [
os.path.join(test_image_dir, path)
for path in os.listdir(test_image_dir)
]
for image_path in image_path_list:
inference(model, image_path)
import dataset
import factory
import utils
import os
DEBUG = True
gpu = 1
K = 100
print('running on gpu {}'.format(gpu))
os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu)
ckpt_file = 'PATH TO YOUR CHECKPOINT FILE'
model = factory.make_siamese_model(ckpt_file).cuda()
model.eval()
dataset = dataset.DAVIS2017(DEBUG)
utils.inference(model, K, 'unknown', DEBUG)
def main(args):
# Device Configuration for Multi-GPU Environment #
device = torch.device(
f'cuda:{args.gpu_num}' if torch.cuda.is_available() else 'cpu')
# Fix Seed for Reproducibility #
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
# Samples and Weights Path #
paths = [args.samples_path, args.weights_path]
for path in paths:
make_dirs(path)
# Prepare Data Loader #
train_div2k_loader = get_div2k_loader(sort='train',
batch_size=args.batch_size,
image_size=args.image_size,
upscale_factor=args.upscale_factor,
crop_size=args.crop_size,
patch_size=args.patch_size,
patch=args.patch,
flip=args.flip,
rotate=args.rotate)
val_div2k_loader = get_div2k_loader(sort='val',
batch_size=args.val_batch_size,
image_size=args.image_size,
upscale_factor=args.upscale_factor,
crop_size=args.crop_size)
print("val_div2k ", val_div2k_loader)
# Prepare Networks #
if args.model == 'edsr':
edsr = EDSR(channels=args.channels,
features=args.dim,
num_residuals=args.num_residuals,
scale_factor=args.upscale_factor).to(device)
else:
raise NotImplementedError
D = Discriminator(in_channels=args.channels,
ndf=args.dim,
linear_dim=args.linear_dim,
out_dim=args.out_dim,
disc_type=args.disc_type).to(device)
if args.phase == 'train':
if args.model == 'edsr':
train_srcnns(train_div2k_loader, val_div2k_loader, edsr, device,
args)
elif args.phase == 'inference':
if args.model == 'edsr':
edsr_weight_path = os.path.join(
args.weights_path,
'{}_Epoch_{}.pkl'.format(edsr.__class__.__name__,
args.num_epochs))
edsr.load_state_dict(torch.load(edsr_weight_path))
inference(val_div2k_loader,
edsr,
args.upscale_factor,
args.num_epochs,
args.inference_path,
device,
save_combined=False)
elif args.phase == 'generate':
generate_all(val_div2k_loader, device, args)
else:
raise NotImplementedError
def runTraining():
print('-' * 40)
print('~~~~~~~~ Starting the training... ~~~~~~')
print('-' * 40)
# Batch size for training MUST be 1 in weakly/semi supervised learning if we want to impose constraints.
batch_size = 1
batch_size_val = 1
lr = 0.0005
epoch = 1000
root_dir = './ACDC-2D-All'
model_dir = 'model'
transform = transforms.Compose([transforms.ToTensor()])
mask_transform = transforms.Compose([transforms.ToTensor()])
train_set = medicalDataLoader.MedicalImageDataset(
'train',
root_dir,
transform=transform,
mask_transform=mask_transform,
augment=False,
equalize=False)
train_loader = DataLoader(train_set,
batch_size=batch_size,
num_workers=5,
shuffle=False)
val_set = medicalDataLoader.MedicalImageDataset(
'val',
root_dir,
transform=transform,
mask_transform=mask_transform,
equalize=False)
val_loader = DataLoader(val_set,
batch_size=batch_size_val,
num_workers=5,
shuffle=False)
minVal = 97.9
maxVal = 1722.6
minSize = torch.FloatTensor(1)
minSize.fill_(np.int64(minVal).item())
maxSize = torch.FloatTensor(1)
maxSize.fill_(np.int64(maxVal).item())
print("~~~~~~~~~~~ Creating the model ~~~~~~~~~~")
num_classes = 2
netG = ENet(1, num_classes)
netG.apply(weights_init)
softMax = nn.Softmax()
Dice_loss = computeDiceOneHotBinary()
modelName = 'WeaklySupervised_CE-2_b'
print(' Model name: {}'.format(modelName))
partial_ce = Partial_CE()
mil_loss = MIL_Loss()
size_loss = Size_Loss()
if torch.cuda.is_available():
netG.cuda()
softMax.cuda()
Dice_loss.cuda()
optimizerG = torch.optim.Adam(netG.parameters(), lr=lr, betas=(0.5, 0.999))
BestDice, BestEpoch = 0, 0
dBAll = []
Losses = []
annotatedPixels = 0
totalPixels = 0
print(" ~~~~~~~~~~~ Starting the training ~~~~~~~~~~")
print(' --------- Params: ---------')
print(' - Lower bound: {}'.format(minVal))
print(' - Upper bound: {}'.format(maxVal))
for i in range(epoch):
netG.train()
lossVal = []
lossVal1 = []
totalImages = len(train_loader)
for j, data in enumerate(train_loader):
image, labels, weak_labels, img_names = data
# prevent batchnorm error for batch of size 1
if image.size(0) != batch_size:
continue
optimizerG.zero_grad()
netG.zero_grad()
MRI = to_var(image)
Segmentation = to_var(labels)
weakAnnotations = to_var(weak_labels)
segmentation_prediction = netG(MRI)
annotatedPixels = annotatedPixels + weak_labels.sum()
totalPixels = totalPixels + weak_labels.shape[
2] * weak_labels.shape[3]
temperature = 0.1
predClass_y = softMax(segmentation_prediction / temperature)
Segmentation_planes = getOneHot_Encoded_Segmentation(Segmentation)
segmentation_prediction_ones = predToSegmentation(predClass_y)
# lossCE_numpy = partial_ce(segmentation_prediction, Segmentation_planes, weakAnnotations)
lossCE_numpy = partial_ce(predClass_y, Segmentation_planes,
weakAnnotations)
# sizeLoss_val = size_loss(segmentation_prediction, Segmentation_planes, Variable(minSize), Variable(maxSize))
sizeLoss_val = size_loss(predClass_y, Segmentation_planes,
Variable(minSize), Variable(maxSize))
# MIL_Loss_val = mil_loss(predClass_y, Segmentation_planes)
# Dice loss (ONLY USED TO COMPUTE THE DICE. This DICE loss version does not work)
DicesN, DicesB = Dice_loss(segmentation_prediction_ones,
Segmentation_planes)
DiceN = DicesToDice(DicesN)
DiceB = DicesToDice(DicesB)
Dice_score = (DiceB + DiceN) / 2
# Choose between the different models
# lossG = lossCE_numpy + MIL_Loss_val
lossG = lossCE_numpy + sizeLoss_val
# lossG = lossCE_numpy
# lossG = sizeLoss_val
lossG.backward(retain_graph=True)
optimizerG.step()
lossVal.append(lossG.data[0])
lossVal1.append(lossCE_numpy.data[0])
printProgressBar(
j + 1,
totalImages,
prefix="[Training] Epoch: {} ".format(i),
length=15,
suffix=" Mean Dice: {:.4f}, Dice1: {:.4f} ".format(
Dice_score.data[0], DiceB.data[0]))
deepSupervision = False
printProgressBar(
totalImages,
totalImages,
done=
f"[Training] Epoch: {i}, LossG: {np.mean(lossVal):.4f}, lossMSE: {np.mean(lossVal1):.4f}"
)
Losses.append(np.mean(lossVal))
d1, sizeGT, sizePred = inference(netG, temperature, val_loader,
batch_size, i, deepSupervision,
modelName, minVal, maxVal)
dBAll.append(d1)
directory = 'Results/Statistics/MIDL/' + modelName
if not os.path.exists(directory):
os.makedirs(directory)
np.save(os.path.join(directory, modelName + '_Losses.npy'), Losses)
np.save(os.path.join(directory, modelName + '_dBAll.npy'), dBAll)
currentDice = d1
print(" [VAL] DSC: (1): {:.4f} ".format(d1))
# saveImagesSegmentation(netG, val_loader_save_imagesPng, batch_size_val_savePng, i, 'test', False)
if currentDice > BestDice:
BestDice = currentDice
if not os.path.exists(model_dir):
os.makedirs(model_dir)
torch.save(netG,
os.path.join(model_dir, "Best_" + modelName + ".pkl"))
if i % (BestEpoch + 10):
for param_group in optimizerG.param_groups:
param_group['lr'] = lr
y = y.to(device)
logit = model(x)
loss_xy, loss_wh, loss_obj, loss_noobj, loss_class = compute_loss(
logit, y)
loss = (lambda_coord * (loss_xy + loss_wh) + loss_obj +
lambda_noobj * loss_noobj + loss_class) / batch_size
valid_loss += loss
valid_loss /= len(test_dloader)
ckpt = {
'model': model.state_dict(),
'optimizer': optimizer.state_dict(),
'epoch': epoch
}
torch.save(ckpt, ckpt_path)
VOC_CLASSES = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car',
'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train',
'tvmonitor')
test_image_dir = 'test_images'
image_path_list = [
os.path.join(test_image_dir, path) for path in os.listdir(test_image_dir)
]
for image_path in image_path_list:
inference(model, image_path, device, VOC_CLASSES)
word2id_fname = f"{model_dir}/word2id.p"
config_json = f"{model_dir}/config.json"
save_sample_fname = f"{model_dir}/sampling_{weights}.csv"
with open(word2id_fname, "rb") as fi:
word_to_id, is_reversed = pickle.load(fi)
id_to_word = {i: w for w, i in word_to_id.items()}
with open(config_json, "r") as fi:
config = json.load(fi)
with open(model_fname, "r") as fi:
model_json = fi.read()
gen_model = model_from_json(model_json)
gen_model.load_weights(weights_fname)
n_samples = 100
maxlen = int(config["maxlen"])
latent_dim = int(config["latent_dim"])
print('----- Generating text -----')
surface_morph = []
for n_sample in range(n_samples):
sent_surface, sent_morph = inference(gen_model, maxlen, latent_dim,
word_to_id, id_to_word,
is_reversed)
print(sent_surface)
surface_morph.append([sent_surface, sent_morph])
with open(save_sample_fname, "w") as fo:
writer = csv.writer(fo)
writer.writerows(surface_morph)
