Leveraging Image Classification to Diagnose Brain Tumors

1.1 Data Preparation & Context

To carry out this image classification problem, we first have to load our images into Python and prepare our dataset for modeling. To do this, we specify two directory paths pointing to folder’s on my local computer containing our 5,712 Training and 1,311 Testing images. For more context, all images came from 3 different sources of MRI scan’s in which they were labeled by the type of brain cancer the patient has, ranging from no tumor, glioma, meningioma, and pituitary. The distinctions between these stages can be better distinguished by medical professionals in the following way:

• Glioma: Often the most serious, gliomas are tumors arising from glial cells in the brain and spinal cord, with a potential for malignancy and rapid progression.
• Meningioma: Generally less serious than gliomas, meningiomas are usually benign tumors that develop from the meninges but can cause significant problems due to their location.
• Pituitary Tumor: Generally the least serious, pituitary tumors are usually benign growths in the pituitary gland that can cause hormonal imbalances.
• No Tumor: Indicates normal brain scans with no signs of tumors, posing no immediate concern for cancer.

import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import os

# Directories
train_dir = '/Users/rileysvensson/Desktop/GSB 545 - Advanced Machine Learning/archive (7)/Training'
test_dir = '/Users/rileysvensson/Desktop/GSB 545 - Advanced Machine Learning/archive (7)/Testing'

Following this path specification, we use the ImageDataGenerator class in Keras is used to transform our images into numerical arrays, making them suitable for training a neural network. By specifying the directories for training, validation, and test datasets, the ImageDataGenerator can automatically load images, apply transformations, and convert them into batches of numerical arrays digestible for our neural network. Using the flow_from_directory method, we create generators for the training, validation, and test sets, with images resized to 150x150 pixels and grouped into batches of 32. This setup results in three sets of images: 4571 for training, 1141 for validation (20% of 5,712), and 1311 for testing, each belonging to one of our four named classes which are used to display a few examples our labeled images in the next step: glioma, meningioma, pituitary, and no tumor.

# Class names
CLASS_NAMES = ['glioma', 'meningioma', 'no tumor', 'pituitary']

# Data augmentation and preprocessing
train_datagen = ImageDataGenerator(
    rescale=1./255,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    validation_split=0.2
)

test_datagen = ImageDataGenerator(rescale=1./255)

# Data generators
train_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=(150, 150),
    batch_size=32,
    class_mode='categorical',
    subset='training'
)

validation_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=(150, 150),
    batch_size=32,
    class_mode='categorical',
    subset='validation'
)

test_generator = test_datagen.flow_from_directory(
    test_dir,
    target_size=(150, 150),
    batch_size=32,
    class_mode='categorical'
)

Found 4571 images belonging to 4 classes.
Found 1141 images belonging to 4 classes.
Found 1311 images belonging to 4 classes.

import matplotlib.pyplot as plt
import numpy as np

# Function to display images
def display_images(generator, num_images):
    images, labels = next(generator)
    images = images[:num_images]
    labels = labels[:num_images]
    
    fig, axes = plt.subplots(1, num_images, figsize=(20, 20))
    for img, label, ax in zip(images, labels, axes):
        ax.imshow(img)
        ax.set_title(CLASS_NAMES[np.argmax(label)])
        ax.axis('off')
    plt.show()

# Display 5 images from the training set
display_images(train_generator, 5)

2.1 Discussion of Metrics:

In this model, we use categorical_crossentropy to measure our loss (or error) because we are dealing with a multi-class classification problem, where we aim to classify images into one of four categories: glioma, meningioma, no tumor, and pituitary. The optimizing function used is Adam, which is an efficient gradient descent algorithm. The key metric we initially focused on is accuracy, which tells us the proportion of correctly classified images. In this case, our model achieved a test accuracy of approximately 93%, meaning that the model correctly identifies the type of brain tumor (or no tumor) in 93% of the images when applied to unseen images.

