Impacchettare modelli ML

Sviluppare modelli di Machine Learning per la produzione

Sinan Ozdemir

Data Scientist, Entrepreneur, and Author

Perché il packaging è importante

Ottimizza le prestazioni
Garantisce compatibilità
Rende i modelli più facili da distribuire

Metodi di packaging

Serializzazione: semplice, leggera e linguaggio-agnostica
Packaging dell'ambiente: cattura l'intero ambiente software
Containerizzazione: ambiente portabile, riproducibile e isolato

Come impacchettare modelli ML

Serializzazione: salvataggio e caricamento di un modello ML
Packaging dell'ambiente: ambiente coerente e riproducibile per il modello ML
Containerizzazione: pacchetta modello, dipendenze e ambiente in un singolo "container"

Serializzare modelli scikit-learn

Serializzare un modello sklearn con 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)

Serializzare un modello sklearn in formato 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'][:])

Serializzare modelli PyTorch e Tensorflow

Serializzare un modello 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))

Serializzare un modello 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)

Impacchettare ambienti ML con Docker

Assicura che l'ambiente permetta l'esecuzione del modello
virtualenv ecc. creano ambienti coerenti e riproducibili
I container Docker sono unità autonome, facili da distribuire

docker

Esempio di 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"]


<---- Usa l'immagine base Python 3.8


<---- Imposta la working directory


<---- Copia il file requirements.txt


<---- Installa le dipendenze del modello


<---- Copia il modello nel container


<---- Indica come avviare il container

Esperimento -> workflow Docker

Serializza il modello ML addestrato con formati come pickle, HDF5 o PyTorch.
Containerizza il modello serializzato, le dipendenze e l'ambiente
Distribuisci l'immagine Docker in un ambiente target (es. cloud)
Esegui il container dall'immagine distribuita e avvia il modello ML
Usa il modello nel container via API o altro punto di accesso

Flusso Docker

Passons à la pratique !

Sviluppare modelli di Machine Learning per la produzione