def predict_softmax(args): model, _ = create_model(args) if torch.cuda.device_count() > 1: model = DataParallel(model) model = model.cuda() model.eval() test_loader = get_test_loader(batch_size=args.val_batch_size, dev_mode=args.dev_mode) preds, scores, founds = [], [], [] with torch.no_grad(): for i, (x, found) in enumerate(test_loader): x = x.cuda() output = model(x, None, True) output = F.softmax(output, dim=1) score, pred = output.max(1) preds.append(pred.cpu()) scores.append(score.cpu()) founds.append(found) print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num), end='\r') preds = torch.cat(preds, 0).numpy() scores = torch.cat(scores, 0).numpy() founds = torch.cat(founds, 0).numpy() classes, stoi = get_classes(num_classes=args.num_classes, start_index=args.start_index, other=args.other) print(preds.shape) pred_labels = [classes[i] for i in preds] create_submission(args, pred_labels, scores, founds, args.sub_file)
def pred_class(args): model = create_model() model_file = os.path.join(MODEL_DIR, model.name, 'best.pth') if not os.path.exists(model_file): raise AssertionError('{} does not exist'.format(model_file)) print('loading {}...'.format(model_file)) model.load_state_dict(torch.load(model_file)) model = model.cuda() model.eval() preds = [] test_loader = get_test_loader(64, 0, img_sz=256) for img in test_loader: img = img.cuda() output = model(img).squeeze() pred = (torch.sigmoid(output) > 0.5).byte().cpu().tolist() preds.extend(pred) df_test = test_loader.meta df_test['Target'] = preds print(sum(preds)) df_test.to_csv('test_cls_preds.csv', index=False, columns=['patientId', 'Target'])
def predict_top3(args): model, _ = create_model(args) model = model.cuda() model.eval() test_loader = get_test_loader(args, batch_size=args.batch_size, dev_mode=args.dev_mode) preds = None with torch.no_grad(): for i, x in enumerate(test_loader): x = x.cuda() #output = torch.sigmoid(model(x)) output, _ = model(x) output = F.softmax(output, dim=1) _, pred = output.topk(3, 1, True, True) if preds is None: preds = pred.cpu() else: preds = torch.cat([preds, pred.cpu()], 0) print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num), end='\r') classes, _ = get_classes(args.cls_type, args.start_index, args.end_index) label_names = [] preds = preds.numpy() print(preds.shape) for row in preds: label_names.append(' '.join([classes[i] for i in row])) if args.dev_mode: print(len(label_names)) print(label_names) create_submission(args, label_names, args.sub_file)
def pred_by_vector_search(args): model = create_feature_model(args) test_loader = get_test_loader(batch_size=args.batch_size, dev_mode=args.dev_mode) outputs = [] founds = [] with torch.no_grad(): for i, (x, found) in tqdm(enumerate(test_loader), total=test_loader.num//args.batch_size): x = x.cuda() output = model(x) outputs.append(output.cpu()) founds.append(found.cpu()) xb = torch.cat(outputs, 0).numpy() founds = torch.cat(founds, 0).numpy() print(xb.shape, founds.shape) index_fn = os.path.join(settings.VECTOR_DIR, '{}.index'.format(model.name)) print('loading index...') index = faiss.read_index(index_fn) print('searching...') D, I = index.search(xb, 10) top1_index_ids = I[:, 0].squeeze() #print('I:', I) #print('top1 index ids:', top1_index_ids) pred_labels = get_labels(top1_index_ids) #print(pred_labels) scores = [0.5] * xb.shape[0] create_submission(args, pred_labels, scores, founds, args.sub_file)
def predict(args): model, _ = create_model(args) test_loader = get_test_loader(batch_size=args.val_batch_size) scores = pred_model_output(model, test_loader, labeled=False) print(scores.shape) print(scores[:2]) create_submission(args, scores)
def ensemble_predict(args): models = create_models_from_ckps(args) test_loader = get_test_loader(batch_size=args.batch_size, dev_mode=args.dev_mode) preds = None scores = None founds = None with torch.no_grad(): for i, (x, found) in enumerate(test_loader): x = x.cuda() #output = torch.sigmoid(model(x)) outputs = [] for model in models: output = model(x, None, True) output = F.softmax(output, dim=1) outputs.append(output) avg_ouput = torch.stack(outputs).mean(0) #print(x[0, 0, :]) #output = model(x) #output = F.softmax(output, dim=1) #pred = (output > 0.03).byte() # use threshold #preds = output.max(1, keepdim=True)[1] #print(output) #break score, pred = avg_ouput.max(1) #print(pred.size()) if preds is None: preds = pred.cpu() else: preds = torch.cat([preds, pred.cpu()], 0) if scores is None: scores = score.cpu() else: scores = torch.cat([scores, score.cpu()], 0) if founds is None: founds = found else: founds = torch.cat([founds, found], 0) print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num), end='\r') classes, stoi = get_classes(num_classes=args.num_classes) preds = preds.numpy() scores = scores.numpy() print(preds.shape) pred_labels = [classes[i] for i in preds] create_submission(args, pred_labels, scores, founds, args.sub_file)
def do_tta_predict(args, model, ckp_path, tta_num=4): ''' return 18000x128x128 np array ''' model.eval() preds = [] meta = None # i is tta index, 0: no change, 1: horizon flip, 2: vertical flip, 3: do both for flip_index in range(tta_num): print('flip_index:', flip_index) test_loader = get_test_loader(args.batch_size, index=flip_index, dev_mode=False, pad_mode=args.pad_mode) meta = test_loader.meta outputs = None with torch.no_grad(): for i, img in enumerate(test_loader): add_depth_channel(img, args.pad_mode) img = img.cuda() output, _ = model(img) output = torch.sigmoid(output) if outputs is None: outputs = output.squeeze() else: outputs = torch.cat([outputs, output.squeeze()], 0) print('{} / {}'.format(args.batch_size * (i + 1), test_loader.num), end='\r') outputs = outputs.cpu().numpy() # flip back masks if flip_index == 1: outputs = np.flip(outputs, 2) elif flip_index == 2: outputs = np.flip(outputs, 1) elif flip_index == 3: outputs = np.flip(outputs, 2) outputs = np.flip(outputs, 1) #print(outputs.shape) preds.append(outputs) parent_dir = ckp_path + '_out' if not os.path.exists(parent_dir): os.makedirs(parent_dir) np_file = os.path.join(parent_dir, 'pred.npy') model_pred_result = np.mean(preds, 0) np.save(np_file, model_pred_result) return model_pred_result, meta
def predict(args): model, _ = create_model(args) model = model.cuda() if torch.cuda.device_count() > 1: model = DataParallel(model) test_loader = get_test_loader(batch_size=args.val_batch_size, dev_mode=args.dev_mode) probs = pred_model_output(model, test_loader) print(probs.shape) print(probs[:2]) np.save(args.out, probs)
def do_tta_predict(args, model, ckp_path, tta_indices): ''' return 18000x128x128 np array ''' model.eval() preds = [] cls_preds = [] meta = None # i is tta index, 0: no change, 1: horizon flip, 2: vertical flip, 3: do both for flip_index in tta_indices: print('flip_index:', flip_index) test_loader = get_test_loader(args.batch_size, index=flip_index, dev_mode=args.dev_mode, img_sz=args.img_sz) meta = test_loader.meta outputs = None cls_outputs = None with torch.no_grad(): for i, img in enumerate(test_loader): img = img.cuda() output, cls_output = model(img) output, cls_output = torch.sigmoid(output), torch.sigmoid(cls_output) if outputs is None: outputs = output.squeeze().cpu() cls_outputs = cls_output.squeeze().cpu() else: outputs = torch.cat([outputs, output.squeeze().cpu()], 0) cls_outputs = torch.cat([cls_outputs, cls_output.squeeze().cpu()]) #cls_preds.extend(cls_output.squeeze().cpu().tolist()) print('{} / {}'.format(args.batch_size*(i+1), test_loader.num), end='\r') outputs = outputs.numpy() cls_outputs = cls_outputs.numpy() outputs = tta_back_mask_np(outputs, flip_index) preds.append(outputs) cls_preds.append(cls_outputs) parent_dir = ckp_path+'_out' if not os.path.exists(parent_dir): os.makedirs(parent_dir) np_file = os.path.join(parent_dir, 'pred_{}.npy'.format(''.join([str(x) for x in tta_indices]))) np_file_cls = os.path.join(parent_dir, 'pred_cls_{}.npy'.format(''.join([str(x) for x in tta_indices]))) model_pred_result = np.mean(preds, 0) model_cls_pred_result = np.mean(cls_preds, 0) np.save(np_file, model_pred_result) np.save(np_file_cls, model_cls_pred_result) return model_pred_result, model_cls_pred_result, meta
def pred_retrieval(args): #model = create_feature_model(args) model = create_retrieval_model(args) test_loader = get_test_loader(batch_size=args.batch_size, dev_mode=args.dev_mode, img_size=256) #224 global_feats = [] local_feats = [] founds = [] with torch.no_grad(): for i, (x, found) in tqdm(enumerate(test_loader), total=test_loader.num//args.batch_size): x = x.cuda() #print('x:', x.size()) global_feat, local_feat, _ = model(x) #print('local:', local_feat.size()) #exit(1) global_feats.append(global_feat.cpu()) #local_feats.append(local_feat.view(local_feat.size(0), -1).cpu()) local_feats.append(local_feat.cpu()) founds.append(found.cpu()) global_feats = torch.cat(global_feats, 0).numpy() local_feats = torch.cat(local_feats, 0).numpy() founds = torch.cat(founds, 0).numpy() xb = global_feats print(global_feats.shape, local_feats.shape, xb.shape, founds.shape) index_fn = args.index_fn #os.path.join(settings_retrieval.VECTOR_DIR, '{}.index_retrieval'.format(model.name)) print('loading index...') index = faiss.read_index(index_fn) print('searching...') bg = time.time() D, I = index.search(xb, 100) print('search time:', time.time() - bg) np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'D.npy'), D) np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'I.npy'), I) np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'founds.npy'), founds) np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'local_feats.npy'), local_feats) np.save(os.path.join(settings_retrieval.VECTOR_DIR, 'feats', 'global_feats.npy'), global_feats) #top1_index_ids = I[:, 0].squeeze() #print(pred_labels) #scores = [0.5] * xb.shape[0] create_retrieval_submission(args, I, founds, args.sub_file)
def ensemble_np(args, np_files, save_np=None): preds = [] for np_file in np_files: pred = np.load(np_file) print(np_file, pred.shape) preds.append(pred) y_pred_test = generate_preds(np.mean(preds, 0), (settings.ORIG_H, settings.ORIG_W), args.pad_mode) if save_np is not None: np.save(save_np, np.mean(preds, 0)) meta = get_test_loader(args.batch_size, index=0, dev_mode=False, pad_mode=args.pad_mode).meta submission = create_submission(meta, y_pred_test) submission.to_csv(args.sub_file, index=None, encoding='utf-8')
def predict_top3(args): model, model_file = create_model(args.backbone, args.img_sz) if not os.path.exists(model_file): raise AssertionError('model file not exist: {}'.format(model_file)) model.eval() test_loader = get_test_loader(batch_size=args.batch_size, dev_mode=args.dev_mode, img_sz=args.img_sz) outputs = model_predict(args, model, model_file) _, preds = outputs.topk(3, 1, True, True) preds = preds.numpy() print(preds.shape) create_submission(args, preds, args.sub_file)
def ensemble(args): #class_params = {0: (0.5, 25000), 1: (0.7, 15000), 2: (0.4, 25000), 3: (0.6, 10000)} models = create_models(args) class_params = find_class_params(args, models) #exit(0) test_loader = get_test_loader(args.encoder_types.split(',')[0], args.batch_size) probs, _ = predict_loader(models, test_loader) encoded_pixels, encoded_pixels_no_minsize = [], [] image_id = 0 for img_out in tqdm(probs): #runner_out = runner.predict_batch({"features": test_batch[0].cuda()})['logits'] #for i, batch in enumerate(runner_out): for probability in img_out: #probability = probability.cpu().detach().numpy() if probability.shape != (350, 525): probability = cv2.resize(probability, dsize=(525, 350), interpolation=cv2.INTER_LINEAR) predict, num_predict = post_process(probability, class_params[image_id % 4][0], class_params[image_id % 4][1]) if num_predict == 0: encoded_pixels.append('') else: r = mask2rle(predict) encoded_pixels.append(r) predict2, num_predict2 = post_process(probability, class_params[image_id % 4][0], 0) if num_predict2 == 0: encoded_pixels_no_minsize.append('') else: r2 = mask2rle(predict2) encoded_pixels_no_minsize.append(r2) image_id += 1 sub = pd.read_csv(os.path.join(settings.DATA_DIR, 'sample_submission.csv')) sub['EncodedPixels'] = encoded_pixels sub.to_csv(args.out, columns=['Image_Label', 'EncodedPixels'], index=False) sub['EncodedPixels'] = encoded_pixels_no_minsize sub.to_csv(args.out+'_no_minsize', columns=['Image_Label', 'EncodedPixels'], index=False)
def do_tta_predict(model): ''' return 18000x128x128 np array ''' model.eval() preds = [] meta = None # i is tta index, 0: no change, 1: horizon flip, 2: vertical flip, 3: do both for flip_index in range(4): test_loader = get_test_loader(batch_size, index=flip_index, dev_mode=False) meta = test_loader.meta print('predicting...', CKP, flip_index) outputs = None with torch.no_grad(): for i, img in enumerate(test_loader): img = img.cuda() output, _ = model(img) output = torch.sigmoid(output) if outputs is None: outputs = output.squeeze() else: outputs = torch.cat([outputs, output.squeeze()], 0) print('{} / {}'.format(batch_size * (i + 1), test_loader.num), end='\r') outputs = outputs.cpu().numpy() # flip back masks if flip_index == 1: outputs = np.flip(outputs, 2) elif flip_index == 2: outputs = np.flip(outputs, 1) elif flip_index == 3: outputs = np.flip(outputs, 2) outputs = np.flip(outputs, 1) #print(outputs.shape) preds.append(outputs) return np.mean(preds, 0), meta
def model_predict(args, model, model_file, check, tta_num=2): model.eval() preds = [] for flip_index in range(tta_num): test_loader = get_test_loader(args, batch_size=args.batch_size, dev_mode=args.dev_mode, tta_index=flip_index) outputs = None with torch.no_grad(): for i, x in enumerate(test_loader): x = x.cuda() output, _ = model(x) if args.activation == 'sigmoid': output = torch.sigmoid(output) else: output = F.softmax(output, dim=1) if outputs is None: outputs = output else: outputs = torch.cat([outputs, output]) print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num), end='\r') if check and i == 0: break preds.append(outputs.cpu().numpy()) #return outputs results = np.mean(preds, 0) parent_dir = model_file + '_out' if not os.path.exists(parent_dir): os.makedirs(parent_dir) np_file = os.path.join(parent_dir, 'pred.npy') np.save(np_file, results) return results
def predict_softmax(args): model, _ = create_model(args) if torch.cuda.device_count() > 1: model = DataParallel(model) model = model.cuda() model.eval() test_loader = get_test_loader(batch_size=args.batch_size, dev_mode=args.dev_mode) preds = None scores = None with torch.no_grad(): for i, x in enumerate(test_loader): x = x.cuda() #output = torch.sigmoid(model(x)) #print(x[0, 0, :]) output = model(x) output = F.softmax(output, dim=1) #pred = (output > 0.03).byte() # use threshold #preds = output.max(1, keepdim=True)[1] #print(output) #break score, pred = output.max(1) #print(pred.size()) if preds is None: preds = pred.cpu() else: preds = torch.cat([preds, pred.cpu()], 0) print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num), end='\r') preds = preds.numpy() print(preds.shape) create_submission(args, preds, args.sub_file)
def model_predict(args, model, model_file, check=False, tta_num=2): model.eval() preds = [] for flip_index in range(tta_num): print('tta index:', flip_index) test_loader = get_test_loader(batch_size=args.batch_size, img_sz=args.img_sz, dev_mode=args.dev_mode, tta_index=flip_index) outputs = None with torch.no_grad(): for i, x in enumerate(test_loader): x = x.cuda() output = model(x) output = F.softmax(output, dim=1) if outputs is None: outputs = output.cpu() else: outputs = torch.cat([outputs, output.cpu()], 0) print('{}/{}'.format(args.batch_size * (i + 1), test_loader.num), end='\r') if check and i == 0: break preds.append(outputs) #return outputs results = torch.mean(torch.stack(preds), 0) parent_dir = model_file + '_out' if not os.path.exists(parent_dir): os.makedirs(parent_dir) np_file = os.path.join(parent_dir, 'pred.npy') np.save(np_file, results.numpy()) return results
def predict_empty_masks(args, recall_thresholds=[ 0.2502807, 0.30874616, 0.47154653, 0.25778872 ]): #[0.30248615, 0.4076966, 0.55904335, 0.29780537] 0875): #[0.32873523, 0.44805834, 0.6001048, 0.3136805] 085): #[0.21345863, 0.1824504, 0.41996846, 0.20917079]095): # #[0.28479144, 0.35337192, 0.5124028, 0.27734384]090): model, model_file = create_model(args.encoder_type, work_dir=args.work_dir, ckp=args.ckp) model = model.cuda() model = DataParallel(model) model.eval() if args.tta: model = tta.ClassificationTTAWrapper(model, tta.aliases.d4_transform(), merge_mode='mean') test_loader = get_test_loader(batch_size=args.val_batch_size) all_preds = [] with torch.no_grad(): for inputs in tqdm(test_loader): inputs = inputs.cuda() outputs = model(inputs, nn.Sigmoid()) all_preds.append(outputs.cpu()) all_preds = torch.cat(all_preds, 0).numpy() img_ids = test_loader.img_ids print(all_preds.shape) image_labels_empty = [] for i, (img, predictions) in enumerate(zip(img_ids, all_preds)): for class_i, class_name in enumerate(class_names): if predictions[class_i] < recall_thresholds[class_i]: image_labels_empty.append(f'{img}_{class_name}') pd.DataFrame({ 'empty_ids': image_labels_empty }).to_csv('empty_ids.csv', index=False)
def predict(args): #model = create_model(args.encoder_type, ckp=args.ckp).cuda() #model = nn.DataParallel(model) #runner = SupervisedRunner(model=model) class_params, runner = find_class_params(args) #runner = create_runner(args) test_loader = get_test_loader(args.encoder_type, args.batch_size) loaders = {"test": test_loader} encoded_pixels = [] image_id = 0 for i, test_batch in enumerate(tqdm(loaders['test'])): runner_out = runner.predict_batch({"features": test_batch[0].cuda()})['logits'] for i, batch in enumerate(runner_out): for probability in batch: probability = probability.cpu().detach().numpy() if probability.shape != (350, 525): probability = cv2.resize(probability, dsize=(525, 350), interpolation=cv2.INTER_LINEAR) predict, num_predict = post_process( sigmoid(probability), class_params[image_id % 4][0], class_params[image_id % 4][1]) if num_predict == 0: encoded_pixels.append('') else: r = mask2rle(predict) encoded_pixels.append(r) image_id += 1 sub = pd.read_csv(os.path.join(settings.DATA_DIR, 'sample_submission.csv')) sub['EncodedPixels'] = encoded_pixels sub.to_csv(args.out, columns=['Image_Label', 'EncodedPixels'], index=False)
model = NeuralNet() ''' if torch.cuda.device_count()>1: print("Let's use", torch.cuda.device_count(), "GPUs!") model = nn.DataParallel(model, device_ids=range(torch.cuda.device_count)) ''' model.to(device) learning_rate = 1e-3 loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9) train_loader, val_loader = get_train_val_loaders() test_loader = get_test_loader() epochs = int(1e3) acc_train_list = [] acc_val_list = [] acc_test_list = [] start = time.time() for t in range(epochs): print(f"Epoch {t+1}\n-------------------------------") loss_train, accuracy_train = train_loop( train_loader, model, loss_fn, optimizer