However, in medical diagnostics, it is crucial to minimize false negatives, where a tumor is present but the model fails to detect it. Therefore, we also evaluate precision, recall, and F1 score for a more comprehensive assessment of the model’s performance. Recall also known as sensitivity, is particularly important as it indicates the model’s ability to correctly identify all actual positive cases, which in this context is detecting tumors when they are present.

from sklearn.metrics import classification_report

# Get the true labels and predictions
y_true = []
y_pred = []

# Suppress verbose output by using `predict` directly without printing each step
for i in range(len(test_generator)):
    x_batch, y_batch = test_generator[i]
    y_true.extend(np.argmax(y_batch, axis=1))
    y_pred.extend(np.argmax(model.predict(x_batch, verbose=0), axis=1))  # Set verbose=0 to suppress output

# Print classification report
print(classification_report(y_true, y_pred, target_names=CLASS_NAMES))

              precision    recall  f1-score   support

      glioma       0.98      0.92      0.95       300
  meningioma       0.91      0.82      0.86       306
    no tumor       0.88      0.99      0.93       405
   pituitary       0.97      0.98      0.97       300

    accuracy                           0.93      1311
   macro avg       0.94      0.93      0.93      1311
weighted avg       0.93      0.93      0.93      1311

The classification report provides detailed metrics for each class. For instance, the recall for the “no tumor” class is 0.99, indicating that the model is highly effective at correctly identifying cases where no tumor is present, while the recall for “meningioma” is 0.82, suggesting there is room for improvement in detecting this tumor type. By analyzing precision, recall, and F1 score alongside accuracy, we can ensure our model not only performs well overall but also minimizes the risk of false negatives, thereby providing more reliable diagnostic support in a real-world medical setting.

2.2 Behind the Scenes: Prediction Example

This final chunk of code provides a detailed look at how the model actually makes predictions on individual images from the test set. By displaying the image and showing the true and predicted labels, we can visually confirm the model’s performance on any specific case. The prediction scores are derived from the softmax layer, which converts the raw output of the network into probabilities for each class, and ensures that they sum up to 100%.

import matplotlib.pyplot as plt
import numpy as np

# Assuming class names are as follows:
CLASS_NAMES = ['glioma', 'meningioma', 'no tumor', 'pituitary']

# Get one example from the test set
for image_batch, label_batch in test_generator:
    image = image_batch[0]
    true_label = label_batch[0]
    
    # Display the image
    plt.imshow(image)
    plt.title(f"True: {CLASS_NAMES[np.argmax(true_label)]}")
    plt.show()
    
    # Make a prediction
    prediction = model.predict(np.expand_dims(image, axis=0))[0]
    scores = {name: score for name, score in zip(CLASS_NAMES, prediction)}
    
    # Print the prediction scores
    for name, score in scores.items():
        print(f"This image is {score * 100:.2f} percent {name}")
    
    # Print the predicted label
    predicted_label = CLASS_NAMES[np.argmax(prediction)]
    print(f"\n Predicted: {predicted_label}")
    
    # Break after one example image application
    break

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 13ms/step
This image is 0.21 percent glioma
This image is 2.56 percent meningioma
This image is 0.01 percent no tumor
This image is 97.22 percent pituitary

 Predicted: pituitary

In this example, the model was given an image of a true pituitary tumor. It predicted the image to be a pituitary tumor with a high confidence of 97.22%, while the other prediction scores showing minuscule confidence with 0.21% for glioma, 2.56% for meningioma, and 0.01% confident that it showed no tumor. This final percentage was important and beneficial to see as our model was 99.99% confident that this patient had a tumor (100-.01), when in fact they did. This demonstrates the model’s ability to accurately identify the type of brain tumor, with the highest confidence score correctly corresponding to the true label. Such detailed prediction scores help in understanding the model’s confidence and decision-making process in specific cases which is crucial in medical diagnostics to ensure reliable and accurate results.