Evaluer la qualité d’un modèle

Pour essayer les exemples présents dans ce tutoriel :

Le machine learning a l’ambition de proposer des méthodes prédictives simples à mettre en oeuvre sur le plan opérationnel. Cette promesse séduit forcément des acteurs ayant un volume de données conséquent et désirant utiliser celles-ci pour anticiper le comportement de clients ou d’utilisateurs de services. Nous avons vu lors du chapitre précédent la manière de structurer un problème en échantillons d’apprentissage et de validation (Figure 1) mais sans en expliquer la raison d’être.

Figure 1: Illustraton de la méthodologie du machine learning

1 Une méthodologie pour éviter le sur-apprentissage

Puisque l’objectif du machine learning est de mettre en oeuvre un modèle sur une population cible qui n’est pas celle sur laquelle le modèle a appris - par exemple un modèle de scoring ne sert pas à changer les prêts des clients existants mais à prendre une décision pour de nouveaux clients - il est logique de privilégier la validité externe d’un modèle. Pour que les anticipations de performance d’un modèle soient réalistes, il est donc nécessaire d’évaluer les modèles dans un cadre similaire à celui dans lequel il sera mis en oeuvre ultérieurement. Autrement dit, une évaluation honnête d’un modèle se doit d’être une évaluation de la validité externe d’un modèle, c’est-à-dire de la capacité à être bon sur une population qu’il n’a pas rencontré lors de son entraînement.

Pourquoi s’embarasser de cette considération ? Parce que construire un modèle sur un échantillon et l’évaluer sur celui-ci amène à une validité interne forte, au détriment de la validité externe. Autrement dit, si vous avez un contrôle sur les questions de cours, et strictement sur celles-ci, la meilleure stratégie à mettre en oeuvre est d’apprendre par coeur votre cours et le restituer comme tel. Un test de ce type ne cherche pas à savoir si vous comprenez votre cours, seulement si vous avez appris votre cours. Il s’agit de tester la validité interne de vos connaissances. Plus les questions s’éloigneront de ce que vous avez appris par coeur, plus vous serez en difficulté.

L’idée est la même pour un algorithme: plus son apprentissage est adhérant à un échantillon initial, plus ses performances prédictives, et donc sa valeur en pratique, seront limités. C’est pour cette raison qu’on évalue la qualité d’un modèle sur un échantillon qu’il n’a pas vu dans son apprentissage: pour privilégier la validité externe à la validité interne.

On parle de sur-apprentissage lorsqu’un modèle a une bonne validité interne mais une mauvaise validité externe, c’est-à-dire de mauvaises qualités prédictives sur un autre échantillon que celui sur lequel il a appris. La structuration d’un problème d’apprentissage sous la forme d’échantillons train/test est une réponse à ce défi puisqu’elle permet de sélectionner le meilleur modèle en extrapolation. Ce sujet peut apparaître trivial mais, dans les faits, de nombreux champs scientifiques empiriques n’adoptent pas cette méthodologie pour émettre des conclusions au-delà de la population sur laquelle ils ont travaillé.

Par exemple, en économie, il est assez commun d’évaluer une politique publique toutes choses égales par ailleurs, d’en déduire un effet marginal et de préconiser des recommandations politiques au-delà de celle-ci. Cependant, il est rare que la politique suivante s’applique à la même population cible ou dans les mêmes conditions institutionnelles, de sorte qu’elle produit généralement des effets différents. Les biais d’échantillonnage, du point de vue des caractéristiques individuelles ou de la période d’étude, sont souvent relégués au second plan et l’estimation des effets marginaux se fait généralement indépendamment de toute notion de validité externe.

Pour en revenir à l’objet de ce chapitre, formellement, ce problème vient de l’arbitrage biais-variance dans la qualité d’estimation[^1]. Soit \(h(X,\theta)\) un modèle statistique. On peut décomposer l’erreur d’estimation en deux parties :

\[ \mathbb{E}\bigg[(y - h(\theta,X))^2 \bigg] = \underbrace{ \bigg( y - \mathbb{E}(h_\theta(X)) \bigg)^2}_{\text{biais}^2} + \underbrace{\mathbb{V}\big(h(\theta,X)\big)}_{\text{variance}} \]

