def generate_test_preds(class_params):
preprocessing_fn = smp.encoders.get_preprocessing_fn(ENCODER, ENCODER_WEIGHTS)
dummy_dataset = CloudDataset(df=sub, datatype='test', img_ids=test_ids[:1], transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
dummy_loader = DataLoader(dummy_dataset, batch_size=1, shuffle=False, num_workers=0)
model = smp.FPN(
encoder_name=ENCODER,
encoder_weights=ENCODER_WEIGHTS,
classes=4,
activation=ACTIVATION,
)
runner = SupervisedRunner(model)
# HACK: We are loading a few examples from our dummy loader so catalyst will properly load the weights
# from our checkpoint
loaders = {"test": dummy_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(
resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
# Now we do real inference on the full dataset
test_dataset = CloudDataset(df=sub, datatype='test', img_ids=test_ids, transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=0)
encoded_pixels = []
image_id = 0
for i, test_batch in enumerate(tqdm.tqdm(test_loader)):
runner_out = runner.predict_batch({"features": test_batch[0].cuda()})['logits'].cpu().detach().numpy()
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
print("Saving submission...")
sub['EncodedPixels'] = encoded_pixels
sub.to_csv('submission.csv', columns=['Image_Label', 'EncodedPixels'], index=False)
print("Saved.")
runner_out = runner.predict_loader(
model=model,
loader=loaders["valid"],
)
# In[ ]:
next(runner_out)[runner.output_key].shape
# # Setup 10 - predict batch
# In[ ]:
features, targets = next(iter(loaders["valid"]))
# In[ ]:
features.shape
# In[ ]:
runner_in = {runner.input_key: features}
runner_out = runner.predict_batch(runner_in)
# In[ ]:
runner_out[runner.output_key].shape
# In[ ]:
class_params[class_id] = (best_threshold, best_size)
del probabilities
with open(output_name + "_params.pkl", 'wb') as handle:
pickle.dump(class_params, handle)
# Calculate train/valid dice
diceScore = {}
for phase in ['train', 'valid']:
running_dice = 0
image_id = 0
for i, test_batch in enumerate(tqdm.tqdm(loaders[phase])):
images, masks = test_batch
runner_out = runner.predict_batch({"features":
images.cuda()})['logits']
for i, (mask, batch) in enumerate(zip(masks, runner_out)):
for j, probability in enumerate(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],
size=size)
running_dice += dice(predict, mask[j, :, :])
image_id += 1
diceScore[phase] = running_dice / image_id
print(f"\n\nDicescore: {diceScore}\n\n")
def generate_test_preds(args):
valid_dice, class_params, = args
test_preds = np.zeros((len(sub), 350, 525), dtype=np.float32)
for i in range(NFOLDS):
logdir = LOG_DIR_BASE + str(i)
preprocessing_fn = smp.encoders.get_preprocessing_fn(
ENCODER, ENCODER_WEIGHTS)
dummy_dataset = CloudDataset(
df=sub,
datatype='test',
img_ids=test_ids[:1],
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
dummy_loader = DataLoader(dummy_dataset,
batch_size=1,
shuffle=False,
num_workers=0)
model = smp.Unet(
encoder_name=ENCODER,
encoder_weights=ENCODER_WEIGHTS,
classes=4,
activation=ACTIVATION,
)
runner = SupervisedRunner(model)
# HACK: We are loading a few examples from our dummy loader so catalyst will properly load the weights
# from our checkpoint
loaders = {"test": dummy_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
# Now we do real inference on the full dataset
test_dataset = CloudDataset(
df=sub,
datatype='test',
img_ids=test_ids,
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
test_loader = DataLoader(test_dataset,
batch_size=1,
shuffle=False,
num_workers=0)
image_id = 0
for batch_index, test_batch in enumerate(tqdm.tqdm(test_loader)):
runner_out = runner.predict_batch(
{"features":
test_batch[0].cuda()})['logits'].cpu().detach().numpy()
for preds in runner_out:
preds = preds.transpose((1, 2, 0))
preds = cv2.resize(
preds,
(525, 350)) # height and width are backward in cv2...
preds = preds.transpose((2, 0, 1))
idx = batch_index * 4
test_preds[idx + 0] += sigmoid(preds[0]) / NFOLDS # fish
test_preds[idx + 1] += sigmoid(preds[1]) / NFOLDS # flower
test_preds[idx + 2] += sigmoid(preds[2]) / NFOLDS # gravel
test_preds[idx + 3] += sigmoid(preds[3]) / NFOLDS # sugar
# Convert ensembled predictions to RLE predictions
encoded_pixels = []
for image_id, preds in enumerate(test_preds):
predict, num_predict = post_process(preds,
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)
print("Saving submission...")
sub['EncodedPixels'] = encoded_pixels
sub.to_csv('unet_submission_{}.csv'.format(valid_dice),
columns=['Image_Label', 'EncodedPixels'],
index=False)
print("Saved.")
gc.collect()
test_dataset = CloudDataset(df=sub,
datatype='test',
img_ids=test_ids,
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
test_loader = DataLoader(test_dataset,
batch_size=8,
shuffle=False,
num_workers=0)
loaders = {"test": test_loader}
encoded_pixels = []
image_id = 0
for i, test_batch in enumerate(tqdm.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)
def generate_test_preds(ensemble_info):
test_preds = np.zeros((len(sub), 350, 525), dtype=np.float32)
num_models = len(ensemble_info)
for model_info in ensemble_info:
class_params = model_info['class_params']
encoder = model_info['encoder']
model_type = model_info['model_type']
logdir = model_info['logdir']
preprocessing_fn = smp.encoders.get_preprocessing_fn(
encoder, ENCODER_WEIGHTS)
model = None
if model_type == 'unet':
model = smp.Unet(
encoder_name=encoder,
encoder_weights=ENCODER_WEIGHTS,
classes=4,
activation=ACTIVATION,
)
elif model_type == 'fpn':
model = smp.FPN(
encoder_name=encoder,
encoder_weights=ENCODER_WEIGHTS,
classes=4,
activation=ACTIVATION,
)
else:
raise NotImplementedError("We only support FPN and UNet")
runner = SupervisedRunner(model)
# HACK: We are loading a few examples from our dummy loader so catalyst will properly load the weights
# from our checkpoint
dummy_dataset = CloudDataset(
df=sub,
datatype='test',
img_ids=test_ids[:1],
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
dummy_loader = DataLoader(dummy_dataset,
batch_size=1,
shuffle=False,
num_workers=0)
loaders = {"test": dummy_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
# Now we do real inference on the full dataset
test_dataset = CloudDataset(
df=sub,
datatype='test',
img_ids=test_ids,
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
test_loader = DataLoader(test_dataset,
batch_size=1,
shuffle=False,
num_workers=0)
image_id = 0
for batch_index, test_batch in enumerate(tqdm.tqdm(test_loader)):
runner_out = runner.predict_batch(
{"features":
test_batch[0].cuda()})['logits'].cpu().detach().numpy()
# Applt TTA transforms
v_flip = test_batch[0].flip(dims=(2, ))
h_flip = test_batch[0].flip(dims=(3, ))
v_flip_out = runner.predict_batch({"features": v_flip.cuda()
})['logits'].cpu().detach()
h_flip_out = runner.predict_batch({"features": h_flip.cuda()
})['logits'].cpu().detach()
# Undo transforms
v_flip_out = v_flip_out.flip(dims=(2, )).numpy()
h_flip_out = h_flip_out.flip(dims=(3, )).numpy()
# Get average
tta_avg_out = (v_flip_out + h_flip_out) / 2
# Combine with original predictions
beta = 0.4 # From fastai TTA
runner_out = (beta) * runner_out + (1 - beta) * tta_avg_out
for preds in runner_out:
preds = preds.transpose((1, 2, 0))
preds = cv2.resize(
preds,
(525, 350)) # height and width are backward in cv2...
preds = preds.transpose((2, 0, 1))
idx = batch_index * 4
test_preds[idx + 0] += sigmoid(preds[0]) / num_models # fish
test_preds[idx + 1] += sigmoid(preds[1]) / num_models # flower
test_preds[idx + 2] += sigmoid(preds[2]) / num_models # gravel
test_preds[idx + 3] += sigmoid(preds[3]) / num_models # sugar
# Convert ensembled predictions to RLE predictions
encoded_pixels = []
for image_id, preds in enumerate(test_preds):
predict, num_predict = post_process(preds,
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)
print("Saving submission...")
sub['EncodedPixels'] = encoded_pixels
sub.to_csv('ensembled_submission.csv',
columns=['Image_Label', 'EncodedPixels'],
index=False)
print("Saved.")
def main_kaggle_smp(path_dataset='/dataset/kaggle/understanding_cloud_organization',
ENCODER='resnet50',
ENCODER_WEIGHTS='imagenet',
num_workers=0,
batch_size=8,
epochs=19,
debug=False,
exec_catalyst=True,
logdir="/src/logs/segmentation",
pretrained=True
):
# below line is potential input args
# (name_dataset='eurosat', lr=0.0001, wd=0, ratio=0.9, batch_size=32, workers=4, epochs=15, num_gpus=1,
# resume=None, dir_weights='./weights'):
torch.backends.cudnn.benchmark = True
# Dataset
train, sub = get_meta_info_table(path_dataset)
train_ids, valid_ids, test_ids = prepare_dataset(train, sub)
preprocessing_fn = smp.encoders.get_preprocessing_fn(ENCODER, ENCODER_WEIGHTS)
train_dataset = CloudDataset(df=train, datatype='train', img_ids=train_ids, transforms=get_training_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn), path=path_dataset)
valid_dataset = CloudDataset(df=train, datatype='valid', img_ids=valid_ids,
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn), path=path_dataset)
# DataLoader
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
valid_loader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers)
loaders = {
"train": train_loader,
"valid": valid_loader
}
# todo: check how to used device in this case
DEVICE = 'cuda'
if debug:
device = 'cpu'
else:
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
ACTIVATION = None
model = smp.Unet(
encoder_name=ENCODER,
encoder_weights=ENCODER_WEIGHTS,
classes=4,
activation=ACTIVATION,
)
images, labels = next(iter(train_loader))
model.to(device)
print(model)
print(summary(model, input_size=tuple(images.shape[1:])))
# use smp epoch
# num_epochs = 19
# model, criterion, optimizer
optimizer = torch.optim.Adam([
{'params': model.decoder.parameters(), 'lr': 1e-2},
{'params': model.encoder.parameters(), 'lr': 1e-3},
])
scheduler = ReduceLROnPlateau(optimizer, factor=0.15, patience=2)
criterion = smp.utils.losses.DiceLoss(eps=1.) # smp.utils.losses.BCEDiceLoss(eps=1.)
if not pretrained:
# catalyst
if exec_catalyst:
device = utils.get_device()
runner = SupervisedRunner(device=device)
# train model
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
scheduler=scheduler,
loaders=loaders,
callbacks=[DiceCallback(), EarlyStoppingCallback(patience=5, min_delta=0.001)],
logdir=logdir,
num_epochs=epochs,
verbose=True
)
# # prediction
# encoded_pixels = []
# loaders = {"infer": valid_loader}
# runner.infer(
# model=model,
# loaders=loaders,
# callbacks=[
# CheckpointCallback(
# resume=f"{logdir}/checkpoints/best.pth"),
# InferCallback()
# ],
# )
# valid_masks = []
#
# # todo: where .pth?
# # todo: from here
# valid_num = valid_dataset.__len__()
# probabilities = np.zeros((valid_num * 4, 350, 525))
# for i, (batch, output) in enumerate(tqdm(zip(
# valid_dataset, runner.callbacks[0].predictions["logits"]))):
# image, mask = batch
# for m in mask:
# if m.shape != (350, 525):
# m = cv2.resize(m, dsize=(525, 350), interpolation=cv2.INTER_LINEAR)
# valid_masks.append(m)
#
# for j, probability in enumerate(output):
# if probability.shape != (350, 525):
# probability = cv2.resize(probability, dsize=(525, 350), interpolation=cv2.INTER_LINEAR)
# probabilities[valid_num * 4 + j, :, :] = probability
#
# # todo: from here
# class_params = {}
# for class_id in range(4):
# print(class_id)
# attempts = []
# for t in range(0, 100, 5):
# t /= 100
# for ms in [0, 100, 1200, 5000, 10000]:
# masks = []
# for i in range(class_id, len(probabilities), 4):
# probability = probabilities[i]
# predict, num_predict = post_process(sigmoid(probability), t, ms)
# masks.append(predict)
#
# d = []
# for i, j in zip(masks, valid_masks[class_id::4]):
# if (i.sum() == 0) & (j.sum() == 0):
# d.append(1)
# else:
# d.append(dice(i, j))
#
# attempts.append((t, ms, np.mean(d)))
#
# attempts_df = pd.DataFrame(attempts, columns=['threshold', 'size', 'dice'])
#
# attempts_df = attempts_df.sort_values('dice', ascending=False)
# print(attempts_df.head())
# best_threshold = attempts_df['threshold'].values[0]
# best_size = attempts_df['size'].values[0]
#
# class_params[class_id] = (best_threshold, best_size)
else:
for epoch in trange(epochs, desc="Epochs"):
metrics_train = train_epoch(model, train_loader, criterion, optimizer, device)
metrics_eval = eval_epoch(model, valid_loader, criterion, device)
scheduler.step(metrics_eval['valid_loss'])
print(f'epoch: {epoch} ', metrics_train, metrics_eval)
else:
if exec_catalyst:
device = utils.get_device()
checkpoint = utils.load_checkpoint(f'{logdir}/checkpoints/best_full.pth')
utils.unpack_checkpoint(checkpoint, model=model)
runner = SupervisedRunner(model=model)
# prediction with infer
encoded_pixels = []
loaders = {"infer": valid_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(
resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
# todo: jupyterで確認中
valid_masks = []
valid_num = valid_dataset.__len__()
probabilities = np.zeros((valid_num * 4, 350, 525))
for i, (batch, output) in enumerate(tqdm(zip(
valid_dataset, runner.callbacks[0].predictions["logits"]))):
image, mask = batch
for m in mask:
if m.shape != (350, 525):
m = cv2.resize(m, dsize=(525, 350), interpolation=cv2.INTER_LINEAR)
valid_masks.append(m)
for j, probability in enumerate(output):
if probability.shape != (350, 525):
probability = cv2.resize(probability, dsize=(525, 350), interpolation=cv2.INTER_LINEAR)
probabilities[i * 4 + j, :, :] = probability
class_params = {}
for class_id in range(4):
print(class_id)
attempts = []
for t in range(0, 100, 5):
t /= 100
for ms in [0, 100, 1200, 5000, 10000]:
masks = []
for i in range(class_id, len(probabilities), 4):
probability = probabilities[i]
predict, num_predict = post_process(sigmoid(probability), t, ms)
masks.append(predict)
d = []
for i, j in zip(masks, valid_masks[class_id::4]):
if (i.sum() == 0) & (j.sum() == 0):
d.append(1)
else:
d.append(dice(i, j))
attempts.append((t, ms, np.mean(d)))
attempts_df = pd.DataFrame(attempts, columns=['threshold', 'size', 'dice'])
attempts_df = attempts_df.sort_values('dice', ascending=False)
print(attempts_df.head())
best_threshold = attempts_df['threshold'].values[0]
best_size = attempts_df['size'].values[0]
class_params[class_id] = (best_threshold, best_size)
# predictions
torch.cuda.empty_cache()
gc.collect()
test_dataset = CloudDataset(df=sub, datatype='test', img_ids=test_ids, transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
test_loader = DataLoader(test_dataset, batch_size=8, shuffle=False, num_workers=0)
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['EncodedPixels'] = encoded_pixels
sub.to_csv('data/kaggle_cloud_org/submission.csv', columns=['Image_Label', 'EncodedPixels'], index=False)
del checkpoint
gc.collect()
if args.tta:
tta_model = tta.SegmentationTTAWrapper(
model, tta.aliases.d4_transform(), merge_mode="sum")
else:
tta_model = model # tta.SegmentationTTAWrapper(
# model, tta.aliases.flip_transform(), merge_mode="mean")
runner = SupervisedRunner(
model=tta_model,
device=get_device())
for i, test_batch in enumerate(tqdm.tqdm(loaders['test'])):
test_batch = test_batch[0].cuda()
runner_out = runner.predict_batch(
{"features": test_batch})['logits']
gc.collect()
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[f"{image_id % 4}"][0],
class_params[f"{image_id % 4}"][1])
if num_predict == 0:
encoded_pixels.append('')
else:
r = mask2rle(predict)
