Pneumonia Detection Using CNN in Python

In this article, we will learn how to build a classifier using a simple Convolution Neural Network which can classify the images of patient's xray to detect whether the patient is Normal or affected by Pneumonia.

To get more understanding, follow the steps accordingly.

Importing Libraries

The libraries we will using are : 

• Pandas- The pandas library is a popular open-source data manipulation and analysis tool in Python. It provides a data structure called a DataFrame, which is similar to a spreadsheet or a SQL table, and allows for easy manipulation and analysis of data.
• Numpy- NumPy is a popular open-source library in Python for scientific computing, specifically for working with numerical data. It provides tools for working with large, multi-dimensional arrays and matrices, and offers a wide range of mathematical functions for performing operations on these arrays.
• Matplotlib- It is a popular open-source data visualization library in Python. It provides a range of tools for creating high-quality visualizations of data, including line plots, scatter plots, bar plots, histograms, and more.
• TensorFlow- TensorFlow is a popular open-source library in Python for building and training machine learning models. It was developed by Google and is widely used in both academia and industry for a variety of applications, including image and speech recognition, natural language processing, and recommendation systems.

import matplotlib.pyplot as plt
import tensorflow as tf
import pandas as pd
import numpy as np
  
import warnings
warnings.filterwarnings('ignore')
  
from tensorflow import keras
from keras import layers
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Activation, Dropout, Flatten, Dense
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.utils import image_dataset_from_directory
from tensorflow.keras.preprocessing.image import ImageDataGenerator, load_img
from tensorflow.keras.preprocessing import image_dataset_from_directory
  
import os
import matplotlib.image as mpimg

Importing Dataset 