Il y a ainsi un compromis à faire entre biais et variance. Un modèle peu parcimonieux, c’est-à-dire proposant un grand nombre de paramètres, va, en général, avoir un faible biais mais une grande variance. En effet, le modèle va tendre à se souvenir d’une combinaison de paramètres à partir d’un grand nombre d’exemples sans être capable d’apprendre la règle qui permette de structurer les données.

Par exemple, la ligne verte ci-dessous est trop dépendante des données et risque de produire une erreur plus importante que la ligne noire (qui moyennise plus) sur de nouvelles données.

La division entre échantillons d’apprentissage et de validation est une première réponse au défi du surapprentissage. Néanmoins, ce n’est pas le seul geste méthodologique pour avoir un bon modèle prédictif.

De manière générale, il sera préférable d’adopter des modèles parcimonieux, c’est-à-dire les modèles faisant le moins d’hypothèses possibles sur la structure des données tout en offrant une performance satisfaisante. Ceci est généralement vu comme une illustration du principe du rasoir d’Ockham: en l’absence d’arguments théoriques, le meilleur modèle est celui qui permet d’expliquer au mieux les données avec les hypothèses les plus minimalistes. Cette approche, très opérationnelle, guidera de nombreux choix méthodologiques que nous mettrons en oeuvre

2 Comment évaluer un modèle ?

L’introduction de cette partie présentait les principaux concepts pour se repérer dans la terminologie du machine learning. Si les concepts d’apprentissage supervisé, non supervisé, classification, régression, etc. ne sont pas clairs, il est recommandé de retourner voir ce chapitre. Pour rappel, le machine learning intervient dans les domaines où on ne dispose pas de modèles théoriques, en contrôlant tous les paramètres, faisant consensus et où on va chercher des règles statistiques, selon une démarche inductive. Ce n’est donc pas une approche scientifique justifiée dans tous les domaines. Par exemple, il vaut mieux privilégier le réglage des satelittes par le biais des équations de gravitation que par le biais d’un algorithme de machine learning qui risque d’introduire du bruit là où ce n’est pas nécessaire.

La principale ligne de partage entre les méthodes d’évaluation sera la nature du phénomène étudié (la variable \(y\)). Selon qu’on dispose ou non d’une mesure directe de notre variable d’intérêt, une sorte de gold standard, on mettra en oeuvre des métriques prédictives directes (cas de l’apprentissage supervisé) ou des métriques de stabilité statistique (apprentissage non supervisé).

Néanmoins, le succès des modèles de fondations, c’est-à-dire de modèles généralistes pouvant être utilisés pour des tâches auxquels ils n’ont pas été entraînés, amène à élargir la question de l’évaluation. Il n’est pas toujours évident de pouvoir définir l’objectif précis d’un modèle généraliste ni de pouvoir évaluer de manière consensuelle sa qualité. ChatGPT ou Claude nous apparaîssent bon, mais comment peut-on avoir une idée de leur pertinence dans différents cas d’usage ? Outre le sujet des annotations, ceci amène à réfléchir, plus globalement, sur le rôle de l’humain dans l’évaluation et le contrôle de décisions prises par des algorithmes.

2.1 Apprentissage supervisé

En apprentissage supervisé, on distingue en général les problèmes de:

• Classification : la variable \(y\) est discrète
• Régression : la variable \(y\) est continue

Les métriques mises en oeuvre peuvent être objectives dans ces deux cas car on dispose d’une valeur réelle, une valeur cible faisant office de gold standard, auquel comparer la valeur prédite.

2.1.1 Classification

Le cas le plus simple à comprendre est celui de la classification binaire. Dans ce cas, soit on a juste, soit on se trompe, sans nuance.

La plupart des critères de performance consistent ainsi à explorer les différentes cases de la matrice de confusion :

Construction de la matrice de confusion

Cette dernière met en regard les valeurs prédites avec les valeurs observées. Le cas binaire est le plus simple à appréhender ; la classification multiclasse est une version généralisée de ce principe.

A partir des 4 coins de cette matrice, il existe plusieurs mesure de performance:

Critère	Mesure	Calcul
Accuracy	Taux de classification correcte	Diagonale du tableau : \(\frac{TP+TN}{TP+FP+FN+FP}\)
Precision	Taux de vrais positifs	Ligne des prédictions positives : \(\frac{TP}{TP+FP}\)
Recall (rappel)	Capacité à identifier les labels positifs	Colonne des prédictions positives : \(\frac{TP}{TP+FN}\)
F1 Score	Mesure synthétique (moyenne harmonique) de la précision et du rappel	\(2 \frac{precision \times recall}{precision + recall}\)

