Image Segmentation Task 2¶

In [ ]:

!python -m pip install cityscapesscripts

Imports¶

In [1]:

import os
import torch
import random
import numpy as np

from os.path import join as pjoin
from datasets.cityscapes import cityscapesDataset

Setup¶

In [2]:

# reproducibility setups
torch.manual_seed(253452757)
random.seed(253452757)
np.random.seed(253452757)

In [3]:

os.environ["CUDA_VISIBLE_DEVICES"]="1" 
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
device 

Out[3]:

device(type='cuda')

Hyperparameters¶

In [4]:

local_path = "./Cityscapes"
bs = 5
epochs = 15
learning_rate = 0.0002
patience = 10

Dataset and Dataloader¶

In [5]:

training_data = cityscapesDataset(local_path, split="train")
training_data_raw = cityscapesDataset(local_path, split="train", is_transform=False)
validation_data = cityscapesDataset(local_path, split="val")
test_data = cityscapesDataset(local_path, split="test")

Annotations files processed
Annotations files processed
Annotations files processed
Annotations files processed

In [6]:

dataloaders = {
    'train' : torch.utils.data.DataLoader(training_data, batch_size=bs, shuffle=True, num_workers=0),
    'val': torch.utils.data.DataLoader(validation_data, batch_size=bs, shuffle=True, num_workers=0)
}

In [7]:

dataset_sizes = {
    'train': len(training_data),
    'val': len(validation_data),
    'test': len(test_data),
    'total': len(training_data) + len(validation_data) + len(test_data)
}

dataset_sizes

Out[7]:

{'train': 2975, 'val': 500, 'test': 1525, 'total': 5000}

Model setup¶

In [8]:

from networks.utils import count_parameters
from networks.r2unet import R2UNet64

In [9]:

model = R2UNet64().to(device)

In [ ]:

print("Number of trainable parameters = ", count_parameters(model, only_trainable=True))
print("Number of total parameters = ", count_parameters(model))

In [14]:

optimizer = torch.optim.Adam(model.parameters(), lr = learning_rate)
loss_f = torch.nn.CrossEntropyLoss(ignore_index = 255)

Training¶

In [10]:

import training

In [10]:

model_path = 'models/r2unet64/'
if not os.path.isdir(model_path):
    os.makedirs(model_path)

In [ ]:

model = training.train(model, dataloaders, dataset_sizes, model_path, loss_f, optimizer, epochs)

In [11]:

checkpoint = torch.load(pjoin(model_path, "epoch-{}.pt".format(epochs-1)))

In [12]:

model.load_state_dict(checkpoint['model_state_dict'])

Out[12]:

<All keys matched successfully>

Evaluate the results¶

In [13]:

import evaluation

In [14]:

metrics = ["accuracy", "sensitivity", "specificity", "dice_coeff", "jaccard_sim"]

In [17]:

eval_report = evaluation.EvaluationReport.from_model(dataloaders['val'], model, labels=list(range(19)))

In [18]:

eval_report.get_metrics(metrics, average="macro")

Out[18]:

{'accuracy': 0.9513,
 'sensitivity': 0.2914,
 'specificity': 0.9739,
 'dice_coeff': 0.2535,
 'jaccard_sim': 0.1717}

In [19]:

eval_report.get_metrics(metrics, average="weighted")

Out[19]:

{'accuracy': 0.8812,
 'sensitivity': 0.5376,
 'specificity': 0.9661,
 'dice_coeff': 0.6111,
 'jaccard_sim': 0.4623}

In [20]:

for i in range(19): 
    print("Class {} - {}".format(i, training_data.label_names()[i]))
    class_metrics = eval_report.get_metrics(metrics, pos_label=i)
    for k in class_metrics.keys():
        print(" {} = {}".format(k, class_metrics[k]))
    print()

Class 0 - road
 accuracy = 0.858
 sensitivity = 0.6491
 specificity = 0.984
 dice_coeff = 0.7747
 jaccard_sim = 0.6323

Class 1 - sidewalk
 accuracy = 0.9383
 sensitivity = 0.2028
 specificity = 0.9804
 dice_coeff = 0.2624
 jaccard_sim = 0.151

