def predict(checkpoint_path, batch_size=1, limit=None):
model = load_checkpoint(checkpoint_path)
model = as_cuda(model)
torch.set_grad_enabled(False)
model.eval()
records = []
ids = list(
map(lambda path: path.split('/')[-1],
get_images_in('data/test')))[:limit]
test_generator = get_test_generator(batch_size, limit)
for inputs, _ in tqdm(test_generator, total=len(test_generator)):
inputs = from_numpy(inputs)
outputs = model(inputs)
masks = to_numpy(torch.argmax(outputs, dim=1))
for mask in masks:
_id = ids.pop(0)
instance_masks = extract_instance_masks_from_binary_mask(mask)
if len(instance_masks) == 0:
records.append((_id, None))
else:
for instance_mask in instance_masks:
records.append((_id, encode_rle(instance_mask)))
image_ids, encoded_pixels = zip(*records)
df = pd.DataFrame({'ImageId': image_ids, 'EncodedPixels': encoded_pixels})
df.to_csv('./data/submissions/__latest.csv', index=False)
def fit(
num_epochs=100,
limit=None,
validation_limit=None,
batch_size=16,
lr=.005,
checkpoint_path=None,
telegram=False,
visualize=False,
num_folds=5,
train_fold_ids=[0, 1, 2, 3],
validation_fold_ids=[4],
steps_per_epoch=None
):
torch.backends.cudnn.benchmark = True
np.random.seed(1991)
logger, image_logger = make_loggers(telegram)
if checkpoint_path:
model = load_checkpoint(checkpoint_path)
else:
model = Devilnet(1)
model = as_cuda(model)
optimizer = torch.optim.SGD(filter(lambda param: param.requires_grad, model.parameters()), lr, weight_decay=1e-3, momentum=0.9, nesterov=True)
train_generator = get_train_generator(num_folds, train_fold_ids, batch_size, limit)
callbacks = [
ModelCheckpoint(model, type(model).__name__.lower(), 'val_f2_score', 'max', logger),
# CyclicLR(step_size=len(train_generator) * 2, min_lr=0.0001, max_lr=0.005, optimizer=optimizer, logger=logger),
# LRSchedule(optimizer, [(0, 0.003), (2, 0.01), (12, 0.001), (17, 0.0001)], logger),
# LRRangeTest(0.00001, 1.0, 20000, optimizer, image_logger),
LROnPlateau('val_f2_score', optimizer, mode='max', factor=0.5, patience=4, min_lr=0, logger=logger),
# ConfusionMatrix([0, 1], logger)
]
if visualize:
callbacks.extend([
LearningCurve(['train_loss', 'val_loss', 'train_mean_iou', 'val_mean_iou', 'train_f2_score', 'val_f2_score'], image_logger),
PredictionGrid(80, image_logger, mean_iou, pred_fn),
Histogram(image_logger, mean_iou),
# WeightGrid(model, image_logger, 32)
])
fit_model(
model=model,
train_generator=train_generator,
validation_generator=get_validation_generator(num_folds, validation_fold_ids, 2, validation_limit),
optimizer=optimizer,
loss_fn=compute_loss,
num_epochs=num_epochs,
logger=logger,
callbacks=callbacks,
metrics=[mean_iou, f2_score],
steps_per_epoch=steps_per_epoch
)
def predict(checkpoint_path, batch_size=1, limit=None, tta=False):
model = load_checkpoint(checkpoint_path)
model = as_cuda(model)
torch.set_grad_enabled(False)
model.eval()
records = []
ids = list(
map(lambda path: path.split('/')[-1],
get_images_in('data/test')))[:limit]
test_generator = get_test_generator(batch_size, limit)
for batch in tqdm(test_generator, total=len(test_generator)):
batch = from_numpy(batch)
masks = None
if tta:
accumulated_outputs = 0
for i, should_flip in product(range(4), [False, True]):
image_batch = batch['image']
image_batch = rotate_image_batch(image_batch, i)
if should_flip: image_batch = flip_image_batch(image_batch)
outputs = torch.sigmoid(model({'image': image_batch})['mask'])
if should_flip: outputs = flip_image_batch(outputs)
outputs = rotate_image_batch(outputs, -i)
accumulated_outputs += outputs
accumulated_outputs /= 8
masks = to_numpy(accumulated_outputs[:, 0, :, :])
else:
outputs = model(batch)
outputs['mask'] = torch.sigmoid(outputs['mask'])
masks = to_numpy(outputs['mask'][:, 0, :, :])
for mask in masks:
_id = ids.pop(0)
instance_masks = extract_instance_masks_from_soft_mask(mask)
if len(instance_masks) == 0:
records.append((_id, None))
else:
for instance_mask in instance_masks:
records.append((_id, encode_rle(instance_mask)))
image_ids, encoded_pixels = zip(*records)
df = pd.DataFrame({'ImageId': image_ids, 'EncodedPixels': encoded_pixels})
df.to_csv('./data/submissions/__latest.csv', index=False)
def predict(checkpoint_path,
submission_path,
batch_size=1,
limit=None,
tta=False):
model = load_checkpoint(checkpoint_path)
model = as_cuda(model)
torch.set_grad_enabled(False)
model.eval()
records = []
ids = list(
map(lambda path: path.split('/')[-1],
get_images_in('data/test')))[:limit]
submission = pd.read_csv(submission_path)
print('Num masks before', len(submission))
test_generator = get_test_generator(batch_size, limit, classification=True)
for batch in tqdm(test_generator, total=len(test_generator)):
batch = from_numpy(batch)
outputs = model(batch)
if tta:
batch['image'] = batch['image'].flip(dims=(3, ))
flipped_outputs = model(batch)
outputs['has_ships'] = (
torch.sigmoid(outputs['has_ships']) +
torch.sigmoid(flipped_outputs['has_ships'])) / 2
else:
outputs['has_ships'] = torch.sigmoid(outputs['has_ships'])
pred_labels = to_numpy(outputs['has_ships'][:, 0].round().long())
for pred in pred_labels:
_id = ids.pop(0)
if pred == 1: continue
submission = submission[submission['ImageId'] != _id].copy()
submission = submission.append(
{
'ImageId': _id,
'EncodedPixels': None
}, ignore_index=True)
print('Num masks after', len(submission))
submission.to_csv('./data/submissions/__latest_filtered.csv', index=False)
def load_checkpoint(path):
if torch.cuda.is_available():
return as_cuda(torch.load(path))
else:
return torch.load(path, map_location='cpu')