Brain Tumor Classification (Deep Learning - CNN)

Classification automatique de tumeurs cérébrales à partir d'images IRM utilisant un réseau de neurones convolutifs (CNN). Le dataset contient 7022 images réparties en quatre classes : gliome, méningiome, adénome hypophysaire et absence de tumeur.

Vue d'ensemble du projet

Ce projet implémente un réseau de neurones convolutifs (CNN) pour la classification de tumeurs cérébrales à partir d'images IRM. Le dataset contient 7022 images réparties en quatre classes : gliome, méningiome, adénome hypophysaire (pituitary) et absence de tumeur (no tumor).

Le workflow couvre l'exploration et le prétraitement des données, la construction d'un CNN from scratch avec TensorFlow/Keras, l'entraînement et la validation du modèle, puis l'évaluation via accuracy, loss et matrice de confusion. Le projet démontre comment les réseaux convolutifs peuvent être appliqués au domaine médical pour assister le diagnostic.

Le modèle atteint une accuracy de 79.63% sur le jeu de test, démontrant une performance satisfaisante pour l'aide au diagnostic médical. L'architecture comprend 3 couches convolutives avec des filtres de tailles croissantes (32, 64, 128) et des couches denses pour la classification finale.

Fonctionnalités clés

🖼️ Prétraitement des images : redimensionnement, normalisation et augmentation des données

🧠 Construction d'un CNN multiclasses avec TensorFlow/Keras

📉 Utilisation de la fonction de coût categorical crossentropy et de l'optimiseur Adam

📊 Suivi des performances via courbes accuracy/loss et matrice de confusion

🔄 Comparaison entre un CNN from scratch et des modèles de transfert learning

🏥 Application concrète dans le domaine de l'imagerie médicale

Implémentation du code

1. Import des bibliothèques

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

2. Prétraitement des données et augmentation

# Normalization & Data Augmentation
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=20,
    width_shift_range=0.1,
    height_shift_range=0.1,
    shear_range=0.1,
    zoom_range=0.1,
    horizontal_flip=True,
    fill_mode='nearest'
)

test_datagen = ImageDataGenerator(rescale=1./255)

# Load images
train_dir = "Training"
test_dir = "Testing"

train_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=(150, 150),  
    batch_size=32,
    class_mode='categorical'
)

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

Output:

Found 5712 images belonging to 4 classes.
Found 1311 images belonging to 4 classes.

3. Architecture du modèle CNN

# Build the CNN Model
model = Sequential([
    Conv2D(32, (3,3), activation='relu', input_shape=(150,150,3)),
    MaxPooling2D(pool_size=(2,2)),
    Dropout(0.25),

    Conv2D(64, (3,3), activation='relu'),
    MaxPooling2D(pool_size=(2,2)),
    Dropout(0.25),

    Conv2D(128, (3,3), activation='relu'),
    MaxPooling2D(pool_size=(2,2)),
    Dropout(0.25),

    Flatten(),
    Dense(512, activation='relu'),
    Dropout(0.5),
    Dense(256, activation='relu'),
    Dropout(0.3),
    Dense(4, activation='softmax')  # 4 classes
])

# Compile the model
model.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

Architecture Summary:

• Total params: 19,166,020 (73.11 MB)

• Trainable params: 19,166,020

• Non-trainable params: 0

• Couches convolutives: 3 (32, 64, 128 filtres)

• Couches denses: 3 (512, 256, 4 neurones)

4. Processus d'entraînement

# Training the model
history = model.fit(
    train_generator,
    steps_per_epoch=train_generator.samples // train_generator.batch_size,
    epochs=20,
    validation_data=test_generator,
    validation_steps=test_generator.samples // test_generator.batch_size,
    verbose=1
)

Résultats d'entraînement (extrait):

Epoch 1/20: accuracy: 0.4296 - loss: 1.2446 - val_accuracy: 0.6961 - val_loss: 0.8000

Epoch 10/20: accuracy: 0.8750 - loss: 0.5147 - val_accuracy: 0.7266 - val_loss: 0.7280

Epoch 20/20: accuracy: 0.7812 - loss: 0.5094 - val_accuracy: 0.7984 - val_loss: 0.5030

5. Évaluation du modèle

# Evaluate the model
test_loss, test_accuracy = model.evaluate(test_generator, verbose=1)
print(f'Test Accuracy: {test_accuracy:.4f}')
print(f'Test Loss: {test_loss:.4f}')

# Plot training history
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

Résultats finaux:

• Test Accuracy: 79.63%

• Test Loss: 0.5070

• Validation Accuracy: 79.84%

• Training Accuracy: 78.12%