Emballer des modèles de Machine Learning

Développer des modèles de Machine Learning pour la production

Sinan Ozdemir

Data Scientist, Entrepreneur, and Author

Pourquoi l'emballage est important

Optimiser les performances
Assurer la compatibilité
Faciliter le déploiement des modèles

Méthodes d'emballage

Sérialisation : simple, légère et indépendante du langage
Emballage d'environnement : capture l'ensemble de l'environnement logiciel
Conteneurisation : environnement portable, reproductible et isolé

Comment emballer des modèles de Machine Learning

Sérialisation : stocker et recharger un modèle de Machine Learning
Emballage d'environnement : environnement cohérent et reproductible pour le modèle
Conteneurisation : regrouper le modèle, ses dépendances et l'environnement dans un seul « conteneur »

Sérialiser des modèles scikit-learn

Sérialiser un modèle sklearn avec pickle :

import pickle

model = ...  # Train the scikit-learn model

# Serialize the model to a file
with open('model.pkl', 'wb') as f:
    pickle.dump(model, f)

# Load the serialized model from the file
with open('model.pkl', 'rb') as f:
    model = pickle.load(f)

Sérialiser un modèle sklearn au format HDF5 :

import h5py
import numpy as np
from sklearn.externals import joblib

model = ...  # Train the scikit-learn model

# Serialize the model to an HDF5 file
with h5py.File('model.h5', 'w') as f:
    f.create_dataset('model_weights',
    data=joblib.dump(model))

# Load the serialized model from the HDF5 file
with h5py.File('model.h5', 'r') as f:
    model = joblib.load(f['model_weights'][:])

Sérialiser des modèles PyTorch et Tensorflow

Sérialiser un modèle PyTorch :

import torch

# Train a PyTorch model and store it in a variable
trained_model = ...

# Serialize the trained model to a file
serialized_model_path = 'model.pt'
torch.save(trained_model.state_dict(), serialized_model_path)

# Load the serialized model from a file
loaded_model = ... # Initialize the model
loaded_model.load_state_dict(
    torch.load(serialized_model_path))

Sérialiser un modèle Tensorflow :

import tensorflow as tf

# Train a Tensorflow model
trained_model = ...

# Save the trained model to a directory 
saved_model_directory = 'model/'
tf.saved_model.save
    (trained_model, saved_model_directory)

# Load the saved model from the directory 
loaded_model = tf.saved_model.load(
    saved_model_directory)

Emballer l'environnement ML avec Docker

Garantir que l'environnement du modèle lui permet de s'exécuter
virtualenv, etc. créent des environnements cohérents et reproductibles
Les conteneurs Docker sont autonomes et faciles à déployer

docker

Exemple de Dockerfile

# Use an existing image as the base image
FROM python:3.8-slim

# Set the working directory
WORKDIR /app

# Copy the requirements file to the image
COPY requirements.txt .

# Install the required dependencies
RUN pip install -r requirements.txt

# Copy the ML model and its dependencies to the image
COPY model/ .

# Set the entrypoint to run the model
ENTRYPOINT ["python", "run_model.py"]


<---- Utiliser l'image de base Python 3.8


<---- Définir le répertoire de travail


<---- Copier le fichier requirements.txt


<---- Installer les dépendances du modèle


<---- Copier le modèle dans le conteneur


<---- Indiquer comment démarrer le conteneur

Expérience → workflow Docker

Sérialiser le modèle entraîné avec un format comme pickle, HDF5 ou PyTorch.
Conteneuriser le modèle sérialisé, ses dépendances et l'environnement
Déployer l'image Docker vers une cible (p. ex. une plateforme cloud)
Exécuter le conteneur Docker à partir de l'image déployée et lancer le modèle
Utiliser le modèle dans le conteneur via une API ou un autre point d'accès

Flux Docker

Passons à la pratique !

Développer des modèles de Machine Learning pour la production