RandomSizedCrop(min_max_height=(int(sz * 0.8), int(sz * 0.8)),
height=sz,
width=sz,
p=0.5),
HueSaturationValue(p=0.4),
HorizontalFlip(0.4),
VerticalFlip(0.4),
Normalize(always_apply=True)
])
test_df = pd.read_csv('data/test_768.csv')
test_image_path = 'data/test_768'
test_meta = np.array(test_df[meta_features].values, dtype=np.float32)
model = EffNet(pretrained_model=pretrained_model,
use_meta=use_meta,
freeze_upto=freeze_upto,
out_neurons=500,
meta_neurons=250).to(device)
# model = Attn_Resnest(pretrained_model, use_meta=use_meta, out_neurons=500, meta_neurons=250).to(device)
# model = Resnest(pretrained_model, use_meta=use_meta, out_neurons=500, meta_neurons=250).to(device)
# model = Mixnet(pretrained_model, use_meta=use_meta, out_neurons=500, meta_neurons=250).to(device)
# model = EffNet_ArcFace(pretrained_model=pretrained_model, use_meta=use_meta, freeze_upto=freeze_upto, out_neurons=500, meta_neurons=250).to(device)
# model = EffNet(pretrained_model=pretrained_model, use_meta=True, freeze_upto=freeze_upto, out_neurons=500, meta_neurons=250).to(device)
# model = seresnext(pretrained_model, use_meta=True).to(device)
pred_cols = ['image_name'].extend([f'TTA{i}' for i in range(TTA)])
# augs = [test_aug, tta_aug1, tta_aug2, tta_aug3, tta_aug4, tta_aug5, tta_aug6, tta_aug7, tta_aug8, tta_aug9]
# augs = [test_aug, tta_aug1, tta_aug3, tta_aug6, tta_aug7, tta_aug8]
augs = [
test_aug, tta_aug1, tta_aug1, tta_aug1, tta_aug3, tta_aug3, tta_aug3,
tta_aug6, tta_aug6, tta_aug6, tta_aug7, tta_aug7, tta_aug7, tta_aug8,
base_criterion = nn.BCEWithLogitsLoss(reduction='sum')
# base_criterion = criterion_margin_focal_binary_cross_entropy
# mixup_criterion_ = partial(mixup_criterion, criterion=base_criterion, rate=1.0)
mixup_criterion = MixupLoss(base_criterion, 1.0)
# ohem_criterion = partial(ohem_loss, rate=1.0, base_crit=base_criterion)
criterions = [base_criterion, mixup_criterion]
# criterion = criterion_margin_focal_binary_cross_entropy
lr_reduce_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau
for f in range(n_fold):
print(f"FOLD #{f}")
train_df = df[(df['fold'] != f)]
valid_df = df[df['fold'] == f]
if 'eff' in model_name:
base = EffNet(pretrained_model=pretrained_model,
num_class=num_class).to(device)
elif 'nfnet' in model_name:
base = NFNet(model_name=pretrained_model,
num_class=num_class).to(device)
elif 'vit' in model_name:
base = ViT(pretrained_model, num_class=num_class) # Not Working
else:
if model_type == 'Normal':
base = Resne_t(pretrained_model, num_class=num_class).to(device)
elif model_type == 'Attention':
base = AttentionResne_t(pretrained_model,
num_class=num_class).to(device)
elif model_type == 'Bottleneck':
base = BotResne_t(pretrained_model, dim=sz,
num_class=num_class).to(device)
elif model_type == 'TripletAttention':
train_folds = [0, 1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16]
valid_folds = [4, 9, 14]
train_df = df[df['fold'] == train_folds[0]]
valid_df = df[df['fold'] == valid_folds[0]]
for i in train_folds[1:]:
train_df = pd.concat([train_df, df[df['fold'] == i]])
for i in valid_folds[1:]:
valid_df = pd.concat([valid_df, df[df['fold'] == i]])
train_df = pd.concat([train_df, pseduo_df], ignore_index=True)
test_df = pseduo_df
train_meta = np.array(train_df[meta_features].values, dtype=np.float32)
valid_meta = np.array(valid_df[meta_features].values, dtype=np.float32)
test_meta = np.array(test_df[meta_features].values, dtype=np.float32)
# model = seresnext(pretrained_model).to(device)
model = EffNet(pretrained_model=pretrained_model, freeze_upto=freeze_upto).to(device)
train_ds = MelanomaDataset(train_df.image_name.values, train_meta, train_df.target.values, dim=sz, transforms=train_aug)
if balanced_sampler:
print('Using Balanced Sampler....')
train_loader = DataLoader(train_ds,batch_size=batch_size, sampler=BalanceClassSampler(labels=train_ds.get_labels(), mode="downsampling"), shuffle=False, num_workers=4)
else:
train_loader = DataLoader(train_ds,batch_size=batch_size, shuffle=True, num_workers=4)
plist = [
{'params': model.backbone.parameters(), 'lr': learning_rate/50},
{'params': model.meta_fc.parameters(), 'lr': learning_rate},
# {'params': model.metric_classify.parameters(), 'lr': learning_rate},
]
optimizer = optim.Adam(plist, lr=learning_rate)
seed_everything(SEED)
os.system("rm -rf *.png")
if mode == 'lr_finder':
wandb.init(mode="disabled")
wandb_logger = WandbLogger(project="Diabetic_Retinopathy", config=params, settings=wandb.Settings(start_method='fork'))
else:
wandb_logger = WandbLogger(project="Diabetic_Retinopathy", config=params, settings=wandb.Settings(start_method='fork'))
wandb.init(project="Diabetic_Retinopathy", config=params, settings=wandb.Settings(start_method='fork'))
wandb.run.name= model_name
np.random.seed(SEED)
os.makedirs(model_dir, exist_ok=True)
os.makedirs(history_dir, exist_ok=True)
if 'eff' in model_name:
base = EffNet(pretrained_model=pretrained_model, num_class=num_class, freeze_upto=freeze_upto).to(device)
elif 'vit' in model_name:
base = ViT(pretrained_model, num_class=num_class) # Not Working
else:
if model_type == 'Normal':
base = Resne_t(pretrained_model, num_class=num_class).to(device)
elif model_type == 'Attention':
base = AttentionResne_t(pretrained_model, num_class=num_class).to(device)
elif model_type == 'Bottleneck':
base = BotResne_t(pretrained_model, dim=sz, num_class=num_class).to(device)
elif model_type == 'TripletAttention':
base = TripletAttentionResne_t(pretrained_model, num_class=num_class).to(device)
elif model_type == 'CBAttention':
base = CBAttentionResne_t(pretrained_model, num_class=num_class).to(device)
wandb.watch(base)
def __init__(self, backbone, expert_dims, use_ce, mimic_ce_dims, concat_experts, concat_mix_experts,
vlad_clusters, attr_fusion_name, attr_vocab_size, same_dim=512):
super().__init__()
modalities = list(expert_dims.keys())
self.expert_dims = expert_dims
self.modalities = modalities
self.use_ce = use_ce
self.mimic_ce_dims = mimic_ce_dims
self.concat_experts = concat_experts
self.concat_mix_experts = concat_mix_experts
self.attr_fusion_name = attr_fusion_name
self.backbone_name = backbone
in_dims = [expert_dims[mod][0] for mod in modalities]
agg_dims = [expert_dims[mod][1] for mod in modalities]
use_bns = [True for modality in self.modalities]
if self.use_ce or self.mimic_ce_dims:
dim_reducers = [ReduceDim(in_dim, same_dim) for in_dim in in_dims]
self.video_dim_reduce = nn.ModuleList(dim_reducers)
if self.use_ce:
self.g_reason_1 = nn.Linear(same_dim * 2, same_dim)
self.g_reason_2 = nn.Linear(same_dim, same_dim)
self.f_reason_1 = nn.Linear(same_dim, same_dim)
self.f_reason_2 = nn.Linear(same_dim, same_dim)
gated_vid_embds = [GatedEmbeddingUnitReasoning(same_dim) for _ in in_dims]
elif self.mimic_ce_dims: # ablation study
gated_vid_embds = [MimicCEGatedEmbeddingUnit(same_dim, same_dim, use_bn=True) for _ in modalities]
elif self.concat_mix_experts: # ablation study
in_dim, out_dim = sum(in_dims), sum(agg_dims)
gated_vid_embds = [GatedEmbeddingUnit(in_dim, out_dim, use_bn=True)]
elif self.concat_experts: # ablation study
gated_vid_embds = []
else:
gated_vid_embds = [GatedEmbeddingUnit(in_dim, dim, use_bn) for
in_dim, dim, use_bn in zip(in_dims, agg_dims, use_bns)]
self.video_GU = nn.ModuleList(gated_vid_embds)
if backbone == 'resnet':
resnet = models.resnet152(pretrained=True)
modules = list(resnet.children())[:-2]
self.backbone = nn.Sequential(*modules)
elif backbone == 'densenet':
densenet = models.densenet169(pretrained=True)
modules = list(densenet.children())[:-1]
self.backbone = nn.Sequential(*modules)
elif backbone in ['inceptionresnetv2', 'pnasnet5large', 'nasnetalarge', 'senet154', 'polynet']:
self.backbone = pretrainedmodels.__dict__[backbone](num_classes=1000, pretrained='imagenet')
else:
raise ValueError
self.dropout = nn.Dropout(p=0.2)
self.avg_pooling = nn.AdaptiveAvgPool2d((1, 1))
# self.video_multi_encoding = VideoMultilevelEncoding(in_dim=in_dims[-1], out_dim=in_dims[-1])
if 'keypoint' in self.expert_dims.keys():
self.effnet = EffNet()
self.keypoint_pooling = NetVLAD(
feature_size=512,
cluster_size=vlad_clusters['keypoint'],
)
if 'attr0' in self.expert_dims.keys():
self.attr_embed = nn.Embedding(attr_vocab_size, 300, padding_idx=0)
attr_pooling_list = [NetVLAD(feature_size=300, cluster_size=vlad_clusters['attr']) for _ in range(6)]
self.attr_pooling = nn.ModuleList(attr_pooling_list)
if attr_fusion_name == 'attrmlb':
self.attr_fusion = AttrMLB()
else:
self.attr_fusion = TIRG(attr_fusion_name, embed_dim=same_dim)