To run the notebook in the local system. The dataset can be downloaded from [ https://www.kaggle.com/datasets/paultimothymooney/chest-xray-pneumonia ]. The dataset is in the format of a zip file. So to import and then unzip it, by running the below code. 

# Dataset Link- https://www.kaggle.com/datasets/paultimothymooney/chest-xray-pneumonia
import zipfile
zip_ref = zipfile.ZipFile('/content/chest-xray-pneumonia.zip', 'r')
zip_ref.extractall('/content')
zip_ref.close()

Read the image dataset

In this section, we will try to understand visualize some images which have been provided to us to build the classifier for each class.

Let's load the training image

# For local system
path = '/content/chest_xray/chest_xray/train'
# For kaggle
path = '/kaggle/input/chest-xray-pneumonia/chest_xray/train'
classes = os.listdir(path)
print(classes)

Output:

['PNEUMONIA', 'NORMAL']

This shows that, there are two classes that we have here i.e. Normal and Pneumonia.

# Define the directories for the X-ray images
PNEUMONIA_dir = os.path.join(path + '/' + classes[0])
NORMAL_dir = os.path.join(path + '/' + classes[1])

# Create lists of the file names in each directory
pneumonia_names = os.listdir(PNEUMONIA_dir)
normal_names = os.listdir(NORMAL_dir)

print('There are ', len(pneumonia_names),
      'images of pneumonia infected in training dataset')
print('There are ', len(normal_names), 'normal images in training dataset')

Output:

There are  3875 images of pneumonia infected in training dataset
There are  1341 normal images in training dataset

Plot the Pneumonia infected Chest X-ray images

# Set the figure size
fig = plt.gcf()
fig.set_size_inches(16, 8)

# Select the starting index for the images to display
pic_index = 210

# Create lists of the file paths for the 16 images to display
pneumonia_images = [os.path.join(PNEUMONIA_dir, fname)
                    for fname in pneumonia_names[pic_index-8:pic_index]]
# Loop through the image paths and display each image in a subplot
for i, img_path in enumerate(pneumonia_images):
    sp = plt.subplot(2, 4, i+1)
    sp.axis('Off')

    # Read in the image using Matplotlib's imread() function
    img = mpimg.imread(img_path)
    plt.imshow(img)

# Display the plot with the 16 images in a 4x4
plt.show()

Output:

Plot the Normal Chest X-ray images

# Set the figure size
fig = plt.gcf()
fig.set_size_inches(16, 8)

# Select the starting index for the images to display
pic_index = 210

# Create lists of the file paths for the 16 images to display
normal_images = [os.path.join(NORMAL_dir, fname)
              for fname in normal_names[pic_index-8:pic_index]]
# Loop through the image paths and display each image in a subplot
for i, img_path in enumerate(normal_images):
    sp = plt.subplot(2, 4, i+1)
    sp.axis('Off')

    # Read in the image using Matplotlib's imread() function
    img = mpimg.imread(img_path)
    plt.imshow(img)

# Display the plot with the 16 images in a 4x4 grid
plt.show()

Output:

Data Preparation for Training

In this section, we will classify the dataset into train,test and validation format.

Train = keras.utils.image_dataset_from_directory(
    directory='/content/chest_xray/chest_xray/train',
    labels="inferred",
    label_mode="categorical",
    batch_size=32,
    image_size=(256, 256))
Test = keras.utils.image_dataset_from_directory(
    directory='/content/chest_xray/chest_xray/test',
    labels="inferred",
    label_mode="categorical",
    batch_size=32,
    image_size=(256, 256))
Validation = keras.utils.image_dataset_from_directory(
    directory='/content/chest_xray/chest_xray/val',
    labels="inferred",
    label_mode="categorical",
    batch_size=32,
    image_size=(256, 256))

Output:

Found 5216 files belonging to 2 classes.
Found 624 files belonging to 2 classes.
Found 16 files belonging to 2 classes.

Model Architecture

The model architecture can be described as follows:

• Input layer: Conv2D layer with 32 filters, 3x3 kernel size, 'relu' activation function, and input shape of (256, 256, 3)
• MaxPooling2D layer with 2x2 pool size
• Conv2D layer with 64 filters, 3x3 kernel size, 'relu' activation function
• MaxPooling2D layer with 2x2 pool size
• Conv2D layer with 64 filters, 3x3 kernel size, 'relu' activation function
• MaxPooling2D layer with 2x2 pool size
• Conv2D layer with 64 filters, 3x3 kernel size, 'relu' activation function
• MaxPooling2D layer with 2x2 pool size
• Flatten layer
• Dense layer with 512 neurons, 'relu' activation function
• BatchNormalization layer
• Dense layer with 512 neurons, 'relu' activation function
• Dropout layer with a rate of 0.1
• BatchNormalization layer
• Dense layer with 512 neurons, 'relu' activation function
• Dropout layer with a rate of 0.2
• BatchNormalization layer
• Dense layer with 512 neurons, 'relu' activation function
• Dropout layer with a rate of 0.2
• BatchNormalization layer
• Output layer: Dense layer with 2 neurons and 'sigmoid' activation function, representing the probabilities of the two classes (pneumonia or normal)

In summary our model has : 

• Four Convolutional Layers followed by MaxPooling Layers.
• Then One Flatten layer to receive and flatten the output of the convolutional layer.
• Then we will have three fully connected layers followed by the output of the flattened layer.
• We have included some BatchNormalization layers to enable stable and fast training and a Dropout layer before the final layer to avoid any possibility of overfitting.
• The final layer is the output layer which has the activation function sigmoid to classify the results into two classes(i,e Normal or Pneumonia).

model = tf.keras.models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(256, 256, 3)),
    layers.MaxPooling2D(2, 2),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D(2, 2),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D(2, 2),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D(2, 2),

    layers.Flatten(),
    layers.Dense(512, activation='relu'),
    layers.BatchNormalization(),
    layers.Dense(512, activation='relu'),
    layers.Dropout(0.1),
    layers.BatchNormalization(),
    layers.Dense(512, activation='relu'),
    layers.Dropout(0.2),
    layers.BatchNormalization(),
    layers.Dense(512, activation='relu'),
    layers.Dropout(0.2),
    layers.BatchNormalization(),
    layers.Dense(2, activation='sigmoid')
])

