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"])
