Machine & Deep Learning

Lance-toi en Python scikit Learn : ton premier pas concret aujourd'hui

Python scikit Learn : l'essentiel en un article — vrai code, schémas et étapes concrètes, extraits d'un cours de 33 leçons.

REHOUMA Haythem

11 Jun 2026 • 12 min read

La meilleure façon d'apprendre Python scikit Learn, c'est de faire. Cet article te met le pied à l'étrier avec des extraits pratiques tirés d'un cours de 33 leçons — de quoi obtenir un premier résultat dès aujourd'hui.

tl;dr

Introduction et installation
Bases du Machine Learning
Preprocessing des donnees
Regression supervisee
Classification supervisee

~$ cat ./parcours.md # Python scikit Learn — 10 chapitres

Introduction et installation

→ Qu'est-ce que le machine learning ?→ Installer scikit-learn et l'ecosysteme+ 1 autres leçons

Bases du Machine Learning

→ Vocabulaire ML — features, labels, overfitting→ L'API uniforme de scikit-learn+ 1 autres leçons

Preprocessing des données

→ Valeurs manquantes et imputation→ Encodage des variables categorielles+ 2 autres leçons

Régression supervisée

→ Regression lineaire et regularisation→ Arbres et RandomForest pour la regression+ 1 autres leçons

Classification supervisée

→ Regression logistique→ k-NN et SVM+ 2 autres leçons

Apprentissage non supervisé

→ Clustering — K-Means, DBSCAN, Agglomerative→ Choisir le K optimal+ 1 autres leçons

Réduction de dimensionnalité

→ PCA — composantes principales→ t-SNE et UMAP — visualisation non lineaire+ 1 autres leçons

Validation et hyperparamètres

→ Cross-validation→ GridSearchCV et RandomizedSearchCV+ 1 autres leçons

🏁

Projet final (+ 2 chapitres en chemin)

→ Tu repars avec un projet concret et démontrable

Premier modele en 10 lignes (Iris)

NOTEObjectif — Realiser votre premier modele de machine learning end-to-end en moins de 10 lignes de code, sur le dataset historique iris.

Le dataset Iris

150 fleurs d'iris reparties en 3 especes (setosa, versicolor, virginica). 4 features mesurees : longueur et largeur des sepales et des petales.

output

from sklearn.datasets import load_iris

iris = load_iris()
print("Features :", iris.feature_names)
print("Classes :", iris.target_names)
print("Shape X :", iris.data.shape)   # (150, 4)
print("Shape y :", iris.target.shape) # (150,)

Le code complet (10 lignes)

output

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
score = model.score(X_test, y_test)
print(f"Accuracy : {score:.2%}")  # ~96.7%

C'est tout. Vous venez de creer un modele de classification qui distingue 3 especes d'iris avec ~97% de precision.

Decryptage ligne par ligne

Ligne	Role
`load_iris(return_X_y=True)`	Charge X (features) et y (labels) directement
`train_test_split(...)`	Decoupe 80% train / 20% test
`random_state=42`	Reproductibilite (toujours la meme division)
`KNeighborsClassifier(...)`	Choix de l'algorithme : k-NN avec k=5
`model.fit(...)`	Entrainement : memorise les exemples
`model.score(...)`	Evalue l'accuracy sur le test

Faire une prediction sur une nouvelle fleur

output

import numpy as np

# Une fleur : sepale 5.1 x 3.5, petale 1.4 x 0.2
nouvelle_fleur = np.array([[5.1, 3.5, 1.4, 0.2]])
prediction = model.predict(nouvelle_fleur)

print("Predit :", iris.target_names[prediction[0]])
# > 'setosa'

# Probabilites pour chaque classe
proba = model.predict_proba(nouvelle_fleur)
print("Probabilites :", proba)
# > [[1.0, 0.0, 0.0]]  -> 100% setosa

Visualiser le resultat

output