Print the summary of the model architecture:

model.summary()

Output:

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 254, 254, 32)      896       
                                                                 
 max_pooling2d (MaxPooling2D  (None, 127, 127, 32)     0         
 )                                                               
                                                                 
 conv2d_1 (Conv2D)           (None, 125, 125, 64)      18496     
                                                                 
 max_pooling2d_1 (MaxPooling  (None, 62, 62, 64)       0         
 2D)                                                             
                                                                 
 conv2d_2 (Conv2D)           (None, 60, 60, 64)        36928     
                                                                 
 max_pooling2d_2 (MaxPooling  (None, 30, 30, 64)       0         
 2D)                                                             
                                                                 
 conv2d_3 (Conv2D)           (None, 28, 28, 64)        36928     
                                                                 
 max_pooling2d_3 (MaxPooling  (None, 14, 14, 64)       0         
 2D)                                                             
                                                                 
 flatten (Flatten)           (None, 12544)             0         
                                                                 
 dense (Dense)               (None, 512)               6423040   
                                                                 
 batch_normalization (BatchN  (None, 512)              2048      
 ormalization)                                                   
                                                                 
 dense_1 (Dense)             (None, 512)               262656    
                                                                 
 dropout (Dropout)           (None, 512)               0         
                                                                 
 batch_normalization_1 (Batc  (None, 512)              2048      
 hNormalization)                                                 
                                                                 
 dense_2 (Dense)             (None, 512)               262656    
                                                                 
 dropout_1 (Dropout)         (None, 512)               0         
                                                                 
 batch_normalization_2 (Batc  (None, 512)              2048      
 hNormalization)                                                 
                                                                 
 dense_3 (Dense)             (None, 512)               262656    
                                                                 
 dropout_2 (Dropout)         (None, 512)               0         
                                                                 
 batch_normalization_3 (Batc  (None, 512)              2048      
 hNormalization)                                                 
                                                                 
 dense_4 (Dense)             (None, 2)                 1026      
                                                                 
=================================================================
Total params: 7,313,474
Trainable params: 7,309,378
Non-trainable params: 4,096
_________________________________________________________________

The input image we have taken initially resized into 256 X 256. And later it transformed into the binary classification value. 

Plot the model architecture:

# Plot the keras model
keras.utils.plot_model(
    model,
    # show the shapes of the input/output tensors of each layer
    show_shapes=True,
    # show the data types of the input/output tensors of each layer
    show_dtype=True,
    # show the activations of each layer in the output graph
    show_layer_activations=True
)

Output:

Compile the Model:

model.compile(
    # specify the loss function to use during training
    loss='binary_crossentropy',
    # specify the optimizer algorithm to use during training
    optimizer='adam',
    # specify the evaluation metrics to use during training
    metrics=['accuracy']
)

Train the model

Now we can train our model,  here we define epochs = 10, but you can perform hyperparameter tuning for better results.

history = model.fit(Train,
          epochs=10,
          validation_data=Validation)

Output:

Epoch 1/10
163/163 [==============================] - 59s 259ms/step - loss: 0.2657 - accuracy: 0.9128 - val_loss: 2.1434 - val_accuracy: 0.5625
Epoch 2/10
163/163 [==============================] - 34s 201ms/step - loss: 0.1493 - accuracy: 0.9505 - val_loss: 3.0297 - val_accuracy: 0.6250
Epoch 3/10
163/163 [==============================] - 34s 198ms/step - loss: 0.1107 - accuracy: 0.9626 - val_loss: 0.5933 - val_accuracy: 0.7500
Epoch 4/10
163/163 [==============================] - 33s 197ms/step - loss: 0.0992 - accuracy: 0.9640 - val_loss: 0.3691 - val_accuracy: 0.8125
Epoch 5/10
163/163 [==============================] - 34s 202ms/step - loss: 0.0968 - accuracy: 0.9651 - val_loss: 3.5919 - val_accuracy: 0.5000
Epoch 6/10
163/163 [==============================] - 34s 199ms/step - loss: 0.1012 - accuracy: 0.9653 - val_loss: 3.8678 - val_accuracy: 0.5000
Epoch 7/10
163/163 [==============================] - 34s 198ms/step - loss: 0.1026 - accuracy: 0.9613 - val_loss: 3.2006 - val_accuracy: 0.5625
Epoch 8/10
163/163 [==============================] - 35s 204ms/step - loss: 0.0785 - accuracy: 0.9701 - val_loss: 1.7824 - val_accuracy: 0.5000
Epoch 9/10
163/163 [==============================] - 34s 198ms/step - loss: 0.0717 - accuracy: 0.9745 - val_loss: 3.3485 - val_accuracy: 0.5625
Epoch 10/10
163/163 [==============================] - 35s 200ms/step - loss: 0.0699 - accuracy: 0.9770 - val_loss: 0.5788 - val_accuracy: 0.6250

