DSLR

Deuxième projet de Machine Learning : reconstruire le Choixpeau de Poudlard avec une régression logistique multiclasse codée de zéro.

Présentation

Le Choixpeau magique ne répond plus : il faut le remplacer par un classifieur capable de répartir chaque élève dans sa maison. C'est un problème de classification multiclasse à quatre classes :

• Gryffondor
• Poufsouffle
• Serdaigle
• Serpentard

Le projet DSLR (Data Science × Logistic Regression) couvre tout le cycle d'un projet de science des données : explorer les données, les visualiser, puis entraîner un modèle de régression logistique.

dataset_train.csv ──► analyse ──► visualisation ──► standardisation ──► descente de gradient ──► weights.json
dataset_test.csv  ──► sigmoïde ──► argmax ──► houses.csv

Le projet

Introduction à la classification supervisée.

L'objectif : vivre de bout en bout la chaîne complète du machine learning — de la donnée brute au fichier de prédiction.

Le programme se compose de trois étapes obligatoires et d'une partie bonus :

1. describe.py — statistiques descriptives de chaque feature numérique, recalculées maison.
2. histogram.py / scatter_plot.py / pair_plot.py — répondre à des questions de visualisation.
3. logreg_train.py → logreg_predict.py — entraîner puis prédire (houses.csv).

En bonus : une descente de gradient stochastique (SGD) et une comparaison du modèle maison avec sklearn.linear_model.LogisticRegression.

Comment ça marche

1. Analyser avant de modéliser

describe.py calcule pour chaque feature numérique : count, mean, std, min, les quartiles (25 %, 50 %, 75 %) et max. La difficulté n'est pas la formule mais la réécriture de mean, std et percentile sans pandas.

2. Visualiser pour poser les bonnes questions

Le pair_plot est l'outil décisif : il montre quelles features séparent le mieux les maisons — celles qui deviennent ensuite les entrées du modèle.

3. Le classifieur : régression logistique one-vs-all

La régression logistique binaire estime une probabilité via la sigmoïde :

σ(z) = 1 / (1 + e^(−z))        avec z = θ₀ + θ₁x₁ + θ₂x₂ + …

Pour quatre maisons, on entraîne un modèle binaire par maison (one-vs-all / one-vs-rest) : « Gryffondor contre les autres », « Poufsouffle contre les autres », etc. À la prédiction, on calcule les quatre probabilités et on retient la plus élevée (argmax).

# Un modèle binaire par maison, sur les mêmes données
theta = gradient_descent(X, y_binary, alpha=0.1, iterations=5000)

4. Standardiser, puis descendre le gradient

Les notes des cours n'ont pas la même échelle : on centre et réduit chaque feature ((x − moyenne) / écart-type) avant d'ajouter une colonne de biais. On met ensuite à jour les poids pour minimiser l'erreur :

h        = σ(X · θ)                 # probabilité prédite
gradient = (1/m) · Xᵀ · (h − y)     # direction de la montée
θ       -= α · gradient             # un pas dans le sens opposé

5. Prédire et écrire houses.csv

logreg_predict.py recharge les poids (weights.json), applique la sigmoïde à chaque élève du jeu de test et écrit la maison retenue :

Index,Hogwarts House
0,Gryffindor
1,Hufflepuff
2,Ravenclaw
3,Hufflepuff
4,Slytherin

Les données & les features

describe.py et les visualisations convergent vers un petit sous-ensemble de cours réellement discriminants pour la maison :

features = [
    "Herbology",
    "Defense Against the Dark Arts",
    "Astronomy",
    "Charms",
    "Flying",
]   # sélection issues du pair_plot

Le pair_plot révèle que la Défense contre les forces du mal, l'Astronomie et les Sortilèges séparent nettement les élèves, tandis que d'autres cours sont répartis de façon quasi homogène — l'histogramme de Care of Magical Creatures en est l'exemple type :

Architecture

Le dépôt public est organisé par étape du projet :

DSLR/
├── Bonus/                     # SGD + accuracy_score
│   ├── stochastic_gradient_descent.py
│   ├── logred_predict_bonus.py
│   └── accuracy_score.py
├── Data_Analysis/
│   └── describe.py            # statistiques descriptives maison
├── Data_Utils/                # boîte à outils partagée
│   ├── math.py                # sigmoid, our_mean, our_std, our_percentile
│   ├── logger.py              # logging coloré
│   └── utils.py               # chargement du CSV
├── Data_Visualization/
│   ├── histogram.py           # histogrammes par cours × maison
│   ├── scatter_plot.py        # nuage de points (features similaires)
│   └── pair_plot.py           # sélection des features
├── Logistic_Regression/
│   ├── logreg_train.py        # entraînement (descente de gradient)
│   ├── logreg_predict.py      # prédiction → houses.csv
│   └── houses.csv
├── Scikit_Learn/
│   └── compare_accuracy.py    # modèle maison vs scikit-learn
├── datasets/
│   ├── dataset_train.csv
│   └── dataset_test.csv
├── docs/enonce.md             # sujet du projet
├── requirements.txt
└── README.md

Technologies

Fonctionnalités

Problème | Solution

Résultats

• Modèle : régression logistique one-vs-all, 5 features sélectionnées via le pair plot.
• Convergence : descente de gradient, α = 0,1, 5 000 itérations.
• Objectif du sujet : 98 % de précision sur dataset_test.csv.
• Bonus : implémentation de la descente de gradient stochastique (shuffle + mises à jour par exemple) et comparaison chiffrée avec LogisticRegression de Scikit-Learn.
• Sortie : houses.csv au format exact attendu (Index,Hogwarts House).

Ce que j'ai appris

Passer de la régression (prédire une valeur) à la classification (prédire une catégorie) tient à un détail : une sigmoïde qui transforme un score en probabilité.

Trois réflexes de data scientist, dans l'ordre :

1. Explorer les données avant de coder quoi que ce soit.
2. Visualiser pour choisir ses features — le pair plot vaut mieux que le tâtonnement.
3. Standardiser avant d'optimiser : sans ça, la descente de gradient n'avance pas.

Et la leçon transversale : maintenant que j'ai écrit la sigmoïde, la log-loss et le one-vs-all à la main, LogisticRegression de Scikit-Learn n'est plus une boîte noire — c'est une implémentation que je sais lire.

Lien

Voir le code