def validate(model, val_dataset, config):
loaders = collections.OrderedDict()
val_loader = utils.get_loader(
val_dataset,
open_fn=lambda x: {
"input_audio": x[-1],
"input_video": x[1],
"targets": x[0]
},
batch_size=config.batch_size,
num_workers=config.workers,
shuffle=False,
)
loaders["valid"] = val_loader
runner = SupervisedRunner(
input_key=["input_audio",
"input_video"]) # parameters of the model in forward(...)
runner.infer(
model,
loaders,
callbacks=collections.OrderedDict({
"snr_callback": SNRCallback(),
"sdr_callback": SDRCallback()
}),
verbose=True,
)
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.")
def generate_valid_preds(args):
train_ids, valid_ids, logdir = args
preprocessing_fn = smp.encoders.get_preprocessing_fn(ENCODER, 'imagenet')
valid_dataset = CloudDataset(
df=train,
datatype='valid',
img_ids=valid_ids,
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
valid_loader = DataLoader(valid_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()
# Generate validation predictions
loaders = {"infer": valid_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
valid_preds = np.load('data/valid_preds.npy')
for im_id, preds in zip(valid_ids,
runner.callbacks[0].predictions["logits"]):
preds = preds.transpose((1, 2, 0))
preds = cv2.resize(preds, (525, 350))
preds = preds.transpose((2, 0, 1))
indexes = train.index[train['im_id'] == im_id]
valid_preds[indexes[0]] = preds[0] # fish
valid_preds[indexes[1]] = preds[1] # flower
valid_preds[indexes[2]] = preds[2] # gravel
valid_preds[indexes[3]] = preds[3] # sugar
np.save('data/valid_preds.npy', valid_preds)
return True
def run_validation(data,
valid_path,
image_size,
batch_size,
splits,
fold_idx,
model,
exp_name,
labels,
ttatype=None):
logdir = 'logs/{}_fold{}/'.format(exp_name, fold_idx)
valid_data = data.loc[splits['test_idx'][fold_idx], :]
model.load_state_dict(
torch.load(os.path.join(logdir,
'checkpoints/best.pth'))['model_state_dict'])
model.eval()
if ttatype == 'd4':
model = tta.TTAWrapper(model, tta.d4_image2label)
elif ttatype == 'fliplr_image2label':
model = tta.TTAWrapper(model, tta.d4_image2label)
runner = SupervisedRunner(model=model)
val_dataset = EyeDataset(dataset_path=valid_path,
labels=data.loc[splits['test_idx'][fold_idx],
labels].values,
ids=data.loc[splits['test_idx'][fold_idx],
'id'].values,
albumentations_tr=aug_val(image_size))
val_loader = DataLoader(val_dataset,
num_workers=8,
pin_memory=False,
batch_size=batch_size,
shuffle=False)
loaders = collections.OrderedDict()
loaders["valid"] = val_loader
#predictions = runner.predict_loader(loaders["valid"], resume=f"{logdir}/checkpoints/best.pth")
runner.infer(model=model, loaders=loaders, callbacks=[InferCallback()])
predictions = runner.callbacks[0].predictions['logits']
probabilities = softmax(torch.from_numpy(predictions), dim=1).numpy()
for idx in range(probabilities.shape[0]):
if all(probabilities[idx, :] < 0.5):
probabilities[idx, 0] = 1.0
predicted_labels = pd.DataFrame(probabilities, columns=labels)
predicted_labels['id'] = data.loc[splits['test_idx'][fold_idx],
'id'].values
predicted_labels.loc[:, 'group'] = predicted_labels.id.apply(
lambda x: x.split('_')[0])
valid_data.loc[:, 'group'] = valid_data.id.apply(lambda x: x.split('_')[0])
valid_data_groupped = valid_data.groupby(['group']).aggregate(
dict(zip(labels, ['max'] * (len(labels)))))
predicted_labels_groupped = predicted_labels.groupby(['group']).aggregate(
dict(zip(labels, ['max'] * (len(labels)))))
return (valid_data_groupped, predicted_labels_groupped)
def main():
test = pd.read_csv(
'/home/yuko/kaggle_understanding_cloud_organization/src/data_process/data/sample_submission.csv'
)
test['label'] = test['Image_Label'].apply(lambda x: x.split('_')[-1])
test['im_id'] = test['Image_Label'].apply(
lambda x: x.replace('_' + x.split('_')[-1], ''))
test['img_label'] = test.EncodedPixels.apply(lambda x: 0
if x is np.nan else 1)
img_label = test.groupby('im_id')['img_label'].agg(list).reset_index()
test_id = np.array(img_label.im_id)
test_dataset = CloudClassDataset(datatype='test',
img_ids=test_id,
transforms=get_validation_augmentation(),
preprocessing=ort_get_preprocessing())
test_loader = DataLoader(test_dataset,
batch_size=8,
shuffle=False,
num_workers=16)
loaders = {"infer": test_loader}
for fold in range(5):
runner = SupervisedRunner()
clf_model = ResNet()
checkpoint = torch.load(
f'/home/yuko/kaggle_understanding_cloud_organization/src/class/segmentation/fold_{fold}/checkpoints/best.pth'
)
clf_model.load_state_dict(checkpoint['model_state_dict'])
clf_model.eval()
runner.infer(
model=clf_model,
loaders=loaders,
callbacks=[InferCallback()],
)
callbacks_num = 0
pred = runner.callbacks[callbacks_num].predictions["logits"]
df_pred = pd.DataFrame(
[pred[:, 0], pred[:, 1], pred[:, 2], pred[:, 3]]).T
df_pred.to_csv(
f'/home/yuko/kaggle_understanding_cloud_organization/src/class/segmentation/pred_{fold}.csv'
)
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.")
DiceCallback(),
EarlyStoppingCallback(patience=5, min_delta=0.001)
],
logdir=logdir,
num_epochs=num_epochs,
verbose=True)
utils.plot_metrics(
logdir=logdir,
# specify which metrics we want to plot
metrics=["loss", "dice", 'lr', '_base/lr'])
encoded_pixels = []
loaders = {"infer": valid_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
valid_masks = []
probabilities = np.zeros((2220, 350, 525))
for i, (batch, output) in enumerate(
tqdm.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):
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir=logdir,
num_epochs=num_epochs,
check=True
)
# # Setup 8 - loader inference
# In[ ]:
from catalyst.dl.callbacks import InferCallback
loaders = collections.OrderedDict([("infer", loaders["train"])])
runner.infer(
model=model, loaders=loaders, callbacks=[InferCallback()], check=True
)
# In[ ]:
runner.callbacks[0].predictions["logits"].shape
# # Setup 9 - batch inference
# In[ ]:
features, targets = next(iter(loaders["infer"]))
# In[ ]:
features.shape
'in_channels': 3
})}
model = models[args.model.lower()][0](**models[args.model.lower()][1])
encoded_pixels = []
loaders = {"infer": valid_loader}
logdir = f'./logs/{args.model}/fold_{args.fold}'
gc.collect()
runner = SupervisedRunner(model=model,
device='cuda',
input_key='image',
input_target_key='mask')
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(
resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
# fp16={"opt_level": "O1"},
)
valid_masks = []
probabilities = np.zeros((2220, 350, 525))
for i, (batch, output) in enumerate(tqdm.tqdm(zip(
valid_dataset, runner.callbacks[0].predictions["logits"]))):
gc.collect()
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)
def find_class_params(args):
runner = SupervisedRunner()
model = create_model(args.encoder_type)
valid_loader = get_train_val_loaders(args.encoder_type,
batch_size=args.batch_size)['valid']
encoded_pixels = []
loaders = {"infer": valid_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[CheckpointCallback(resume=args.ckp),
InferCallback()],
)
print(runner.callbacks)
valid_masks = []
probabilities = np.zeros((2220, 350, 525))
for i, (batch, output) in enumerate(
tqdm(
zip(valid_loader.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]:
for ms in [5000, 10000, 15000, 20000, 22500, 25000, 30000]:
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)
print(class_params)
return class_params, runner
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():
fold_path = args.fold_path
fold_num = args.fold_num
model_name = args.model_name
train_csv = args.train_csv
sub_csv = args.sub_csv
encoder = args.encoder
num_workers = args.num_workers
batch_size = args.batch_size
log_path = args.log_path
is_tta = args.is_tta
test_batch_size = args.test_batch_size
attention_type = args.attention_type
print(log_path)
train = pd.read_csv(train_csv)
train['label'] = train['Image_Label'].apply(lambda x: x.split('_')[-1])
train['im_id'] = train['Image_Label'].apply(lambda x: x.replace('_' + x.split('_')[-1], ''))
val_fold = pd.read_csv(f'{fold_path}/valid_file_fold_{fold_num}.csv')
valid_ids = np.array(val_fold.file_name)
attention_type = None if attention_type == 'None' else attention_type
encoder_weights = 'imagenet'
if model_name == 'Unet':
model = smp.Unet(
encoder_name=encoder,
encoder_weights=encoder_weights,
classes=CLASS,
activation='softmax',
attention_type=attention_type,
)
if model_name == 'Linknet':
model = smp.Linknet(
encoder_name=encoder,
encoder_weights=encoder_weights,
classes=CLASS,
activation='softmax',
)
if model_name == 'FPN':
model = smp.FPN(
encoder_name=encoder,
encoder_weights=encoder_weights,
classes=CLASS,
activation='softmax',
)
if model_name == 'ORG':
model = Linknet_resnet18_ASPP(
)
preprocessing_fn = smp.encoders.get_preprocessing_fn(encoder, encoder_weights)
valid_dataset = CloudDataset(df=train,
datatype='valid',
img_ids=valid_ids,
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
valid_loader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers)
loaders = {"infer": valid_loader}
runner = SupervisedRunner()
checkpoint = torch.load(f"{log_path}/checkpoints/best.pth")
model.load_state_dict(checkpoint['model_state_dict'])
model.eval()
transforms = tta.Compose(
[
tta.HorizontalFlip(),
tta.VerticalFlip(),
]
)
model = tta.SegmentationTTAWrapper(model, transforms)
runner.infer(
model=model,
loaders=loaders,
callbacks=[InferCallback()],
)
callbacks_num = 0
valid_masks = []
probabilities = np.zeros((valid_dataset.__len__() * CLASS, IMG_SIZE[0], IMG_SIZE[1]))
# ========
# val predict
#
for batch in tqdm(valid_dataset): # クラスごとの予測値
_, mask = batch
for m in mask:
m = resize_img(m)
valid_masks.append(m)
for i, output in enumerate(tqdm(runner.callbacks[callbacks_num].predictions["logits"])):
for j, probability in enumerate(output):
probability = resize_img(probability) # 各クラスごとにprobability(予測値)が取り出されている。jは0~3だと思う。
probabilities[i * CLASS + j, :, :] = probability
# ========
# search best size and threshold
#
class_params = {}
for class_id in range(CLASS):
attempts = []
for threshold in range(20, 90, 5):
threshold /= 100
for min_size in [10000, 15000, 20000]:
masks = class_masks(class_id, probabilities, threshold, min_size)
dices = class_dices(class_id, masks, valid_masks)
attempts.append((threshold, min_size, np.mean(dices)))
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)
# ========
# gc
#
torch.cuda.empty_cache()
gc.collect()
# ========
# predict
#
sub = pd.read_csv(sub_csv)
sub['label'] = sub['Image_Label'].apply(lambda x: x.split('_')[-1])
sub['im_id'] = sub['Image_Label'].apply(lambda x: x.replace('_' + x.split('_')[-1], ''))
test_ids = sub['Image_Label'].apply(lambda x: x.split('_')[0]).drop_duplicates().values
test_dataset = CloudDataset(df=sub,
datatype='test',
img_ids=test_ids,
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
encoded_pixels = get_test_encoded_pixels(test_dataset, runner, class_params, test_batch_size)
sub['EncodedPixels'] = encoded_pixels
# ========
# val dice
#
val_Image_Label = []
for i, row in val_fold.iterrows():
val_Image_Label.append(row.file_name + '_Fish')
val_Image_Label.append(row.file_name + '_Flower')
val_Image_Label.append(row.file_name + '_Gravel')
val_Image_Label.append(row.file_name + '_Sugar')
val_encoded_pixels = get_test_encoded_pixels(valid_dataset, runner, class_params, test_batch_size)
val = pd.DataFrame(val_encoded_pixels, columns=['EncodedPixels'])
val['Image_Label'] = val_Image_Label
sub.to_csv(f'./sub/sub_{model_name}_fold_{fold_num}_{encoder}.csv', columns=['Image_Label', 'EncodedPixels'], index=False)
val.to_csv(f'./val/val_{model_name}_fold_{fold_num}_{encoder}.csv', columns=['Image_Label', 'EncodedPixels'], index=False)
def main():
parser = argparse.ArgumentParser()
arg = parser.add_argument
arg('--seed', type=int, default=1234, help='Random seed')
arg('--model-name',
type=str,
default=Path('seresnext101'),
help='String model name used for saving')
arg('--run-root',
type=Path,
default=Path('../results'),
help='Directory for saving model')
arg('--data-root', type=Path, default=Path('../data'))
arg('--image-size', type=int, default=224, help='Image size for training')
arg('--batch-size',
type=int,
default=16,
help='Batch size during training')
arg('--fold', type=int, default=0, help='Validation fold')
arg('--n-epochs', type=int, default=10, help='Epoch to run')
arg('--learning-rate',
type=float,
default=1e-3,
help='Initial learning rate')
arg('--step', type=int, default=1, help='Current training step')
arg('--patience', type=int, default=4)
arg('--criterion', type=str, default='bce', help='Criterion')
arg('--optimizer', default='Adam', help='Name of the optimizer')
arg('--continue_train', type=bool, default=False)
arg('--checkpoint',
type=str,
default=Path('../results'),
help='Checkpoint file path')
arg('--workers', type=int, default=2)
arg('--debug', type=bool, default=True)
args = parser.parse_args()
set_seed(args.seed)
"""
SET PARAMS
"""
args.debug = True
ON_KAGGLE = configs.ON_KAGGLE
N_CLASSES = configs.NUM_CLASSES
args.image_size = configs.SIZE
args.data_root = configs.DATA_ROOT
use_cuda = cuda.is_available()
fold = args.fold
num_workers = args.workers
num_epochs = args.n_epochs
batch_size = args.batch_size
learning_rate = args.learning_rate
"""
LOAD DATA
"""
print(os.listdir(args.data_root))
folds = pd.read_csv(args.data_root / 'folds.csv')
train_root = args.data_root / 'train'
if args.debug:
folds = folds.head(50)
train_fold = folds[folds['fold'] != fold]
valid_fold = folds[folds['fold'] == fold]
check_fold(train_fold, valid_fold)
def get_dataloader(df: pd.DataFrame, image_transform) -> DataLoader:
"""
Calls dataloader to load Imet Dataset
"""
return DataLoader(
ImetDataset(train_root, df, image_transform),
shuffle=True,
batch_size=batch_size,
num_workers=num_workers,
)
train_loader = get_dataloader(train_fold, image_transform=albu_transform)
valid_loader = get_dataloader(valid_fold, image_transform=valid_transform)
print('{} items in train, {} in valid'.format(len(train_loader.dataset),
len(valid_loader.dataset)))
loaders = OrderedDict()
loaders["train"] = train_loader
loaders["valid"] = valid_loader
"""
MODEL
"""
model = seresnext101(num_classes=N_CLASSES)
if use_cuda:
model = model.cuda()
criterion = nn.BCEWithLogitsLoss()
optimizer = Adam(model.parameters(), lr=learning_rate)
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.5,
patience=args.patience)
"""
MODEL RUNNER
"""
# call an instance of the model runner
runner = SupervisedRunner()
# logs folder
current_time = datetime.now().strftime('%b%d_%H_%M')
prefix = f'{current_time}_{args.model_name}'
logdir = os.path.join(args.run_root, prefix)
os.makedirs(logdir, exist_ok=False)
print('\tTrain session :', prefix)
print('\tOn KAGGLE :', ON_KAGGLE)
print('\tDebug :', args.debug)
print('\tClasses number :', N_CLASSES)
print('\tModel :', args.model_name)
print('\tParameters :', model.parameters())
print('\tImage size :', args.image_size)
print('\tEpochs :', num_epochs)
print('\tWorkers :', num_workers)
print('\tLog dir :', logdir)
print('\tLearning rate :', learning_rate)
print('\tBatch size :', batch_size)
print('\tPatience :', args.patience)
if args.continue_train:
state = load_model(model, args.checkpoint)
epoch = state['epoch']
step = state['step']
print('Loaded model weights from {}, epoch {}, step {}'.format(
args.checkpoint, epoch, step))
# model training
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
scheduler=scheduler,
loaders=loaders,
callbacks=[
F1ScoreCallback(threshold=0.5),
#F2ScoreCallback(num_classes=N_CLASSES),
EarlyStoppingCallback(patience=args.patience, min_delta=0.01)
],
logdir=logdir,
num_epochs=num_epochs,
verbose=True)
# by default it only plots loss, works in IPython Notebooks
#utils.plot_metrics(logdir=logdir, metrics=["loss", "_base/lr"])
"""
INFERENCE TEST
"""
loaders = OrderedDict([("infer", loaders["train"])])
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
print(runner.callbacks[1].predictions["logits"])
probabilities_list = []
ttatype='d4'
for fold_idx in range(len(splits['test_idx'])):
print('Getting predictions from fold {}'.format(fold_idx))
logdir = 'logs/{}_fold{}/'.format(exp_name, fold_idx)
model = prepare_model(model_name, n_classes)
model.cuda()
model.load_state_dict(torch.load(os.path.join(logdir,'checkpoints/best.pth'))['model_state_dict'])
model.eval()
if ttatype=='d4':
model = tta.TTAWrapper(model, tta.d4_image2label)
elif ttatype=='fliplr_image2label':
model = tta.TTAWrapper(model, tta.d4_image2label)
runner = SupervisedRunner(model=model)
#predictions = runner.predict_loader(loaders["valid"], resume=f"{logdir}/checkpoints/best.pth")
runner.infer(model=model,loaders=loaders,callbacks=[InferCallback()])
predictions = runner.callbacks[0].predictions['logits']
probabilities = softmax(torch.from_numpy(predictions),dim=1).numpy()
for idx in range(probabilities.shape[0]):
if all(probabilities[idx,:]<0.5):
probabilities[idx,0] = 1.0
probabilities_list.append(probabilities)
probabilities_combined = np.stack(probabilities_list,axis=0).mean(axis=0)
predicted_labels = pd.DataFrame(probabilities_combined, columns=labels)
predicted_labels['id'] = test_data.loc[:,'id'].values
predicted_labels.loc[:,'ID'] = predicted_labels.id.apply(lambda x: x.split('_')[0])
predicted_labels_groupped = predicted_labels.groupby(['ID']).aggregate(dict(zip(labels,['max']*(len(labels)))))
predicted_labels_groupped['ID'] = predicted_labels_groupped.index.values.astype(int)
predicted_labels_groupped.reset_index(drop=True, inplace=True)
predicted_labels_groupped.sort_values('ID',inplace=True)
predicted_labels_groupped = predicted_labels_groupped.loc[:,['ID']+labels]
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)
def generate_class_params(i_dont_know_how_to_return_values_without_map):
preprocessing_fn = smp.encoders.get_preprocessing_fn(
ENCODER, ENCODER_WEIGHTS)
valid_dataset = CloudDataset(
df=train,
datatype='valid',
img_ids=valid_ids,
transforms=get_validation_augmentation(),
preprocessing=get_preprocessing(preprocessing_fn))
valid_loader = DataLoader(valid_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()
# Generate validation predictions
encoded_pixels = []
loaders = {"infer": valid_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
valid_masks = []
probabilities = np.zeros((2220, 350, 525))
for i, (batch, output) in enumerate(
tqdm.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(30, 100, 5):
t /= 100
for ms in [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)
return class_params
# encoder = 'efficientnet-b4'
# arch = 'linknet'
model, preprocessing_fn = get_model(encoder, type=arch)
valid_dataset, loaders = get_loaders(bs, num_workers, preprocessing_fn)
train_loader = loaders['train']
valid_loader = loaders['valid']
print("Loading model")
runner = SupervisedRunner()
encoded_pixels = []
loaders = {"infer": valid_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[CheckpointCallback(resume=model_path),
InferCallback()],
)
loaders['train'] = train_loader
loaders['valid'] = valid_loader
size = (320, 480)
if load_params:
print(">>>> Loading params")
with open(output_name + "_params.pkl", 'rb') as handle:
class_params = pickle.load(handle)
else:
print("Learning threshold and min area")
valid_masks = []
LIMIT = 800
probabilities = np.zeros((int(LIMIT * 4), 320, 480)) #HARDCODED FOR NOW
def training(train_ids, valid_ids, num_split, encoder, decoder):
"""
模型训练
"""
train = "./data/Clouds_Classify/train.csv"
# Data overview
train = pd.read_csv(open(train))
train.head()
train['label'] = train['Image_Label'].apply(lambda x: x.split('_')[1])
train['im_id'] = train['Image_Label'].apply(lambda x: x.split('_')[0])
ENCODER = encoder
ENCODER_WEIGHTS = 'imagenet'
if decoder == 'unet':
model = smp.Unet(
encoder_name=ENCODER,
encoder_weights=ENCODER_WEIGHTS,
classes=4,
activation=None,
)
else:
model = smp.FPN(
encoder_name=ENCODER,
encoder_weights=ENCODER_WEIGHTS,
classes=4,
activation=None,
)
preprocessing_fn = smp.encoders.get_preprocessing_fn(
ENCODER, ENCODER_WEIGHTS)
num_workers = 4
bs = 12
train_dataset = CloudDataset(
df=train,
transforms=get_training_augmentation(),
datatype='train',
img_ids=train_ids,
preprocessing=get_preprocessing(preprocessing_fn))
valid_dataset = CloudDataset(
df=train,
transforms=get_validation_augmentation(),
datatype='valid',
img_ids=valid_ids,
preprocessing=get_preprocessing(preprocessing_fn))
train_loader = DataLoader(train_dataset,
batch_size=bs,
shuffle=True,
num_workers=num_workers)
valid_loader = DataLoader(valid_dataset,
batch_size=bs,
shuffle=False,
num_workers=num_workers)
loaders = {"train": train_loader, "valid": valid_loader}
num_epochs = 50
logdir = "./logs/log_{}_{}/log_{}".format(encoder, decoder, num_split)
# 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.35, patience=4)
criterion = smp.utils.losses.BCEDiceLoss(eps=1.)
runner = SupervisedRunner()
runner.train(model=model,
criterion=criterion,
optimizer=optimizer,
scheduler=scheduler,
loaders=loaders,
callbacks=[DiceCallback()],
logdir=logdir,
num_epochs=num_epochs,
verbose=True)
# Exploring predictions
loaders = {"infer": valid_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
def main(config):
opts = config()
path = opts.path
train = pd.read_csv(f'{path}/train.csv')
sub = pd.read_csv(f'{path}/sample_submission.csv')
n_train = len(os.listdir(f'{path}/train_images'))
n_test = len(os.listdir(f'{path}/test_images'))
sub['label'] = sub['Image_Label'].apply(lambda x: x.split('_')[1])
sub['im_id'] = sub['Image_Label'].apply(lambda x: x.split('_')[0])
train.loc[train['EncodedPixels'].isnull() == False,
'Image_Label'].apply(lambda x: x.split('_')[1]).value_counts()
train.loc[train['EncodedPixels'].isnull() == False, 'Image_Label'].apply(
lambda x: x.split('_')[0]).value_counts().value_counts()
train['label'] = train['Image_Label'].apply(lambda x: x.split('_')[1])
train['im_id'] = train['Image_Label'].apply(lambda x: x.split('_')[0])
valid_ids = pd.read_csv("csvs/valid_threshold.csv")["img_id"].values
test_ids = sub['Image_Label'].apply(
lambda x: x.split('_')[0]).drop_duplicates().values
# print(valid_ids)
ENCODER = opts.backborn
ENCODER_WEIGHTS = opts.encoder_weights
DEVICE = 'cuda'
ACTIVATION = None
model = get_model(model_type=opts.model_type,
encoder=ENCODER,
encoder_weights=ENCODER_WEIGHTS,
activation=ACTIVATION,
n_classes=opts.class_num,
task=opts.task,
attention_type=opts.attention_type,
head='simple',
center=opts.center,
tta=opts.tta)
if opts.refine:
model = get_ref_model(infer_model=model,
encoder=opts.ref_backborn,
encoder_weights=ENCODER_WEIGHTS,
activation=ACTIVATION,
n_classes=opts.class_num,
preprocess=opts.preprocess,
tta=opts.tta)
model = convert_model(model)
preprocessing_fn = encoders.get_preprocessing_fn(ENCODER, ENCODER_WEIGHTS)
encoded_pixels = []
runner = SupervisedRunner()
probabilities = np.zeros((2220, 350, 525))
for i in range(opts.fold_max):
if opts.refine:
logdir = f"{opts.logdir}_refine/fold{i}"
else:
logdir = f"{opts.logdir}/fold{i}"
valid_dataset = CloudDataset(
df=train,
datatype='valid',
img_ids=valid_ids,
transforms=get_validation_augmentation(opts.img_size),
preprocessing=get_preprocessing(preprocessing_fn))
valid_loader = DataLoader(valid_dataset,
batch_size=opts.batchsize,
shuffle=False,
num_workers=opts.num_workers)
loaders = {"infer": valid_loader}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth"),
InferCallback()
],
)
valid_masks = []
for i, (batch, output) in enumerate(
tqdm.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, :, :] += sigmoid(probability)
probabilities /= opts.fold_max
if opts.tta:
np.save(
f'probabilities/{opts.logdir.split("/")[-1]}_{opts.img_size[0]}x{opts.img_size[1]}_tta_valid.npy',
probabilities)
else:
np.save(
f'probabilities/{opts.logdir.split("/")[-1]}_{opts.img_size[0]}x{opts.img_size[1]}_valid.npy',
probabilities)
torch.cuda.empty_cache()
gc.collect()
class_params = {}
cv_d = []
for class_id in tqdm.trange(opts.class_num, desc='class_id', leave=False):
# print(class_id)
attempts = []
for tt in tqdm.trange(0, 100, 10, desc='top_threshold', leave=False):
tt /= 100
for bt in tqdm.trange(0,
100,
10,
desc='bot_threshold',
leave=False):
bt /= 100
for ms in tqdm.tqdm([
0, 100, 1000, 5000, 10000, 11000, 14000, 15000, 16000,
18000, 19000, 20000, 21000, 23000, 25000, 27000, 30000,
50000
],
desc='min_size',
leave=False):
masks = []
for i in range(class_id, len(probabilities), 4):
probability = probabilities[i]
predict, num_predict = post_process(
probability, tt, ms, bt)
masks.append(predict)
d = []
for i, j in zip(masks, valid_masks[class_id::4]):
# print(i.shape, j.shape)
if (i.sum() == 0) & (j.sum() == 0):
d.append(1)
else:
d.append(dice(i, j))
attempts.append((tt, ms, bt, np.mean(d)))
attempts_df = pd.DataFrame(
attempts,
columns=['top_threshold', 'size', 'bottom_threshold', 'dice'])
attempts_df = attempts_df.sort_values('dice', ascending=False)
print(attempts_df.head())
cv_d.append(attempts_df['dice'].values[0])
best_top_threshold = attempts_df['top_threshold'].values[0]
best_size = attempts_df['size'].values[0]
best_bottom_threshold = attempts_df['bottom_threshold'].values[0]
class_params[class_id] = (best_top_threshold, best_size,
best_bottom_threshold)
cv_d = np.array(cv_d)
print("CV Dice:", np.mean(cv_d))
pathlist = [
"../input/test_images/" + i.split("_")[0] for i in sub['Image_Label']
]
del masks
del valid_masks
del probabilities
gc.collect()
############# predict ###################
probabilities = np.zeros((n_test, 4, 350, 525))
for fold in tqdm.trange(opts.fold_max, desc='fold loop'):
if opts.refine:
logdir = f"{opts.logdir}_refine/fold{fold}"
else:
logdir = f"{opts.logdir}/fold{fold}"
# loaders = {"test": test_loader}
test_dataset = CloudDataset(
df=sub,
datatype='test',
img_ids=test_ids,
transforms=get_validation_augmentation(opts.img_size),
preprocessing=get_preprocessing(preprocessing_fn))
test_loader = DataLoader(test_dataset,
batch_size=opts.batchsize,
shuffle=False,
num_workers=opts.num_workers)
runner_out = runner.predict_loader(
model,
test_loader,
resume=f"{logdir}/checkpoints/best.pth",
verbose=True)
for i, batch in enumerate(
tqdm.tqdm(runner_out, desc='probability loop')):
for j, probability in enumerate(batch):
if probability.shape != (350, 525):
probability = cv2.resize(probability,
dsize=(525, 350),
interpolation=cv2.INTER_LINEAR)
probabilities[i, j, :, :] += sigmoid(probability)
gc.collect()
probabilities /= opts.fold_max
if opts.tta:
np.save(
f'probabilities/{opts.logdir.split("/")[-1]}_{opts.img_size[0]}x{opts.img_size[1]}_tta_test.npy',
probabilities)
else:
np.save(
f'probabilities/{opts.logdir.split("/")[-1]}_{opts.img_size[0]}x{opts.img_size[1]}_test.npy',
probabilities)
image_id = 0
print("##################### start post_process #####################")
for i in tqdm.trange(n_test, desc='post porocess loop'):
for probability in probabilities[i]:
predict, num_predict = post_process(probability,
class_params[image_id % 4][0],
class_params[image_id % 4][1],
class_params[image_id % 4][2])
if num_predict == 0:
encoded_pixels.append('')
else:
black_mask = get_black_mask(pathlist[image_id])
predict = np.multiply(predict, black_mask)
r = mask2rle(predict)
encoded_pixels.append(r)
image_id += 1
gc.collect()
print("##################### Finish post_process #####################")
#######################################
sub['EncodedPixels'] = encoded_pixels
sub.to_csv(
f'submissions/submission_{opts.logdir.split("/")[-1]}_{opts.img_size[0]}x{opts.img_size[1]}.csv',
columns=['Image_Label', 'EncodedPixels'],
index=False)
def optimal_valid(k, net, config, loader_fold, ENCODER, ENCODER_WEIGHTS,
ACTIVATION):
runner = SupervisedRunner()
model = load_model(net, ENCODER, ENCODER_WEIGHTS, ACTIVATION)
logdir = "./logs/segmentation_{}_{}Fold".format(net, k)
loaders = {"infer": loader_fold[k]['valid']}
runner.infer(
model=model,
loaders=loaders,
callbacks=[
CheckpointCallback(resume=f"{logdir}/checkpoints/{config}.pth"),
InferCallback()
],
)
###################### dummy test ######################
if 1:
label_list = ["Fish", "Flower", "Gravel", "Sugar"]
valid_masks = []
probabilities = np.zeros(
(len(loader_fold[k]['valid'].dataset) * 4, 350, 525))
for i, (batch, output) in tqdm.tqdm_notebook(
enumerate(
zip(loaders['infer'].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
# Find optimal values
# First of all, my thanks to @samusram for finding a mistake in my validation
# https://www.kaggle.com/c/understanding_cloud_organization/discussion/107711#622412
# And now I find optimal values separately for each class.
class_params = {}
for class_id in range(4):
print(label_list[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]
best_dice = attempts_df['dice'].values[0]
class_params[class_id] = (best_threshold, best_size, best_dice)
print("Best Threshold", class_params)
print()
print("Avg Valid Dice", (class_params[0][2] + class_params[1][2] +
class_params[2][2] + class_params[3][2]) / 4)
else:
class_params = {
0: (0.6, 10000, 0.614792005689229),
1: (0.7, 10000, 0.7479094686835059),
2: (0.55, 10000, 0.6083618093569516),
3: (0.45, 10000, 0.5766765025111799)
}
###################### dummy test ######################
# print("Classification Report")
del loaders
torch.cuda.empty_cache()
gc.collect()
return class_params, runner