def getDataLoader(df, image_folder, process, batch_size = 64, image_size = 224, train_weights = None, replacement = True, option_da = []): if process == 'train': trnsfms = albumentations.Compose([ albumentations.Resize(height=image_size, width=image_size), RGBToGray(always_apply = True) if 'gray' in option_da else Empty(), albumentations.HorizontalFlip(), albumentations.OneOf([ albumentations.RandomContrast(), albumentations.RandomBrightness(), ]), albumentations.ShiftScaleRotate(rotate_limit=20, scale_limit=0.2), albumentations.JpegCompression(80), albumentations.HueSaturationValue(), albumentations.Normalize(), AT.ToTensor() ]) elif process == 'val' or process =='test': trnsfms = albumentations.Compose([ albumentations.Resize(height=image_size, width=image_size), RGBToGray(always_apply = True) if 'gray' in option_da else Empty(), albumentations.Normalize(), AT.ToTensor() ]) dataset = WhaleDataLoader(image_folder = image_folder, process=process, df=df, transform=trnsfms) if process == 'train': tr_ind = np.arange(0, df.shape[0], 1) train_sampler = WeightedSubsetRandomSampler(tr_ind, train_weights, replacement = replacement) loader = DataLoader(dataset, batch_size=batch_size, num_workers=4, pin_memory=True, sampler=train_sampler) else: loader = DataLoader(dataset, batch_size=batch_size, num_workers=4, pin_memory=True, shuffle=False) return loader
def get_training_augmentation(img): #print(type(img)) train_transform = [ albumentations.Resize(32 , 32), AT.ToTensor() ] transforms = albumentations.Compose(train_transform) return lambda img:transforms(image=np.array(img))['image']
def data_loader_mask(): """ Converting the images for PILImage to tensor, so they can be accepted as the input to the network :return : """ print("Loading Dataset") default_transform = albu.Compose( [PadDifferentlyIfNeeded(512, 512, mask_value=0), AT.ToTensor()]) transform = albu.Compose([ albu.RandomRotate90(1.0), albu.HorizontalFlip(0.5), PadDifferentlyIfNeeded(512, 512, mask_value=0), AT.ToTensor() ]) testset_gt = ImageDataset(root=TEST_ENHANCED_IMG_DIR, transform=default_transform) trainset_2_gt = ImageDataset(root=ENHANCED2_IMG_DIR, transform=transform) testset_inp = ImageDataset(root=TEST_INPUT_IMG_DIR, transform=default_transform) trainset_1_inp = ImageDataset(root=INPUT_IMG_DIR, transform=transform) train_loader_cross = torch.utils.data.DataLoader( ConcatDataset(trainset_1_inp, trainset_2_gt), num_workers=NUM_WORKERS, batch_size=BATCH_SIZE * GPUS_NUM, # Enlarge batch_size by a factor of len(device_ids) shuffle=True, ) test_loader = torch.utils.data.DataLoader( ConcatDataset(testset_inp, testset_gt), num_workers=NUM_WORKERS, batch_size=BATCH_SIZE * GPUS_NUM, # Enlarge batch_size by a factor of len(device_ids) shuffle=False) print("Finished loading dataset") return train_loader_cross, test_loader
def __init__(self, split): self.split = split self.aug = albumentations.Compose([ albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), AT.ToTensor() ]) if self.split == 'train': self.aug = albumentations.Compose([ albumentations.HorizontalFlip(), albumentations.RandomBrightness(), #albumentations.ShiftScaleRotate(rotate_limit=15, scale_limit=0.10), #albumentations.HueSaturationValue(), albumentations.Cutout(1, 4, 4, 0.5), #albumentations.GaussNoise(), #albumentations.ElasticTransform(), albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), AT.ToTensor() ])
def main(): parser = argparse.ArgumentParser() parser.add_argument('-s', help='Settings file') args = parser.parse_args() with open(args.s) as config_file: config = json.load(config_file) path_to_out = config.get('out_path') is_available_cuda = config.get('cuda', False) test_ds = CancerDataset(csv_file=config.get('data_csv'), root_dir=config.get('data'), transform_image=albumentations.Compose([ albumentations.Resize(int(config.get('width')), int(config.get('height'))), albumentations.Normalize(), AT.ToTensor() ])) loader_test = DataLoader(test_ds, batch_size=config.get('batch_size'), num_workers=1) submission_names = test_ds.get_train_img_names() model = fm.get_dense_net_121(pretrained=False) model.load_state_dict(torch.load(config.get('model'))) model.eval() if is_available_cuda: model.cuda() predicted_labels = [] pbar = tqdm(loader_test) for batch_idx, data in enumerate(pbar): with torch.no_grad(): if is_available_cuda: data = Variable(data[0].cuda(), requires_grad=False) else: data = Variable(data[0], requires_grad=False) y_predicted = model(data) y_predicted = torch.sigmoid(y_predicted) for predicted in y_predicted: predicted_labels.append(predicted.cpu().numpy()[0]) del data del y_predicted predicted_labels = numpy.array(predicted_labels) utils.generate_submission(submission_names, predicted_labels, path_to_out)
def __init__(self, df: pd.DataFrame = None, datatype: str = 'train', img_ids: np.array = None, transforms = albu.Compose([albu.HorizontalFlip(),AT.ToTensor()]), preprocessing=None): self.df = df if datatype != 'test': self.data_folder = f"{settings.DATA_DIR}/train" else: self.data_folder = f"{settings.DATA_DIR}/test" self.img_ids = img_ids self.transforms = transforms self.preprocessing = preprocessing
def __init__(self, df: pd.DataFrame = None, datatype: str = 'train', img_ids: np.array = None, # AT被替换成了torch transforms = albu.Compose([albu.HorizontalFlip(), AT.ToTensor()]), preprocessing=None): self.df = df if datatype != 'test': self.data_folder = f"{path}/train_images" else: self.data_folder = f"{path}/test_images" self.img_ids = img_ids self.transforms = transforms self.preprocessing = preprocessing
def __init__(self, path: str, df: pd.DataFrame = None, datatype: str = "train", im_ids: np.array = None, transforms=albu.Compose( [albu.HorizontalFlip(), AT.ToTensor()]), preprocessing=None): df["hasMask"] = ~df["EncodedPixels"].isna() self.df = df if datatype != "test": self.data_folder = os.path.join(path, "train_images") else: self.data_folder = os.path.join(path, "test_images") self.img_ids = im_ids self.transforms = transforms self.preprocessing = preprocessing
def __init__(self, path: str, df: pd.DataFrame = None, datatype: str = "train", im_ids: np.array = None, transforms=albu.Compose( [albu.HorizontalFlip(), AT.ToTensor()]), preprocessing=None, use_resized_dataset=False): self.df = df if datatype != "test": self.data_folder = os.path.join(path, "train_images") else: self.data_folder = os.path.join(path, "test_images") self.masks_folder = os.path.join( path, "masks") # only when use_resized_dataset=True self.use_resized_dataset = use_resized_dataset self.img_ids = im_ids self.transforms = transforms self.preprocessing = preprocessing
def main(params): wd = 4e-4 train_transforms = albumentations.Compose([ #albumentations.CenterCrop(64, 64), albumentations.RandomRotate90(p=0.5), albumentations.Transpose(p=0.5), albumentations.Flip(p=0.5), albumentations.OneOf([ albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(), albumentations.RandomBrightness(), albumentations.RandomContrast(), albumentations.JpegCompression(), albumentations.Blur(), albumentations.GaussNoise() ], p=0.5), albumentations.HueSaturationValue(p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.15, rotate_limit=45, p=0.5), albumentations.Normalize(), AT.ToTensor() ]) valid_transforms = albumentations.Compose([ #albumentations.CenterCrop(64, 64), albumentations.Normalize(), AT.ToTensor() ]) sgd = partial(optim.Adam, lr=params.base_lr) writer = SummaryWriter(params.model_dir + "/log") model = Model().cuda() trn_dl, val_dl = get_train_and_valid_dataload(params.data_dir, train_transforms, valid_transforms) loss_fn = nn.BCEWithLogitsLoss() metric = BCA() learner = Learner(model=model, trn_dl=trn_dl, val_dl=val_dl, optim_fn=sgd, metrics=[metric], loss_fn=loss_fn, callbacks=[], writer=writer) #to_fp16(learner, 512) learner.callbacks.append( SaveBestModel(learner, small_better=False, name='best.pth', model_dir=params.model_dir)) epoches = params.num_epoches warmup_batches = 2 * len(trn_dl) lr1 = np.linspace(params.base_lr / 25, params.base_lr, num=warmup_batches, endpoint=False) lr2 = np.linspace(params.base_lr, params.base_lr / 25, num=epoches * len(trn_dl) - warmup_batches) lrs = np.concatenate((lr1, lr2)) lr_sched = LrScheduler(learner.optimizer, lrs) learner.fit(epoches, lr_sched)
RESIZE_H = 160 RESIZE_W = 320 data_transforms = albumentations.Compose([ albumentations.Resize(RESIZE_H, RESIZE_W), albumentations.HorizontalFlip(), albumentations.OneOf([ albumentations.RandomContrast(), albumentations.RandomBrightness(), ]), albumentations.ShiftScaleRotate(rotate_limit=10, scale_limit=0.15), albumentations.JpegCompression(80), albumentations.HueSaturationValue(), albumentations.Normalize(), AT.ToTensor() ]) data_transforms_test = albumentations.Compose([ albumentations.Resize(RESIZE_H, RESIZE_W), albumentations.Normalize(), AT.ToTensor() ]) # In[11]: def prepare_labels(y): # From here: https://www.kaggle.com/pestipeti/keras-cnn-starter values = np.array(y)
def get_transforms_test(): transforms_test_list = [] if config['transforms'] == 'pytorch': if config['pytorch']['resize']['test']: transforms_test_list.append( transforms.Resize( size=(config['pytorch']['resize']['test_size'], config['pytorch']['resize']['test_size']))) if config['pytorch']['centerCrop']['test']: transforms_test_list.append( transforms.Resize( size=(config['pytorch']['centerCrop']['test_size'], config['pytorch']['centerCrop']['test_size']))) if config['pytorch']['randomHorizontalFlip']['test']: transforms_test_list.append(transforms.RandomHorizontalFlip()) if config['pytorch']['randomRotation']['test']: transforms_test_list.append( transforms.RandomRotation( degrees=config['pytorch']['randomRotation']['degrees'])) if config['pytorch']['toTensor']['test']: transforms_test_list.append(transforms.ToTensor()) if config['pytorch']['normalize']['test']: transforms_test_list.append( transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])) test_transforms = transforms.Compose(transforms_test_list) else: if config['albumentations']['resize']['test']: transforms_test_list.append( A.Resize(config['albumentations']['resize']['test_size'], config['albumentations']['resize']['test_size'])) if config['albumentations']['centerCrop']['test']: transforms_test_list.append( transforms.Resize( config['albumentations']['centerCrop']['test_size'], config['albumentations']['centerCrop']['test_size'])) if config['albumentations']['horizontalFlip']['test']: transforms_test_list.append(A.HorizontalFlip()) if config['albumentations']['rotate']['test']: transforms_test_list.append( A.Rotate(config['albumentations']['rotate']['limit'])) if config['albumentations']['clahe']['test']: transforms_test_list.append(A.CLAHE()) if config['albumentations']['gaussNoise']['test']: transforms_test_list.append(A.GaussNoise()) if config['albumentations']['randomBrightness']['test']: transforms_test_list.append(A.RandomBrightness()) if config['albumentations']['randomContrast']['test']: transforms_test_list.append(A.RandomContrast()) if config['albumentations']['randomBrightnrssContrast']['test']: transforms_test_list.append(A.RandomBrightnessContrast()) if config['albumentations']['hueSaturationValue']['test']: transforms_test_list.append(A.HueSaturationValue()) if config['albumentations']['normalize']['test']: transforms_test_list.append( A.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])) if config['albumentations']['toTensor']['test']: transforms_test_list.append(AT.ToTensor()) test_transforms = A.Compose(transforms_test_list) return test_transforms
def main(model_dir, data_dir): data_transforms_test = albumentations.Compose([ #albumentations.CenterCrop(64, 64), albumentations.Normalize(), AT.ToTensor() ]) data_transforms_tta0 = albumentations.Compose([ #albumentations.CenterCrop(64, 64), albumentations.RandomRotate90(p=0.5), albumentations.Transpose(p=0.5), albumentations.Flip(p=0.5), albumentations.Normalize(), AT.ToTensor() ]) data_transforms_tta1 = albumentations.Compose([ #albumentations.CenterCrop(64, 64), albumentations.RandomRotate90(p=1), albumentations.Normalize(), AT.ToTensor() ]) data_transforms_tta2 = albumentations.Compose([ #albumentations.CenterCrop(64, 64), albumentations.Transpose(p=1), albumentations.Normalize(), AT.ToTensor() ]) data_transforms_tta3 = albumentations.Compose([ #albumentations.CenterCrop(64, 64), albumentations.Flip(p=1), albumentations.Normalize(), AT.ToTensor() ]) best_train_result_path = os.path.join(model_dir, "best.pth") checkpoint = torch.load(best_train_result_path) model = Model() model.load_state_dict(checkpoint["model"]) model.cuda() model.eval() NUM_TTA = 8 sigmoid = lambda x: scipy.special.expit(x) test_data_dir = os.path.join(data_dir, "test") submit_sample_csv = os.path.join(data_dir, "sample_submission.csv") result_csv = os.path.join(data_dir, "sub_tta.csv") for num_tta in range(NUM_TTA): if num_tta == 0: test_set = CancerDataset(datafolder=test_data_dir, datatype='test', transform=data_transforms_test) test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, num_workers=num_workers) elif num_tta == 1: test_set = CancerDataset(datafolder=test_data_dir, datatype='test', transform=data_transforms_tta1) test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, num_workers=num_workers) elif num_tta == 2: test_set = CancerDataset(datafolder=test_data_dir, datatype='test', transform=data_transforms_tta2) test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, num_workers=num_workers) elif num_tta == 3: test_set = CancerDataset(datafolder=test_data_dir, datatype='test', transform=data_transforms_tta3) test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, num_workers=num_workers) else: test_set = CancerDataset(datafolder=test_data_dir, datatype='test', transform=data_transforms_tta0) test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, num_workers=num_workers) preds = [] for batch_i, (data, target) in enumerate(test_loader): data, target = data.cuda(), target.cuda() output = model(data).detach() pr = output[:, 0].cpu().numpy() for i in pr: preds.append(sigmoid(i) / NUM_TTA) if num_tta == 0: test_preds = pd.DataFrame({ 'imgs': test_set.image_files_list, 'preds': preds }) test_preds['imgs'] = test_preds['imgs'].apply( lambda x: x.split('.')[0]) else: test_preds['preds'] += np.array(preds) sub = pd.read_csv(submit_sample_csv) sub = pd.merge(sub, test_preds, left_on='id', right_on='imgs') sub = sub[['id', 'preds']] sub.columns = ['id', 'label'] sub.to_csv(result_csv, index=False)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-s', help='Settings file') args = parser.parse_args() with open(args.s) as config_file: config = json.load(config_file) best_accuracy = -1.0 save_path = config.get('dest_model') model = fm.get_dense_net_121(pretrained=True) src_path = config.get('src_model') if src_path is not None: model.load_state_dict(torch.load(src_path)) is_available_cuda = config.get('cuda', False) if is_available_cuda: model.cuda() data_transforms = albumentations.Compose([ albumentations.Resize(int(config.get('width')), int(config.get('height'))), albumentations.RandomRotate90(p=0.5), albumentations.Transpose(p=0.5), albumentations.Flip(p=0.5), albumentations.OneOf([ albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(), albumentations.RandomBrightness(), albumentations.RandomContrast(), albumentations.JpegCompression(), albumentations.Blur(), albumentations.GaussNoise() ], p=0.5), albumentations.HueSaturationValue(p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.15, rotate_limit=45, p=0.5), albumentations.Normalize(), AT.ToTensor() ]) data_transforms_valid = albumentations.Compose([ albumentations.Resize(int(config.get('width')), int(config.get('height'))), albumentations.Normalize(), AT.ToTensor() ]) optimizer = optim.Adam(model.parameters(), lr=0.00001) writer = SummaryWriter() train_ds = CancerDataset( csv_file=config.get('train_csv'), root_dir=config.get('data_train'), transform_image=data_transforms, ) valid_ds = CancerDataset(csv_file=config.get('valid_csv'), root_dir=config.get('data_validate'), transform_image=data_transforms_valid) loader_validate = DataLoader(valid_ds, batch_size=config.get('batch_size'), num_workers=1) loader_train = DataLoader(train_ds, batch_size=config.get('batch_size'), num_workers=1) criterion = nn.BCEWithLogitsLoss() start_epoch = config.get('st_epoch', 0) for epoch in range(config.get('do_epoch', 1000)): utils.train(model, writer, is_available_cuda, loader_train, criterion, optimizer, epoch + start_epoch) accuracy = utils.validate(model, writer, is_available_cuda, loader_validate, criterion, epoch + start_epoch) if accuracy > best_accuracy: best_accuracy = accuracy best_model = copy.deepcopy(model) best_model.cpu() pth_model = '{0}_{1}.pt'.format(save_path, epoch + start_epoch) torch.save(best_model.state_dict(), pth_model)
def get_transforms_train(): transforms_train_list = [] if config['transforms'] == 'pytorch': if config['pytorch']['resize']['train']: transforms_train_list.append( transforms.Resize( size=(config['pytorch']['resize']['train_size'], config['pytorch']['resize']['train_size']))) if config['pytorch']['centerCrop']['train']: transforms_train_list.append( transforms.Resize( size=(config['pytorch']['centerCrop']['train_size'], config['pytorch']['centerCrop']['train_size']))) if config['pytorch']['colorJitter']['train']: transforms_train_list.append( transforms.RandomApply([ transforms.ColorJitter( config['pytorch']['colorJitter']['brightness']) ], p=0.75)) if config['pytorch']['randomCrop']['train']: transforms_train_list.append( transforms.RandomCrop( size=config['pytorch']['randomCrop']['train_size'], padding=config['pytorch']['randomCrop']['padding'])) if config['pytorch']['randomResizedCrop']['train']: transforms_train_list.append( transforms.RandomResizedCrop( size=config['pytorch']['randomResizedCrop']['train_size'])) if config['pytorch']['randomHorizontalFlip']['train']: transforms_train_list.append(transforms.RandomHorizontalFlip()) if config['pytorch']['randomAffine']['train']: transforms_train_list.append( transforms.RandomAffine( degrees=config['pytorch']['randomAffine']['degrees'], scale=config['pytorch']['randomAffine']['scale'])) if config['pytorch']['randomRotation']['train']: transforms_train_list.append( transforms.RandomRotation( degrees=config['pytorch']['randomRotation']['degrees'])) if config['pytorch']['toTensor']['train']: transforms_train_list.append(transforms.ToTensor()) if config['pytorch']['normalize']['train']: transforms_train_list.append( transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])) if config['pytorch']['randomErasing']['train']: transforms_train_list.append( transforms.RandomErasing( p=config['pytorch']['randomErasing']['p'], value=config['pytorch']['randomErasing']['value'])) train_transforms = transforms.Compose(transforms_train_list) else: if config['albumentations']['resize']['train']: transforms_train_list.append( A.Resize(config['albumentations']['resize']['train_size'], config['albumentations']['resize']['train_size'])) if config['albumentations']['centerCrop']['train']: transforms_train_list.append( transforms.Resize( config['albumentations']['centerCrop']['train_size'], config['albumentations']['centerCrop']['train_size'])) if config['albumentations']['horizontalFlip']['train']: transforms_train_list.append(A.HorizontalFlip()) if config['albumentations']['rotate']['train']: transforms_train_list.append( A.Rotate(config['albumentations']['rotate']['limit'])) if config['albumentations']['clahe']['train']: transforms_train_list.append(A.CLAHE()) if config['albumentations']['gaussNoise']['train']: transforms_train_list.append(A.GaussNoise()) if config['albumentations']['randomBrightness']['train']: transforms_train_list.append(A.RandomBrightness()) if config['albumentations']['randomContrast']['train']: transforms_train_list.append(A.RandomContrast()) if config['albumentations']['randomBrightnrssContrast']['train']: transforms_train_list.append(A.RandomBrightnessContrast()) if config['albumentations']['hueSaturationValue']['train']: transforms_train_list.append(A.HueSaturationValue()) if config['albumentations']['normalize']['train']: transforms_train_list.append( A.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])) if config['albumentations']['toTensor']['train']: transforms_train_list.append(AT.ToTensor()) train_transforms = A.Compose(transforms_train_list) return train_transforms
def main(): train = pd.read_csv('C:/Data/slepota_data/train.csv') test = pd.read_csv('C:/Data/slepota_data/test.csv') sample_submission = pd.read_csv( 'C:/Data/slepota_data/sample_submission.csv') y, le = prepare_labels(train['diagnosis']) data_transforms = albumentations.Compose([ albumentations.Resize(224, 224), albumentations.HorizontalFlip(p=0.5), albumentations.RandomBrightness(), albumentations.ShiftScaleRotate(rotate_limit=15, scale_limit=0.10), albumentations.JpegCompression(80), albumentations.HueSaturationValue(), albumentations.Normalize(), AT.ToTensor() ]) test_transforms = albumentations.Compose([ albumentations.Resize(224, 224), albumentations.HorizontalFlip(), albumentations.Normalize(), AT.ToTensor(), ]) #Возможно добавить больше test time augmentation train_set = GlassDataset(df=train, datatype='train', transform=data_transforms, y=y) test_set = GlassDataset(df=test, datatype='test', transform=test_transforms) tr, val = train_test_split(train.diagnosis, stratify=train.diagnosis, test_size=0.1) train_sampler = SubsetRandomSampler(list(tr.index)) validation_sampler = SubsetRandomSampler(list(val.index)) batch_size = 64 num_workers = 0 train_loader = DataLoader(train_set, batch_size=batch_size, sampler=train_sampler, num_workers=num_workers) valid_loader = DataLoader(train_set, batch_size=batch_size, sampler=validation_sampler, num_workers=num_workers) test_loader = DataLoader(test_set, batch_size=batch_size, num_workers=num_workers) model = pretrainedmodels.__dict__['resnet101'](pretrained=None) model.avg_pool = nn.AdaptiveAvgPool2d(1) model.last_linear = nn.Sequential( nn.BatchNorm1d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True), nn.Dropout(p=0.25), nn.Linear(in_features=2048, out_features=2048, bias=True), nn.ReLU(), nn.BatchNorm1d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True), nn.Dropout(p=0.5), nn.Linear(in_features=2048, out_features=1, bias=True), ) model.load_state_dict(torch.load("../input/mmmodel/model.bin")) model = model.to(device) for param in model.parameters(): param.requires_grad = False model.eval() valid_predictions = np.zeros((len(val), 1)) tk_valid = tqdm(valid_loader) for i, x_batch in enumerate(tk_valid): x_batch = x_batch["image"] pred = model(x_batch.to(device)) valid_predictions[i * 32:(i + 1) * 32] = pred.detach().cpu().squeeze( ).numpy().ravel().reshape(-1, 1) test_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) test_preds1 = np.zeros((len(test_set), 1)) tk0 = tqdm(test_loader) for i, x_batch in enumerate(tk0): x_batch = x_batch["image"] pred = model(x_batch.to(device)) test_preds1[i * 32:(i + 1) * 32] = pred.detach().cpu().squeeze().numpy( ).ravel().reshape(-1, 1) test_preds2 = np.zeros((len(test_set), 1)) tk0 = tqdm(test_loader) for i, x_batch in enumerate(tk0): x_batch = x_batch["image"] pred = model(x_batch.to(device)) test_preds2[i * 32:(i + 1) * 32] = pred.detach().cpu().squeeze().numpy( ).ravel().reshape(-1, 1) test_preds3 = np.zeros((len(test_set), 1)) tk0 = tqdm(test_loader) for i, x_batch in enumerate(tk0): x_batch = x_batch["image"] pred = model(x_batch.to(device)) test_preds3[i * 32:(i + 1) * 32] = pred.detach().cpu().squeeze().numpy( ).ravel().reshape(-1, 1) test_preds4 = np.zeros((len(test_set), 1)) tk0 = tqdm(test_loader) for i, x_batch in enumerate(tk0): x_batch = x_batch["image"] pred = model(x_batch.to(device)) test_preds4[i * 32:(i + 1) * 32] = pred.detach().cpu().squeeze().numpy( ).ravel().reshape(-1, 1) test_preds5 = np.zeros((len(test_set), 1)) tk0 = tqdm(test_loader) for i, x_batch in enumerate(tk0): x_batch = x_batch["image"] pred = model(x_batch.to(device)) test_preds5[i * 32:(i + 1) * 32] = pred.detach().cpu().squeeze().numpy( ).ravel().reshape(-1, 1) test_predictions = (test_preds1 + test_preds2 + test_preds3 + test_preds4 + test_preds5) / 5.0 optR = kappa_optimizer.OptimizerRounder() optR.fit(valid_predictions, y) coefficients = optR.coefficient() valid_predictions = optR.predict(valid_predictions, coefficients) test_predictions = optR.predict(test_predictions, coefficients) sample_submission.diagnosis = test_predictions.astype(int) sample_submission.to_csv("submission.csv", index=False) print('Validation prediction: ', valid_predictions) print('Validation score: ', metrics.cohen_kappa_score(y, valid_predictions, weights='quadratic'))