def __call__(self): print("Inference") if self.get("infer_flag"): test_df = pd.DataFrame() test_df["image_id"] = list(os.listdir(osp.join(self.data_path, "test_images"))) if test_df.shape[0] == 1: for i in range(7): test_df = test_df.append(test_df) test_df = test_df.reset_index(drop=True) test_dataset = TestDataset(test_df, self.data_path, get_transforms('valid', self.get("val_transform_params"))) testloader = DataLoader(test_dataset, batch_size=self.get("batch_size"), num_workers=self.get("num_workers"), shuffle=False, pin_memory=False) oof_preds = [] for seed in self.seeds: for fold in range(self.get("n_splits")): self.params["seed"] = seed self.params["fold"] = fold self.params["pretrained"] = False model = CassavaClassifierModel(self.params) model.read_weight() preds = model.predict(testloader) pd.DataFrame(preds, columns=[f"pred_{n}" for n in range(self.params["output_size"])]).to_csv(osp.join(self.preds_path, f"pred_{seed}_{fold}.csv"), index=False) oof_preds.append(preds) oof_preds = np.mean(np.array(oof_preds), axis=0) oof_preds = pd.DataFrame(preds, columns=[f"pred_{n}" for n in range(self.params["output_size"])]) oof_preds.to_csv(osp.join(self.preds_path, "pred.csv"), index=False)
def test_model(self, img): if self.is_cpu: model = torch.load(self.model_path, map_location=torch.device("cpu")) else: model = torch.load(self.model_path) model = model["model"] model.eval() img_t = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img = img_t augmented = get_transforms((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))(image=img) imgtf1 = augmented["image"] x = imgtf1[np.newaxis, ...] x.shape x = x.to(device) pred = model(x) y = pred[0].detach().cpu().numpy() y = np.exp(y) / sum(np.exp(y)) onx = list(np.argsort(y)) onx = onx[::-1] ony = y[onx] ony = list(np.round(ony, 2)) for i in range(len(ony)): ony[i] = float(ony[i]) for i in range(len(onx)): onx[i] = str(int(onx[i])).zfill(5) return onx, ony
def load_prepare_data(train_path, val_path, batch_size, shuffle, verbose=True): assert CLASSES train_transform, val_transform = get_transforms() train_ds = QuickDrawDataset(csv_file=train_path, transform=train_transform) train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=shuffle, num_workers=0) val_ds, val_dl = None, None if val_path: val_ds = QuickDrawDataset(csv_file=val_path, transform=val_transform) val_dl = DataLoader(val_ds, batch_size=batch_size, shuffle=shuffle, num_workers=0) if verbose: print('Number of classes:', len(CLASSES)) print('Train: %d, Valid: %d' % (len(train_ds), len(val_ds) if val_ds else 0)) return train_ds, train_dl, val_ds, val_dl
def main(): df, _ = get_df(args.kernel_type, args.out_dim, args.data_dir) transforms_train, transforms_val = get_transforms(args.image_size) folds = [int(i) for i in args.train_fold.split(',')] run(folds, df, transforms_train, transforms_val)
def main(): train_dataframe, valid_dataframe = make_train_valid_dfs() train_loader = make_loaders( dataframe=train_dataframe, vocabulary=Vocabulary(freq_threshold=config.FREQ_THRESHOLD), transforms=get_transforms(mode="train"), mode="train", ) vocab = train_loader.dataset.vocab valid_loader = make_loaders( dataframe=valid_dataframe, vocabulary=vocab, transforms=get_transforms(mode="valid"), mode="valid", ) encoder, decoder, encoder_optimizer, decoder_optimizer = build_model( vocab_size=vocab.vocab_size) criterion = nn.CrossEntropyLoss(ignore_index=vocab.stoi["<PAD>"]) encoder_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( encoder_optimizer, factor=config.FACTOR, patience=config.PATIENCE, verbose=True) decoder_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( decoder_optimizer, factor=config.FACTOR, patience=config.PATIENCE, verbose=True) for epoch in range(config.EPOCHS): train_loss = train_one_epoch( train_loader, encoder, decoder, criterion, encoder_optimizer, decoder_optimizer, config.DEVICE, ) # encoder_scheduler.step(valid_loss.avg) # decoder_scheduler.step(valid_loss.avg) predict(valid_loader, encoder, decoder, config.DEVICE)
def main(): df, df_test, meta_features, n_meta_features, mel_idx = get_df( args.kernel_type, args.out_dim, args.data_dir, args.data_folder, args.use_meta) transforms_train, transforms_val = get_transforms(args.image_size) folds = [int(i) for i in args.fold.split(',')] for fold in folds: run(fold, df, meta_features, n_meta_features, transforms_train, transforms_val, mel_idx)
def __init__(self, model_path): super(Server, self).__init__() self.my_socket = None self.n_clients = 0 self.guesses = [] print(model_path) self.model = QuickDrawNet.load_from_file(model_path) self.model.eval() _, self.transform = get_transforms()
def main(): # Récupération des données df, df_test, meta_features, n_meta_features, mel_idx = get_df( args.kernel_type, args.out_dim, args.data_dir, args.data_folder, args.use_meta) # Récupérer les augmentations qui nous devons appliquer sur les images transforms_train, transforms_val = get_transforms(args.image_size) # trainer et valider notre réseau de neurone en se basant sur la méthode K- fold folds = [int(i) for i in args.fold.split(',')] for fold in folds: run(fold, df, meta_features, n_meta_features, transforms_train, transforms_val, mel_idx)
def load_prepare_data(test_path, verbose=True): assert CLASSES _, test_transform = get_transforms() test_ds = QuickDrawDataset(csv_file=test_path, transform=test_transform) test_dl = DataLoader(test_ds, batch_size=64, shuffle=False, num_workers=0) if verbose: print('Number of classes:', len(CLASSES)) print('Test: %d' % len(test_ds)) return test_ds, test_dl
def main(): train_dataframe, valid_dataframe = make_train_valid_dfs() train_loader = make_loaders( dataframe=train_dataframe, vocabulary=Vocabulary(freq_threshold=config.FREQ_THRESHOLD), transforms=get_transforms(mode="train"), mode="train", ) vocab = train_loader.dataset.vocab valid_loader = make_loaders( dataframe=valid_dataframe, vocabulary=vocab, transforms=get_transforms(mode="valid"), mode="valid", ) # model = CaptioningTransformer(vocab_size=vocab.vocab_size, d_model=config.D_MODEL).to(config.DEVICE) model = TransformerCaptioning(vocab_size=vocab.vocab_size).to( config.DEVICE) optimizer = torch.optim.Adam(model.parameters(), lr=config.LR) lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.8, patience=3) criterion = nn.CrossEntropyLoss(ignore_index=vocab.stoi["<PAD>"]) train_eval( config.EPOCHS, model, train_loader, valid_loader, criterion, optimizer, config.DEVICE, config, lr_scheduler, )
def build_loaders(dataframe, tokenizer, mode): transforms = get_transforms(mode=mode) dataset = CLIPDataset( dataframe["image"].values, dataframe["caption"].values, tokenizer=tokenizer, transforms=transforms, ) dataloader = torch.utils.data.DataLoader( dataset, batch_size=CFG.batch_size, num_workers=CFG.num_workers, shuffle=True if mode == "train" else False, ) return dataloader
def train(self, train_df, val_df, seed, fold): if self.debug: train_df = train_df[:self.get("batch_size")+1] val_df = val_df[:self.get("batch_size")+1] self.params["epochs"] = 1 if self.raw_dirname == "cassava-leaf-disease-classification-merged": val_df = val_df[val_df["source"] == 2021] train_dataset = TrainDataset(train_df, self.data_path, get_transforms('train', self.get("tr_transform_params"), self.get("tr_transforms"))) val_dataset = TrainDataset(val_df, self.data_path, get_transforms('valid', self.get("val_transform_params"))) trainloader, validloader = get_dataloader(train_dataset, val_dataset, self.get("batch_size"), self.get("num_workers")) self.params["seed"] = seed self.params["fold"] = fold self.params["pretrained"] = True model = CassavaClassifierModel(self.params) if self.get("do_retrain"): model.read_weight() model.fit(trainloader, validloader) # valid predict val_preds = model.val_preds val_preds = pd.DataFrame(val_preds, columns=[f"pred_{n}" for n in range(self.params["output_size"])]) val_preds.to_csv(osp.join(self.val_preds_path, f"preds_{seed}_{fold}.csv"), index=False)
def Loader(img_path=None, uploaded_image=None, upload_state=False, demo_state=True): test_dataset = CassavaDataset(test, img_path, uploaded_image=uploaded_image, transform=get_transforms(data='valid'), uploaded_state=upload_state, demo_state=demo_state) test_loader = DataLoader(test_dataset, batch_size=CFG.batch_size, shuffle=False, num_workers=CFG.num_workers, pin_memory=True) return test_loader
def setup(self, stage=None): tfms_trn, tfms_val = get_transforms(self.imgsz) self.num_classes = self.dftrn.label_group.nunique() self.i2grp = sorted(self.dftrn.label_group.unique()) self.grp2i = {v: k for k, v in enumerate(self.i2grp)} self.dftrn.label_group = self.dftrn.label_group.map(self.grp2i) self.dfval.label_group = self.dfval.label_group.map(self.grp2i) self.train_dataset = ShopeeDataset(self.dftrn, transform=tfms_trn) self.eval_dataset = ShopeeDataset(self.dfval, transform=tfms_val) # get adaptive margin tmp = np.sqrt( 1 / np.sqrt(self.dftrn.label_group.value_counts().sort_index().values)) self.margins = (tmp - tmp.min()) / (tmp.max() - tmp.min()) * 0.45 + 0.05
def plot_top_loss(k=10): df = pd.read_csv(os.path.join(cfg.ds_folder, 'new_valid.csv'), encoding='utf8') folder = os.path.join(cfg.ds_folder, 'train') _, tfms = get_transforms(cfg.img_size) model = get_model_by_name(cfg.model_name) model.load_state_dict( torch.load(glob("../runs/exp15/best*")[0])['state_dict']) model.to("cuda:0") model.eval() error_list = [] error_index = [] for i in tqdm(range(len(df))): with torch.no_grad(): filename = os.path.join(folder, str(df['id'][i]) + ".jpg") label = df['label'][i] img = cv2.cvtColor(cv2.imread(filename), cv2.COLOR_BGR2RGB) img = tfms(image=img)['image'].astype('float32').transpose(2, 0, 1) img = torch.from_numpy( img.reshape(-1, 3, cfg.img_size, cfg.img_size)).to("cuda:0") pred = model(img) _, pred_label = torch.max(pred, dim=1) yes = (pred_label.cpu() == label).item() if yes: continue else: error_score = pred.cpu().numpy().squeeze()[pred_label] error_list.append(error_score) error_index.append(i) ind = np.argpartition(np.array(error_list), -k)[-k:] error_img_index = np.array(error_index)[ind] # plot plt.figure(figsize=(12, 6)) for i in range(k): plt.subplot(2, 5, i + 1) plt.imshow( Image.open( os.path.join(folder, str(df['id'][error_img_index[i]]) + ".jpg")).convert('RGB')) print("filename is", str(df['id'][error_img_index[i]]) + ".jpg") plt.title("label {}".format(df['label'][error_img_index[i]])) plt.show()
def main(): ''' #################################################### # stone data 데이터셋 : dataset.get_df_stone #################################################### ''' df_train, df_test, meta_features, n_meta_features, target_idx = get_df_stone( k_fold=args.k_fold, out_dim=args.out_dim, data_dir=args.data_dir, data_folder=args.data_folder, use_meta=args.use_meta, use_ext=args.use_ext) # 모델 트랜스폼 가져오기 transforms_train, transforms_val = get_transforms(args.image_size) folds = range(args.k_fold) #folds = [0, 1, 2, 3, 4] for fold in folds: run(fold, df_train, meta_features, n_meta_features, transforms_train, transforms_val, target_idx)
def main(): ''' #################################################### # stone data 데이터셋 : dataset.get_df_stone #################################################### ''' df_train, df_test, meta_features, n_meta_features, target_idx = get_df_stone( k_fold=args.k_fold, out_dim=args.out_dim, data_dir=args.data_dir, data_folder=args.data_folder, use_meta=args.use_meta, use_ext=args.use_ext) # customize image transform # albumentations.MotionBlur(blur_limit=attack_strength, p=1.0), # 모델 트랜스폼 가져오기 #transforms_train, transforms_val = get_transforms(args.image_size) auc_save = [] #attack_strengths = [0,3,5,7,9,11] attack_strengths = [13, 17, 21, 25, 29] for attack_strength in attack_strengths: transforms_train, transforms_val = get_transforms( args.image_size, attack_strength) auc_max = run(0, df_train, meta_features, n_meta_features, transforms_train, transforms_val, target_idx) print(auc_max) auc_save.append(auc_max) with open(os.path.join("./noise_watch", f'log_{args.kernel_type}.txt'), 'a') as appender: appender.write('attack_strengths : ' + str(attack_strength) + ' auc : ' + str(auc_max) + '\n') plt.plot(auc_save) plt.show()
from utils import seed_everything from dataset import ImageDataset, get_transforms from trainer import CycleGAN from visualize import unnorm device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') ''' Seeding all random parameters for reproducibility ''' seed_everything(42) '''Default configuration for training CycleGAN''' size = 256 batch_size = 1 mean = [0.5, 0.5, 0.5] std = [0.5, 0.5, 0.5] '''Reading data and creating Dataloader''' monet_dir = 'monet_jpg/' photo_dir = 'photo_jpg/' transform = get_transforms(size, mean, std) img_dataset = ImageDataset(monet_dir=monet_dir, photo_dir=photo_dir, transform=transform) img_dl = DataLoader(img_dataset, batch_size=batch_size, pin_memory=True) '''Fixed set of monet and photos for visualizing them throughout the training process''' idx = np.random.randint(0, len(img_dataset), 5) fixed_photo = torch.cat([img_dataset[i][0].unsqueeze(0) for i in idx], 0) fixed_monet = torch.cat([img_dataset[i][1].unsqueeze(0) for i in idx], 0) ''' Creating an instance of the trainer class ''' gan = CycleGAN(3, 3, 100, device, (fixed_photo, fixed_monet), decay_epoch=50) gan.train(img_dl) '''Finally visualising photos against their generated monet-style paintings''' fig, ax = plt.subplots(5, 2, figsize=(12, 8)) for i in range(5): photo_img, monet_img = next(iter(img_dl))
shuffle=True, random_state=CFG.seed) for n, (train_index, val_index) in enumerate(Fold.split(folds, folds['InChI_length'])): folds.loc[val_index, 'fold'] = int(n) fold = 0 trn_idx = folds[folds['fold'] != fold].index val_idx = folds[folds['fold'] == fold].index[:60000] train_folds = folds.loc[trn_idx].reset_index(drop=True) valid_folds = folds.loc[val_idx].reset_index(drop=True) train_dataset = TrainDataset(train_folds, tokenizer, transform=get_transforms(data='train')) valid_dataset = TrainDataset(valid_folds, tokenizer, transform=get_transforms(data='valid')) train_loader = DataLoader(train_dataset, batch_size=CFG.batch_size, shuffle=True, num_workers=CFG.num_workers, pin_memory=True, drop_last=True, collate_fn=bms_collate) valid_loader = DataLoader( valid_dataset, batch_size=CFG.batch_size, shuffle=False,
def main(): df, df_test, meta_features, n_meta_features, mel_idx = get_df( args.kernel_type, args.out_dim, args.data_dir, args.data_folder, args.use_meta ) transforms_train, transforms_val = get_transforms(args.image_size) LOGITS = [] PROBS = [] dfs = [] for fold in range(5): df_valid = df[df['fold'] == fold] if args.DEBUG: df_valid = pd.concat([ df_valid[df_valid['target'] == mel_idx].sample(args.batch_size * 3), df_valid[df_valid['target'] != mel_idx].sample(args.batch_size * 3) ]) dataset_valid = MelanomaDataset(df_valid, 'valid', meta_features, transform=transforms_val) valid_loader = torch.utils.data.DataLoader(dataset_valid, batch_size=args.batch_size, num_workers=args.num_workers) if args.eval == 'best': model_file = os.path.join(args.model_dir, f'{args.kernel_type}_best_fold{fold}.pth') elif args.eval == 'best_20': model_file = os.path.join(args.model_dir, f'{args.kernel_type}_best_20_fold{fold}.pth') if args.eval == 'final': model_file = os.path.join(args.model_dir, f'{args.kernel_type}_final_fold{fold}.pth') model = ModelClass( args.enet_type, n_meta_features=n_meta_features, n_meta_dim=[int(nd) for nd in args.n_meta_dim.split(',')], out_dim=args.out_dim ) model = model.to(device) try: # single GPU model_file model.load_state_dict(torch.load(model_file), strict=True) except: # multi GPU model_file state_dict = torch.load(model_file) state_dict = {k[7:] if k.startswith('module.') else k: state_dict[k] for k in state_dict.keys()} model.load_state_dict(state_dict, strict=True) if len(os.environ['CUDA_VISIBLE_DEVICES']) > 1: model = torch.nn.DataParallel(model) model.eval() this_LOGITS, this_PROBS = val_epoch(model, valid_loader, mel_idx, is_ext=df_valid['is_ext'].values, n_test=8, get_output=True) LOGITS.append(this_LOGITS) PROBS.append(this_PROBS) dfs.append(df_valid) dfs = pd.concat(dfs).reset_index(drop=True) dfs['pred'] = np.concatenate(PROBS).squeeze()[:, mel_idx] auc_all_raw = roc_auc_score(dfs['target'] == mel_idx, dfs['pred']) dfs2 = dfs.copy() for i in range(5): dfs2.loc[dfs2['fold'] == i, 'pred'] = dfs2.loc[dfs2['fold'] == i, 'pred'].rank(pct=True) auc_all_rank = roc_auc_score(dfs2['target'] == mel_idx, dfs2['pred']) dfs3 = dfs[dfs.is_ext == 0].copy().reset_index(drop=True) auc_20_raw = roc_auc_score(dfs3['target'] == mel_idx, dfs3['pred']) for i in range(5): dfs3.loc[dfs3['fold'] == i, 'pred'] = dfs3.loc[dfs3['fold'] == i, 'pred'].rank(pct=True) auc_20_rank = roc_auc_score(dfs3['target'] == mel_idx, dfs3['pred']) content = f'Eval {args.eval}:\nauc_all_raw : {auc_all_raw:.5f}\nauc_all_rank : {auc_all_rank:.5f}\nauc_20_raw : {auc_20_raw:.5f}\nauc_20_rank : {auc_20_rank:.5f}\n' print(content) with open(os.path.join(args.log_dir, f'log_{args.kernel_type}.txt'), 'a') as appender: appender.write(content + '\n') np.save(os.path.join(args.oof_dir, f'{args.kernel_type}_{args.eval}_oof.npy'), dfs['pred'].values)
def main(): ''' #################################################### # stone data 데이터셋 : dataset.get_df_stone #################################################### ''' df_train, df_test, meta_features, n_meta_features, target_idx = get_df_stone( k_fold=args.k_fold, out_dim=args.out_dim, data_dir=args.data_dir, data_folder=args.data_folder, use_meta=args.use_meta, use_ext=args.use_ext) transforms_train, transforms_val = get_transforms(args.image_size) # https://discuss.pytorch.org/t/error-expected-more-than-1-value-per-channel-when-training/26274 # batch_normalization에서 배치 사이즈 1인 경우 에러 발생할 수 있음 # 문제가 발생한 경우 배치 사이즈를 조정해서 해야한다. if args.DEBUG: df_test = df_test.sample(args.batch_size * 3) dataset_test = MMC_ClassificationDataset(df_test, 'test', meta_features, transform=transforms_val) test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=args.batch_size, num_workers=args.num_workers) PROBS = [] folds = range(args.k_fold) for fold in folds: if args.eval == 'best': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_best_fold{fold}.pth') elif args.eval == 'best_no_ext': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_best_no_ext_fold{fold}.pth') if args.eval == 'final': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_final_fold{fold}.pth') model = ModelClass( args.enet_type, n_meta_features=n_meta_features, n_meta_dim=[int(nd) for nd in args.n_meta_dim.split(',')], out_dim=args.out_dim) model = model.to(device) try: # single GPU model_file model.load_state_dict(torch.load(model_file), strict=True) except: # multi GPU model_file state_dict = torch.load(model_file) state_dict = { k[7:] if k.startswith('module.') else k: state_dict[k] for k in state_dict.keys() } model.load_state_dict(state_dict, strict=True) if len(os.environ['CUDA_VISIBLE_DEVICES']) > 1: model = torch.nn.DataParallel(model) model.eval() PROBS = [] TARGETS = [] with torch.no_grad(): for (data) in tqdm(test_loader): if args.use_meta: data, meta = data data, meta = data.to(device), meta.to(device) probs = torch.zeros( (data.shape[0], args.out_dim)).to(device) for I in range(args.n_test): l = model(get_trans(data, I), meta) probs += l.softmax(1) else: data = data.to(device) probs = torch.zeros( (data.shape[0], args.out_dim)).to(device) for I in range(args.n_test): l = model(get_trans(data, I)) probs += l.softmax(1) probs /= args.n_test PROBS.append(probs.detach().cpu()) PROBS = torch.cat(PROBS).numpy() df_test['target'] = PROBS[:, target_idx] #acc = (PROBS.argmax(1) == TARGETS).mean() * 100. #auc = roc_auc_score((TARGETS == target_idx).astype(float), PROBS[:, target_idx]) #df_test[['image_name', 'target']].to_csv(os.path.join(args.sub_dir, f'sub_{args.kernel_type}_{args.eval}_{fold}_{acc:.2f}_{auc:.4f}.csv'), index=False) df_test[['image_name', 'target']].to_csv(os.path.join( args.sub_dir, f'sub_{args.kernel_type}_{args.eval}_{fold}.csv'), index=False)
def main(): df, df_test, meta_features, n_meta_features, mel_idx = get_df( args.kernel_type, args.out_dim, args.data_dir, args.data_folder, args.use_meta ) transforms_train, transforms_val = get_transforms(args.image_size) if args.DEBUG: df_test = df_test.sample(args.batch_size * 3) dataset_test = MelanomaDataset(df_test, 'test', meta_features, transform=transforms_val) test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=args.batch_size, num_workers=args.num_workers) PROBS = [] ## ! this is defined twice? for fold in range(5): # ! use model built from each fold if args.eval == 'best': # ! default model_file = os.path.join(args.model_dir, f'{args.kernel_type}_best_fold{fold}.pth') elif args.eval == 'best_20': model_file = os.path.join(args.model_dir, f'{args.kernel_type}_best_20_fold{fold}.pth') if args.eval == 'final': model_file = os.path.join(args.model_dir, f'{args.kernel_type}_final_fold{fold}.pth') model = ModelClass( args.enet_type, n_meta_features=n_meta_features, n_meta_dim=[int(nd) for nd in args.n_meta_dim.split(',')], out_dim=args.out_dim ) model = model.to(device) try: # single GPU model_file model.load_state_dict(torch.load(model_file), strict=True) except: # multi GPU model_file state_dict = torch.load(model_file) state_dict = {k[7:] if k.startswith('module.') else k: state_dict[k] for k in state_dict.keys()} model.load_state_dict(state_dict, strict=True) if len(os.environ['CUDA_VISIBLE_DEVICES']) > 1: model = torch.nn.DataParallel(model) model.eval() PROBS = [] ## ! this is defined twice? with torch.no_grad(): for (data) in tqdm(test_loader): if args.use_meta: data, meta = data data, meta = data.to(device), meta.to(device) probs = torch.zeros((data.shape[0], args.out_dim)).to(device) # batch x label for I in range(args.n_test): # ! fliping images 8 times. l = model(get_trans(data, I), meta) probs += l.softmax(1) else: data = data.to(device) probs = torch.zeros((data.shape[0], args.out_dim)).to(device) for I in range(args.n_test): l = model(get_trans(data, I)) probs += l.softmax(1) probs /= args.n_test # ! average over all the flips PROBS.append(probs.detach().cpu()) ## append prediction for this batch PROBS = torch.cat(PROBS).numpy() ## put in numpy format, PROBS is total_obs_size x num_labels df_test['target'] = PROBS[:, mel_idx] # ! takes @mel_idx column df_test[['image_name', 'target']].to_csv(os.path.join(args.sub_dir, f'sub_{args.kernel_type}_{args.eval}.csv'), index=False)
def main(fold): COMPUTE_CV = True DEVICE = "cuda" if torch.cuda.is_available() else "cpu" data = pd.read_csv('../train_fold.csv') data['filepath'] = data['image'].apply( lambda x: os.path.join('../', 'train_images', x)) target_encoder = LabelEncoder() data['label_group'] = target_encoder.fit_transform(data['label_group']) train = data[data['fold'] != fold].reset_index(drop=True) valid = data[data['fold'] == fold].reset_index(drop=True) # Defining DataSet train_dataset = ShopeeDataset( csv=train, transforms=get_transforms(img_size=DIM[0], trans_type='train'), mode='train', ) valid_dataset = ShopeeDataset( csv=valid, transforms=get_transforms(img_size=DIM[0], trans_type='valid'), mode='train', ) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=TRAIN_BATCH_SIZE, pin_memory=True, drop_last=True, num_workers=NUM_WORKERS) valid_loader = torch.utils.data.DataLoader( valid_dataset, batch_size=VALID_BATCH_SIZE, num_workers=NUM_WORKERS, shuffle=False, pin_memory=True, drop_last=False, ) # get adaptive margin tmp = np.sqrt( 1 / np.sqrt(data['label_group'].value_counts().sort_index().values)) margins = (tmp - tmp.min()) / (tmp.max() - tmp.min()) * 0.45 + 0.05 # Defining Model for specific fold if model_version == "V1": model = ShopeeNet(**model_params) elif model_version == "V2": model = ShopeeNetV2(**model_params) else: model = ShopeeNetV3(**model_params) model.to(DEVICE) def fetch_loss(loss_type=None): if loss_type is None: loss = nn.CrossEntropyLoss() elif loss_type == 'arcface': loss = ArcFaceLossAdaptiveMargin(margins=margins, out_dim=model_params['n_classes'], s=80) return loss criterion = fetch_loss() criterion.to(DEVICE) optimizer = torch.optim.Adam(model.parameters(), lr=scheduler_params['lr_start']) scheduler_cosine = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts( optimizer, EPOCHS) scheduler_warmup = GradualWarmupSchedulerV2( optimizer, multiplier=10, total_epoch=1, after_scheduler=scheduler_cosine) #Defining LR SChe scheduler = None # THE ENGINE LOOP best_loss = 2 << 13 for epoch in range(EPOCHS): scheduler_warmup.step(epoch - 1) train_loss = train_fn(train_loader, model, criterion, optimizer, DEVICE, epoch_th=epoch, scheduler=scheduler) valid_loss = eval_fn(valid_loader, model, criterion, DEVICE) print( 'Fold {} | Epoch {}/{} | Training | Loss: {:.4f} | Valid | Loss: {:.4f}' .format(fold, epoch + 1, EPOCHS, train_loss['loss'].avg, valid_loss['loss'].avg)) with open(log_name, 'a') as csvfile: writer = csv.writer(csvfile) writer.writerow([ fold, epoch + 1, train_loss['loss'].avg, valid_loss['loss'].avg ]) if valid_loss['loss'].avg < best_loss: best_loss = valid_loss['loss'].avg torch.save( model.state_dict(), os.path.join( "./models", model_name, f'{model_version}_fold_{fold}_model_{model_params["model_name"]}_IMG_SIZE_{DIM[0]}_{model_params["loss_module"]}.bin' )) print('best model found for epoch {}'.format(epoch))
import numpy as np from tqdm import tqdm from scipy import stats import ttach as tta from dataset import TestDataset, get_transforms, get_tta_transforms from utils import get_kfold_model, get_model_by_name, Config parser = ArgumentParser() parser.add_argument("--weights", type=str, default="../runs/exp12/") parser.add_argument("--tta", type=str, default='no') opt = parser.parse_args() cfg = Config() desc_test = os.path.join(cfg.ds_folder, 'test.csv') _, transform_test = get_transforms(cfg.img_size) valid_data = TestDataset(desc_test, data_folder=os.path.join(cfg.ds_folder, "test"), transform=transform_test) test_loader = DataLoader(dataset=valid_data, batch_size=cfg.bs, shuffle=False) models = [] for path in get_kfold_model(opt.weights): model = get_model_by_name(cfg.model_name) model.load_state_dict(torch.load(path)['state_dict']) if opt.tta == 'yes': model = tta.ClassificationTTAWrapper(model, get_tta_transforms(), merge_mode='mean') models.append(model)
def main(): torch.cuda.set_device(1) # get dataframe df, out_dim = get_df(args.kernel_type, args.data_dir, args.train_step) print(f"out_dim = {out_dim}") # get adaptive margin tmp = np.sqrt(1 / np.sqrt(df['landmark_id'].value_counts().sort_index().values)) margins = (tmp - tmp.min()) / (tmp.max() - tmp.min()) * 0.45 + 0.05 # get augmentations transforms_train, transforms_val = get_transforms(args.image_size) print("\ndata augmentation is done!\n") #extract images in folder 0 as demo df_demo_0 = df[df['filepath'].str.startswith('/mnt/data/sjx/CS498_DL_Project/data/train/0/0')] df_demo_1 = df[df['filepath'].str.startswith('/mnt/data/sjx/CS498_DL_Project/data/train/0/1')] df_demo_2 = df[df['filepath'].str.startswith('/mnt/data/sjx/CS498_DL_Project/data/train/0/2')] df_demo_3 = df[df['filepath'].str.startswith('/mnt/data/sjx/CS498_DL_Project/data/train/0/3')] df_demo = df_demo_0.append([df_demo_1, df_demo_2, df_demo_3]) # get train and valid dataset df = df_demo df_train = df[df['fold'] != args.fold] df_valid = df[df['fold'] == args.fold].reset_index(drop=True).query("index % 15==0") dataset_train = LandmarkDataset(df_train, 'train', 'train', transform=transforms_train) dataset_valid = LandmarkDataset(df_valid, 'train', 'val', transform=transforms_val) valid_loader = torch.utils.data.DataLoader(dataset_valid, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True) print("dataset has been prepared!\n") # model print(torch.cuda.current_device()) model = ModelClass(args.enet_type, out_dim=out_dim) model = nn.DataParallel(model, device_ids=[1, 3]).to("cuda:1, 3") # loss func def criterion(logits_m, target): arc = ArcFaceLossAdaptiveMargin(margins=margins, s=80) loss_m = arc(logits_m, target, out_dim) return loss_m # optimizer optimizer = optim.Adam(model.parameters(), lr=args.init_lr) # load pretrained if len(args.load_from) > 0: # Todo: checkpoint = torch.load(args.load_from, map_location=lambda storage, loc: storage.cuda(3)) state_dict = checkpoint['model_state_dict'] state_dict = {k[7:] if k.startswith('module.') else k: state_dict[k] for k in state_dict.keys()} if args.train_step == 1: del state_dict['metric_classify.weight'] model.load_state_dict(state_dict, strict=False) else: model.load_state_dict(state_dict, strict=True) # if 'optimizer_state_dict' in checkpoint: # optimizer.load_state_dict(checkpoint['optimizer_state_dict']) del checkpoint, state_dict torch.cuda.empty_cache() import gc gc.collect() # lr scheduler scheduler_cosine = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, args.n_epochs-1) scheduler_warmup = GradualWarmupSchedulerV2(optimizer, multiplier=10, total_epoch=1, after_scheduler=scheduler_cosine) # train & valid loop gap_m_max = 0. model_file = os.path.join(args.model_dir, f'{args.kernel_type}_fold{args.fold}.pth') for epoch in range(args.start_from_epoch, args.n_epochs+1): print(time.ctime(), 'Epoch:', epoch) train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=True, drop_last=True) train_loss = train_epoch(model, train_loader, optimizer, criterion) val_loss, acc_m, gap_m = val_epoch(model, valid_loader, criterion) scheduler_warmup.step(epoch-1) if args.local_rank == 0: content = time.ctime() + ' ' + f'Fold {args.fold}, Epoch {epoch}, lr: {optimizer.param_groups[0]["lr"]:.7f}, train loss: {np.mean(train_loss):.5f}, valid loss: {(val_loss):.5f}, acc_m: {(acc_m):.6f}, gap_m: {(gap_m):.6f}.' print(content) with open(os.path.join(args.log_dir, f'{args.kernel_type}.txt'), 'a') as appender: appender.write(content + '\n') print('gap_m_max ({:.6f} --> {:.6f}). Saving model ...'.format(gap_m_max, gap_m)) torch.save({ 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), }, model_file) gap_m_max = gap_m if epoch == args.stop_at_epoch: print(time.ctime(), 'Training Finished!') break torch.save({ 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), }, os.path.join(args.model_dir, f'{args.kernel_type}_fold{args.fold}_final.pth'))
def main(): ''' #################################################### # stone data 데이터셋 : dataset.get_df_stone #################################################### ''' df_train, df_test, meta_features, n_meta_features, target_idx = get_df_stone( k_fold=args.k_fold, out_dim=args.out_dim, data_dir=args.data_dir, data_folder=args.data_folder, use_meta=args.use_meta, use_ext=args.use_ext) transforms_train, transforms_val = get_transforms(args.image_size) LOGITS = [] PROBS = [] TARGETS = [] dfs = [] folds = range(args.k_fold) for fold in folds: print(f'Evaluate data fold{str(fold)}') df_valid = df_train[df_train['fold'] == fold] # batch_normalization에서 배치 사이즈 1인 경우 에러 발생할 수 있으므로, 데이터 한개 버림 if len(df_valid) % args.batch_size == 1: df_valid = df_valid.sample(len(df_valid) - 1) if args.DEBUG: df_valid = pd.concat([ df_valid[df_valid['target'] == target_idx].sample( args.batch_size * 3), df_valid[df_valid['target'] != target_idx].sample( args.batch_size * 3) ]) dataset_valid = MMC_ClassificationDataset(df_valid, 'valid', meta_features, transform=transforms_val) valid_loader = torch.utils.data.DataLoader( dataset_valid, batch_size=args.batch_size, num_workers=args.num_workers) if args.eval == 'best': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_best_fold{fold}.pth') elif args.eval == 'best_no_ext': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_best_no_ext_fold{fold}.pth') if args.eval == 'final': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_final_fold{fold}.pth') model = ModelClass( args.enet_type, n_meta_features=n_meta_features, n_meta_dim=[int(nd) for nd in args.n_meta_dim.split(',')], out_dim=args.out_dim) model = model.to(device) # model summary if args.use_meta: pass # 코드 확인이 필요함 # summary(model, [(3, args.image_size, args.image_size), n_meta_features]) else: if fold == 0: # 한번만 summary(model, (3, args.image_size, args.image_size)) try: # single GPU model_file model.load_state_dict(torch.load(model_file), strict=True) except: # multi GPU model_file state_dict = torch.load(model_file) state_dict = { k[7:] if k.startswith('module.') else k: state_dict[k] for k in state_dict.keys() } model.load_state_dict(state_dict, strict=True) if len(os.environ['CUDA_VISIBLE_DEVICES']) > 1: model = torch.nn.DataParallel(model) model.eval() ''' #################################################### # stone data를 위한 평가함수 : val_epoch_stonedata #################################################### ''' this_LOGITS, this_PROBS, this_TARGETS = val_epoch_stonedata( model, valid_loader, target_idx, is_ext=df_valid['is_ext'].values, n_test=8, get_output=True) LOGITS.append(this_LOGITS) PROBS.append(this_PROBS) TARGETS.append(this_TARGETS) dfs.append(df_valid) dfs = pd.concat(dfs).reset_index(drop=True) dfs['pred'] = np.concatenate(PROBS).squeeze()[:, target_idx] Accuracy = (round(dfs['pred']) == dfs['target']).mean() * 100. auc_all_raw = roc_auc_score(dfs['target'] == target_idx, dfs['pred']) dfs2 = dfs.copy() for i in folds: dfs2.loc[dfs2['fold'] == i, 'pred'] = dfs2.loc[dfs2['fold'] == i, 'pred'].rank(pct=True) auc_all_rank = roc_auc_score(dfs2['target'] == target_idx, dfs2['pred']) if args.use_ext: # 외부데이터를 사용할 경우, 외부데이터를 제외하고 모델을 따로 평가해본다. dfs3 = dfs[dfs.is_ext == 0].copy().reset_index(drop=True) auc_no_ext_raw = roc_auc_score(dfs3['target'] == target_idx, dfs3['pred']) for i in folds: dfs3.loc[dfs3['fold'] == i, 'pred'] = dfs3.loc[dfs3['fold'] == i, 'pred'].rank(pct=True) auc_no_ext_rank = roc_auc_score(dfs3['target'] == target_idx, dfs3['pred']) content = time.ctime() + ' ' + f'Eval {args.eval}:\nAccuracy : {Accuracy:.5f}\n' \ f'auc_all_raw : {auc_all_raw:.5f}\nauc_all_rank : {auc_all_rank:.5f}\n' \ f'auc_no_ext_raw : {auc_no_ext_raw:.5f}\nauc_no_ext_rank : {auc_no_ext_rank:.5f}\n' else: content = time.ctime() + ' ' + f'Eval {args.eval}:\nAccuracy : {Accuracy:.5f}\n' \ f'AUC_all_raw : {auc_all_raw:.5f}\nAUC_all_rank : {auc_all_rank:.5f}\n' # 로그파일 맨 뒤에 결과 추가해줌 print(content) with open(os.path.join(args.log_dir, f'log_{args.kernel_type}.txt'), 'a') as appender: appender.write(content + '\n') np.save( os.path.join(args.oof_dir, f'{args.kernel_type}_{args.eval}_oof.npy'), dfs['pred'].values) # 결과 csv 저장 dfs[['filepath', 'patient_id', 'target', 'pred' ]].to_csv(os.path.join(args.oof_dir, f'{args.kernel_type}_{args.eval}_oof.csv'), index=True)
def predict_image(image_path): OUTPUTS = [] n_test = 8 transforms_train, transforms_val = get_transforms(config.image_size) dataset_test = MelanomaDataset(None, 'test', None, transform=transforms_val, image_path=image_path) test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=1, num_workers=0) for fold in range(5): model_file = os.path.join( config.model_dir, f'{config.kernel_type}_best_o_fold{fold}.pth') ModelClass = Effnet_Melanoma model = ModelClass(config.enet_type, out_dim=config.out_dim) model = model.to(config.device) try: # single GPU model_file model.load_state_dict(torch.load(model_file, map_location=config.device), strict=True) except: # multi GPU model_file state_dict = torch.load(model_file, map_location=config.device) state_dict = { k[7:] if k.startswith('module.') else k: state_dict[k] for k in state_dict.keys() } model.load_state_dict(state_dict, strict=True) model.eval() LOGITS = [] PROBS = [] with torch.no_grad(): for (data) in tqdm(test_loader): if config.use_meta: data, meta = data data, meta = data.to(config.device), meta.to(config.device) logits = torch.zeros( (data.shape[0], config.out_dim)).to(config.device) probs = torch.zeros( (data.shape[0], config.out_dim)).to(config.device) for I in range(n_test): l = model(get_trans(data, I), meta) logits += l probs += l.softmax(1) else: data = data.to(config.device) logits = torch.zeros( (data.shape[0], config.out_dim)).to(config.device) probs = torch.zeros( (data.shape[0], config.out_dim)).to(config.device) for I in range(n_test): l = model(get_trans(data, I)) logits += l probs += l.softmax(1) logits /= n_test probs /= n_test LOGITS.append(logits.detach().cpu()) PROBS.append(probs.detach().cpu()) LOGITS = torch.cat(LOGITS).numpy() PROBS = torch.cat(PROBS).numpy() OUTPUTS.append(PROBS[:, config.mel_idx]) #If you are predicting on your own moles, your don't need to rank the probability pred = np.zeros(OUTPUTS[0].shape[0]) for probs in OUTPUTS: pred += probs pred /= len(OUTPUTS) return round(pred[0], 8)
def __init__(self, path, hparams=None, teacher=None, lr=1e-3, bs=128, imsize=128, reg=True, n_patches=9, is_stack=False, epochs=None, norm_output=True, ordinal=False): super().__init__() self.path = path self.lr = lr self.bs = bs self.imsize = imsize self.reg = reg self.n_patches = n_patches self.is_stack = is_stack self.epochs = epochs self.norm_output = norm_output self.ordinal = ordinal if reg: if is_stack: self.model = EffNetPatch(n=5 if ordinal else 1, n_patches=n_patches) else: self.model = EffNetConcat(n=5 if ordinal else 1, n_patches=n_patches) if ordinal: self.loss_fn = nn.BCEWithLogitsLoss() # Try Focal Loss else: # self.loss_fn = F.mse_loss self.loss_fn = nn.SmoothL1Loss() # self.loss_fn = nn.L1Loss() else: if is_stack: self.model = EffNetPatch(n=6, n_patches=n_patches) else: self.model = EffNetConcat(n=6, n_patches=n_patches) # self.loss_fn = LabelSmoothingLoss(6, 0.1) self.loss_fn = F.cross_entropy self.teacher = BaselineModel.load_from_checkpoint( teacher, map_location='cuda:0', path=path, bs=bs, imsize=imsize, lr=lr, n_patches=n_patches, reg=True, is_stack=is_stack, norm_output=norm_output, ordinal=ordinal).eval() self.teacher.apply(lambda m: m.requires_grad_(False)) # log hparams tfms = { 'local': str( get_transforms(imsize, train=True, local=True, is_stack=is_stack, n_patches=n_patches)), 'global': str( get_transforms(imsize, train=True, local=False, is_stack=is_stack, n_patches=n_patches)) } self.hparams = { 'lr': lr, 'bs': bs, 'patch_size': imsize, 'tfms': tfms, 'n_patches': n_patches, 'loss_fn': self.loss_fn.__class__.__name__, 'is_stack': is_stack, 'path': str(self.path), 'ordinal': ordinal, 'norm_target': norm_output }
def main(): df, df_test, meta_features, n_meta_features, mel_idx = get_df( args.kernel_type, args.out_dim, args.data_dir_2020, args.data_dir_2019, args.data_dir_2018, args.use_meta) transforms_train, transforms_val = get_transforms(args.image_size) if args.DEBUG: df_test = df_test.sample(args.batch_size * 3) dataset_test = MelanomaDataset(df_test, 'test', meta_features, transform=transforms_val) test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=args.batch_size, num_workers=args.num_workers) # load model models = [] for fold in range(1): if args.eval == 'best': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_best_fold{fold}.pth') elif args.eval == 'best_20': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_best_20_fold{fold}.pth') if args.eval == 'final': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_final_fold{fold}.pth') model = ModelClass( args.enet_type, n_meta_features=n_meta_features, n_meta_dim=[int(nd) for nd in args.n_meta_dim.split(',')], out_dim=args.out_dim, pretrained=True, # meta_model=args.meta_model ) model = model.to(device) try: # single GPU model_file model.load_state_dict(torch.load(model_file), strict=True) except: # multi GPU model_file state_dict = torch.load(model_file) state_dict = { k[7:] if k.startswith('module.') else k: state_dict[k] for k in state_dict.keys() } model.load_state_dict(state_dict, strict=True) if len(os.environ['CUDA_VISIBLE_DEVICES']) > 1: model = torch.nn.DataParallel(model) model.eval() models.append(model) # predict PROBS = [] with torch.no_grad(): for (data) in tqdm(test_loader): if args.use_meta: data, meta = data data, meta = data.to(device), meta.to(device) probs = torch.zeros((data.shape[0], args.out_dim)).to(device) for model in models: for I in range(args.n_test): l = model(get_trans(data, I), meta) probs += l.softmax(1) else: data = data.to(device) probs = torch.zeros((data.shape[0], args.out_dim)).to(device) for model in models: for I in range(args.n_test): l = model(get_trans(data, I)) probs += l.softmax(1) probs /= args.n_test probs /= len(models) PROBS.append(probs.detach().cpu()) PROBS = torch.cat(PROBS).numpy() # save cvs df_test['target'] = PROBS[:, mel_idx] df_test['image_name'] = df_test['image'] df_test[['image_name', 'target' ]].to_csv(os.path.join(args.sub_dir, f'sub_{args.kernel_type}_{args.eval}.csv'), index=False)
def main(): df, df_test, meta_features, n_meta_features, mel_idx = get_df( args.kernel_type, args.out_dim, args.data_dir, args.data_folder, args.use_meta) transforms_train, transforms_val = get_transforms(args.image_size) if args.DEBUG: df_test = df_test.sample(args.batch_size * 3) dataset_test = MelanomaDataset(df_test, 'test', meta_features, transform=transforms_val) test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=args.batch_size, num_workers=args.num_workers) print(f'\nPredicting test set using {args.enet_type} ...') OUTPUTS = [] for fold in range(5): if args.eval == 'best': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_best_fold{fold}.pth') elif args.eval == 'best_20': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_best_20_fold{fold}.pth') if args.eval == 'final': model_file = os.path.join( args.model_dir, f'{args.kernel_type}_final_fold{fold}.pth') model = ModelClass( args.enet_type, n_meta_features=n_meta_features, n_meta_dim=[int(nd) for nd in args.n_meta_dim.split(',')], out_dim=args.out_dim) model = model.to(device) try: # single GPU model_file model.load_state_dict(torch.load(model_file), strict=True) except: # multi GPU model_file state_dict = torch.load(model_file) state_dict = { k[7:] if k.startswith('module.') else k: state_dict[k] for k in state_dict.keys() } model.load_state_dict(state_dict, strict=True) if len(os.environ['CUDA_VISIBLE_DEVICES']) > 1: model = torch.nn.DataParallel(model) model.eval() PROBS = [] with torch.no_grad(): for (data) in tqdm(test_loader): if args.use_meta: data, meta = data data, meta = data.to(device), meta.to(device) probs = torch.zeros( (data.shape[0], args.out_dim)).to(device) for I in range(args.n_test): l = model(get_trans(data, I), meta) probs += l.softmax(1) else: data = data.to(device) probs = torch.zeros( (data.shape[0], args.out_dim)).to(device) for I in range(args.n_test): l = model(get_trans(data, I)) probs += l.softmax(1) probs /= args.n_test PROBS.append(probs.detach().cpu()) PROBS = torch.cat(PROBS).numpy() OUTPUTS.append(PROBS[:, mel_idx]) # Rank per fold (If you are predicting on your own moles, your don't need to rank the probability) pred = np.zeros(OUTPUTS[0].shape[0]) for probs in OUTPUTS: pred += pd.Series(probs).rank(pct=True).values pred /= len(OUTPUTS) df_test['target'] = pred df_test[['image_name', 'target' ]].to_csv(os.path.join(args.sub_dir, f'sub_{args.kernel_type}_{args.eval}.csv'), index=False) print('\nSaved submission in -> ./subs')