Entraîner : de la régression logistique au LambdaMART

Les trois familles de LTR (choisir par la simplicité)

Pointwise : traiter chaque candidat indépendamment (« bon/pas bon »), classer par le score prédit. C'est une simple régression logistique (cours ML !) — la baseline : si elle bat les poids manuels, c'est déjà une victoire ;
Pairwise : apprendre « A doit passer avant B » sur les paires d'un même groupe (RankNet, RankSVM) — colle mieux à la nature du problème ;
Listwise : optimiser directement la métrique de ranking sur toute la liste (LambdaMART — du gradient boosting LTR, l'état de l'art tabulaire, dispo dans LightGBM/XGBoost avec l'objectif rank).

La démarche de production : pointwise d'abord (baseline interprétable), et ne passer au listwise que si le gain le justifie — exactement l'escalade « régression → boosting » du cours ML.

Le TP : apprendre les poids sur des candidats simulés

On simule des groupes de candidats avec leurs 5 sous-scores, un « vrai » poids caché, et on vérifie qu'une régression retrouve les poids et améliore le match@1 face à des poids naïfs :

🐍 À toi de jouer

import numpy as np
from sklearn.linear_model import LogisticRegression
rng = np.random.default_rng(0)

# 400 requêtes, 5 candidats chacune, 5 sous-scores par candidat
Q, K = 400, 5
vrais_poids = np.array([0.45, 0.10, 0.30, 0.05, 0.10])   # la "vérité" cachée
X, y, groups = [], [], []
for _ in range(Q):
    cand = rng.random((K, 5))                            # 5 candidats × 5 sous-scores
    utilite = cand @ vrais_poids + rng.normal(0, 0.05, K)
    gagnant = utilite.argmax()                           # le bon = plus haute utilité
    X.append(cand); y.append(np.eye(K)[gagnant]); groups.append(cand)
X = np.vstack(X); y = np.concatenate(y)

# split PAR GROUPE (les 320 premières requêtes en train)
tr = 320 * K
model = LogisticRegression().fit(X[:tr], y[:tr])         # pointwise
poids_appris = model.coef_[0]

def match_at_1(scoreur, qs):
    ok = sum(scoreur(q).argmax() == (q @ vrais_poids).argmax() for q in qs)
    return ok / len(qs)

test = groups[320:]
naif   = lambda q: q @ np.ones(5)                        # poids égaux (baseline bête)
appris = lambda q: q @ poids_appris
print("poids appris  :", poids_appris.round(2))
print("poids réels   :", vrais_poids)
print(f"\nmatch@1 poids naïfs (égaux) : {match_at_1(naif, test):.2%}")
print(f"match@1 poids appris        : {match_at_1(appris, test):.2%}")
print("\n→ le modèle a retrouvé la structure et classe bien mieux.")

Les réglages qui comptent

normaliser les features par groupe aide souvent (les scores d'une requête facile et d'une dure ne sont pas à la même échelle) ;
régularisation contre le sur-ajustement (peu de groupes = fort risque, cours ML) ;
pour LambdaMART : n_estimators, learning_rate, et l'objectif de ranking (lambdarank) avec la métrique cible (ndcg/map) ;
early stopping sur un match@1 de validation — on optimise la vraie métrique, pas une proxy.

🧩 Quiz1/3

L'approche pointwise du LTR, c'est concrètement…

🃏 Flashcards1/4