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)