Néanmoins, certaines métriques préfèrent plutôt prendre en compte les probabilités de prédiction. Si un modèle fait une prédiction mais avec une confiance très modérée et qu’on l’accepte, peut-on lui en tenir rigeur ? Pour cela, on fixe un seuil de probabilité \(c\) à partir duquel on prédit qu’une observation donnée appartient à une certaine classe prédite:

\[ \mathbb{P}(y_i=1|X_i) > c \Rightarrow \widehat{y}_i = 1 \]

Plus on augmente \(c\), plus on est sélectif sur le critère d’appartenance à la classe. La précision, i.e. le taux de vrais positifs parmi les prédictions positives, augmente. Mais on augmente le nombre de positifs manqués (ce sont des faux négatifs). Autrement dit, quand on est pointilleux, on diminue le rappel. Pour chaque valeur de \(c\) correspond une matrice de confusion et donc des mesures de performances. La courbe ROC consiste à faire varier \(c\) de 0 à 1 et vérifier l’effet sur les performances :

L’aire sous la courbe (AUC) permet d’évaluer quantitativement le meilleur modèle au sens de ce critère. L’AUC représente la probabilité que le modèle soit capable de distinguer entre la classe positive et négative.

2.1.2 Régression

Lorsqu’on travaille sur une variable quantitative, l’objectif est d’avoir une prédiction la plus proche de celle-ci. Les indicateurs de performance en régression consistent donc à mesurer l’écart entre la valeur prédite et la valeur observée :

Nom	Formule
Mean squared error	\(MSE = \mathbb{E}\left[(y - h_\theta(X))^2\right]\)
Root Mean squared error	\(RMSE = \sqrt{\mathbb{E}\left[(y - h_\theta(X))^2\right]}\)
Mean Absolute Error	\(MAE = \mathbb{E} \bigg[ \lvert y - h_\theta(X) \rvert \bigg]\)
Mean Absolute Percentage Error	\(MAE = \mathbb{E}\left[ \left\lvert \frac{y - h_\theta(X)}{y} \right\rvert \right]\)

Ces métriques devraient rappeler des souvenirs si vous êtes familiers de la méthode des moindres carrés, ou plus généralement de la régression linéaire. Cette méthode vise justement à trouver des paramètres qui minimisent ces métriques, dans un cadre statistique formel.

2.2 Apprentissage non supervisé

Dans cet ensemble de méthodes, on ne dispose pas de gold standard pour comparer la prédiction à la valeur observée. Pour mesurer la performance d’un algorithme, il faut donc se résoudre à utiliser des métriques de stabilité des prédictions, basées sur des critères statistiques. Cela permet d’évaluer si le fait de complexifier l’algorithme change fondamentalement la distribution des prédictions.

Les métriques utilisées dépendent du type d’apprentissage mis en oeuvre. Par exemple, le clustering par K-means utilise généralement une mesure d’inertie qui quantifie l’homogénéité des clusters. Une bonne performance correspond au cas où les clusters sont homogènes et se distinguent l’un de l’autre. Plus on a de clusters (le \(K\) de \(K-means\)), plus ceux-ci tendent à être homogènes. Si on ne choisit pas un \(K\) adéquat, on peut faire du sur-apprentissage: si on ne compare les modèles qu’en fonction de leur homogénéité, on va choisir un nombre de cluster très élevé ce qui correspond à un cas classique de surapprentissage. Les méthodes de sélection du nombre de cluster optimal, comme la méthode du coude, visent à évaluer le moment où le gain d’inertie lié à l’augmentation du nombre de clusters tend à s’affaisser. On sélectionne alors le nombre de clusters qui offre le meilleur compromis entre parcimonie et performance.

2.3 Comment sont évalués les grands modèles de langage et les IA génératives ?

S’il apparaît relativement intuitif d’évaluer des modèles supervisés (pour lesquels on dispose d’observations faisant office de vérité absolue), comment juger de la qualité d’un outil comme ChatGPT ou Copilot ? Comment définir une bonne IA générative : est-ce une IA qui fournit une information juste du premier coup (véracité) ? une IA qui fait preuve de capacité de raisonnements (chain of thought) dans une discussion ? Doit-on juger le style ou uniquement le fond ?

