Deep Learning - CNN

Projet Actif

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%

Résultats d'entraînement

CNN Training Results - Accuracy and Loss Curves

Analyse des courbes d'accuracy

• Accuracy d'entraînement : volatile mais tendance croissante
• Accuracy de validation : plus stable, atteint 80%
• Signes d'overfitting modéré en fin d'entraînement
• Performance finale satisfaisante pour le domaine médical

Analyse des courbes de loss

• Loss d'entraînement : décroissance avec volatilité
• Loss de validation : tendance décroissante stable
• Convergence vers des valeurs faibles (~0.5)
• Bonne généralisation du modèle

Technologies utilisées

Python

TensorFlow

Keras

NumPy

Matplotlib

PIL

Scikit-learn

Voir le code source

Détails du projet

Client

Projet Personnel

Timeline

2025 – Présent

Rôle

Développeur Deep Learning

À propos du dataset

Dataset: Brain Tumor MRI Dataset (combinaison Figshare, SARTAJ, Br35H)

Images: 7022 IRM en niveaux de gris et couleur

Classes: glioma, meningioma, pituitary, no tumor

Taille: variable (redimensionnées en 150x150 pixels)

Type: Classification multiclasse

Algorithme: CNN (réseau convolutif) + comparaison avec transfert learning

Prétraitement: Normalisation (rescale), data augmentation (rotation, zoom, flip)

Performance du modèle

Test Accuracy

79.63%

Validation Accuracy

79.84%

Test Loss

0.5070

Paramètres

19,166,020 (73.11 MB)

Autres projets

JobHub – Plateforme d'Emploi Intelligente avec Agent IA

Application Web Full-Stack

Email AI Platform

Intelligence Artificielle

Ovia

Intelligence Artificielle

MediBook Platform

Web Application (Healthcare SaaS)

MediBook Healthcare Passport

Web Application (Healthcare SaaS)

MediBook Pharma Platform

Web Application (Healthcare SaaS)