Model Evaluation

Let’s visualize the training and validation accuracy with each epoch.

history_df = pd.DataFrame(history.history)
history_df.loc[:, ['loss', 'val_loss']].plot()
history_df.loc[:, ['accuracy', 'val_accuracy']].plot()
plt.show()

Output:

Our model is performing good on training dataset, but not on test dataset. So, this is the case of overfitting. This may be due to imbalanced dataset.

Find the accuracy on Test Datasets

loss, accuracy = model.evaluate(Test)
print('The accuracy of the model on test dataset is',
      np.round(accuracy*100))

Output:

20/20 [==============================] - 4s 130ms/step - loss: 0.4542 - accuracy: 0.8237
The accuracy of the model on test dataset is 82.0

Prediction

Let’s check the model for random images.

# Load the image from the directory
# "/content/chest_xray/chest_xray/test/NORMAL/IM-0010-0001.jpeg"
# with the target size of (256, 256)
test_image = tf.keras.utils.load_img(
    "/content/chest_xray/chest_xray/test/NORMAL/IM-0010-0001.jpeg",
    target_size=(256, 256))

# Display the loaded image
plt.imshow(test_image)

# Convert the loaded image into a NumPy array and
# expand its dimensions to match the expected input shape of the model
test_image = tf.keras.utils.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis=0)

# Use the trained model to make a prediction on the input image
result = model.predict(test_image)

# Extract the probability of the input image belonging
# to each class from the prediction result
class_probabilities = result[0]

# Determine the class with the highest probability and print its label
if class_probabilities[0] > class_probabilities[1]:
    print("Normal")
else:
    print("Pneumonia")

Output:

1/1 [==============================] - 0s 328ms/step
Pneumonia

# Load the image from the directory
# "/content/chest_xray/chest_xray/test/N
# ORMAL/IM-0010-0001.jpeg" with the target size of (256, 256)
test_image = tf.keras.utils.load_img(
    "/content/chest_xray/chest_xray/test/PNEUMONIA/person100_bacteria_478.jpeg",
     target_size=(256, 256))

# Display the loaded image
plt.imshow(test_image)

# Convert the loaded image into a NumPy array
# and expand its dimensions to match the
# expected input shape of the model
test_image = tf.keras.utils.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis=0)

# Use the trained model to make a prediction on the input image
result = model.predict(test_image)

# Extract the probability of the input
# image belonging to each class from
# the prediction result
class_probabilities = result[0]

# Determine the class with the highest
# probability and print its label
if class_probabilities[0] > class_probabilities[1]:
    print("Normal")
else:
    print("Pneumonia")

Output:

1/1 [==============================] - 0s 328ms/step
Pneumonia

Conclusions:

Our model is performing well but as per losses and accuracy curve per iterations. It is overfitting. This may be due to the unbalanced dataset. By balancing the dataset with an equal number of normal and pneumonia images. We can get a better result.

chinmaya121221

Follow

Improve

Article Tags :

• Machine Learning
• AI-ML-DS
• Python-Output
• python
• Machine Learning Projects

+1 More

Practice Tags :

• Machine Learning
• python