API de sciki-learn et modèles customisés#

Links: notebook, html, PDF, python, slides, GitHub

scikit-learn est devenu le module incontournable quand il s’agit de machine learning. Cela tient en partie à son API épurée qui permet à quiconque d’implémenter ses propres modèles tout permettant à scikit-learn de les manipuler comme s’il s’agissait des siens.

from jyquickhelper import add_notebook_menu
add_notebook_menu(last_level=3)

Cette présentation détaille l’API de scikit-learn, aborde la mise en production avec pickle, montre un exemple d’implémentation d’un modèle customisé appliqué à la sélection d’arbres dans une forêt aléatoire.

import matplotlib.pyplot as plt
from jupytalk.pres_helper import show_images

Design et API #

On peut penser que deux implémentations du même algorithme se valent à partir du moment où elles produisent les mêmes résultats. Voici deux chaises, vers laquelle votre instinct vous poussera-t-il ?

show_images("zigzag.jpg", "chaise.jpg", figsize=(14, 4), title2="Le Corbusier");

Quatre ou cinq librairies ont fait le succès de Python #

numpy: calcul matriciel - existait avant Python (matlab, R, …)
pandas: manipulation de données - existait avant Python (R, …)
matplotlib: graphes - existait avant Python - (matlab, R…)
scikit-learn: machine learning - innovation : design
jupyter: notebooks - innovation : mélange interactif code, texte, images

show_images("trends.png", title1="Google Trendss Python / Matlab");

Machine learning résumé #

Modèle de machine learning = résultat d’une optimisation
Cette optimisation dépend de paramètres (dimension, pas du gradient, …)
Optimisation = apprentissage
On s’en sert pour faire de la prédiction.

Ce que les codeurs imaginent #

Des designs souvent très jolis mais à usage unique.

show_images("coop.jpg", "coop2.jpg", title1="Coop Himeblau", title2="Rooftop", figsize=(16,8));

Vues incompatibles #

Les chercheurs aiment l’innonvation, cherchent de nouveaux modèles.
Les datascientist assemblent des modèles existants.
L’estimation d’un modèle arrivent à la toute fin.

On retient facilement ce qui est court et qui se répète.

Vocabulaire scikit-learn #

Predictor : modèle de machine learning qu’on apprend (fit) et qui prédit (predict)
Transformer : prétraitement de données qui précède un prédicteur, qu’on apprend (fit) et qui transforme les données (transform)

Utilisation de classes : predictor #

::

class Predictor:

def __init__(self, **kwargs):: # kwargs sont les paramètres d’apprentissage
def fit(self, X, y):: # apprentissage return self
def predict(self, X):: # prédiction

Utilisation de classes : transformer #

::

class Transformer:

def __init__(self, **kwargs):: # kwargs sont les paramètres d’apprentissage
def fit(self, X, y):: # apprentissage return self
def transform(self, X):: # prédiction

pipeline (sandwitch en français)#

Normalisation + ACP + Régression Logistique

Classe	Step 1	Step 2	Step 3	Step 4
Normalizer	`fit(X)`	`X2=transf orm(X)`	`X2=transf orm(X)`	`X2=transf orm(X)`
PCA	.	`fit(X2)`	`X3=transf orm(X2)`	`X3=transf orm(X2)`
LogisticReg ression	.	.	``fit(X3,y) ``	`X4=predic t(X3)`

En langage Python #

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import Normalizer
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression

pipe = Pipeline([
    ('norm', Normalizer()),
    ('pca', PCA()),
    ('lr', LogisticRegression())
])

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
data = load_iris()
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y)
pipe.fit(X_train, y_train)

Pipeline(steps=[('norm', Normalizer()), ('pca', PCA()),
                ('lr', LogisticRegression())])

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

prediction = pipe.predict(X_test)
prediction[:5]

array([0, 2, 0, 2, 2])

pipe.score(X_test, y_test)

0.6578947368421053

Raffinement #

show_images("church-of-light-1024x614.jpg", title1="Tadao Ando", figsize=(10, 6));

Un design commun aux régresseurs et classifieurs #

Les régresseurs sont les plus simples, ils modèlisent une fonction $f(X \in \mathbb{R}^d) \rightarrow \mathbb{R}$ .
Les classifieurs modélisent une fonction $f(X \in \mathbb{R}^d) \rightarrow \mathbb{N}$

Mais

Les classifieurs sont liés à la notion de distance par rapport à la frontière, distance qu’on relie ensuite à une probabilité mais pas toujours.

show_images('logreg.png');

Besoin d’un classifieur #

::

class Classifier:

def __init__(self, **kwargs):: # kwargs sont les paramètres d’apprentissage
def fit(self, X, y):: # apprentissage return self
def decision_function(self, X):: # distances
def predict_proba(self, X):: # distances –> proba
def predict(self, X):: # classes

Besoin d’un régresseur par mimétisme #

::

class Classifier:

def __init__(self, **kwargs):: # kwargs sont les paramètres d’apprentissage
def fit(self, X, y):: # apprentissage return self
def decision_function(self, X):: # une ou plusieurs régressions
def predict(self, X):: # moyennes

Paramètres et résultats d’apprentissage #

Tout attribut terminé par _ est un résultat d’apprentissage.
A l’opposé, tout ce qui ne se termine pas par _ est connu avant l’apprentissage