Ces interrogations sont des champs actifs de recherche. Les modèles de fondation étant très généraux, entraînés à différentes tâches, parfois de manière supervisée, parfois de manière non supervisée, il est difficile de définir un objectif unique permettant de considérer qu’un modèle est, sans ambiguité, meilleur qu’un autre. Le leaderboard MTEB (Massive Text Embedding Benchmark) présente par exemple de nombreuses métriques pour des tâches diverses et il peut être difficile de s’y retrouver. Sans compter que le rythme effrené de publication de nouveaux modèles change régulièrement ce classement.

Globalement, même s’il existe des métriques où on fait automatiquement évaluer la qualité d’un texte à un autre LLM (métriques LLM as a judge), pour avoir des modèles de langage de qualité, il est nécessaire d’avoir de l’évaluation humaine à plusieurs niveaux. En premier lieu, il est utile d’avoir un corpus de données annotées (des textes avec un résumé rédigé par un humain, des descriptions d’images, etc.) pour la phase d’entraînement et d’évaluation. Ceci permet de guider le comportement du modèle sur une tâche donnée.

Mais l’humain peut aussi intervenir ex post, pour faire remonter une évaluation de la qualité d’un modèle. On parle de feedbacks. Ceci peut prendre plusieurs formes, par exemple une évaluation positive ou négative de la réponse ou une évaluation plus qualitative. Ces informations remontées ne vont pas forcément servir à la version actuelle du modèle mais pourront servir ultérieurement pour entraîner un modèle selon une technique de renforcement.

2.4 Evaluer sans être tourné vers le passé: les enjeux de la supervision des modèles

Il convient de garder en mémoire qu’un modèle de machine learning est entraîné sur des données passées. Un usage opérationnel de celui-ci, dans la phase suivante de son cycle de vie, implique donc de faire des hypothèses fortes sur la stabilité des nouvelles données reçues. Si le contexte évolue, un modèle risque de ne plus apporter des performances satisfaisantes. Si dans certains cas cela peut être rapidement mesuré à partir d’indicateurs clés (ventes, nombre de nouveaux clients, etc.) il est tout de même important de conserver un contrôle sur les modèles.

Ceci ouvre à la notion d’observabilité d’un modèle de machine learning. En informatique, l’observabilité est le principe qui consiste à surveille, mesurer et comprendre l’état d’une application pour s’assurer que celle-ci soit toujours en mesure de répondre à ses utilisateurs. L’idée de l’observabilité en machine learning est similaire: il s’agit de contrôler qu’un modèle permet toujours d’avoir des performances satisfaisantes au cours du temps. Le principal risque dans le cycle de vie d’un modèle est celui du data drift, changement dans la distribution des données au fil du temps qui entraîne une dégradation des performances d’un modèle de machine learning. Bien sûr, avoir construit un modèle à bonne validité externe va réduire l’effet de ce risque mais il sera inévitable qu’il ait des effets si la structure des données change trop par rapport au contexte d’entraînement.

Pour garder un modèle pertinent dans le temps, il sera nécessaire de régulièrement collecter de nouvelles données (principe des annotations) et adopter une stratégie de ré-entraînement. Ceci ouvre la voie aux problématiques de la mise en production et du MLOps qui sont le point de départ d’un cours que Romain Avouac et moi donnons.

3 Les hyperparamètres et la validation croisée

La Figure 1 présentait le pipeline simple pour introduire à la notion d’entraînement d’un modèle. Ce pipeline fait abstraction d’hypothèses exogènes à l’estimation mais qui sont à faire sur des paramètres car elles affectent la performance de la prédiction.

Par exemple, de nombreux modèles proposent une pénalisation des modèles non parcimonieux pour éviter le sur-apprentissage. Le choix de la pénalisation idéale dépend de la structure des données et n’est jamais connue, ex-ante par le modélisateur. Faut-il pénaliser fortement ou non le modèle ?

La notion de validation croisée permettra de généraliser cette approche. Ces paramètres qui affectent la prédiction seront pas la suite appelés des hyperparamètres. Comme nous allons le voir, nous allons aboutir à un raffinement de l’approche pour obtenir un pipeline ayant plutôt cet aspect :

