def predict_softmax(args):
model, _ = create_model(args)
if torch.cuda.device_count() > 1:
model = DataParallel(model)
model = model.cuda()
model.eval()
test_loader = get_test_loader(batch_size=args.val_batch_size,
dev_mode=args.dev_mode)
preds, scores, founds = [], [], []
with torch.no_grad():
for i, (x, found) in enumerate(test_loader):
x = x.cuda()
output = model(x, None, True)
output = F.softmax(output, dim=1)
score, pred = output.max(1)
preds.append(pred.cpu())
scores.append(score.cpu())
founds.append(found)
print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num),
end='\r')
preds = torch.cat(preds, 0).numpy()
scores = torch.cat(scores, 0).numpy()
founds = torch.cat(founds, 0).numpy()
classes, stoi = get_classes(num_classes=args.num_classes,
start_index=args.start_index,
other=args.other)
print(preds.shape)
pred_labels = [classes[i] for i in preds]
create_submission(args, pred_labels, scores, founds, args.sub_file)
def pred_class(args):
model = create_model()
model_file = os.path.join(MODEL_DIR, model.name, 'best.pth')
if not os.path.exists(model_file):
raise AssertionError('{} does not exist'.format(model_file))
print('loading {}...'.format(model_file))
model.load_state_dict(torch.load(model_file))
model = model.cuda()
model.eval()
preds = []
test_loader = get_test_loader(64, 0, img_sz=256)
for img in test_loader:
img = img.cuda()
output = model(img).squeeze()
pred = (torch.sigmoid(output) > 0.5).byte().cpu().tolist()
preds.extend(pred)
df_test = test_loader.meta
df_test['Target'] = preds
print(sum(preds))
df_test.to_csv('test_cls_preds.csv',
index=False,
columns=['patientId', 'Target'])
def predict_top3(args):
model, _ = create_model(args)
model = model.cuda()
model.eval()
test_loader = get_test_loader(args,
batch_size=args.batch_size,
dev_mode=args.dev_mode)
preds = None
with torch.no_grad():
for i, x in enumerate(test_loader):
x = x.cuda()
#output = torch.sigmoid(model(x))
output, _ = model(x)
output = F.softmax(output, dim=1)
_, pred = output.topk(3, 1, True, True)
if preds is None:
preds = pred.cpu()
else:
preds = torch.cat([preds, pred.cpu()], 0)
print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num),
end='\r')
classes, _ = get_classes(args.cls_type, args.start_index, args.end_index)
label_names = []
preds = preds.numpy()
print(preds.shape)
for row in preds:
label_names.append(' '.join([classes[i] for i in row]))
if args.dev_mode:
print(len(label_names))
print(label_names)
create_submission(args, label_names, args.sub_file)
def pred_by_vector_search(args):
model = create_feature_model(args)
test_loader = get_test_loader(batch_size=args.batch_size, dev_mode=args.dev_mode)
outputs = []
founds = []
with torch.no_grad():
for i, (x, found) in tqdm(enumerate(test_loader), total=test_loader.num//args.batch_size):
x = x.cuda()
output = model(x)
outputs.append(output.cpu())
founds.append(found.cpu())
xb = torch.cat(outputs, 0).numpy()
founds = torch.cat(founds, 0).numpy()
print(xb.shape, founds.shape)
index_fn = os.path.join(settings.VECTOR_DIR, '{}.index'.format(model.name))
print('loading index...')
index = faiss.read_index(index_fn)
print('searching...')
D, I = index.search(xb, 10)
top1_index_ids = I[:, 0].squeeze()
#print('I:', I)
#print('top1 index ids:', top1_index_ids)
pred_labels = get_labels(top1_index_ids)
#print(pred_labels)
scores = [0.5] * xb.shape[0]
create_submission(args, pred_labels, scores, founds, args.sub_file)
def predict(args):
model, _ = create_model(args)
test_loader = get_test_loader(batch_size=args.val_batch_size)
scores = pred_model_output(model, test_loader, labeled=False)
print(scores.shape)
print(scores[:2])
create_submission(args, scores)
def ensemble_predict(args):
models = create_models_from_ckps(args)
test_loader = get_test_loader(batch_size=args.batch_size,
dev_mode=args.dev_mode)
preds = None
scores = None
founds = None
with torch.no_grad():
for i, (x, found) in enumerate(test_loader):
x = x.cuda()
#output = torch.sigmoid(model(x))
outputs = []
for model in models:
output = model(x, None, True)
output = F.softmax(output, dim=1)
outputs.append(output)
avg_ouput = torch.stack(outputs).mean(0)
#print(x[0, 0, :])
#output = model(x)
#output = F.softmax(output, dim=1)
#pred = (output > 0.03).byte() # use threshold
#preds = output.max(1, keepdim=True)[1]
#print(output)
#break
score, pred = avg_ouput.max(1)
#print(pred.size())
if preds is None:
preds = pred.cpu()
else:
preds = torch.cat([preds, pred.cpu()], 0)
if scores is None:
scores = score.cpu()
else:
scores = torch.cat([scores, score.cpu()], 0)
if founds is None:
founds = found
else:
founds = torch.cat([founds, found], 0)
print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num),
end='\r')
classes, stoi = get_classes(num_classes=args.num_classes)
preds = preds.numpy()
scores = scores.numpy()
print(preds.shape)
pred_labels = [classes[i] for i in preds]
create_submission(args, pred_labels, scores, founds, args.sub_file)
def do_tta_predict(args, model, ckp_path, tta_num=4):
'''
return 18000x128x128 np array
'''
model.eval()
preds = []
meta = None
# i is tta index, 0: no change, 1: horizon flip, 2: vertical flip, 3: do both
for flip_index in range(tta_num):
print('flip_index:', flip_index)
test_loader = get_test_loader(args.batch_size,
index=flip_index,
dev_mode=False,
pad_mode=args.pad_mode)
meta = test_loader.meta
outputs = None
with torch.no_grad():
for i, img in enumerate(test_loader):
add_depth_channel(img, args.pad_mode)
img = img.cuda()
output, _ = model(img)
output = torch.sigmoid(output)
if outputs is None:
outputs = output.squeeze()
else:
outputs = torch.cat([outputs, output.squeeze()], 0)
print('{} / {}'.format(args.batch_size * (i + 1),
test_loader.num),
end='\r')
outputs = outputs.cpu().numpy()
# flip back masks
if flip_index == 1:
outputs = np.flip(outputs, 2)
elif flip_index == 2:
outputs = np.flip(outputs, 1)
elif flip_index == 3:
outputs = np.flip(outputs, 2)
outputs = np.flip(outputs, 1)
#print(outputs.shape)
preds.append(outputs)
parent_dir = ckp_path + '_out'
if not os.path.exists(parent_dir):
os.makedirs(parent_dir)
np_file = os.path.join(parent_dir, 'pred.npy')
model_pred_result = np.mean(preds, 0)
np.save(np_file, model_pred_result)
return model_pred_result, meta
def predict(args):
model, _ = create_model(args)
model = model.cuda()
if torch.cuda.device_count() > 1:
model = DataParallel(model)
test_loader = get_test_loader(batch_size=args.val_batch_size, dev_mode=args.dev_mode)
probs = pred_model_output(model, test_loader)
print(probs.shape)
print(probs[:2])
np.save(args.out, probs)
def do_tta_predict(args, model, ckp_path, tta_indices):
'''
return 18000x128x128 np array
'''
model.eval()
preds = []
cls_preds = []
meta = None
# i is tta index, 0: no change, 1: horizon flip, 2: vertical flip, 3: do both
for flip_index in tta_indices:
print('flip_index:', flip_index)
test_loader = get_test_loader(args.batch_size, index=flip_index, dev_mode=args.dev_mode, img_sz=args.img_sz)
meta = test_loader.meta
outputs = None
cls_outputs = None
with torch.no_grad():
for i, img in enumerate(test_loader):
img = img.cuda()
output, cls_output = model(img)
output, cls_output = torch.sigmoid(output), torch.sigmoid(cls_output)
if outputs is None:
outputs = output.squeeze().cpu()
cls_outputs = cls_output.squeeze().cpu()
else:
outputs = torch.cat([outputs, output.squeeze().cpu()], 0)
cls_outputs = torch.cat([cls_outputs, cls_output.squeeze().cpu()])
#cls_preds.extend(cls_output.squeeze().cpu().tolist())
print('{} / {}'.format(args.batch_size*(i+1), test_loader.num), end='\r')
outputs = outputs.numpy()
cls_outputs = cls_outputs.numpy()
outputs = tta_back_mask_np(outputs, flip_index)
preds.append(outputs)
cls_preds.append(cls_outputs)
parent_dir = ckp_path+'_out'
if not os.path.exists(parent_dir):
os.makedirs(parent_dir)
np_file = os.path.join(parent_dir, 'pred_{}.npy'.format(''.join([str(x) for x in tta_indices])))
np_file_cls = os.path.join(parent_dir, 'pred_cls_{}.npy'.format(''.join([str(x) for x in tta_indices])))
model_pred_result = np.mean(preds, 0)
model_cls_pred_result = np.mean(cls_preds, 0)
np.save(np_file, model_pred_result)
np.save(np_file_cls, model_cls_pred_result)
return model_pred_result, model_cls_pred_result, meta
def pred_retrieval(args):
#model = create_feature_model(args)
model = create_retrieval_model(args)
test_loader = get_test_loader(batch_size=args.batch_size, dev_mode=args.dev_mode, img_size=256) #224
global_feats = []
local_feats = []
founds = []
with torch.no_grad():
for i, (x, found) in tqdm(enumerate(test_loader), total=test_loader.num//args.batch_size):
x = x.cuda()
#print('x:', x.size())
global_feat, local_feat, _ = model(x)
#print('local:', local_feat.size())
#exit(1)
global_feats.append(global_feat.cpu())
#local_feats.append(local_feat.view(local_feat.size(0), -1).cpu())
local_feats.append(local_feat.cpu())
founds.append(found.cpu())
global_feats = torch.cat(global_feats, 0).numpy()
local_feats = torch.cat(local_feats, 0).numpy()
founds = torch.cat(founds, 0).numpy()
xb = global_feats
print(global_feats.shape, local_feats.shape, xb.shape, founds.shape)
index_fn = args.index_fn #os.path.join(settings_retrieval.VECTOR_DIR, '{}.index_retrieval'.format(model.name))
print('loading index...')
index = faiss.read_index(index_fn)
print('searching...')
bg = time.time()
D, I = index.search(xb, 100)
print('search time:', time.time() - bg)
np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'D.npy'), D)
np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'I.npy'), I)
np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'founds.npy'), founds)
np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'local_feats.npy'), local_feats)
np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'global_feats.npy'), global_feats)
#top1_index_ids = I[:, 0].squeeze()
#print(pred_labels)
#scores = [0.5] * xb.shape[0]
create_retrieval_submission(args, I, founds, args.sub_file)
def ensemble_np(args, np_files, save_np=None):
preds = []
for np_file in np_files:
pred = np.load(np_file)
print(np_file, pred.shape)
preds.append(pred)
y_pred_test = generate_preds(np.mean(preds, 0), (settings.ORIG_H, settings.ORIG_W), args.pad_mode)
if save_np is not None:
np.save(save_np, np.mean(preds, 0))
meta = get_test_loader(args.batch_size, index=0, dev_mode=False, pad_mode=args.pad_mode).meta
submission = create_submission(meta, y_pred_test)
submission.to_csv(args.sub_file, index=None, encoding='utf-8')
def predict_top3(args):
model, model_file = create_model(args.backbone, args.img_sz)
if not os.path.exists(model_file):
raise AssertionError('model file not exist: {}'.format(model_file))
model.eval()
test_loader = get_test_loader(batch_size=args.batch_size,
dev_mode=args.dev_mode,
img_sz=args.img_sz)
outputs = model_predict(args, model, model_file)
_, preds = outputs.topk(3, 1, True, True)
preds = preds.numpy()
print(preds.shape)
create_submission(args, preds, args.sub_file)
def ensemble(args):
#class_params = {0: (0.5, 25000), 1: (0.7, 15000), 2: (0.4, 25000), 3: (0.6, 10000)}
models = create_models(args)
class_params = find_class_params(args, models)
#exit(0)
test_loader = get_test_loader(args.encoder_types.split(',')[0], args.batch_size)
probs, _ = predict_loader(models, test_loader)
encoded_pixels, encoded_pixels_no_minsize = [], []
image_id = 0
for img_out in tqdm(probs):
#runner_out = runner.predict_batch({"features": test_batch[0].cuda()})['logits']
#for i, batch in enumerate(runner_out):
for probability in img_out:
#probability = probability.cpu().detach().numpy()
if probability.shape != (350, 525):
probability = cv2.resize(probability, dsize=(525, 350), interpolation=cv2.INTER_LINEAR)
predict, num_predict = post_process(probability, class_params[image_id % 4][0], class_params[image_id % 4][1])
if num_predict == 0:
encoded_pixels.append('')
else:
r = mask2rle(predict)
encoded_pixels.append(r)
predict2, num_predict2 = post_process(probability, class_params[image_id % 4][0], 0)
if num_predict2 == 0:
encoded_pixels_no_minsize.append('')
else:
r2 = mask2rle(predict2)
encoded_pixels_no_minsize.append(r2)
image_id += 1
sub = pd.read_csv(os.path.join(settings.DATA_DIR, 'sample_submission.csv'))
sub['EncodedPixels'] = encoded_pixels
sub.to_csv(args.out, columns=['Image_Label', 'EncodedPixels'], index=False)
sub['EncodedPixels'] = encoded_pixels_no_minsize
sub.to_csv(args.out+'_no_minsize', columns=['Image_Label', 'EncodedPixels'], index=False)
def do_tta_predict(model):
'''
return 18000x128x128 np array
'''
model.eval()
preds = []
meta = None
# i is tta index, 0: no change, 1: horizon flip, 2: vertical flip, 3: do both
for flip_index in range(4):
test_loader = get_test_loader(batch_size,
index=flip_index,
dev_mode=False)
meta = test_loader.meta
print('predicting...', CKP, flip_index)
outputs = None
with torch.no_grad():
for i, img in enumerate(test_loader):
img = img.cuda()
output, _ = model(img)
output = torch.sigmoid(output)
if outputs is None:
outputs = output.squeeze()
else:
outputs = torch.cat([outputs, output.squeeze()], 0)
print('{} / {}'.format(batch_size * (i + 1), test_loader.num),
end='\r')
outputs = outputs.cpu().numpy()
# flip back masks
if flip_index == 1:
outputs = np.flip(outputs, 2)
elif flip_index == 2:
outputs = np.flip(outputs, 1)
elif flip_index == 3:
outputs = np.flip(outputs, 2)
outputs = np.flip(outputs, 1)
#print(outputs.shape)
preds.append(outputs)
return np.mean(preds, 0), meta
def model_predict(args, model, model_file, check, tta_num=2):
model.eval()
preds = []
for flip_index in range(tta_num):
test_loader = get_test_loader(args,
batch_size=args.batch_size,
dev_mode=args.dev_mode,
tta_index=flip_index)
outputs = None
with torch.no_grad():
for i, x in enumerate(test_loader):
x = x.cuda()
output, _ = model(x)
if args.activation == 'sigmoid':
output = torch.sigmoid(output)
else:
output = F.softmax(output, dim=1)
if outputs is None:
outputs = output
else:
outputs = torch.cat([outputs, output])
print('{}/{}'.format(args.batch_size * (i + 1),
test_loader.num),
end='\r')
if check and i == 0:
break
preds.append(outputs.cpu().numpy())
#return outputs
results = np.mean(preds, 0)
parent_dir = model_file + '_out'
if not os.path.exists(parent_dir):
os.makedirs(parent_dir)
np_file = os.path.join(parent_dir, 'pred.npy')
np.save(np_file, results)
return results
def predict_softmax(args):
model, _ = create_model(args)
if torch.cuda.device_count() > 1:
model = DataParallel(model)
model = model.cuda()
model.eval()
test_loader = get_test_loader(batch_size=args.batch_size,
dev_mode=args.dev_mode)
preds = None
scores = None
with torch.no_grad():
for i, x in enumerate(test_loader):
x = x.cuda()
#output = torch.sigmoid(model(x))
#print(x[0, 0, :])
output = model(x)
output = F.softmax(output, dim=1)
#pred = (output > 0.03).byte() # use threshold
#preds = output.max(1, keepdim=True)[1]
#print(output)
#break
score, pred = output.max(1)
#print(pred.size())
if preds is None:
preds = pred.cpu()
else:
preds = torch.cat([preds, pred.cpu()], 0)
print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num),
end='\r')
preds = preds.numpy()
print(preds.shape)
create_submission(args, preds, args.sub_file)
def model_predict(args, model, model_file, check=False, tta_num=2):
model.eval()
preds = []
for flip_index in range(tta_num):
print('tta index:', flip_index)
test_loader = get_test_loader(batch_size=args.batch_size,
img_sz=args.img_sz,
dev_mode=args.dev_mode,
tta_index=flip_index)
outputs = None
with torch.no_grad():
for i, x in enumerate(test_loader):
x = x.cuda()
output = model(x)
output = F.softmax(output, dim=1)
if outputs is None:
outputs = output.cpu()
else:
outputs = torch.cat([outputs, output.cpu()], 0)
print('{}/{}'.format(args.batch_size * (i + 1),
test_loader.num),
end='\r')
if check and i == 0:
break
preds.append(outputs)
#return outputs
results = torch.mean(torch.stack(preds), 0)
parent_dir = model_file + '_out'
if not os.path.exists(parent_dir):
os.makedirs(parent_dir)
np_file = os.path.join(parent_dir, 'pred.npy')
np.save(np_file, results.numpy())
return results
def predict_empty_masks(args,
recall_thresholds=[
0.2502807, 0.30874616, 0.47154653, 0.25778872
]):
#[0.30248615, 0.4076966, 0.55904335, 0.29780537] 0875):
#[0.32873523, 0.44805834, 0.6001048, 0.3136805] 085):
#[0.21345863, 0.1824504, 0.41996846, 0.20917079]095):
# #[0.28479144, 0.35337192, 0.5124028, 0.27734384]090):
model, model_file = create_model(args.encoder_type,
work_dir=args.work_dir,
ckp=args.ckp)
model = model.cuda()
model = DataParallel(model)
model.eval()
if args.tta:
model = tta.ClassificationTTAWrapper(model,
tta.aliases.d4_transform(),
merge_mode='mean')
test_loader = get_test_loader(batch_size=args.val_batch_size)
all_preds = []
with torch.no_grad():
for inputs in tqdm(test_loader):
inputs = inputs.cuda()
outputs = model(inputs, nn.Sigmoid())
all_preds.append(outputs.cpu())
all_preds = torch.cat(all_preds, 0).numpy()
img_ids = test_loader.img_ids
print(all_preds.shape)
image_labels_empty = []
for i, (img, predictions) in enumerate(zip(img_ids, all_preds)):
for class_i, class_name in enumerate(class_names):
if predictions[class_i] < recall_thresholds[class_i]:
image_labels_empty.append(f'{img}_{class_name}')
pd.DataFrame({
'empty_ids': image_labels_empty
}).to_csv('empty_ids.csv', index=False)
def predict(args):
#model = create_model(args.encoder_type, ckp=args.ckp).cuda()
#model = nn.DataParallel(model)
#runner = SupervisedRunner(model=model)
class_params, runner = find_class_params(args)
#runner = create_runner(args)
test_loader = get_test_loader(args.encoder_type, args.batch_size)
loaders = {"test": test_loader}
encoded_pixels = []
image_id = 0
for i, test_batch in enumerate(tqdm(loaders['test'])):
runner_out = runner.predict_batch({"features":
test_batch[0].cuda()})['logits']
for i, batch in enumerate(runner_out):
for probability in batch:
probability = probability.cpu().detach().numpy()
if probability.shape != (350, 525):
probability = cv2.resize(probability,
dsize=(525, 350),
interpolation=cv2.INTER_LINEAR)
predict, num_predict = post_process(
sigmoid(probability), class_params[image_id % 4][0],
class_params[image_id % 4][1])
if num_predict == 0:
encoded_pixels.append('')
else:
r = mask2rle(predict)
encoded_pixels.append(r)
image_id += 1
sub = pd.read_csv(os.path.join(settings.DATA_DIR, 'sample_submission.csv'))
sub['EncodedPixels'] = encoded_pixels
sub.to_csv(args.out, columns=['Image_Label', 'EncodedPixels'], index=False)
model = NeuralNet()
'''
if torch.cuda.device_count()>1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
model = nn.DataParallel(model, device_ids=range(torch.cuda.device_count))
'''
model.to(device)
learning_rate = 1e-3
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9)
train_loader, val_loader = get_train_val_loaders()
test_loader = get_test_loader()
epochs = int(1e3)
acc_train_list = []
acc_val_list = []
acc_test_list = []
start = time.time()
for t in range(epochs):
print(f"Epoch {t+1}\n-------------------------------")
loss_train, accuracy_train = train_loop(
train_loader, model, loss_fn, optimizer