import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# Vrais labels
axes[0].scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap="viridis")
axes[0].set_title("Vraies classes")
axes[0].set_xlabel("Longueur sepale")
axes[0].set_ylabel("Largeur sepale")

# Predictions
predictions = model.predict(X_test)
axes[1].scatter(X_test[:, 0], X_test[:, 1], c=predictions, cmap="viridis")
axes[1].set_title("Predictions du modele")
axes[1].set_xlabel("Longueur sepale")

plt.tight_layout()
plt.show()

Le pattern fit / predict / score

TIPAPI uniforme — Cette structure (fit → predict → score) est la meme pour TOUS les modeles scikit-learn. Une fois apprise, vous pouvez essayer 30 algorithmes en changeant juste l'import.

output

# Meme code, modele different :
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)
print(model.score(X_test, y_test))

# Meme code, encore un autre :
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
print(model.score(X_test, y_test))

Bonnes pratiques des le debut

WARNINGPiege — Sur iris, presque tout marche tres bien (97%). C'est un dataset jouet. En vrai, vous galererez plus — et c'est normal !

Defi pratique

TIPExercice — Reprenez le code de 10 lignes et :

Essayez 3 algorithmes differents (KNN, DecisionTree, RandomForest)
Variez random_state et observez si le score change
Essayez k=1 puis k=10 dans KNeighborsClassifier

Sauvegarder un modele en production

NOTEObjectif — Persister un modele entraine et le recharger plus tard (API, batch, monitoring).

joblib : la methode recommandee

output

import joblib

# Sauvegarder
joblib.dump(pipe, "model.joblib")

# Charger
loaded_pipe = joblib.load("model.joblib")
preds = loaded_pipe.predict(X_new)

Avec compression

output

# Niveau 0 (rapide) a 9 (max compression)
joblib.dump(pipe, "model.joblib.gz", compress=3)
loaded = joblib.load("model.joblib.gz")

pickle (alternative)

output

import pickle

with open("model.pkl", "wb") as f:
    pickle.dump(pipe, f)

with open("model.pkl", "rb") as f:
    pipe = pickle.load(f)

WARNINGjoblib vs pickle — joblib est plus efficace pour les gros arrays NumPy (ce qui caracterise sklearn). pickle reste compatible avec tout Python.

Production : packaging complet

output

import joblib
import sklearn
import numpy as np

# Sauvegarder modele + metadata
artifact = {
    "model": pipe,
    "feature_names": feature_names,
    "target_names": target_names,
    "sklearn_version": sklearn.__version__,
    "numpy_version": np.__version__,
    "training_date": "2026-05-15",
    "metrics": {"f1": 0.94, "auc": 0.97}
}
joblib.dump(artifact, "model_v1.joblib")

API FastAPI minimale

output

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI()
artifact = joblib.load("model_v1.joblib")
model = artifact["model"]

class Input(BaseModel):
    features: list[float]

@app.post("/predict")
def predict(data: Input):
    pred = model.predict([data.features])
    proba = model.predict_proba([data.features])[0].tolist()
    return {"prediction": int(pred[0]), "probabilities": proba}

Versionner avec MLflow

output

import mlflow
import mlflow.sklearn

with mlflow.start_run():
    pipe.fit(X_tr, y_tr)
    
    # Logger params, metriques, modele
    mlflow.log_params({"max_depth": 10, "n_estimators": 200})
    mlflow.log_metric("f1", 0.94)
    mlflow.sklearn.log_model(pipe, "model", registered_model_name="my_model")

Qu'est-ce que le machine learning ?

NOTEObjectif — Comprendre ce qu'est le machine learning, distinguer les 3 grandes familles (supervise / non supervise / renforcement), et savoir quand utiliser le ML versus une logique classique.

Definition pragmatique

Le machine learning (ou apprentissage automatique) consiste a construire un programme qui apprend a effectuer une tache a partir d'exemples plutot que de regles ecrites a la main.