La validation croisée est une méthode permettant de choisir la valeur du paramètre qui optimise la qualité de la prédiction en agrégeant des scores de performance sur des découpages différents de l’échantillon d’apprentissage.

La validation croisée permet d’évaluer les performances de modèles différents (SVM, random forest, etc.) ou, couplé à une stratégie de grid search, de trouver les valeurs des hyperparamètres qui aboutissent à la meilleure prédiction.

Note

L’étape de découpage de l’échantillon de validation croisée est à distinguer de l’étape split_sample_test. A ce stade, on a déjà partitionné les données en échantillon d’apprentissage et test. C’est l’échantillon d’apprentissage qu’on découpe en sous-morceaux.

La méthode la plus commune est la validation croisée k-fold. On partitionne les données en \(K\) morceaux et on considère chaque pli, tour à tour, comme un échantillon de test en apprenant sur les \(K-1\) échantillons restants. Les \(K\) indicateurs ainsi calculés sur les \(K\) échantillons de test peuvent être moyennés et comparés pour plusieurs valeurs des hyperparamètres.

Il existe d’autres types de validation croisée, notamment la leave one out qui consiste à considérer une fois exactement chaque observation comme l’échantillon de test (une n-fold cross validation).

Informations additionnelles

environment files have been tested on.

Latest built version: 2024-11-20

Python version used:

'3.12.6 | packaged by conda-forge | (main, Sep 30 2024, 18:08:52) [GCC 13.3.0]'