Class 2 - building
 accuracy = 0.8368
 sensitivity = 0.5315
 specificity = 0.9226
 dice_coeff = 0.5883
 jaccard_sim = 0.4167

Class 3 - wall
 accuracy = 0.9498
 sensitivity = 0.1813
 specificity = 0.9555
 dice_coeff = 0.0504
 jaccard_sim = 0.0258

Class 4 - fence
 accuracy = 0.9812
 sensitivity = 0.1828
 specificity = 0.9879
 dice_coeff = 0.1381
 jaccard_sim = 0.0742

Class 5 - pole
 accuracy = 0.9862
 sensitivity = 0.1397
 specificity = 0.9989
 dice_coeff = 0.2309
 jaccard_sim = 0.1305

Class 6 - traffic light
 accuracy = 0.9979
 sensitivity = 0.0319
 specificity = 0.9998
 dice_coeff = 0.0572
 jaccard_sim = 0.0294

Class 7 - traffic sign
 accuracy = 0.9856
 sensitivity = 0.3436
 specificity = 0.9899
 dice_coeff = 0.2414
 jaccard_sim = 0.1372

Class 8 - vegetation
 accuracy = 0.9012
 sensitivity = 0.5083
 specificity = 0.9836
 dice_coeff = 0.6407
 jaccard_sim = 0.4713

Class 9 - terrain
 accuracy = 0.9809
 sensitivity = 0.4555
 specificity = 0.9853
 dice_coeff = 0.2843
 jaccard_sim = 0.1657

Class 10 - sky
 accuracy = 0.9816
 sensitivity = 0.4751
 specificity = 0.9993
 dice_coeff = 0.6351
 jaccard_sim = 0.4653

Class 11 - person
 accuracy = 0.9874
 sensitivity = 0.2491
 specificity = 0.9971
 dice_coeff = 0.3385
 jaccard_sim = 0.2037

Class 12 - rider
 accuracy = 0.9978
 sensitivity = 0.0082
 specificity = 1.0
 dice_coeff = 0.016
 jaccard_sim = 0.0081

Class 13 - car
 accuracy = 0.8963
 sensitivity = 0.6849
 specificity = 0.911
 dice_coeff = 0.4626
 jaccard_sim = 0.3009

Class 14 - truck
 accuracy = 0.997
 sensitivity = 0.0
 specificity = 1.0
 dice_coeff = 0.0
 jaccard_sim = 0.0

Class 15 - bus
 accuracy = 0.888
 sensitivity = 0.6375
 specificity = 0.889
 dice_coeff = 0.0423
 jaccard_sim = 0.0216

Class 16 - train
 accuracy = 0.9188
 sensitivity = 0.2296
 specificity = 0.9195
 dice_coeff = 0.0063
 jaccard_sim = 0.0032

Class 17 - motorcycle
 accuracy = 0.9992
 sensitivity = 0.0
 specificity = 1.0
 dice_coeff = 0.0
 jaccard_sim = 0.0

Class 18 - bicycle
 accuracy = 0.9931
 sensitivity = 0.0248
 specificity = 1.0
 dice_coeff = 0.0482
 jaccard_sim = 0.0247

Visualize the results¶

In [12]:

from utils import plot_seg_results

In [13]:

img_size = (512, 256)
init_pic = 123
n_pics = 5

In [14]:

inputs = torch.stack([training_data[i][0] for i in range(init_pic, init_pic + n_pics)])
images = [training_data_raw[i][0].resize(img_size) for i in range(init_pic, init_pic + n_pics)]
ground_truths = torch.stack([training_data[i][1] for i in range(init_pic, init_pic + n_pics)])

In [15]:

outputs = model(inputs.to(device))
predictions = torch.argmax(outputs.squeeze().cpu(), dim = 1)

In [16]:

predictions = [training_data.decode_segmap(pred.numpy()) for pred in predictions]
ground_truths = [training_data.decode_segmap(gt.numpy()) for gt in ground_truths]

In [17]:

plot_seg_results(images, ground_truths, predictions)