def run_cls(config_file_cls):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 1. classification inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_cls)
validloader = make_loader(data_folder=config.data.train_dir,
df_path=config.data.train_df_path,
phase='valid',
batch_size=config.train.batch_size,
num_workers=config.num_workers,
idx_fold=config.data.params.idx_fold,
transforms=get_transforms(
config.transforms.test),
num_classes=config.data.num_classes,
task='cls')
model = CustomNet(config.model.encoder, config.data.num_classes)
model.to(config.device)
model.eval()
checkpoint = load_checkpoint(f"{config.work_dir}/checkpoints/best.pth")
model.load_state_dict(checkpoint['model_state_dict'])
all_predictions = []
all_targets = []
with torch.no_grad():
for i, (batch_images, batch_targets) in enumerate(tqdm(validloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta,
task='cls')
all_targets.append(batch_targets)
all_predictions.append(batch_preds)
all_predictions = np.concatenate(all_predictions)
all_targets = np.concatenate(all_targets)
# evaluation
all_accuracy_scores = []
all_f1_scores = []
thresholds = np.linspace(0.1, 0.9, 9)
for th in thresholds:
accuracy = accuracy_score(all_targets > th, all_predictions > th)
f1 = f1_score(all_targets > th,
all_predictions > th,
average='samples')
all_accuracy_scores.append(accuracy)
all_f1_scores.append(f1)
for th, score in zip(thresholds, all_accuracy_scores):
print('validation accuracy for threshold {} = {}'.format(th, score))
for th, score in zip(thresholds, all_f1_scores):
print('validation f1 score for threshold {} = {}'.format(th, score))
np.save('valid_preds', all_predictions)
def run_cls(config_dir):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 1. classification inference
# ------------------------------------------------------------------------------------------------------------
config_root = Path(config_dir) / 'cls'
config_paths = [config_root / p for p in os.listdir(config_root)]
base_config_paths = [
Path(config_dir) / p for p in os.listdir(config_dir) if 'yml' in p
]
config = load_config(base_config_paths[0])
models = []
for c in config_paths:
models.append(load_model(c))
model = MultiClsModels(models)
testloader = make_loader(
data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test),
num_classes=config.data.num_classes,
)
all_fnames = []
all_predictions = []
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta,
task='cls')
all_fnames.extend(batch_fnames)
all_predictions.append(batch_preds)
all_predictions = np.concatenate(all_predictions)
np.save('all_preds', all_predictions)
df = pd.DataFrame(data=all_predictions, index=all_fnames)
df.to_csv('cls_preds.csv')
df.to_csv(KAGGLE_WORK_DIR + '/cls_preds.csv')
def run_cls(config_file_cls):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 1. classification inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_cls)
model = CustomNet(config.model.encoder, config.data.num_classes)
testloader = make_loader(
data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test),
num_classes=config.data.num_classes,
)
model.to(config.device)
model.eval()
checkpoint = load_checkpoint(f"{config.work_dir}/checkpoints/best.pth")
model.load_state_dict(checkpoint['model_state_dict'])
all_fnames = []
all_predictions = []
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta,
task='cls')
all_fnames.extend(batch_fnames)
all_predictions.append(batch_preds)
all_predictions = np.concatenate(all_predictions)
np.save('all_preds', all_predictions)
df = pd.DataFrame(data=all_predictions, index=all_fnames)
df.to_csv('cls_preds.csv', index=False)
df.to_csv(f"{config.work_dir}/cls_preds.csv", index=False)
def run_seg(config_file_seg):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 2. segmentation inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_seg)
model = getattr(smp, config.model.arch)(
encoder_name=config.model.encoder,
encoder_weights=config.model.pretrained,
classes=config.data.num_classes,
activation=None,
)
if os.path.exists('cls_preds.csv'):
testloader = make_loader(data_folder=config.data.test_dir,
df_path='cls_preds.csv',
phase='filtered_test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(
config.transforms.test))
else:
testloader = make_loader(data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(
config.transforms.test))
model.to(config.device)
model.eval()
checkpoint = load_checkpoint(f"{config.work_dir}/checkpoints/best.pth")
model.load_state_dict(checkpoint['model_state_dict'])
if os.path.exists(config.work_dir + '/threshold_search.json'):
with open(config.work_dir + '/threshold_search.json') as json_file:
data = json.load(json_file)
df = pd.DataFrame(data)
min_sizes = list(df.T.idxmax().values.astype(int))
print('load best threshold from validation:', min_sizes)
else:
min_sizes = config.test.min_size
print('load default threshold:', min_sizes)
predictions = []
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta)
for fname, preds in zip(batch_fnames, batch_preds):
if config.data.num_classes == 4:
for cls in range(preds.shape[0]):
mask = preds[cls, :, :]
mask, num = post_process(mask,
config.test.best_threshold,
min_sizes[cls])
rle = mask2rle(mask)
name = fname + f"_{cls + 1}"
predictions.append([name, rle])
else: # == 5
for cls in range(1, 5):
mask = preds[cls, :, :]
mask, num = post_process(mask,
config.test.best_threshold,
min_sizes[cls])
rle = mask2rle(mask)
name = fname + f"_{cls}"
predictions.append([name, rle])
# ------------------------------------------------------------------------------------------------------------
# submission
# ------------------------------------------------------------------------------------------------------------
df = pd.DataFrame(predictions,
columns=['ImageId_ClassId', 'EncodedPixels'])
df.to_csv(config.work_dir + "/submission.csv", index=False)
def ensemble():
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# parmeters and configs
# ------------------------------------------------------------------------------------------------------------
config_paths320 = [
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold0.yml',
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold1.yml',
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold2.yml',
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold3.yml',
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold4.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold0.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold1.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold2.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold3.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold4.yml',
]
config_paths384 = [
'config/seg/032_efnet_b3_Unet_img384_RandomSizedCrop_half_cosine_fold0.yml',
'config/seg/032_efnet_b3_Unet_img384_RandomSizedCrop_half_cosine_fold1.yml',
'config/seg/032_efnet_b3_Unet_img384_RandomSizedCrop_half_cosine_fold2.yml',
'config/seg/032_efnet_b3_Unet_img384_RandomSizedCrop_half_cosine_fold3.yml',
'config/seg/032_efnet_b3_Unet_img384_RandomSizedCrop_half_cosine_fold4.yml',
'config/seg/048_resnet34_FPN_img384_mixup_fold0.yml',
'config/seg/048_resnet34_FPN_img384_mixup_fold1.yml',
'config/seg/048_resnet34_FPN_img384_mixup_fold2.yml',
'config/seg/048_resnet34_FPN_img384_mixup_fold3.yml',
'config/seg/048_resnet34_FPN_img384_mixup_fold4.yml',
]
LABEL_THRESHOLDS = [0.68, 0.69, 0.69, 0.67]
MASK_THRESHOLDS = [0.31, 0.36, 0.31, 0.34]
MIN_SIZES = [7500, 10000, 7500, 7500]
WEIGHTS = [0.5, 0.5]
# ------------------------------------------------------------------------------------------------------------
#
# ------------------------------------------------------------------------------------------------------------
config = load_config('config/base_config.yml')
def get_model_and_loader(config_paths):
config = load_config(config_paths[0])
models = []
for c in config_paths:
models.append(load_model(c))
model = MultiSegModels(models)
testloader = make_loader(
data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test))
return model, testloader
model320, loader320 = get_model_and_loader(config_paths320)
model384, loader384 = get_model_and_loader(config_paths384)
predictions = []
with torch.no_grad():
for (batch_fnames320,
batch_images320), (batch_fnames384, batch_images384) in tqdm(
zip(loader320, loader384)):
batch_images320 = batch_images320.to(config.device)
batch_images384 = batch_images384.to(config.device)
batch_preds320 = predict_batch(model320,
batch_images320,
tta=config.test.tta)
batch_preds384 = predict_batch(model384,
batch_images384,
tta=config.test.tta)
batch_preds320 = resize_batch_images(batch_preds320, SUB_HEIGHT,
SUB_WIDTH)
batch_preds384 = resize_batch_images(batch_preds384, SUB_HEIGHT,
SUB_WIDTH)
batch_preds = batch_preds320 * \
WEIGHTS[0] + batch_preds384 * WEIGHTS[1]
batch_labels320 = torch.nn.functional.adaptive_max_pool2d(
torch.sigmoid(torch.Tensor(batch_preds320)),
1).view(batch_preds320.shape[0], -1)
batch_labels384 = torch.nn.functional.adaptive_max_pool2d(
torch.sigmoid(torch.Tensor(batch_preds384)),
1).view(batch_preds384.shape[0], -1)
batch_labels = batch_labels320 * \
WEIGHTS[0] + batch_labels384 * WEIGHTS[1]
for fname, preds, labels in zip(batch_fnames320, batch_preds,
batch_labels):
for cls in range(4):
if labels[cls] <= LABEL_THRESHOLDS[cls]:
pred = np.zeros(preds[cls, :, :].shape)
else:
pred, _ = post_process(preds[cls, :, :],
MASK_THRESHOLDS[cls],
MIN_SIZES[cls],
height=SUB_HEIGHT,
width=SUB_WIDTH)
rle = mask2rle(pred)
cls_name = INV_CLASSES[cls]
name = fname + f"_{cls_name}"
predictions.append([name, rle])
# ------------------------------------------------------------------------------------------------------------
# submission
# ------------------------------------------------------------------------------------------------------------
sub_df = pd.DataFrame(predictions,
columns=['Image_Label', 'EncodedPixels'])
sample_submission = pd.read_csv(config.data.sample_submission_path)
df_merged = pd.merge(sample_submission,
sub_df,
on='Image_Label',
how='left')
df_merged.fillna('', inplace=True)
df_merged['EncodedPixels'] = df_merged['EncodedPixels_y']
df_merged = df_merged[['Image_Label', 'EncodedPixels']]
df_merged.to_csv("submission.csv", index=False)
if 'COLAB_GPU' in os.environ:
config.work_dir = '/content/drive/My Drive/kaggle_cloud/'
elif 'KAGGLE_WORKING_DIR' in os.environ:
config.work_dir = '/kaggle/working/'
else:
config.work_dir = '.'
df_merged.to_csv(config.work_dir + '/submission.csv', index=False)
def run_seg(config_file_seg):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 2. segmentation inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_seg)
if 'COLAB_GPU' in os.environ:
config.work_dir = '/content/drive/My Drive/kaggle_cloud/' + config.work_dir
elif 'KAGGLE_WORKING_DIR' in os.environ:
config.work_dir = '/kaggle/working/' + config.work_dir
if os.path.exists('cls_preds.csv'):
testloader = make_loader(
data_folder=config.data.test_dir,
df_path='cls_preds.csv',
phase='filtered_test',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test))
else:
testloader = make_loader(
data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test))
model = load_model(config_file_seg)
if os.path.exists(config.work_dir + '/threshold_search.json'):
with open(config.work_dir + '/threshold_search.json') as json_file:
data = json.load(json_file)
df = pd.DataFrame(data)
min_sizes = list(df.T.idxmax().values.astype(int))
print('load best threshold from validation:', min_sizes)
else:
min_sizes = config.test.min_size
print('load default threshold:', min_sizes)
predictions = []
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta)
for fname, preds in zip(batch_fnames, batch_preds):
for cls in range(preds.shape[0]):
pred, _ = post_process(
preds[cls, :, :],
config.test.best_threshold,
min_sizes[cls],
height=config.transforms.test.Resize.height,
width=config.transforms.test.Resize.width)
pred = cv2.resize(pred, (SUB_WIDTH, SUB_HEIGHT))
pred = (pred > 0.5).astype(int)
rle = mask2rle(pred)
cls_name = INV_CLASSES[cls]
name = fname + f"_{cls_name}"
predictions.append([name, rle])
# ------------------------------------------------------------------------------------------------------------
# submission
# ------------------------------------------------------------------------------------------------------------
df = pd.DataFrame(predictions, columns=['Image_Label', 'EncodedPixels'])
df.to_csv(config.work_dir + "/submission.csv", index=False)
def run_seg(config_file_seg):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 2. segmentation inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_seg)
validloader = make_loader(
data_folder=config.data.train_dir,
df_path=config.data.train_df_path,
phase='valid',
batch_size=config.train.batch_size,
num_workers=config.num_workers,
idx_fold=config.data.params.idx_fold,
transforms=get_transforms(config.transforms.test),
num_classes=config.data.num_classes,
)
# create segmentation model with pre-trained encoder
model = getattr(smp, config.model.arch)(
encoder_name=config.model.encoder,
encoder_weights=config.model.pretrained,
classes=config.data.num_classes,
activation=None,
)
model.to(config.device)
model.eval()
checkpoint = load_checkpoint(f"{config.work_dir}/checkpoints/best.pth")
model.load_state_dict(checkpoint['model_state_dict'])
all_dice = {}
min_sizes = [100, 300, 500, 750, 1000, 1500, 2000, 3000]
for min_size in min_sizes:
all_dice[min_size] = {}
for cls in range(config.data.num_classes):
all_dice[min_size][cls] = []
with torch.no_grad():
for i, (batch_images, batch_masks) in enumerate(tqdm(validloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta)
batch_masks = batch_masks.cpu().numpy()
for masks, preds in zip(batch_masks, batch_preds):
for cls in range(config.data.num_classes):
for min_size in min_sizes:
pred, _ = post_process(preds[cls, :, :],
config.test.best_threshold,
min_size)
mask = masks[cls, :, :]
all_dice[min_size][cls].append(dice_score(pred, mask))
for cls in range(config.data.num_classes):
for min_size in min_sizes:
all_dice[min_size][cls] = sum(all_dice[min_size][cls]) / len(
all_dice[min_size][cls])
dict_to_json(all_dice, config.work_dir + '/threshold_search.json')
if config.data.num_classes == 4:
defect_class = cls + 1
else:
defect_class = cls
print('average dice score for class{} for min_size {}: {}'.format(
defect_class, min_size, all_dice[min_size][cls]))
def validation(config_file_seg):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
config = load_config(config_file_seg)
if 'COLAB_GPU' in os.environ:
config.work_dir = '/content/drive/My Drive/kaggle_cloud/' + config.work_dir
elif 'KAGGLE_WORKING_DIR' in os.environ:
config.work_dir = '/kaggle/working/' + config.work_dir
validloader = make_loader(
data_folder=config.data.train_dir,
df_path=config.data.train_df_path,
phase='valid',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
idx_fold=config.data.params.idx_fold,
transforms=get_transforms(config.transforms.test),
num_classes=config.data.num_classes,
)
model = load_model(config_file_seg)
min_sizes = np.arange(0, 20000, 5000)
label_thresholds = [0.6, 0.7, 0.8]
mask_thresholds = [0.2, 0.3, 0.4]
all_dice = np.zeros(
(4, len(label_thresholds), len(mask_thresholds), len(min_sizes)))
count = 0
with torch.no_grad():
for i, (batch_images, batch_masks) in enumerate(tqdm(validloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta)
batch_labels = torch.nn.functional.adaptive_max_pool2d(
torch.sigmoid(torch.Tensor(batch_preds)),
1).view(batch_preds.shape[0], -1)
batch_masks = batch_masks.cpu().numpy()
batch_labels = batch_labels.cpu().numpy()
batch_masks = resize_batch_images(batch_masks, SUB_HEIGHT,
SUB_WIDTH)
batch_preds = resize_batch_images(batch_preds, SUB_HEIGHT,
SUB_WIDTH)
for labels, masks, preds in zip(batch_labels, batch_masks,
batch_preds):
for cls in range(config.data.num_classes):
for i, label_th in enumerate(label_thresholds):
for j, mask_th in enumerate(mask_thresholds):
for k, min_size in enumerate(min_sizes):
if labels[cls] <= label_th:
pred = np.zeros(preds[cls, :, :].shape)
else:
pred, _ = post_process(preds[cls, :, :],
mask_th,
min_size,
height=SUB_HEIGHT,
width=SUB_WIDTH)
mask = masks[cls, :, :]
dice = dice_score(pred, mask)
all_dice[cls, i, j, k] += dice
count += 1
all_dice = all_dice / (count)
np.save('all_dice', all_dice)
parameters = {}
parameters['label_thresholds'] = []
parameters['mask_thresholds'] = []
parameters['min_sizes'] = []
parameters['dice'] = []
cv_score = 0
for cls in range(4):
i, j, k = np.where((all_dice[cls] == all_dice[cls].max()))
parameters['label_thresholds'].append(float(label_thresholds[i[0]]))
parameters['mask_thresholds'].append(float(mask_thresholds[j[0]]))
parameters['min_sizes'].append(int(min_sizes[k[0]]))
parameters['dice'].append(float(all_dice[cls].max()))
cv_score += all_dice[cls].max() / 4
print('cv_score:', cv_score)
dict_to_json(parameters, config.work_dir + '/parameters.json')
print(pd.DataFrame(parameters))
def run_seg(config_dir):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 2. segmentation inference
# ------------------------------------------------------------------------------------------------------------
config_root = Path(config_dir) / 'seg'
config_paths = [config_root / p for p in os.listdir(config_root)]
base_config_paths = [
Path(config_dir) / p for p in os.listdir(config_dir) if 'yml' in p
]
config = load_config(base_config_paths[0])
models = []
for c in config_paths:
models.append(load_model(c))
model = MultiSegModels(models)
if os.path.exists('cls_preds.csv'):
testloader = make_loader(data_folder=config.data.test_dir,
df_path='cls_preds.csv',
phase='filtered_test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(
config.transforms.test))
else:
testloader = make_loader(data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(
config.transforms.test))
if os.path.exists(config.work_dir + '/threshold_search.json'):
with open(config.work_dir + '/threshold_search.json') as json_file:
data = json.load(json_file)
df = pd.DataFrame(data)
min_sizes = list(df.T.idxmax().values.astype(int))
print('load best threshold from validation:', min_sizes)
else:
min_sizes = config.test.min_size
print('load default threshold:', min_sizes)
predictions = []
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta)
for fname, preds in zip(batch_fnames, batch_preds):
for cls in range(preds.shape[0]):
mask = preds[cls, :, :]
mask, num = post_process(mask, config.test.best_threshold,
min_sizes[cls])
rle = mask2rle(mask)
name = fname + f"_{cls + 1}"
predictions.append([name, rle])
# ------------------------------------------------------------------------------------------------------------
# submission
# ------------------------------------------------------------------------------------------------------------
sub_df = pd.DataFrame(predictions,
columns=['ImageId_ClassId', 'EncodedPixels'])
sample_submission = pd.read_csv(config.data.sample_submission_path)
df_merged = pd.merge(sample_submission,
sub_df,
on='ImageId_ClassId',
how='left')
df_merged.fillna('', inplace=True)
df_merged['EncodedPixels'] = df_merged['EncodedPixels_y']
df_merged = df_merged[['ImageId_ClassId', 'EncodedPixels']]
df_merged.to_csv("submission.csv", index=False)
df_merged.to_csv(KAGGLE_WORK_DIR + "/submission.csv", index=False)
def ensemble():
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# parmeters and configs
# ------------------------------------------------------------------------------------------------------------
config_paths320 = [
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold0.yml',
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold1.yml',
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold2.yml',
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold3.yml',
'config/seg/017_efnet_b3_Unet_img320_cutout5_aug_fold4.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold0.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold1.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold2.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold3.yml',
'config/seg/030_efnet_b0_Unet_bs16_half_cosine_fold4.yml',
]
#see there use later on
# LABEL_THRESHOLDS = [0.68, 0.69, 0.69, 0.67]
# MASK_THRESHOLDS = [0.31, 0.36, 0.31, 0.34]
LABEL_THRESHOLDS = [0.67, 0.67, 0.67, 0.67,0.67,0.67,0.67,0.50]
MASK_THRESHOLDS = [0.31, 0.31, 0.31, 0.31,0.31,0.31,0.31,0.31]
# MIN_SIZES = [7500, 7500, 7500, 7500,7500,7500,7500,7500]
MIN_SIZES = [0,0,0,0,0,0,0,0]
WEIGHTS = [0.5, 0.5]
# ------------------------------------------------------------------------------------------------------------
#
# ------------------------------------------------------------------------------------------------------------
config = load_config('config/base_config.yml')
''' load the models for evaluation'''
def get_model_and_loader(config_paths):
config = load_config(config_paths[0])
models = []
for c in config_paths:
models.append(load_model(c))
model = MultiSegModels(models)
print(config.data.test_dir)
testloader = make_loader(
data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test)
)
return model, testloader
model320, loader320=get_model_and_loader(config_paths320)
predictions = []
with torch.no_grad():
for (batch_fnames320, batch_images320) in tqdm(loader320):
batch_images320 = batch_images320.to(config.device)
print(batch_images320.size())
batch_preds320 = predict_batch(
model320, batch_images320, tta=config.test.tta)
#resize the images from multi resolution models
batch_preds320 = resize_batch_images(
batch_preds320, SUB_HEIGHT, SUB_WIDTH)
batch_preds=batch_preds320
batch_labels320 = torch.nn.functional.adaptive_max_pool2d(torch.sigmoid(
torch.Tensor(batch_preds320)), 1).view(batch_preds320.shape[0], -1)
#print(batch_labels320)
#change batch_labels by weighing factor later on
batch_labels =batch_labels320
print("batch_preds",batch_preds.shape)
print("batch_labels",batch_labels.size())
for fname, preds, labels in zip(batch_fnames320, batch_preds, batch_labels):
print("ad",labels.size())
for cls in range(8):
if labels[cls] <= LABEL_THRESHOLDS[cls]:
pred = np.zeros(preds[cls, :, :].shape)
print("setting 0",cls)
else:
if cls==7:
print("ok")
#print("probability",preds[cls, :, :])
pred, _ = post_process(
preds[cls, :, :], MASK_THRESHOLDS[cls], MIN_SIZES[cls], height=SUB_HEIGHT, width=SUB_WIDTH)
cls_name = INV_CLASSES[cls]
print(fname)
dump_name='results/masks/experiment1/'+fname+'class_'+str(cls)+'.jpg'
print(dump_name)
cv2.imwrite(dump_name, pred* 255)
