The coronavirus outbreak has caused a devastating effect on people all around the world and has infected millions.

The exponential escalation of the spread of the disease makes it emergent for appropriate screening methods to detect the

disease and take steps in mitigating it. The conventional testing technique involves the use of Reverse-Transcriptase

Polymerase Chain Reaction (RT-PCR). Due to limited sensitivity it is more prone to providing high false negative rates. Also

due to a high turnaround time (6-9 hours) and a high cost, an alternative approach for screening is called for. Chest

radiographs are the most frequently used imaging procedures in radiology. They are cheaper compared to CT scans and are

more readily available and accessible to the public. Application of advanced artificial intelligence (AI) techniques coupled with

radiological imaging can be helpful for the accurate detection of this disease. In this projecct we will study how state of the art model - EfficientNetB7 is applied to the problem of classification.

To check out my research paper on this work please refer to the following url:

Here

os.listdir('/content/gdrive/My Drive/Final XRAY')

['models', 'TEST', 'TRAIN']

%reload_ext autoreload
%autoreload 2
%matplotlib inline

Next up we will import all the necessary libraries. We will use the fastai library which consists of various state of the art pretrained models for image classification and a lot of utilitarian tools which make deep learning easier with less lines of code!

from fastai import *
from fastai.vision import *
import matplotlib.pyplot as plt
import numpy as np
from sklearn import metrics
from fastai.callbacks import *

EfficientNets

With the rise of transfer learning, the essentiality of scaling has been deeply realised for enhancing the performance as well as efficieny of models. Traditionaly scaling can be done in three dimensions viz. depth, width and resolution in terms of convolutional neural networks. Depth scaling pertains to increasing the number of layers in the model, making it more deeper; width scaling makes the model wider (one possible way is to increase the number of channels in a layer) and resolution scaling means using high resolution images so that features are more fine-grained. Each method applied individually has some drawbacks such as in depth scaling we have the problem of vanishing gradients and in width scaling the accuracy saturates after a point and there is a limit to increasing resolution of images and a slight increase doesnt result in significant improvement of performance. Hence Efficientnets are proposed to deal with balancing all dimensions of a network during CNN scaling for getting improved accuracy and efficieny. The authors proposed a simple yet very effective scaling technique which uses a compound coefficientto uniformly scale network width, depth, and resolution in a principled way. We used the pytorch wrapper for efficientnets. To install run the following command:

pip install efficientnet-pytorch

import warnings
warnings.filterwarnings('ignore')

Now we will define an ImageDataBunch which gets our image data into DataLoaders over which our models can be fit. We use the from_folder function to get the images from our folder which is subdivided into Train and Test folders. For image transformations we use the get_transforms function which performs various augmentations on our images viz rotation, , horizontal flip, vertical flip, zooming, warping, affine transformation etc.

The input target size of the images is defined as 224 since most models are compatible with this size including efficientnets. We maintain a Batch Size of 32 in order to ensure efficient usage of memory.

path = '/content/gdrive/My Drive/Final XRAY'
np.random.seed(44)
data = ImageDataBunch.from_folder(path, train="TRAIN", valid ="TEST",
        ds_tfms=get_transforms(), size=(224,224), bs=32, num_workers=4).normalize()

data.classes, data.c

(['COVID', 'NON-COVID', 'PNEUMONIA'], 3)

data.train_ds

LabelList (1482 items)
x: ImageList
Image (3, 224, 224),Image (3, 224, 224),Image (3, 224, 224),Image (3, 224, 224),Image (3, 224, 224)
y: CategoryList
COVID,COVID,COVID,COVID,COVID
Path: /content/gdrive/My Drive/Final XRAY

data.valid_ds

LabelList (217 items)
x: ImageList
Image (3, 224, 224),Image (3, 224, 224),Image (3, 224, 224),Image (3, 224, 224),Image (3, 224, 224)
y: CategoryList
COVID,COVID,COVID,COVID,COVID
Path: /content/gdrive/My Drive/Final XRAY

We can visualize our Training data in the following cell.

The train and validation split of the respective images is as follows.

Split COVID-19 NO-FINDINGS PNEUMONIA

Training Set 454 610 418

Testing Set 41 94 82

data.show_batch(rows=3, figsize=(10,10))

import efficientnet_pytorch
from efficientnet_pytorch import EfficientNet

We will use EfficientNetB7 for training.

model = EfficientNet.from_pretrained('efficientnet-b7')

Loaded pretrained weights for efficientnet-b7

To better capture the essence of the performance of the model, along with traditional metrics we use the top2 accuracy which is predicted true for each image if the actual label of the image falls in the top 2 softmax probabilities of the model.

top_5 = partial(top_k_accuracy, k=2)

learn = Learner(data, model, metrics=[accuracy, top_5, error_rate], loss_func=LabelSmoothingCrossEntropy(), callback_fns=[ShowGraph, ReduceLROnPlateauCallback]).to_fp16()

learn.fit_one_cycle(4)

learn.recorder.plot_losses()

learn.recorder.plot_metrics()

Fastai comes with a very important utility of finding an appropriate learning rate and then fine tuning our models later with the set learning rate. This boosts the performance of the models significantly.

learn.unfreeze()
learn.lr_find()
learn.recorder.plot(suggestion = True)

LR Finder is complete, type {learner_name}.recorder.plot() to see the graph. Min numerical gradient: 6.92E-06 Min loss divided by 10: 6.31E-08 

learn.fit_one_cycle(100, max_lr=slice(6.82e-6))

interp = ClassificationInterpretation.from_learner(learn)
interp.plot_confusion_matrix(title='Confusion matrix')

probs,targets = learn.get_preds(ds_type=DatasetType.Valid) # Predicting without TTA



probs = np.argmax(probs, axis=1)
correct = 0
for idx, pred in enumerate(probs):
    if pred == targets[idx]:
        correct += 1
accuracy = correct / len(probs)
print(len(probs), correct, accuracy)

from sklearn.metrics import confusion_matrix
np.set_printoptions(threshold=np.inf) # shows whole confusion matrix

cm1 = confusion_matrix(targets, probs)
print(cm1)

from sklearn.metrics import classification_report
y_true1 = targets
y_pred1 = probs
target_names = ['Covid-19', 'No_findings', 'Pneumonia']
print(classification_report(y_true1, y_pred1, target_names=target_names))

import matplotlib.pyplot as plt

plt.figure()
plt.plot(fpr, tpr, color='darkorange', label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
plt.xlim([-0.01, 1.0])
plt.ylim([0.0, 1.01])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic (DenseNet 169) ')
plt.legend(loc="lower right")