Machine Learning & Intelligence Artificielle

École Technique - Année Académique 2025-2026

Accueil / Projets ML / Santander Customer Transaction Prediction

Projet Machine Learning Complet

Santander Customer Transaction Prediction - Du modèle à l'interface web

🎯 Contexte et Objectif du Projet

Dans ce projet, vous allez développer une application complète de Machine Learning en partant de zéro jusqu'au déploiement d'une interface utilisateur fonctionnelle. Vous travaillerez sur un dataset réel de Kaggle pour prédire si un client effectuera une transaction bancaire.

Ce projet couvre l'ensemble du pipeline ML professionnel :

⚠️ Dataset : Santander Customer Transaction Prediction

Source Kaggle : https://www.kaggle.com/c/santander-customer-transaction-prediction

Caractéristique Détails
Type de problème Classification binaire (Transaction : Oui / Non)
Nombre de features 200 variables anonymisées (var_0 à var_199)
Observations ~200,000 lignes dans le train set
Difficulté Intermédiaire à Avancé
Challenges principaux • Données déséquilibrées
• 200 features (risque d'overfitting)
• Feature selection nécessaire
• Variables anonymisées

📊 Objectifs Pédagogiques

À la fin de ce projet, vous serez capable de :

🏗️ Architecture du Projet

Le projet est structuré en 3 composantes interdépendantes :

┌─────────────────────────────────────────────────────────────┐ │ ARCHITECTURE GLOBALE │ └─────────────────────────────────────────────────────────────┘ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ │ PHASE 1: ML │─────▶│ PHASE 2: API │─────▶│ PHASE 3: FRONT │ │ │ │ │ │ │ │ • Exploration │ │ • Flask REST API │ │ • Streamlit/ │ │ • Preprocessing │ │ • Endpoints │ │ Flask/Django │ │ • Training │ │ • Predictions │ │ • Interface web │ │ • Evaluation │ │ • JSON Response │ │ • Visualisation │ │ • Model Save │ │ │ │ │ └──────────────────┘ └──────────────────┘ └──────────────────┘ │ │ │ ▼ ▼ ▼ best_model.pkl app.py (Flask) streamlit_app.py scaler.pkl CORS enabled HTTP requests

Structure des fichiers recommandée :

santander_project/ ├── data/ │ ├── train.csv # Dataset d'entraînement │ └── test.csv # Dataset de test │ ├── notebooks/ │ ├── 01_exploration.ipynb # Analyse exploratoire │ ├── 02_preprocessing.ipynb # Nettoyage et feature engineering │ └── 03_modeling.ipynb # Entraînement des modèles │ ├── models/ │ ├── best_model.pkl # Meilleur modèle sauvegardé │ └── scaler.pkl # Scaler pour normalisation │ ├── api/ │ ├── app.py # Application Flask │ ├── requirements.txt # Dépendances API │ └── test_api.py # Script de test │ ├── frontend/ │ ├── streamlit_app.py # Interface Streamlit │ ├── flask_app/ # Alternative Flask │ │ ├── app.py │ │ ├── templates/ │ │ └── static/ │ └── requirements.txt # Dépendances frontend │ ├── scripts/ │ └── download_data.py # Script Kaggle download │ └── README.md # Documentation projet

🤖 PHASE 1 : MACHINE LEARNING

Étapes de la Phase Machine Learning

1Téléchargement des Données Kaggle

Objectif : Configurer l'API Kaggle et télécharger le dataset Santander.

Instructions :

  1. Créez un compte sur Kaggle.com
  2. Allez dans votre profil → Account → API → "Create New API Token"
  3. Téléchargez le fichier kaggle.json
  4. Placez-le dans ~/.kaggle/ (Linux/Mac) ou C:\Users\YourName\.kaggle\ (Windows)
  5. Installez l'API Kaggle : pip install kaggle

2Exploration des Données (EDA)

Objectif : Comprendre la structure et les caractéristiques du dataset.

Analyses à réaliser :

  • Charger le dataset avec pandas
  • Vérifier les dimensions (shape, colonnes)
  • Analyser la variable cible (target) - distribution des classes
  • Détecter les valeurs manquantes
  • Statistiques descriptives (mean, std, min, max)
  • Visualisations : histogrammes, boxplots, correlation matrix
  • Identifier les features les plus importantes

⚠️ Points d'attention

  • Le dataset est très déséquilibré (~10% de classe positive)
  • Les 200 features sont anonymisées - pas d'interprétation métier possible
  • Aucune valeur manquante (déjà nettoyé)
  • Toutes les variables sont numériques (pas de catégorielles)

3Preprocessing des Données

Objectif : Préparer les données pour l'entraînement des modèles.

Étapes de preprocessing :

  • Séparation features/target : Séparer X (features) et y (target)
  • Train/Validation split : 80% train, 20% validation (stratified)
  • Standardisation : Normaliser les features avec StandardScaler
  • Feature selection (optionnel) : SelectKBest, PCA, ou variance threshold
  • Gestion du déséquilibre : Class weights ou SMOTE

4Entraînement des Modèles

Objectif : Tester plusieurs algorithmes et sélectionner le meilleur.

Modèles à comparer :

  • Logistic Regression - Baseline simple
  • Random Forest - Ensemble method robuste
  • XGBoost - State-of-the-art pour données tabulaires
  • LightGBM - Rapide et performant

5Optimisation des Hyperparamètres

Objectif : Améliorer les performances avec GridSearchCV.

6Évaluation Finale

Objectif : Analyser en profondeur les performances du modèle.

Métriques à calculer :

  • ROC-AUC Score - Métrique principale pour classes déséquilibrées
  • Precision, Recall, F1-Score - Pour chaque classe
  • Confusion Matrix - Visualisation des erreurs
  • ROC Curve - Courbe performance
  • Feature Importance - Variables les plus importantes

🔌 PHASE 2 : API FLASK

Création de l'API REST

7Développement de l'API Flask

Objectif : Créer une API REST pour exposer le modèle en production.

Fonctionnalités de l'API :

  • Endpoint POST /predict - Recevoir features et retourner prédiction
  • Endpoint GET /health - Vérifier l'état de l'API
  • Endpoint GET /model-info - Informations sur le modèle
  • Gestion des erreurs (400, 500)
  • CORS activé pour permettre les requêtes frontend
  • Validation des inputs

8Tests de l'API

Objectif : Valider le bon fonctionnement de tous les endpoints.

🎨 PHASE 3 : INTERFACE UTILISATEUR

Développement de l'Interface Web

9Interface Streamlit (Option 1 - Recommandée)

Objectif : Créer une interface interactive avec Streamlit.

Pourquoi Streamlit ?

  • Développement ultra-rapide (100% Python)
  • Design moderne intégré
  • Widgets interactifs natifs
  • Idéal pour dashboards ML

Requirements pour Streamlit :

# frontend/requirements.txt streamlit==1.28.0 requests==2.31.0 pandas==2.0.3 numpy==1.24.3 plotly==5.17.0

Pour lancer l'application :

# Terminal 1: Lancer l'API cd api python app.py # Terminal 2: Lancer Streamlit cd frontend streamlit run streamlit_app.py

💡 Option 2: Interface Flask + HTML/CSS

Si vous préférez créer une interface web classique avec templates HTML :

  • Créez des templates Jinja2 dans templates/
  • Styles CSS dans static/css/
  • JavaScript pour les appels AJAX dans static/js/
  • Plus de contrôle sur le design mais plus de code

💡 Option 3: Django

Pour une application plus complète avec base de données :

  • Créez un projet Django complet
  • Modèles pour stocker l'historique des prédictions
  • Authentification utilisateur
  • Dashboard d'administration
  • Plus complexe mais très professionnel

📦 Livrables Attendus

1. Code Source Complet

Tous les scripts Python organisés dans la structure de dossiers recommandée :

  • Notebooks Jupyter avec analyses et commentaires
  • Scripts de téléchargement et preprocessing
  • Code de l'API Flask
  • Code de l'interface (Streamlit/Flask/Django)

2. Modèles Entraînés

Fichiers .pkl dans le dossier models/ :

  • best_model.pkl ou best_model_optimized.pkl
  • scaler.pkl

3. Fichiers de Configuration

  • requirements.txt pour chaque composante (API, frontend)
  • .gitignore pour exclure les gros fichiers
  • Fichiers de configuration Kaggle si applicable

4. Documentation

README.md contenant :

  • Description du projet
  • Instructions d'installation (pip install -r requirements.txt)
  • Comment télécharger les données
  • Comment lancer l'API
  • Comment lancer l'interface
  • Exemples d'utilisation
  • Architecture du projet

5. Rapport de Projet (PDF ou Markdown)

Document de 5-10 pages incluant :

  • Introduction : Contexte et objectifs
  • Dataset : Description, EDA, statistiques clés
  • Preprocessing : Techniques utilisées
  • Modèles : Algorithmes testés, hyperparamètres
  • Résultats : Métriques, comparaison des modèles
  • API : Architecture, endpoints, choix techniques
  • Interface : Choix de technologie, fonctionnalités
  • Difficultés rencontrées et solutions
  • Améliorations futures possibles
  • Conclusion

6. Démonstration

Vidéo ou présentation live montrant :

  • L'API en fonctionnement (test avec Postman ou curl)
  • L'interface web en action
  • Exemples de prédictions
  • Explication du code (parties importantes)

📊 Barème de Notation (100 points)

1. Qualité du Modèle ML 40 pts
2. API Flask 30 pts
3. Interface Utilisateur 20 pts
4. Code et Documentation 10 pts
TOTAL : 100 points

🌟 Points Bonus (jusqu'à +20 points)

💡 Conseils pour Réussir

📚 Ressources et Références

⏰ Délai et Remise

Délai : À définir avec votre enseignant (recommandé: 3-4 semaines)

Format de remise :