def app(test_img_path, submission_path, device): """Wraps inference code for Efficiency scoring. Parameters ---------- test_img_path : str Path to test images. submission_path : str Path to save `submission.csv`. device : str Device to run model on. """ ######################################## # place your code here # ######################################## model = DummyModel().to(device) weights = torch.load('model_weights/dummy_weights.pkl', map_location=device) model.load_state_dict(weights) img_paths = glob(os.path.join(test_img_path, '*')) submission = ['ImageId_ClassId,EncodedPixels\n'] model.eval() with torch.no_grad(): for path in tqdm(img_paths): name = path.split('/')[-1] image = normalize(cv2.imread(path, cv2.IMREAD_COLOR)) image = torch.from_numpy(image.transpose(2, 0, 1)) score = model(image.unsqueeze(0).to(device)) mask = (score.cpu().numpy()[0] > 0.5).astype(np.uint8) rle = mask_to_rle(mask, name) submission.append(rle) with open(os.path.join(submission_path, 'dummy_submission.csv'), 'w') as f: f.write(''.join(submission))
def predict_on_test(self): sample_df = pd.read_csv( os.path.join(self.DATA_PATH_BASE, "sample_submission.csv")) # this part was taken from @raddar's kernel: https://www.kaggle.com/raddar/better-sample-submission masks_ = sample_df.groupby("ImageId")["ImageId"].count().reset_index( name="N") masks_ = masks_.loc[masks_.N > 1].ImageId.values ### sample_df = sample_df.drop_duplicates( "ImageId", keep="last").reset_index(drop=True) tt = transforms.ToTensor() sublist = [] counter = 0 # changed from 0.25 to 0.5... need to check the data and analyze...(test on dev set) threshold = 0.55 for index, row in tqdm(sample_df.iterrows(), total=len(sample_df)): image_id = row["ImageId"] if image_id in masks_: img_path = os.path.join(self.DATA_PATH_BASE + "/test/" + image_id + ".png") img = Image.open(img_path).convert("RGB") width, height = img.size img = img.resize((1024, 1024), resample=Image.BILINEAR) img = tt(img) result = self.model_ft([img.to(self.device)])[0] if len(result["masks"]) > 0: counter += 1 mask_added = 0 for ppx in range(len(result["masks"])): if result["scores"][ppx] >= threshold: mask_added += 1 res = transforms.ToPILImage()( result["masks"][ppx].permute(1, 2, 0).cpu().numpy()) res = np.asarray( res.resize((width, height), resample=Image.BILINEAR)) res = (res[:, :] * 255.0 > 127).astype(np.uint8).T rle = utils.mask_to_rle(res, width, height) sublist.append([image_id, rle]) if mask_added == 0: rle = " -1" sublist.append([image_id, rle]) else: rle = " -1" sublist.append([image_id, rle]) else: rle = " -1" sublist.append([image_id, rle]) submission_df = pd.DataFrame(sublist, columns=sample_df.columns.values) submission_df.to_csv("submission.csv", index=False) print(counter)
def predict_rle(model, device, data_loader, metric_logger, print_freq): header = "DEV prediction test" sublist = [] counter = 0 # changed from 0.25 to 0.5... need to check the data and analyze...(test on dev set) threshold = 0.55 assert data_loader.batch_size == 1 for images, targets in metric_logger.log_every(data_loader, print_freq, header): width, height = images.size image_id = targets["image_id"] images = list(image.to(device) for image in images) targets = [{k: v.to(device) for k, v in t.items()} for t in targets] result = model(images, targets)[0] if len(result["masks"]) > 0: counter += 1 mask_added = 0 for ppx in range(len(result["masks"])): if result["scores"][ppx] >= threshold: mask_added += 1 res = transforms.ToPILImage()( result["masks"][ppx].permute(1, 2, 0).cpu().numpy()) res = np.asarray( res.resize((width, height), resample=Image.BILINEAR)) res = (res[:, :] * 255.0 > 127).astype(np.uint8).T rle = utils.mask_to_rle(res, width, height) sublist.append([image_id, rle]) if mask_added == 0: rle = " -1" sublist.append([image_id, rle]) else: rle = " -1" sublist.append([image_id, rle]) return sublist
mask = pd.read_csv(PATH) k = mask.groupby('ImageId').count()[" EncodedPixels"] list_ImageId = k.index[k > 1] for i in tqdm(range(len(list_ImageId))): tmp = mask.loc[mask['ImageId'] == list_ImageId[i]] final_mask = np.zeros((1024, 1024)) for index, row in tmp.iterrows(): RLE_mask = row[" EncodedPixels"] if RLE_mask.strip() != str(-1): rle_mask = rle2mask(RLE_mask[1:], 1024, 1024).T else: rle_mask = np.zeros((1024, 1024)) final_mask[np.where(rle_mask)] = 1 final_rle = mask_to_rle(final_mask.T, 1024, 1024) new_csv['ImageId'].append(list_ImageId[i]) new_csv[' EncodedPixels'].append(final_rle) k = mask.groupby('ImageId').count()[" EncodedPixels"] list_ImageId = k.index[k == 1] for i in tqdm(range(len(list_ImageId))): new_csv['ImageId'].append(list_ImageId[i]) new_csv[' EncodedPixels'].append(mask.loc[ mask['ImageId'] == list_ImageId[i]][" EncodedPixels"].values[0]) new_df = pd.DataFrame(data=new_csv) df = new_df df = df.sample(frac=1).reset_index(drop=True)
def inference(model_ft, device): model_ft.eval() for param in model_ft.parameters(): param.requires_grad = False model_ft.to(device) assert model_ft.training == False test_start = time.time() sample_df = pd.read_csv(config.sub_sample_path) leak_df = pd.read_csv(config.leak_path) leak_id = [] for id, anno in zip(leak_df['ImageId'], leak_df['EncodedPixels']): if anno == '-1': leak_id.append(id) print(f'leak_id: {len(leak_id)}') print(f'leak id: {leak_id[:5]}') tt = transforms.ToTensor() sublist = [] counter = 0 best_thr = 0.5 Noise_th = 75.0 * (1024 / 128.0)**2 for index, row in tqdm(sample_df.iterrows(), total=len(sample_df), desc='test'): image_id = row['ImageId'] if image_id not in leak_id: img_path = os.path.join(config.test_png_path, image_id + '.png') img = Image.open(img_path).convert("RGB") width, height = img.size img_row = img.resize((1024, 1024), resample=Image.BILINEAR) img = tt(img_row) img = img.reshape((1, *img.numpy().shape)) logits = model_ft(img.to(device))[:, 0, :, :] preds = torch.sigmoid(logits)[0].cpu().numpy() # mask = (preds > best_thr).astype(np.uint8) # if no_tta # TTA HFlip hflip_img = img.flip(-1) hflip_logits = model_ft(hflip_img.to(device))[:, 0, :, :] hflip_logits = hflip_logits.flip(-1) hflip_preds = torch.sigmoid(hflip_logits)[0].cpu().numpy() # CLAHE TTA clahe = alb.CLAHE(p=1.0) clahe_im = clahe(image=np.asarray(img_row))['image'] clahe_im = tt(clahe_im) clahe_im = clahe_im.reshape((1, *clahe_im.numpy().shape)) clahe_logits = model_ft(clahe_im.to(device))[:, 0, :, :] clahe_preds = torch.sigmoid(clahe_logits)[0].cpu().numpy() preds = (preds + hflip_preds + clahe_preds) / 3 mask = (preds > best_thr).astype(np.uint8) mask = Image.fromarray(np.uint8(mask)) mask = mask.resize((1024, 1024), resample=Image.BILINEAR) mask = np.asarray(mask) mask = morphology.remove_small_objects(mask, min_size=Noise_th, connectivity=2) mask = mask.T if np.count_nonzero(mask) == 0: rle = " -1" else: rle = mask_to_rle(mask, width, height) else: rle = '-1' if image_id == '1.2.276.0.7230010.3.1.4.8323329.6830.1517875201.424165': rle = '-1' sublist.append([image_id, rle]) if not os.path.exists('results'): os.makedirs('results') if not os.path.exists('checkpoints'): os.makedirs('checkpoints') submission_df = pd.DataFrame(sublist, columns=sample_df.columns.values) submission_df.to_csv("results/sub_ony_mask.csv", index=False) print('test time: {:.3f}min'.format((time.time() - test_start) / 60)) torch.save({ 'model': model_ft, 'leaks': leak_id }, 'checkpoints/deeplabv3_leak.pth')
def predict_rle_from_acts(acts, data_loader, metric_logger, print_freq, threshold=0.5): header = "DEV prediction test" sublist = [] counter = 0 data_loader_b1 = torch.utils.data.DataLoader( data_loader.dataset, batch_size=1, shuffle=False, num_workers=0, # 4: 08:19, 8: 08:40 collate_fn=PS_torch._collate_fn_for_data_loader, ) idx = 0 mask_add_cnt = [] for image, target in metric_logger.log_every(data_loader_b1, print_freq, header): width, height = 1024, 1024 result = acts[idx] image_id = target[0]["image_id"].cpu().numpy() idx += 1 if len(result["masks"]) > 0: counter += 1 mask_added = 0 for ppx in range(len(result["masks"])): if result["scores"][ppx] >= threshold: mask_added += 1 # res = transforms.ToPILImage()(result["masks"][ppx].permute(1, 2, 0).cpu().numpy()) res = transforms.ToPILImage()( result["masks"][ppx].transpose((1, 2, 0))) res = np.asarray( res.resize((width, height), resample=Image.BILINEAR)) res = (res[:, :] * 255.0 > 127).astype(np.uint8).T rle = utils.mask_to_rle(res, width, height) sublist.append([image_id, rle]) if mask_added == 0: rle = " -1" sublist.append([image_id, rle]) mask_add_cnt.append(mask_added) else: rle = " -1" sublist.append([image_id, rle]) mask_add_cnt.append(0) # no mask if idx % 100 == 0: mask_stat = np.array(mask_add_cnt) metric_logger.update( **{ "mask0": ((mask_stat == 0).sum() / idx), "mask1": ((mask_stat == 1).sum() / idx), "mask2": ((mask_stat == 2).sum() / idx), "mask>2": ((mask_stat > 2).sum() / idx), }) mask_stat = np.array(mask_add_cnt) assert len(mask_stat) == idx metric_logger.print_and_log_to_file( f"image cnt: {idx}, image predicted mask cnt: {counter}, " f"mask 0,1,2,3+ {(mask_stat==0).sum()/idx}, " f"{(mask_stat==1).sum()/idx}, {(mask_stat==2).sum()/idx}, {(mask_stat>2).sum()/idx}" ) return sublist, mask_stat
print('test_pred_ids.shape = {}'.format(np.array(test_pred_ids).shape)) print('test_pred_rle.shape = {}'.format(np.array(test_pred_rle).shape)) # Inspect a test prediction and check run length encoding. # n = np.random.randint(len(x_test)) n = 171 pred = u_net.get_prediction_from_path( sess, [x_test[n]], method=METHOD, tgt_size=(IMG_HEIGHT, IMG_WIDTH), compatibility_multiplier=32, full_prediction=True)[0] y_test_pred = utils.trsf_proba_to_binary(pred) y_test_pred_original_size = utils.resize_as_original( [y_test_pred], [test_sizes[n]])[:, :, 0] rle = list(utils.mask_to_rle(y_test_pred_original_size)) mask_rec = utils.rle_to_mask(rle, test_sizes[n]) print('Run length encoding: {} matches, {} misses'.format( np.sum((mask_rec == y_test_pred_original_size)), np.sum((mask_rec != y_test_pred_original_size)))) fig, axs = plt.subplots(2, 3, figsize=(20, 13)) axs[0, 0].imshow(utils.read_image(test_df['image_path'].loc[n])) axs[0, 0].set_title('{}.) original test image'.format(n)) axs[0, 1].imshow(np.squeeze((utils.read_image(x_test[n])))) axs[0, 1].set_title('{}.) transformed test image'.format(n)) axs[0, 2].imshow(np.squeeze(pred[:, :, 0]), cm.gray) axs[0, 2].set_title('{}.) predicted test mask probabilities'.format(n)) axs[1, 0].imshow(np.squeeze(y_test_pred[:, :, 0]), cm.gray) axs[1, 0].set_title('{}.) predicted test mask'.format(n)) axs[1, 1].imshow(np.squeeze(y_test_pred_original_size[:, :, 0]), cm.gray)