Package	Version
affine	2.4.0
aiobotocore	2.15.1
aiohappyeyeballs	2.4.3
aiohttp	3.10.8
aioitertools	0.12.0
aiosignal	1.3.1
alembic	1.13.3
altair	5.4.1
aniso8601	9.0.1
annotated-types	0.7.0
appdirs	1.4.4
archspec	0.2.3
asttokens	2.4.1
attrs	24.2.0
babel	2.16.0
bcrypt	4.2.0
beautifulsoup4	4.12.3
black	24.8.0
blinker	1.8.2
blis	0.7.11
bokeh	3.5.2
boltons	24.0.0
boto3	1.35.23
botocore	1.35.23
branca	0.7.2
Brotli	1.1.0
cachetools	5.5.0
cartiflette	0.0.2
Cartopy	0.24.1
catalogue	2.0.10
cattrs	24.1.2
certifi	2024.8.30
cffi	1.17.1
charset-normalizer	3.3.2
click	8.1.7
click-plugins	1.1.1
cligj	0.7.2
cloudpathlib	0.20.0
cloudpickle	3.0.0
colorama	0.4.6
comm	0.2.2
commonmark	0.9.1
conda	24.9.1
conda-libmamba-solver	24.7.0
conda-package-handling	2.3.0
conda_package_streaming	0.10.0
confection	0.1.5
contextily	1.6.2
contourpy	1.3.0
cryptography	43.0.1
cycler	0.12.1
cymem	2.0.8
cytoolz	1.0.0
dask	2024.9.1
dask-expr	1.1.15
databricks-sdk	0.33.0
debugpy	1.8.6
decorator	5.1.1
Deprecated	1.2.14
diskcache	5.6.3
distributed	2024.9.1
distro	1.9.0
docker	7.1.0
duckdb	0.10.1
en-core-web-sm	3.7.1
entrypoints	0.4
et_xmlfile	2.0.0
exceptiongroup	1.2.2
executing	2.1.0
fastexcel	0.11.6
fastjsonschema	2.20.0
fiona	1.10.1
Flask	3.0.3
folium	0.17.0
fontawesomefree	6.6.0
fonttools	4.54.1
frozendict	2.4.4
frozenlist	1.4.1
fsspec	2023.12.2
gensim	4.3.2
geographiclib	2.0
geopandas	1.0.1
geoplot	0.5.1
geopy	2.4.1
gitdb	4.0.11
GitPython	3.1.43
google-auth	2.35.0
graphene	3.3
graphql-core	3.2.4
graphql-relay	3.2.0
graphviz	0.20.3
great-tables	0.12.0
greenlet	3.1.1
gunicorn	22.0.0
h2	4.1.0
hpack	4.0.0
htmltools	0.6.0
hyperframe	6.0.1
idna	3.10
imageio	2.36.0
importlib_metadata	8.5.0
importlib_resources	6.4.5
inflate64	1.0.0
ipykernel	6.29.5
ipython	8.28.0
itsdangerous	2.2.0
jedi	0.19.1
Jinja2	3.1.4
jmespath	1.0.1
joblib	1.4.2
jsonpatch	1.33
jsonpointer	3.0.0
jsonschema	4.23.0
jsonschema-specifications	2024.10.1
jupyter-cache	1.0.0
jupyter_client	8.6.3
jupyter_core	5.7.2
kaleido	0.2.1
kiwisolver	1.4.7
langcodes	3.5.0
language_data	1.3.0
lazy_loader	0.4
libmambapy	1.5.9
locket	1.0.0
lxml	5.3.0
lz4	4.3.3
Mako	1.3.5
mamba	1.5.9
mapclassify	2.8.1
marisa-trie	1.2.1
Markdown	3.6
markdown-it-py	3.0.0
MarkupSafe	2.1.5
matplotlib	3.9.2
matplotlib-inline	0.1.7
mdurl	0.1.2
menuinst	2.1.2
mercantile	1.2.1
mizani	0.11.4
mlflow	2.16.2
mlflow-skinny	2.16.2
msgpack	1.1.0
multidict	6.1.0
multivolumefile	0.2.3
munkres	1.1.4
murmurhash	1.0.10
mypy-extensions	1.0.0
narwhals	1.14.1
nbclient	0.10.0
nbformat	5.10.4
nest_asyncio	1.6.0
networkx	3.3
nltk	3.9.1
numpy	1.26.4
opencv-python-headless	4.10.0.84
openpyxl	3.1.5
opentelemetry-api	1.16.0
opentelemetry-sdk	1.16.0
opentelemetry-semantic-conventions	0.37b0
OWSLib	0.28.1
packaging	24.1
pandas	2.2.3
paramiko	3.5.0
parso	0.8.4
partd	1.4.2
pathspec	0.12.1
patsy	0.5.6
Pebble	5.0.7
pexpect	4.9.0
pickleshare	0.7.5
pillow	10.4.0
pip	24.2
platformdirs	4.3.6
plotly	5.24.1
plotnine	0.13.6
pluggy	1.5.0
polars	1.8.2
preshed	3.0.9
prometheus_client	0.21.0
prometheus_flask_exporter	0.23.1
prompt_toolkit	3.0.48
protobuf	4.25.3
psutil	6.0.0
ptyprocess	0.7.0
pure_eval	0.2.3
py7zr	0.20.8
pyarrow	17.0.0
pyarrow-hotfix	0.6
pyasn1	0.6.1
pyasn1_modules	0.4.1
pybcj	1.0.2
pycosat	0.6.6
pycparser	2.22
pycryptodomex	3.21.0
pydantic	2.9.2
pydantic_core	2.23.4
Pygments	2.18.0
PyNaCl	1.5.0
pynsee	0.1.8
pyogrio	0.10.0
pyOpenSSL	24.2.1
pyparsing	3.1.4
pyppmd	1.1.0
pyproj	3.7.0
pyshp	2.3.1
PySocks	1.7.1
python-dateutil	2.9.0
python-dotenv	1.0.1
python-magic	0.4.27
pytz	2024.1
pyu2f	0.1.5
pywaffle	1.1.1
PyYAML	6.0.2
pyzmq	26.2.0
pyzstd	0.16.2
querystring_parser	1.2.4
rasterio	1.4.2
referencing	0.35.1
regex	2024.9.11
requests	2.32.3
requests-cache	1.2.1
retrying	1.3.4
rich	13.9.4
rpds-py	0.21.0
rsa	4.9
ruamel.yaml	0.18.6
ruamel.yaml.clib	0.2.8
s3fs	2023.12.2
s3transfer	0.10.2
scikit-image	0.24.0
scikit-learn	1.5.2
scipy	1.13.0
seaborn	0.13.2
setuptools	74.1.2
shapely	2.0.6
shellingham	1.5.4
six	1.16.0
smart-open	7.0.5
smmap	5.0.0
sortedcontainers	2.4.0
soupsieve	2.5
spacy	3.7.5
spacy-legacy	3.0.12
spacy-loggers	1.0.5
SQLAlchemy	2.0.35
sqlparse	0.5.1
srsly	2.4.8
stack-data	0.6.2
statsmodels	0.14.4
tabulate	0.9.0
tblib	3.0.0
tenacity	9.0.0
texttable	1.7.0
thinc	8.2.5
threadpoolctl	3.5.0
tifffile	2024.9.20
toolz	1.0.0
topojson	1.9
tornado	6.4.1
tqdm	4.66.5
traitlets	5.14.3
truststore	0.9.2
typer	0.13.1
typing_extensions	4.12.2
tzdata	2024.2
Unidecode	1.3.8
url-normalize	1.4.3
urllib3	1.26.20
wasabi	1.1.3
wcwidth	0.2.13
weasel	0.4.1
webdriver-manager	4.0.2
websocket-client	1.8.0
Werkzeug	3.0.4
wheel	0.44.0
wordcloud	1.9.3
wrapt	1.16.0
xgboost	2.1.1
xlrd	2.0.1
xyzservices	2024.9.0
yarl	1.13.1
yellowbrick	1.5
zict	3.0.0
zipp	3.20.2
zstandard	0.23.0