TIPAnalogie — Apprendre a un enfant a reconnaitre un chat : on ne lui donne pas une regle ("le chat a 4 pattes, des moustaches..."), on lui montre des photos de chats jusqu'a ce qu'il puisse generaliser.

Quand utiliser le ML ?

Probleme	Approche
Convertir Celsius en Fahrenheit	Formule classique (pas de ML)
Predire le prix d'une maison	ML supervise (regression)
Detecter un spam	ML supervise (classification)
Grouper des clients similaires	ML non supervise (clustering)
Reconnaitre un visage	Deep learning (variante ML)
Battre un humain aux echecs	ML par renforcement

Les 3 familles de ML

1. Supervise

On a des donnees avec etiquettes (X, y).

But : predire y a partir de X.

2. Non supervise

On a des donnees sans etiquettes (X seul).

But : decouvrir des structures cachees.

3. Renforcement

Un agent apprend par essai-erreur dans un environnement.

But : maximiser une recompense.

Exemples concrets par famille

Supervise — Regression

output

# X : surface du logement, nb pieces, quartier...
# y : prix de vente (chiffre)
# But : predire le prix d'une nouvelle maison

Supervise — Classification

output

# X : contenu de l'email
# y : "spam" ou "non-spam" (categorie)
# But : classer un nouvel email

Non supervise — Clustering

output

# X : achats des clients (montant, frequence...)
# Pas de y
# But : regrouper en 3-5 segments clientele

Le workflow type d'un projet ML

WARNINGPige courant — 80% du temps reel d'un projet ML est consacre aux etapes 2-4 (donnees), pas a l'entrainement. C'est la realite vs l'image hollywoodienne.

Pourquoi scikit-learn ?

va-plus-loin

Cet article couvre les extraits les plus utiles — le cours complet Python scikit Learn (10 chapitres, 33 leçons, exercices corrigés et projet final) t'emmène jusqu'au bout.

./acceder-au-cours-complet cours gratuit : Maîtriser Claude Code

FAQ

Combien de temps pour apprendre Python scikit Learn ?

Avec une progression structurée (10 chapitres, 33 leçons courtes et pratiques), on atteint un niveau opérationnel en quelques semaines à raison de 30 à 60 minutes par jour. L'important est de pratiquer chaque notion immédiatement.

Faut-il des prérequis ?

Des bases en informatique suffisent. Si tu sais utiliser un terminal et lire du code simple, tu es prêt.

Par où commencer concrètement ?

Reproduis les commandes de cet article, puis suis le cours complet Python scikit Learn : il enchaîne les 33 leçons dans l'ordre, avec exercices et projet final.

./a-lire-aussi

→ Lance-toi en Machine Learning Débutants : ton premier pas concret aujourd'hui → Machine Learning Simplifié en pratique : le code et les commandes qui comptent vraiment → Apprentissage Automatique Python : les 9 étapes clés pour passer de zéro à opérationnel

📬 Tu veux recevoir ce type de guide chaque semaine ? Abonne-toi gratuitement — code réel, zéro blabla.

Premier modele en 10 lignes (Iris)

Le dataset Iris

Le code complet (10 lignes)

Decryptage ligne par ligne

Faire une prediction sur une nouvelle fleur

Visualiser le resultat

Le pattern fit / predict / score

Bonnes pratiques des le debut

Defi pratique

Sauvegarder un modele en production

joblib : la methode recommandee

Avec compression

pickle (alternative)

Production : packaging complet

API FastAPI minimale

Versionner avec MLflow

Qu'est-ce que le machine learning ?

Definition pragmatique

Quand utiliser le ML ?

Les 3 familles de ML

1. Supervise

2. Non supervise

3. Renforcement

Exemples concrets par famille

Supervise — Regression

Supervise — Classification

Non supervise — Clustering

Le workflow type d'un projet ML

Pourquoi scikit-learn ?

FAQ

Stay up to date