Choisir SAGA et la tolérance pour une régression logistique multiclasses parcimonieuse

Code Machine Learning for Trading

Résumé

Cette note de configuration explique pourquoi une régression logistique à trois classes pénalisée par L1 utilise SAGA plutôt que le solveur liblinear de scikit-learn. Elle cite la compatibilité multiclasses des versions récentes de scikit-learn et indique que SAGA a été beaucoup plus rapide dans des expériences mesurées sur la microstructure du Nasdaq-100. Dans les paramètres testés, les mesures rapportées de perte logarithmique hors échantillon et de précision favorisaient également SAGA.

La note porte sur le réglage de la tolérance à 0.001, afin que la parcimonie L1 se traduise par des coefficients exactement égaux à zéro. Avec une tolérance plus large, certains coefficients restaient simplement proches de zéro, faussant le décompte des caractéristiques retenues. Dans les comparaisons rapportées, le réglage plus strict a produit un nombre de coefficients nuls au moins égal à celui de liblinear. Ces résultats d’implémentation et de benchmark concernent un panel particulier et ne sont pas des garanties générales : le temps d’exécution sur l’ensemble des données est explicitement inconnu, et sa projection dépend d’une estimation incertaine de la mise à l’échelle.

Idées clés

SAGA convient à la configuration de régression logistique à trois classes lorsque l’ajustement multiclasses avec liblinear peut échouer dans les versions récentes des bibliothèques.
Des expériences mesurées sur un panel de microstructure du Nasdaq-100 ont montré que SAGA était plus rapide et légèrement meilleur sur les mesures hors échantillon rapportées.
Une tolérance de convergence plus stricte aide à distinguer les coefficients L1 réellement nuls des valeurs non nulles de faible amplitude.
Les temps rapportés ne permettent pas d’établir le temps d’exécution sur l’ensemble des données.

Étiquettes

Apprentissage automatique Statistiques

Texte intégral

# logistic_l1_C0.1.yaml


```yaml
# L1 logistic regression. The solver is `saga` rather than `liblinear`, and the tolerance
# is set explicitly rather than left at scikit-learn's 1e-4 default.
#
# Two reasons, and the first one is not optional. These labels are three-class (-1, 0, 1),
# and scikit-learn 1.8 makes multiclass `liblinear` a hard error; #740 already moved our
# floor to 1.7. `OneVsRestClassifier(liblinear)` would reproduce the current objective
# exactly - liblinear multiclass IS one-vs-rest - and would keep the problem below.
#
# The second is that `liblinear` does not finish. It is single-threaded coordinate descent
# and scales about N^1.4 here. Measured on nasdaq100_microstructure's `fwd_dir_15m` panel:
#
#     rows      liblinear 1000/1e-4     saga 200/1e-2
#     400,000     144.4s  converged      11.0s  converged
#   1,200,000     716.9s  converged      44.8s  converged
#
# which extrapolates to roughly eight hours per configuration at the full 16.9M rows against
# about twenty minutes. That is not a projection: `06_linear` ran 7h23m at 100% of one core
# on 2026-09-05 and was killed with two of thirteen configurations still unfinished, both of
# them these L1 ones.
#
# saga is also better out of sample at every C measured here: log loss 1.0273-1.0276 against
# liblinear's 1.0293-1.0294, and accuracy 0.415-0.420 against 0.404-0.410.
#
# `tol: 0.001` here rather than the 0.01 the weakly-penalised configurations use, because
# this is where the penalty binds and exact sparsity is the point of the sweep. At 1e-2 saga
# leaves coefficients stranded NEAR zero instead of AT zero, which `coef_ != 0` then counts
# as live. Measured on the same panel, exact zeros against coefficients below 1e-8, out of
# 198:
#
#     C        liblinear 1e-4     saga 1e-2        saga 1e-3
#     0.001      128 / 128         148 / 149        157 / 157
#     0.01        40 /  40          24 /  52         87 /  87
#     0.1          8 /   8           3 /   4         24 /  26
#
# The 24-against-52 at C=0.01 is the defect: twenty-eight coefficients below 1e-8 that are
# not zero. At 1e-3 the two counts agree and saga is *more* sparse than liblinear at every C
# here, so the tighter tolerance is not a concession - it is what makes the L1 solution an
# L1 solution.
#
# Cost at 1.2M rows: 226s, 352s and 287s for C=0.001, 0.01 and 0.1 against liblinear's 30s,
# 202s and 499s. **The full-panel cost of this arm is not established** - the 16.9M-row
# extrapolation is uncertain because it rests on a single scaling estimate taken from the
# tol=1e-2 timings. Watch it on the first run rather than assuming it is small.
model_class: LogisticRegression
params:
  C: 0.1
  max_iter: 200
  penalty: l1
  solver: saga
  tol: 0.001

```

Reproduit dans son intégralité avec attribution, conformément à la licence de la source. Licence: MIT

Ce résumé a été rédigé par l’agent de recherche de Stratmill à partir de la source originale ; il n’en est pas une copie.