View file history

md`Ce fichier a été modifié __${table_commit.length}__ fois depuis sa création le ${creation_string} (dernière modification le ${last_modification_string})`

creation = d3.min(
  table_commit.map(d => new Date(d.Date))
)

last_modification = d3.max(
  table_commit.map(d => new Date(d.Date))
)

creation_string = creation.toLocaleString("fr", {
  "day": "numeric",
  "month": "long",
  "year": "numeric"
})

last_modification_string = last_modification.toLocaleString("fr", {
  "day": "numeric",
  "month": "long",
  "year": "numeric"
})

html`<div>${git_history_table}</div>`

html`<div>${git_history_plot}</div>`

SHA	Date	Author	Description
c1853b9	2024-11-20 15:09:19	Lino Galiana	Reprise eval + reprise S3 (#576)
ddc423f	2024-11-12 10:26:14	lgaliana	Quarto rendering
cbe6459	2024-11-12 07:24:15	lgaliana	Revoir quelques abstracts
2962738	2024-11-09 09:18:45	Lino Galiana	Commence à reprendre la partie évaluation (#573)
1a8267a	2024-11-07 17:11:44	lgaliana	Finalize chapter and fix problem
4f5d200	2024-08-12 15:17:51	Lino Galiana	Retire les vieux scripts (#540)
06d003a	2024-04-23 10:09:22	Lino Galiana	Continue la restructuration des sous-parties (#492)
005d89b	2023-12-20 17:23:04	Lino Galiana	Finalise l’affichage des statistiques Git (#478)
3fba612	2023-12-17 18:16:42	Lino Galiana	Remove some badges from python (#476)
1684220	2023-12-02 12:06:40	Antoine Palazzolo	Première partie de relecture de fin du cours (#467)
1f23de2	2023-12-01 17:25:36	Lino Galiana	Stockage des images sur S3 (#466)
a06a268	2023-11-23 18:23:28	Antoine Palazzolo	2ème relectures chapitres ML (#457)
b68369d	2023-11-18 18:21:13	Lino Galiana	Reprise du chapitre sur la classification (#455)
fd3c955	2023-11-18 14:22:38	Lino Galiana	Formattage des chapitres scikit (#453)
889a71b	2023-11-10 11:40:51	Antoine Palazzolo	Modification TP 3 (#443)
a771183	2023-10-09 11:27:45	Antoine Palazzolo	Relecture TD2 par Antoine (#418)
9a4e226	2023-08-28 17:11:52	Lino Galiana	Action to check URL still exist (#399)
a8f90c2	2023-08-28 09:26:12	Lino Galiana	Update featured paths (#396)
3bdf3b0	2023-08-25 11:23:02	Lino Galiana	Simplification de la structure 🤓 (#393)
78ea2cb	2023-07-20 20:27:31	Lino Galiana	Change titles levels (#381)
29ff3f5	2023-07-07 14:17:53	linogaliana	description everywhere
f21a24d	2023-07-02 10:58:15	Lino Galiana	Pipeline Quarto & Pages 🚀 (#365)
f5f0f9c	2022-11-02 19:19:07	Lino Galiana	Relecture début partie modélisation KA (#318)
f10815b	2022-08-25 16:00:03	Lino Galiana	Notebooks should now look more beautiful (#260)
494a85a	2022-08-05 14:49:56	Lino Galiana	Images featured ✨ (#252)
d201e3c	2022-08-03 15:50:34	Lino Galiana	Pimp la homepage ✨ (#249)
6264438	2022-06-29 14:53:05	Lino Galiana	Retire typo math (#243)
12965ba	2022-05-25 15:53:27	Lino Galiana	:launch: Bascule vers quarto (#226)
9c71d6e	2022-03-08 10:34:26	Lino Galiana	Plus d’éléments sur S3 (#218)
c3bf4d4	2021-12-06 19:43:26	Lino Galiana	Finalise debug partie ML (#190)
fb14d40	2021-12-06 17:00:52	Lino Galiana	Modifie l’import du script (#187)
37ecfa3	2021-12-06 14:48:05	Lino Galiana	Essaye nom différent (#186)
2c8fd0d	2021-12-06 13:06:36	Lino Galiana	Problème d’exécution du script import data ML (#185)
5d0a5e3	2021-12-04 07:41:43	Lino Galiana	MAJ URL script recup data (#184)
5c10490	2021-12-03 17:44:08	Lino Galiana	Relec @antuki partie modelisation (#183)
2a8809f	2021-10-27 12:05:34	Lino Galiana	Simplification des hooks pour gagner en flexibilité et clarté (#166)
2e4d586	2021-09-02 12:03:39	Lino Galiana	Simplify badges generation (#130)
80877d2	2021-06-28 11:34:24	Lino Galiana	Ajout d’un exercice de NLP à partir openfood database (#98)
4cdb759	2021-05-12 10:37:23	Lino Galiana	:sparkles: :star2: Nouveau thème hugo :snake: :fire: (#105)
7f9f97b	2021-04-30 21:44:04	Lino Galiana	🐳 + 🐍 New workflow (docker 🐳) and new dataset for modelization (2020 🇺🇸 elections) (#99)
671f75a	2020-10-21 15:15:24	Lino Galiana	Introduction au Machine Learning (#72)

git_history_table = Inputs.table(
  table_commit,
  {
    format: {
      SHA: x => md`[${x}](${github_repo}/commit/${x})`,
      Description: x => md`${replacePullRequestPattern(x, github_repo)}`,
      /*Date: x => x.toLocaleString("fr", {
        "month": "numeric",
        "day": "numeric",
        "year": "numeric"
        })
      */
    }
  }
)

git_history_plot = Plot.plot({
  marks: [
    Plot.ruleY([0], {stroke: "royalblue"}),
    Plot.dot(
          table_commit,
          Plot.pointerX({x: (d) => new Date(d.date), y: 0, stroke: "red"})),
    Plot.dot(table_commit, {x: (d) => new Date(d.Date), y: 0, fill: "royalblue"})
  ]
})

function replacePullRequestPattern(inputString, githubRepo) {
    // Use a regular expression to match the pattern #digit
    var pattern = /#(\d+)/g;

    // Replace the pattern with ${github_repo}/pull/#digit
    var replacedString = inputString.replace(pattern, '[#$1](' + githubRepo + '/pull/$1)');

    return replacedString;
}

github_repo = "https://github.com/linogaliana/python-datascientist"

table_commit = {

// Get the HTML table by its class name
var table = document.querySelector('.commit-table');

// Check if the table exists
if (table) {
    // Initialize an array to store the table data
    var dataArray = [];

    // Extract headers from the first row
    var headers = [];
    for (var i = 0; i < table.rows[0].cells.length; i++) {
        headers.push(table.rows[0].cells[i].textContent.trim());
    }

    // Iterate through the rows, starting from the second row
    for (var i = 1; i < table.rows.length; i++) {
        var row = table.rows[i];
        var rowData = {};

        // Iterate through the cells in the row
        for (var j = 0; j < row.cells.length; j++) {
            // Use headers as keys and cell content as values
            rowData[headers[j]] = row.cells[j].textContent.trim();
        }

        // Push the rowData object to the dataArray
        dataArray.push(rowData);
    }
  }

  return dataArray

}

// Get the element with class 'git-details'
{
  var gitDetails = document.querySelector('.commit-table');

  // Check if the element exists
  if (gitDetails) {
      // Hide the element
      gitDetails.style.display = 'none';
  }
}

Plot = require('@observablehq/plot@0.6.12/dist/plot.umd.min.js')