def infer( config_path, log_dir ): """ Inference: 1. loaders 2. model """ # quering params from experiment config batch_size = 116 test_dataset = LipreadingDataset( "test") loaders = { "infer": DataLoader( test_dataset, batch_size=batch_size, shuffle=True, num_workers=0, drop_last=False,) } model = LipNext() device = "cuda" if torch.cuda.is_available() else "cpu" runner = SupervisedRunner(device=device) runner.infer( model=model, loaders=loaders, callbacks=[ AccuracyCallback(accuracy_args=[1, 3]), InferenceCallback(), CheckpointCallbackV2( config_path=config_path, resume=("/home/dmitry.klimenkov/Documents/projects/visper_pytorch/logdir" "/Mobi-VSR-5W-mixed_aligned_patience5_sometests/checkpoints/train.0.35.8553.pth")) # NegativeMiningCallback() ], state_kwargs={ "log_dir": log_dir }, check=True )
class BERTClassificationModel: def __init__(self, model_name="cl-tohoku/bert-base-japanese-whole-word-masking", checkpoints_dir=None): """ Text classification model based on Japanese BERT Model. Attributes ---------- model_name : str The BERT model file checkpoints_dir : str The path of trained BERT model dir ------- fit() Train a text classification model. eval() Evaluate the trained model. predict() Predict a label. """ self.runner = SupervisedRunner( input_key=("features", "attention_mask") ) if checkpoints_dir: config_file = f"{checkpoints_dir}/checkpoints/config.pkl" if os.path.exists(config_file): with open(config_file, "rb") as f: self.label2id, self.config = pickle.load(f) self.id2label = {v: k for k, v in self.label2id.items()} num_labels = len(self.label2id) self.max_seq_length = self.config["max_seq_length"] self.batch_size = self.config["batch_size"] self.model_name = self.config["model_name"] self.elapsed_time = self.config["elapsed_time"] self.tokenizer = AutoTokenizer.from_pretrained(self.model_name) self.model = BERTBaseJapaneseModel(self.model_name, num_labels) self.data_for_predict = ClassificationDataset( tokenizer=self.tokenizer, label2id=self.label2id, max_seq_length=self.max_seq_length, texts=["checkpoints"] ) temporary_data = { "temporary": DataLoader( dataset=self.data_for_predict, batch_size=self.batch_size, shuffle=False ) } # Load the trained BERT model self.runner.infer( model=self.model, loaders=temporary_data, resume=f"{checkpoints_dir}/checkpoints/best.pth" ) else: self.model_name = model_name self.tokenizer = AutoTokenizer.from_pretrained(model_name) self.pad_vid = self.tokenizer.vocab["[PAD]"] self.data_for_predict = None def fit(self, train_df, dev_df, batch_size=16, max_seq_length=256, learning_rate=5e-5, epochs=1, log_dir=None, verbose=False): start = time.time() config = { "model_name": self.model_name, "batch_size": batch_size, "max_seq_length": max_seq_length, "learning_rate": learning_rate, "epochs": epochs, "log_dir": log_dir } train_y = train_df[0] train_X = train_df[1] label2id = dict( zip(sorted(set(train_y)), range(len(set(train_y)))) ) self.id2label = {v: k for k, v in label2id.items()} num_labels = len(label2id) self.train_data = ClassificationDataset( tokenizer=self.tokenizer, label2id=label2id, max_seq_length=max_seq_length, texts=train_X, labels=train_y ) dev_y = dev_df[0] dev_X = dev_df[1] self.dev_data = ClassificationDataset( tokenizer=self.tokenizer, label2id=label2id, max_seq_length=max_seq_length, texts=dev_X, labels=dev_y ) train_dev_loaders = { "train": DataLoader( dataset=self.train_data, batch_size=batch_size, shuffle=True ), "valid": DataLoader( dataset=self.dev_data, batch_size=batch_size, shuffle=False ) } model = BERTBaseJapaneseModel(self.model_name, num_labels) criterion = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer) self.runner.train( model=model, criterion=criterion, optimizer=optimizer, scheduler=scheduler, loaders=train_dev_loaders, callbacks=[ AccuracyCallback(num_classes=num_labels), ], fp16=None, logdir=log_dir, num_epochs=epochs, verbose=verbose ) self.elapsed_time = time.time() - start config["elapsed_time"] = self.elapsed_time if os.path.exists(f"{log_dir}/checkpoints"): filename = f"{log_dir}/checkpoints/config.pkl" with open(filename, "wb") as f: pickle.dump([label2id, config], f) def predict(self, text): if self.data_for_predict: x = self.data_for_predict._from_text(text) else: x = self.train_data._from_text(text) x["features"] = x["features"].reshape(1, -1) x["attention_mask"] = x["attention_mask"].reshape(1, -1) logits = self.runner.predict_batch(x)['logits'] pred_id = logits.argmax(axis=1) pred_y = self.id2label[int(pred_id)] return pred_y def eval(self, test_df): test_Y = test_df[0] pred_Y = [self.predict(text) for text in test_df[1]] accuracy = accuracy_score(test_Y, pred_Y) macro_f1 = f1_score(test_Y, pred_Y, average="macro") cr = classification_report(test_Y, pred_Y) eval_metrics = classifiers.EvaluationMetrics( accuracy, macro_f1, cr, self.elapsed_time ) return eval_metrics
) dataset_length = len(testset) loaders = collections.OrderedDict() testloader = torch.utils.data.DataLoader(testset, shuffle=False) model = SimpleNetRGB(11, channels_in=3) runner = SupervisedRunner(device="cuda") loaders["valid"] = testloader loaders = collections.OrderedDict([("infer", loaders["valid"])]) runner.infer( model=model, loaders=loaders, callbacks=[ InferCallback(), CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth"), ], ) predictions = runner.callbacks[0].predictions["logits"].reshape( dataset_length, 9) predictions = sigmoid(predictions) # predictions = softmax(predictions, axis=1) predictions = np.concatenate([np.expand_dims(ids, axis=1), predictions], axis=1) pred_frame = pd.DataFrame(predictions, columns=[ "field_id", "crop_id_1",
model = smp.FPN(encoder_name="resnext50_32x4d", classes=6, dropout=0.05) device = utils.get_device() if is_fp16_used: fp16_params = dict(opt_level="O1") # params for FP16 else: fp16_params = None runner = SupervisedRunner(device=device, input_key="image", input_target_key="mask") runner.infer( model=model, loaders=infer_loaders, callbacks=OrderedDict([ ("loader", CheckpointCallback(resume=f"{logdir}/checkpoints/best.pth")), ("infer", CustomInferCallback()) ]), fp16=fp16_params, ) # In[ ]: heatmap = utils.detach(runner.callbacks["infer"].heatmap[0]) plt.figure(figsize=(20, 9)) plt.imshow(heatmap, cmap="hot", interpolation="nearest") plt.show() # ### Advanced: test-time augmentations (TTA) # # There is [ttach](https://github.com/qubvel/ttach) is a new awesome library for test-time augmentation for segmentation or classification tasks.
def main(): parser = argparse.ArgumentParser() parser.add_argument('--encoder', type=str, default='efficientnet-b0') parser.add_argument('--model', type=str, default='unet') parser.add_argument('--loc', type=str) parser.add_argument('--data_folder', type=str, default='../input/') parser.add_argument('--batch_size', type=int, default=2) parser.add_argument('--optimize', type=bool, default=False) parser.add_argument('--tta_pre', type=bool, default=False) parser.add_argument('--tta_post', type=bool, default=False) parser.add_argument('--merge', type=str, default='mean') parser.add_argument('--min_size', type=int, default=10000) parser.add_argument('--thresh', type=float, default=0.5) parser.add_argument('--name', type=str) args = parser.parse_args() encoder = args.encoder model = args.model loc = args.loc data_folder = args.data_folder bs = args.batch_size optimize = args.optimize tta_pre = args.tta_pre tta_post = args.tta_post merge = args.merge min_size = args.min_size thresh = args.thresh name = args.name if model == 'unet': model = smp.Unet(encoder_name=encoder, encoder_weights='imagenet', classes=4, activation=None) if model == 'fpn': model = smp.FPN( encoder_name=encoder, encoder_weights='imagenet', classes=4, activation=None, ) if model == 'pspnet': model = smp.PSPNet( encoder_name=encoder, encoder_weights='imagenet', classes=4, activation=None, ) if model == 'linknet': model = smp.Linknet( encoder_name=encoder, encoder_weights='imagenet', classes=4, activation=None, ) preprocessing_fn = smp.encoders.get_preprocessing_fn(encoder, 'imagenet') test_df = get_dataset(train=False) test_df = prepare_dataset(test_df) test_ids = test_df['Image_Label'].apply( lambda x: x.split('_')[0]).drop_duplicates().values test_dataset = CloudDataset( df=test_df, datatype='test', img_ids=test_ids, transforms=valid1(), preprocessing=get_preprocessing(preprocessing_fn)) test_loader = DataLoader(test_dataset, batch_size=bs, shuffle=False) val_df = get_dataset(train=True) val_df = prepare_dataset(val_df) _, val_ids = get_train_test(val_df) valid_dataset = CloudDataset( df=val_df, datatype='train', img_ids=val_ids, transforms=valid1(), preprocessing=get_preprocessing(preprocessing_fn)) valid_loader = DataLoader(valid_dataset, batch_size=bs, shuffle=False) model.load_state_dict(torch.load(loc)['model_state_dict']) class_params = { 0: (thresh, min_size), 1: (thresh, min_size), 2: (thresh, min_size), 3: (thresh, min_size) } if optimize: print("OPTIMIZING") print(tta_pre) if tta_pre: opt_model = tta.SegmentationTTAWrapper( model, tta.Compose([ tta.HorizontalFlip(), tta.VerticalFlip(), tta.Rotate90(angles=[0, 180]) ]), merge_mode=merge) else: opt_model = model tta_runner = SupervisedRunner() print("INFERRING ON VALID") tta_runner.infer( model=opt_model, loaders={'valid': valid_loader}, callbacks=[InferCallback()], verbose=True, ) valid_masks = [] probabilities = np.zeros((4 * len(valid_dataset), 350, 525)) for i, (batch, output) in enumerate( tqdm( zip(valid_dataset, tta_runner.callbacks[0].predictions["logits"]))): _, mask = batch for m in mask: if m.shape != (350, 525): m = cv2.resize(m, dsize=(525, 350), interpolation=cv2.INTER_LINEAR) valid_masks.append(m) for j, probability in enumerate(output): if probability.shape != (350, 525): probability = cv2.resize(probability, dsize=(525, 350), interpolation=cv2.INTER_LINEAR) probabilities[(i * 4) + j, :, :] = probability print("RUNNING GRID SEARCH") for class_id in range(4): print(class_id) attempts = [] for t in range(30, 70, 5): t /= 100 for ms in [7500, 10000, 12500, 15000, 175000]: masks = [] for i in range(class_id, len(probabilities), 4): probability = probabilities[i] predict, num_predict = post_process( sigmoid(probability), t, ms) masks.append(predict) d = [] for i, j in zip(masks, valid_masks[class_id::4]): if (i.sum() == 0) & (j.sum() == 0): d.append(1) else: d.append(dice(i, j)) attempts.append((t, ms, np.mean(d))) attempts_df = pd.DataFrame(attempts, columns=['threshold', 'size', 'dice']) attempts_df = attempts_df.sort_values('dice', ascending=False) print(attempts_df.head()) best_threshold = attempts_df['threshold'].values[0] best_size = attempts_df['size'].values[0] class_params[class_id] = (best_threshold, best_size) del opt_model del tta_runner del valid_masks del probabilities gc.collect() if tta_post: model = tta.SegmentationTTAWrapper(model, tta.Compose([ tta.HorizontalFlip(), tta.VerticalFlip(), tta.Rotate90(angles=[0, 180]) ]), merge_mode=merge) else: model = model print(tta_post) runner = SupervisedRunner() runner.infer( model=model, loaders={'test': test_loader}, callbacks=[InferCallback()], verbose=True, ) encoded_pixels = [] image_id = 0 for i, image in enumerate(tqdm(runner.callbacks[0].predictions['logits'])): for i, prob in enumerate(image): if prob.shape != (350, 525): prob = cv2.resize(prob, dsize=(525, 350), interpolation=cv2.INTER_LINEAR) predict, num_predict = post_process(sigmoid(prob), 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 test_df['EncodedPixels'] = encoded_pixels test_df.to_csv(name, columns=['Image_Label', 'EncodedPixels'], index=False)
optimizer=optimizer, scheduler=scheduler, loaders=train_val_loaders, callbacks=[ AccuracyCallback(num_classes=int(params["model"]["num_classes"])), OptimizerCallback( accumulation_steps=int(params["training"]["accum_steps"])), ], logdir=params["training"]["log_dir"], num_epochs=int(params["training"]["num_epochs"]), verbose=True, ) # and running inference torch.cuda.empty_cache() runner.infer( model=model, loaders=test_loaders, callbacks=[ CheckpointCallback( resume=f"{params['training']['log_dir']}/checkpoints/best.pth"), InferCallback(), ], verbose=True, ) # lastly, saving predicted scores for the test set predicted_scores = runner.callbacks[0].predictions["logits"] np.savetxt(X=predicted_scores, fname=params["data"]["path_to_test_pred_scores"])