show_images("lasso.png");

Problèmes standards - moule commun #

show_images('sklearn_base.png');

Analyser ou prédire #

Certains modèles ne peuvent pas prédire, simplement analyser. C’est le cas du SpectralClustering.

::

class NoPredictionButAnalysis:

def __init__(self, **kwargs):: # kwargs sont les paramètres d’apprentissage
def fit_predict(self, X, y=None):: # apprentissage et prédiction return self

Limites du concept #

Et si on veut réutiliser les sorties d’un prédicteur pour en faire autre chose ?

VotingClassifier

A suivre… dans la dernière partie.

Le design, c’est le design, le code, c’est de la bidouille.

pickle #

Un modèle c’est :

une classe, un pipeline, une liste de traitements définis avant apprentissage
des coefficients obtenus après apprentissage

Comment conserver le résultat ? –> pickle

Cas des dataframes #

from pandas import DataFrame, read_csv
df = DataFrame(X)
df['label'] = y
df.head()

	0	1	2	3
0	5.1	3.5	1.4	0.2
1	4.9	3.0	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5.0	3.6	1.4	0.2

df.to_csv("data_iris.csv")

%timeit read_csv("data_iris.csv")

1.77 ms ± 117 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

import pickle

with open("data_iris.pickle", "wb") as f:
    pickle.dump(df, f)

def load_from_pickle(name):
    with open(name, "rb") as f:
        return pickle.load(f)

%timeit load_from_pickle("data_iris.pickle")

264 µs ± 18.2 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

pickle est plus rapide #

read_csv : convertit un fichier texte en dataframe –> format intermédiaire csv
pickle : conserve des données comme elles sont stockées en mémoire –> pas de conversion

from jyquickhelper import RenderJsDot
RenderJsDot('''digraph{ rankdir="LR";
    B [label="mémoire"]; C [label="csv"]; C2 [label="csv"];
    D [label="disque"]; B -> C [label="to_csv", color="red"];
    C -> D ; D -> C2 ;
    C2 -> B [label="read_csv", color="red"];
    B -> D [label="pickle.dump", color="blue"];
    D -> B [label="pickle.load", color="blue"];
}''')

scikit-learn, pickle #

unique moyen de conserver les modèles

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

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

from numpy.testing import assert_almost_equal
assert_almost_equal(pipe.predict(X_test), pipe2.predict(X_test))

Problème avec pickle #

L’état de la mémoire dépend très fortement des librairies installées
Changer de version scikit-learn –> l’état de la mémoire est différente
Analogie : pickle ne conserve que les coefficients en mémoire, ils sont cryptés en quelque sorte.
On ne peut les décrypter qu’avec le même code.

Dissocier les colonnes #

Toutes les colonnes subissent le même traitement.

pipe = Pipeline([
    ('norm', Normalizer()),
    ('pca', PCA()),
    ('lr', LogisticRegression())
])

Mais ce n’est pas forcément ce que l’on veut.

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import MinMaxScaler

pipe2 = Pipeline([
    ('multi', ColumnTransformer([
        ('c01', Normalizer(), [0, 1]),
        ('c23', MinMaxScaler(), [2, 3]),
    ])),
    ('pca', PCA()),
    ('lr', LogisticRegression())
])

pipe2.fit(X_train, y_train);

from mlinsights.plotting import pipeline2dot
RenderJsDot(pipeline2dot(pipe2, X_train))

Conclusion #

L’API est une sorte de légo. Tout marche si on respecte les dimensions de départ.

show_images('lego.png', 'lego-architecture-studio-8804.jpg', figsize=(16,6));

show_images('vue-interieure-cite-de-musique-christian-de.jpg', 'PaulPoiret-7.jpg', figsize=(16,6));

show_images('lycee_chanzy_maquette.jpg', figsize=(16,10));

Links

Contents

Information

Previous topic

Next topic

API de sciki-learn et modèles customisés#

Design et API #

Quatre ou cinq librairies ont fait le succès de Python #

Machine learning résumé #

Ce que les codeurs imaginent #

Vues incompatibles #

Vocabulaire scikit-learn #

Utilisation de classes : predictor #

Utilisation de classes : transformer #

pipeline (sandwitch en français)#

En langage Python #

Raffinement #

Un design commun aux régresseurs et classifieurs #

Besoin d’un classifieur #

Besoin d’un régresseur par mimétisme #

Paramètres et résultats d’apprentissage #

Problèmes standards - moule commun #

Analyser ou prédire #

Limites du concept #

pickle #

Cas des dataframes #

pickle est plus rapide #

scikit-learn, pickle #

Problème avec pickle #

Dissocier les colonnes #

Concepts appliqués à un nouveau régresseur #

Sketch de l’algorithme #

Ce que l’on veut #

Implémentation #

Résultats #

Critère AIC #

pickling #

Conclusion #

	0	1	2	3
0	5.1	3.5	1.4	0.2
1	4.9	3.0	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5.0	3.6	1.4	0.2

	0	1	2	3
0	5.1	3.5	1.4	0.2
1	4.9	3.0	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5.0	3.6	1.4	0.2

	0	1	2	3
0	5.1	3.5	1.4	0.2
1	4.9	3.0	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5.0	3.6	1.4	0.2