Come salvare un modello addestrato in Python

Salvataggio modello addestrato in Python.

Quando si lavora su casi d’uso di machine learning (ML) reali, trovare l’algoritmo/modello migliore non è la fine delle tue responsabilità. È fondamentale salvare, archiviare e impacchettare questi modelli per il loro futuro utilizzo e distribuzione in produzione.

Queste pratiche sono necessarie per diverse ragioni:

  • Backup: Un modello addestrato può essere salvato come backup nel caso in cui i dati originali vengano danneggiati o distrutti. 
  • Riusabilità e riproducibilità: La costruzione di modelli di ML richiede molto tempo. Per risparmiare costi e tempo, diventa essenziale che il tuo modello ti dia gli stessi risultati ogni volta che lo esegui. Il modo corretto di salvare e archiviare il tuo modello si occupa di questo.
  • Distribuzione: Quando si distribuisce un modello addestrato in un ambiente reale, diventa necessario impacchettarlo per una distribuzione facile. Ciò consente ad altri sistemi e applicazioni di utilizzare lo stesso modello senza troppi problemi.

Per ribadire, mentre il salvataggio e l’archiviazione dei modelli di ML consentono una facile condivisione, riutilizzabilità e riproducibilità; l’impacchettamento dei modelli consente una distribuzione rapida e indolore. Queste 3 operazioni lavorano in armonia per semplificare l’intero processo di gestione del modello. 

In questo articolo, imparerai i diversi metodi per salvare, archiviare e impacchettare un modello di machine learning addestrato, insieme ai pro e contro di ciascun metodo. Ma prima di tutto, devi capire la distinzione tra questi tre termini. 

Salva vs impacchetta vs archivia i modelli di ML

Anche se tutti questi termini sembrano simili, non sono la stessa cosa. 

Salva vs Archivia vs Impacchetta i modelli di ML | Fonte: Autore

Salvare un modello si riferisce al processo di salvare i parametri del modello, i pesi, ecc., in un file. Di solito, tutti i modelli di ML e DL forniscono qualche tipo di metodo (ad es. model.save()) per salvare i modelli. Ma devi essere consapevole che il salvataggio è un’azione singola e fornisce solo un file binario del modello, quindi hai ancora bisogno di codice per rendere la tua applicazione di ML pronta per la produzione.

Impacchettare, d’altra parte, si riferisce al processo di raggruppare o contenere i componenti necessari di un modello, come il file del modello, le dipendenze, i file di configurazione, ecc., in un unico pacchetto distribuibile. L’obiettivo di un pacchetto è rendere più facile la distribuzione e la distribuzione del modello di ML in un ambiente di produzione. 

Una volta impacchettato, un modello può essere distribuito su diversi ambienti, il che consente al modello di essere utilizzato in vari contesti di produzione come applicazioni web, applicazioni mobili, ecc. Docker è uno degli strumenti che ti consente di farlo.

Archiviare il modello di ML si riferisce al processo di salvare i file del modello addestrato in un archivio centralizzato a cui è possibile accedere in qualsiasi momento quando necessario. Quando si archivia un modello, si sceglie normalmente un tipo di archiviazione da cui è possibile recuperare il modello e utilizzarlo in qualsiasi momento. Il registro dei modelli è una categoria di strumenti che risolve questo problema per te.

Ora vediamo come possiamo salvare il nostro modello.

Come salvare un modello addestrato in Python?

In questa sezione, vedrai diversi modi per salvare modelli di machine learning (ML) e deep learning (DL). Per iniziare, creiamo un semplice modello di classificazione utilizzando il famoso dataset Iris. 

Nota: Il focus di questo articolo non è mostrarti come creare il miglior modello di ML, ma spiegare quanto efficacemente puoi salvare modelli addestrati. 

Prima di tutto, è necessario caricare le dipendenze necessarie e il dataset iris come segue:

# carica le dipendenze
import pandas as pd 

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler 
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report, confusion_matrix

# carica il dataset
url = "iris.data"

# nomi delle colonne da utilizzare
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

# leggi il dataset dall'URL
dataset = pd.read_csv(url, names=names) 

# controlla le prime righe dei dati di classificazione iris
dataset.head()

Successivamente, è necessario suddividere i dati in set di addestramento e di test e applicare le fasi di preprocessing necessarie, come la standardizzazione delle caratteristiche. 

# separa le caratteristiche indipendenti e dipendenti
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values 

# Dividi il dataset in sottoinsiemi di allenamento e di test casuali
X_train, X_test, y_train, y_test = train_test_split(X, 
                                                    y, test_size=0.20) 
# standardizzazione delle caratteristiche
scaler = StandardScaler()
scaler.fit(X_train)

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test) 

Infine, è necessario allenare un modello di classificazione (scegli pure quale) sui dati di allenamento e verificare le sue prestazioni sui dati di test. 

# allenamento di un classificatore KNN
modello = KNeighborsClassifier(n_neighbors=5)
modello.fit(X_train, y_train) 

# fare previsioni sui dati di test
y_predetto = modello.predict(X_test)

# verifica i risultati
print(confusion_matrix(y_test, y_predetto))
print(classification_report(y_test, y_predetto)) 

Risultati della classificazione dell’Iris | Fonte: Autore

Ora hai un modello di apprendimento automatico che desideri salvare per un uso futuro. Il primo modo per salvare un modello di apprendimento automatico è utilizzare il file pickle. 

Salvataggio del modello addestrato con pickle

Il modulo pickle può essere utilizzato per serializzare e deserializzare gli oggetti Python. Pickling è il processo di conversione di una gerarchia di oggetti Python in uno stream di byte, mentre Unpickling è il processo di conversione di uno stream di byte (da un file binario o da altri oggetti che sembrano fatti di byte) in una gerarchia di oggetti.

Per salvare i modelli di apprendimento automatico utilizzati come file pickle, è necessario utilizzare il modulo Pickle che è già incluso nell’installazione predefinita di Python. 

Per salvare il tuo modello di classificazione iris devi semplicemente decidere un nome di file e salvare il tuo modello in un file pickle in questo modo:

import pickle

# salva il modello di classificazione dell'iris come file pickle
file_modello_pkl = "modello_classificazione_iris.pkl"  

with open(file_modello_pkl, 'wb') as file:  
    pickle.dump(modello, file)

Come puoi vedere, il file viene aperto in modalità wb (scrittura binaria) per salvare il modello come byte. Inoltre, il metodo dump() memorizza il modello nel file pickle indicato. 

Puoi anche caricare questo modello utilizzando il metodo load() del modulo pickle. Ora devi aprire il file in modalità rb (lettura binaria) per caricare il modello salvato.

# carica il modello dal file pickle
with open(file_modello_pkl, 'rb') as file:  
    modello = pickle.load(file)

# valuta il modello 
y_predetto = modello.predict(X_test)

# verifica i risultati
print(classification_report(y_test, y_predetto)) 

Una volta caricato, puoi utilizzare questo modello per fare previsioni. 

Risultato della classificazione dell’Iris | Fonte: Autore

Vantaggi dell’approccio pickle in Python 

  • 1
    Il pickling è un modulo standard in Python, il che lo rende facile da usare per salvare e ripristinare modelli di apprendimento automatico.
  • 2
    I file pickle possono gestire la maggior parte degli oggetti Python, inclusi gli oggetti personalizzati, rendendolo un modo versatile per salvare i modelli.
  • 3
    Per modelli di piccole dimensioni, l’approccio pickle è abbastanza veloce ed efficiente. 
  • 4
    Quando un modello di apprendimento automatico viene disimballato, viene ripristinato al suo stato precedente, incluso qualsiasi variabile o configurazione. Ciò rende i file pickle di Python una delle migliori alternative per il salvataggio di modelli di apprendimento automatico. 

Svantaggi dell’approccio pickle in Python

  • 1
    Se si disimballano dati non affidabili, pickling potrebbe rappresentare una minaccia per la sicurezza. La disimballatura di un oggetto può eseguire del codice dannoso, quindi è fondamentale disimballare solo informazioni da fonti affidabili.
  • 2
    L’uso degli oggetti pickled potrebbe essere limitato in alcune circostanze poiché non possono essere trasferiti tra diverse versioni di Python o sistemi operativi.
  • 3
    Per modelli con una grande quantità di memoria, il pickling può comportare la creazione di file enormi, il che può essere problematico.
  • 4
    Il pickling può rendere difficile tenere traccia delle modifiche apportate a un modello nel tempo, specialmente se il modello viene aggiornato frequentemente e non è fattibile creare più file pickle per diverse versioni di modelli che si provano. 

Pickle è più adatto per modelli di piccole dimensioni e ha anche alcuni problemi di sicurezza, queste ragioni sono sufficienti per cercare un’alternativa per salvare i modelli di apprendimento automatico. Successivamente, discuteremo Joblib per salvare e caricare modelli di apprendimento automatico.

Nota: Nelle sezioni successive vedrai lo stesso modello di classificazione iris salvato utilizzando diverse tecniche.

Salvataggio del modello addestrato con Joblib

Joblib è un insieme di strumenti (tipicamente parte dell’ecosistema Scipy) che forniscono pipelining leggero in Python. Si concentra principalmente sulla memorizzazione su disco, memoizzazione e calcolo parallelo ed è utilizzato per salvare e caricare oggetti Python. Joblib è stato specificamente ottimizzato per gli array NumPy per renderlo veloce e affidabile per i modelli di apprendimento automatico che hanno molti parametri.

Per salvare modelli di grandi dimensioni con Joblib, è necessario utilizzare il modulo Python Joblib che viene preinstallato con Python.

import joblib 

# salvataggio del modello con joblib 
nome_file = 'modello_joblib.sav'
joblib.dump(model, nome_file)

Per salvare il modello, è necessario definire un nome file con estensione ‘.sav’ o ‘.pkl’ e chiamare il metodo dump() di Joblib.

Come pickle, Joblib fornisce il metodo load() per caricare il modello di apprendimento automatico salvato.

# caricamento del modello con joblib
modello_caricato = joblib.load(nome_file)

# valutazione del modello 
y_predetto = model.predict(X_test)

# verifica dei risultati
print(classification_report(y_test, y_predetto)) 

Dopo aver caricato il modello con Joblib, sei libero di utilizzarlo sui dati per fare previsioni.

Risultati della classificazione dell’iris | Fonte: Autore

Vantaggi del salvataggio dei modelli di apprendimento automatico con Joblib

  • 1
    Le prestazioni veloci ed efficaci sono un componente chiave di Joblib, specialmente per modelli con requisiti di memoria sostanziali.
  • 2
    Il processo di serializzazione e deserializzazione può essere parallelizzato tramite Joblib, il che può migliorare le prestazioni su macchine multicore.
  • 3
    Per i modelli che richiedono molta memoria, Joblib utilizza un formato di file con mappa di memoria per ridurre l’utilizzo della memoria.
  • 4
    Joblib offre varie funzionalità di sicurezza, come un elenco bianco di funzioni sicure che possono essere utilizzate durante la deserializzazione, per aiutare a proteggere contro dati non affidabili.

Svantaggi del salvataggio dei modelli di apprendimento automatico con Joblib

  • 1
    Joblib è ottimizzato per gli array NumPy e potrebbe non funzionare altrettanto bene con altri tipi di oggetti.
  • 2
    Joblib offre meno flessibilità rispetto a Pickle perché ci sono meno opzioni disponibili per configurare il processo di serializzazione.
  • 3
    Rispetto a Pickle, Joblib è meno conosciuto, il che può rendere più difficile trovare aiuto e documentazione al riguardo.

Anche se Joblib risolve i principali problemi incontrati da pickle, ha alcuni problemi propri. Successivamente, vedrai come puoi salvare e ripristinare manualmente i modelli utilizzando JSON.

Salvataggio del modello addestrato con JSON

Quando si desidera avere il pieno controllo sulla procedura di salvataggio e ripristino del proprio modello di apprendimento automatico, entra in gioco JSON. A differenza degli altri due metodi, questo metodo non salva direttamente il modello di apprendimento automatico su un file; invece, è necessario definire esplicitamente i diversi parametri del modello per salvarli.

Per utilizzare questo metodo, è necessario utilizzare il modulo Python json che viene fornito con l’installazione predefinita di Python. Utilizzare il metodo JSON richiede uno sforzo aggiuntivo per scrivere tutti i parametri che un modello di apprendimento automatico contiene. Per salvare il modello utilizzando JSON, creiamo una funzione come questa:

import json 

# creazione della funzione di salvataggio json
def salva_json(modello, percorso_file, X_train, y_train): 
    modello_salvato = {}
    modello_salvato["algoritmo"] = model.get_params()['algoritmo'],
    modello_salvato["max_iter"] = model.get_params()['leaf_size'],
    modello_salvato["solver"] = model.get_params()['metric'],
    modello_salvato["metric_params"] = model.get_params()['metric_params'],
    modello_salvato["n_jobs"] = model.get_params()['n_jobs'],
    modello_salvato["n_neighbors"] = model.get_params()['n_neighbors'],
    modello_salvato["p"] = model.get_params()['p'],
    modello_salvato["weights"] = model.get_params()['weights'],
    modello_salvato["X_train"] = X_train.tolist() if X_train is not None else "None",
    modello_salvato["y_train"] = y_train.tolist() if y_train is not None else "None"
    
    testo_json = json.dumps(modello_salvato, indent=4)
    with open(percorso_file, "w") as file: 
        file.write(testo_json)

# salvataggio del modello di classificazione dell'iris in un file json
percorso_file = 'modello_json.json'
salva_json(modello, percorso_file, X_train, y_train)

Vedi come è necessario definire ciascun parametro del modello e i dati da memorizzare in JSON. I diversi modelli hanno metodi diversi per esaminare i dettagli dei parametri. Ad esempio, il metodo get_params() per KNeighboursClassifier restituisce l’elenco di tutti gli iperparametri nel modello. È necessario salvare tutti questi iperparametri e i valori dei dati in un dizionario che viene quindi salvato in un file con estensione ‘.json’.

Per leggere questo file JSON è sufficiente aprirlo e accedere ai parametri come segue:

# crea la funzione di caricamento json
def load_json(filepath):
    with open(filepath, "r") as file:
        saved_model = json.load(file)

    return saved_model

# carica le configurazioni del modello
saved_model = load_json('json_model.json')
saved_model

Nel codice sopra, viene creata una funzione load_json() che apre il file JSON in modalità di lettura e restituisce tutti i parametri e i dati come dizionario.

Modello caricato da JSON | Fonte: Autore

Sfortunatamente, non è possibile utilizzare direttamente il modello salvato con JSON, è necessario leggere questi parametri e dati per addestrare nuovamente il modello da soli.

Vantaggi del salvataggio dei modelli di apprendimento automatico con JSON

  • 1
    I modelli che devono essere scambiati tra vari sistemi possono essere fatti utilizzando JSON, che è un formato portatile che può essere letto da una vasta gamma di linguaggi di programmazione e piattaforme.
  • 2
    JSON è un formato basato su testo che è facile da leggere e capire, rendendolo una buona scelta per i modelli che devono essere ispezionati o modificati dagli esseri umani.
  • 3
    Rispetto a Pickle o Joblib, JSON è un formato leggero che crea file più piccoli, il che può essere cruciale per i modelli che devono essere trasferiti su Internet.
  • 4
    A differenza di pickle, che esegue il codice durante la deserializzazione, JSON è un formato sicuro che riduce al minimo le minacce alla sicurezza.

Svantaggi del salvataggio dei modelli di apprendimento automatico con JSON

  • 1
    Poiché JSON supporta solo un numero limitato di tipi di dati, potrebbe non essere compatibile con modelli di apprendimento automatico sofisticati che utilizzano tipi di dati unici.
  • 2
    In particolare, per modelli di grandi dimensioni, la serializzazione e deserializzazione JSON possono essere più lente rispetto ad altri formati.
  • 3
    Rispetto ai formati alternativi, JSON offre meno flessibilità e potrebbe richiedere più sforzo per adattare la procedura di serializzazione.
  • 4
    JSON è un formato di perdita che potrebbe non preservare tutte le informazioni nel modello originale, il che può essere un problema per i modelli che richiedono una replicazione esatta.

Per garantire la sicurezza e i vantaggi di JSON/pickle, è possibile salvare il modello in un database dedicato. Successivamente, vedrai come salvare un modello di apprendimento automatico in un database.

Salvataggio di un modello di apprendimento profondo con TensorFlow Keras

TensorFlow è un framework popolare per l’addestramento di modelli basati su DL, e Keras è un wrapper per TensorFlow. Viene utilizzato un design di rete neurale con numerosi strati e un insieme di dati etichettati per addestrare modelli di apprendimento profondo. Questi modelli hanno due componenti principali, pesi e architettura della rete, che è necessario salvare per ripristinarli per utilizzi futuri. Di solito ci sono due modi per salvare modelli di apprendimento profondo:

  1. Salva l’architettura del modello in un file JSON o YAML e i pesi in un file HDF5.
  2. Salva sia il modello che l’architettura in un file HDF5, protobuf o tflite.

Puoi fare riferimento a uno qualsiasi di questi metodi, ma il metodo più utilizzato è quello di salvare i pesi del modello e l’architettura insieme in un file HDF5.

Per salvare un modello di apprendimento profondo in TensorFlow Keras, puoi utilizzare il metodo save() dell’oggetto Keras Model. Questo metodo salva l’intero modello, inclusa l’architettura del modello, l’ottimizzatore e i pesi, in un formato che può essere caricato in seguito per fare previsioni.

Ecco un esempio di codice che mostra come salvare un modello DL basato su TensorFlow Keras:

# importa le dipendenze di TensorFlow
from tensorflow.keras.models import Sequential, model_from_json
from tensorflow.keras.layers import Dense

# definisci l'architettura del modello
model = Sequential()
model.add(Dense(12, input_dim=4, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# Compila il modello
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# Addestra il modello
model.fit(X_train, y_train, epochs=150, batch_size=10, verbose=0)

# salva il modello e la sua architettura
model.save('modello.h5')

Ecco qua, devi solo definire l’architettura del modello, allenare i modelli con le impostazioni appropriate e infine salvarlo usando il metodo save().

Caricare i modelli salvati con Keras è semplice come leggere un file in Python. Devi solo chiamare il metodo load_model() fornendo il percorso del file del modello e il tuo modello verrà caricato.

# definire la dipendenza 
from tensorflow.keras.models import load_model

# caricare il modello 
model = load_model('model.h5')

# controllare le informazioni del modello 
model.summary()

Il tuo modello è ora caricato e pronto per l’uso.

Modello Tensorflow caricato | Fonte: Autore

Vantaggi del salvataggio dei modelli con TensorFlow Keras

  • 1
    Salvare e caricare modelli con TensorFlow Keras è molto semplice utilizzando le funzioni save() e load_model(). Questo rende facile salvare e condividere modelli con altre persone o distribuirli in produzione.
  • 2
    L’intera architettura del modello, l’ottimizzatore e i pesi vengono salvati in un unico file quando si salva un modello Keras. Senza doversi preoccupare di caricare separatamente l’architettura e i pesi, è semplice caricare il modello e generare previsioni.
  • 3
    TensorFlow Keras supporta diversi formati di file per il salvataggio dei modelli, tra cui il formato HDF5 (.h5), il formato SavedModel di TensorFlow (.pb) e il formato TensorFlow Lite (.tflite). Ciò ti offre flessibilità nella scelta del formato più adatto alle tue esigenze.

Svantaggi del salvataggio dei modelli con TensorFlow Keras

  • 1
    Quando si salva un modello Keras, il file risultante può essere piuttosto grande, specialmente se si ha un gran numero di strati o parametri. Ciò può rendere difficile condividere o distribuire il modello, soprattutto in situazioni in cui la larghezza di banda o lo spazio di archiviazione sono limitati.
  • 2
    I modelli salvati con una versione di TensorFlow Keras potrebbero non funzionare con un’altra. Se si cerca di caricare un modello che è stato salvato con una versione diversa di Keras o TensorFlow, potrebbero verificarsi problemi.
  • 3
    Sebbene sia semplice salvare un modello Keras, è possibile utilizzare solo le funzionalità che Keras offre per la memorizzazione dei modelli. Potrebbe essere necessario un framework o una strategia diversa se si desidera maggiore flessibilità nel modo in cui i modelli vengono salvati o caricati.

C’è un altro framework ampiamente utilizzato chiamato Pytorch per l’allenamento dei modelli basati su DL. Vediamo come è possibile salvare i modelli di deep learning basati su Pytorch con Python.

Salvataggio del modello di deep learning con Pytorch

Sviluppato da Facebook, Pytorch è uno dei framework più utilizzati per lo sviluppo di soluzioni basate su DL. Fornisce un grafo computazionale dinamico, che consente di modificare il modello al volo, rendendolo ideale per la ricerca e l sperimentazione. Utilizza i formati file ‘.pt’ e ‘.pth’ per salvare l’architettura del modello e i suoi pesi.

Per salvare un modello di deep learning in PyTorch, è possibile utilizzare il metodo save() dell’oggetto torch.nn.Module di PyTorch. Questo metodo salva l’intero modello, compresa l’architettura del modello e i pesi, in un formato che può essere caricato successivamente per effettuare previsioni.

Ecco un esempio di codice che mostra come salvare un modello PyTorch:

# importare le dipendenze
import torch
import torch.nn as nn
import numpy as np

# convertire gli array numpy dei dati in tensori
X_train = torch.FloatTensor(X_train)
X_test = torch.FloatTensor(X_test)
y_train = torch.LongTensor(y_train)
y_test = torch.LongTensor(y_test)

# definire l'architettura del modello
class NeuralNetworkClassificationModel(nn.Module):
    def __init__(self,input_dim,output_dim):
        super(NeuralNetworkClassificationModel,self).__init__()
        self.input_layer    = nn.Linear(input_dim,128)
        self.hidden_layer1  = nn.Linear(128,64)
        self.output_layer   = nn.Linear(64,output_dim)
        self.relu = nn.ReLU()
    
    
    def forward(self,x):
        out =  self.relu(self.input_layer(x))
        out =  self.relu(self.hidden_layer1(out))
        out =  self.output_layer(out)
        return out

# definire le dimensioni di input e output
input_dim  = 4 
output_dim = 3
model = NeuralNetworkClassificationModel(input_dim,output_dim)

# creare ottimizzatore e oggetto di funzione di perdita
learning_rate = 0.01
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate)

# definire i passaggi di allenamento
def train_network(model,optimizer,criterion,X_train,y_train,X_test,y_test,num_epochs,train_losses,test_losses):
    for epoch in range(num_epochs):
        # eliminare i gradienti dal passaggio precedente loss.backward()
        optimizer.zero_grad()
        
        # alimentazione in avanti
        output_train = model(X_train)

        # calcolare la perdita
        loss_train = criterion(output_train, y_train)

        # propagazione all'indietro: calcolare i gradienti
        loss_train.backward()

        # aggiornare i pesi
        optimizer.step()
        
        output_test = model(X_test)
        loss_test = criterion(output_test,y_test)

        train_losses[epoch] = loss_train.item()
        test_losses[epoch] = loss_test.item()

        if (epoch + 1) % 50 == 0:
            print(f"Epoch { epoch+1 }/{ num_epochs }, Train Loss: { loss_train.item():.4f }, Test Loss: {loss_test.item():.4f}")

# allenare il modello
num_epochs = 1000
train_losses = np.zeros(num_epochs)
test_losses  = np.zeros(num_epochs)
train_network(model,optimizer,criterion,X_train,y_train,X_test,y_test,num_epochs,train_losses,test_losses)

# salvare il modello 
torch.save(model, 'model_pytorch.pt')

A differenza di Tensorflow, Pytorch ti permette di avere un maggiore controllo sull’addestramento del modello, come si può vedere nel codice sopra. Dopo aver addestrato il modello, puoi salvare i pesi e l’architettura utilizzando il metodo save().

Per caricare il modello salvato con Pytorch è necessario utilizzare il metodo load().

# caricamento del modello
model = torch.load('model_pytorch.pt')
# verifica del riepilogo del modello
model.eval()

Modello Pytorch caricato | Fonte: Autore

Vantaggi del salvataggio dei modelli con Pytorch

  • 1
    Il grafo computazionale utilizzato da PyTorch è dinamico, il che significa che viene costruito durante l’esecuzione del programma. Ciò consente una maggiore flessibilità nella modifica del modello durante l’addestramento o l’inferenza.
  • 2
    Per modelli dinamici, come quelli con input o output di lunghezza variabile, che sono frequenti nell’elaborazione del linguaggio naturale (NLP) e nella visione artificiale, PyTorch offre un supporto migliorato.
  • 3
    Dato che PyTorch è scritto in Python e funziona bene con altre librerie Python come NumPy e pandas, la manipolazione dei dati sia prima che dopo l’addestramento è semplice.

Svantaggi del salvataggio dei modelli con Pytorch

  • 1
    Anche se PyTorch fornisce un’API accessibile, potrebbe esserci una curva di apprendimento ripida per i nuovi arrivati nel deep learning o nella programmazione Python.
  • 2
    Poiché PyTorch è essenzialmente un framework per la ricerca, potrebbe non avere gli stessi strumenti per il deployment in produzione di altri framework di deep learning come TensorFlow o Keras.

Questo non è tutto, è possibile utilizzare piattaforme di registrazione dei modelli per salvare modelli basati su DL, soprattutto quelli di grandi dimensioni. Ciò rende facile distribuirli e mantenerli senza richiedere sforzi aggiuntivi da parte degli sviluppatori.

Puoi trovare il dataset e il codice utilizzati in questo articolo qui.

Come confezionare i modelli di ML?

Un modello di ML è tipicamente ottimizzato per le prestazioni sul dataset di addestramento e l’ambiente specifico in cui è stato addestrato. Tuttavia, quando si tratta di distribuire i modelli in diversi ambienti, come un ambiente di produzione, potrebbero sorgere varie sfide.

Queste sfide riguardano, ma non sono limitate a, differenze nell’hardware, nel software e negli input dei dati. Confezionare il modello rende più facile affrontare questi problemi, in quanto consente di esportare o serializzare il modello in un formato standard che può essere caricato e utilizzato in vari ambienti.

Attualmente ci sono varie opzioni disponibili per il confezionamento. Confezionando il modello in un formato standard come PMML (Predictive Model Markup Language), ONNX, formato TensorFlow SavedModel, ecc., diventa più facile condividere e collaborare su un modello senza preoccuparsi delle diverse librerie e strumenti utilizzati dai diversi team. Ora, vediamo alcuni esempi di confezionamento di un modello di ML con diversi framework in Python.

Nota: Anche per questa sezione, vedrai lo stesso esempio di classificazione dell’iris.

Confezionamento dei modelli con PMML

Utilizzando la libreria PMML in Python, è possibile esportare i modelli di machine learning nel formato PMML e quindi distribuirli come servizio web, sistema di elaborazione batch o piattaforma di integrazione dati. Ciò può rendere più facile condividere e collaborare su modelli di machine learning, nonché distribuirli in vari ambienti di produzione.

Per confezionare un modello di ML utilizzando PMML è possibile utilizzare diversi moduli come sklearn2pmml, jpmml-sklearn, jpmml-tensorflow, ecc.

Nota: Per utilizzare PMML, è necessario avere Java Runtime installato nel sistema.

Ecco un esempio di frammento di codice che consente di confezionare il modello classificatore iris addestrato utilizzando PMML.

from sklearn2pmml import PMMLPipeline, sklearn2pmml
# confezionamento del modello classificatore iris con PMML
sklearn2pmml(PMMLPipeline([("estimator",
                        	model)]),
         	"iris_model.pmml",
         	with_repr=True)

Nel codice sopra, è sufficiente creare un oggetto PMML pipeline passando l’oggetto del modello. Poi è necessario salvare l’oggetto PMML utilizzando il metodo sklearn2pmml(). Questo è tutto, ora puoi utilizzare il file “iris_model.pmml” in diversi ambienti.

Vantaggi nell’utilizzo di PMML

  • 1
    Poiché PMML è un formato indipendente dalla piattaforma, i modelli PMML possono essere integrati con numerose piattaforme di elaborazione dei dati e utilizzati in una varietà di situazioni di produzione.
  • 2
    PMML può ridurre il vincolo del fornitore poiché consente agli utenti di esportare ed importare modelli da diverse piattaforme di apprendimento automatico.
  • 3
    I modelli PMML possono essere facilmente implementati in ambienti di produzione poiché possono essere integrati con diverse piattaforme e sistemi di elaborazione dei dati.

Svantaggi nell’utilizzo di PMML

  • 1
    Alcuni modelli e algoritmi di apprendimento automatico potrebbero non poter essere esportati nel formato PMML a causa del supporto limitato.
  • 2
    PMML è un formato basato su XML che può essere verboso e inflessibile, il che potrebbe rendere difficile modificare o aggiornare i modelli dopo che sono stati esportati nel formato PMML.
  • 3
    Potrebbe essere difficile creare modelli PMML, specialmente per modelli complicati con diverse caratteristiche e interazioni.

Confezionamento dei modelli con ONNX

Sviluppato da Microsoft e Facebook, ONNX (Open Neural Network Exchange) è un formato aperto per rappresentare modelli di apprendimento automatico. Consente l’interoperabilità tra diversi framework e strumenti di deep learning.

I modelli ONNX possono essere implementati in modo efficiente su una varietà di piattaforme, tra cui dispositivi mobili, dispositivi edge e il cloud. Supporta una varietà di runtime, tra cui Caffe2, TensorFlow, PyTorch e MXNet, che consente di implementare i modelli su diversi dispositivi e piattaforme con uno sforzo minimo.

Per salvare il modello utilizzando ONNX, è necessario avere i pacchetti onnx e onnxruntime scaricati nel sistema.

Ecco un esempio di come è possibile convertire il modello di apprendimento automatico esistente nel formato ONNX.

# carica le dipendenze
import onnxmltools
import onnxruntime

# Converti il modello KNeighborsClassifier nel formato ONNX
onnx_model = onnxmltools.convert_sklearn(model)

# Salva il modello ONNX in un file
onnx_file = "iris_knn.onnx"
onnxmltools.utils.save_model(onnx_model, onnx_file)

È sufficiente importare i moduli necessari e utilizzare il metodo convert_sklearn() per convertire il modello sklearn nel modello ONNX. Una volta completata la conversione, utilizzando il metodo save_model(), è possibile memorizzare il modello ONNX in un file con estensione “.onnx”. Sebbene qui si veda un esempio di un modello di apprendimento automatico, ONNX è principalmente utilizzato per modelli di deep learning.

È anche possibile caricare questo modello utilizzando il modulo ONNX Runtime.

# Carica il modello ONNX in ONNX Runtime
sess = onnxruntime.InferenceSession(onnx_file)

# Valuta il modello su alcuni dati di test
input_data = {"X": X_test[:10].astype('float32')}
output = sess.run(None, input_data)

È necessario creare una sessione utilizzando il metodo InferenceSession() per caricare il modello ONNX da un file e quindi utilizzare il metodo sess.run() per effettuare predizioni dal modello.

Vantaggi nell’utilizzo di ONNX

  • 1
    Con un piccolo sforzo, i modelli ONNX possono essere facilmente implementati su diverse piattaforme, tra cui dispositivi mobili e il cloud. Grazie al supporto di ONNX per una vasta gamma di runtime, è semplice implementare modelli su diverse piattaforme hardware e software.
  • 2
    I modelli ONNX sono ottimizzati per le prestazioni, il che significa che possono essere eseguiti più velocemente e consumare meno risorse rispetto ai modelli in altri formati.

Svantaggi nell’utilizzo di ONNX

  • 1
    ONNX è principalmente progettato per modelli di deep learning e potrebbe non essere adatto per altri tipi di modelli di apprendimento automatico.
  • 2
    I modelli ONNX potrebbero non essere compatibili con tutte le versioni di diversi framework di deep learning, il che potrebbe richiedere uno sforzo aggiuntivo per garantire la compatibilità.

Confezionamento dei modelli con Tensorflow SavedModel

Il formato SavedModel di Tensorflow consente di salvare e caricare facilmente i modelli di deep learning e garantisce la compatibilità con altri strumenti e piattaforme di Tensorflow. Inoltre, offre un modo efficiente ed efficiente per implementare i nostri modelli in ambienti di produzione.

SavedModel supporta una vasta gamma di scenari di distribuzione, inclusa la distribuzione di modelli con Tensorflow Serving, il deploy di modelli su dispositivi mobili con Tensorflow Lite e l’esportazione di modelli in altre librerie di machine learning come ONNX.

Fornisce un modo semplice e snello per salvare e caricare modelli Tensorflow. L’API è facile da usare e ben documentata e il formato è progettato per essere efficiente e scalabile.

Nota: Puoi utilizzare lo stesso modello TensorFlow addestrato nella sezione precedente.

Per salvare il modello nel formato SavedModel, puoi utilizzare le seguenti righe di codice:

import tensorflow as tf

# usando il formato SavedModel per salvare il modello
tf.saved_model.save(model, "my_model")

Puoi anche caricare il modello con il metodo load().

# Carica il modello
loaded_model = tf.saved_model.load("my_model")

Vantaggi dell’utilizzo di Tensorflow SavedModel

  • 1
    SavedModel è indipendente dalla piattaforma e compatibile con le versioni, il che rende facile condividere e distribuire modelli su diverse piattaforme e versioni di TensorFlow.
  • 2
    SavedModel supporta una varietà di scenari di distribuzione, inclusa l’esportazione di modelli in altre librerie di machine learning come ONNX, la distribuzione di modelli con TensorFlow Serving e la distribuzione di modelli su dispositivi mobili utilizzando TensorFlow Lite.
  • 3
    SavedModel è ottimizzato per l’addestramento e l’inferenza, con il supporto per l’addestramento distribuito e la possibilità di utilizzare GPU e TPU per accelerare l’addestramento.

Svantaggi dell’utilizzo di Tensorflow SavedModel

  • 1
    I file SavedModel possono essere grandi, in particolare per modelli complessi, il che può renderli difficili da archiviare e trasferire.
  • 2
    Dato che SavedModel è esclusivo di TensorFlow, la sua compatibilità con altre librerie di machine learning e strumenti potrebbe essere limitata.
  • 3
    Il modello salvato è un file binario che può essere difficile da ispezionare, rendendo più difficile comprendere i dettagli dell’architettura e del funzionamento del modello.

Ora che hai visto più modi di confezionare modelli di ML e DL, devi anche essere consapevole del fatto che ci sono vari strumenti disponibili che forniscono infrastrutture per confezionare, distribuire e servire questi modelli. Due dei più popolari sono BentoML e MLFlow.

BentoML

BentoML è un framework flessibile per la creazione e il deploy di servizi di machine learning pronti per la produzione. Consente ai data scientist di confezionare i loro modelli addestrati, le loro dipendenze e il codice di infrastruttura necessario per servire il modello in un pacchetto riutilizzabile chiamato “Bento”.

BentoML supporta vari framework di machine learning e piattaforme di deploy e fornisce un’API unificata per la gestione del ciclo di vita del modello. Una volta che un modello è confezionato come Bento, può essere distribuito su varie piattaforme di servizio come AWS Lambda, Kubernetes o Docker. BentoML offre anche un server API che può essere utilizzato per servire il modello tramite un’API REST. Puoi saperne di più qui.

MLFlow

MLFlow è una piattaforma open-source per la gestione del ciclo di vita completo del machine learning. Fornisce un set completo di strumenti per tracciare gli esperimenti, confezionare il codice e le dipendenze e distribuire i modelli.

MLFlow consente ai data scientist di confezionare facilmente i loro modelli in un formato standard che può essere distribuito su varie piattaforme come AWS SageMaker, Azure ML e Google Cloud AI Platform. La piattaforma offre anche un registro dei modelli per gestire le versioni del modello e monitorarne le prestazioni nel tempo. Inoltre, MLFlow offre un’API REST per servire i modelli, che può essere facilmente integrata in applicazioni web o altri servizi.

Come archiviare modelli di ML?

Ora che sappiamo come salvare i modelli, vediamo come possiamo archiviarli per facilitarne il recupero veloce e facile.

Archiviare modelli di ML in un database

C’è anche la possibilità di salvare i modelli di ML in database relazionali come PostgreSQL, MySQL, Oracle SQL, ecc. o in database NoSQL come MongoDB, Cassandra, ecc. La scelta del database dipende totalmente da fattori come il tipo e il volume dei dati da archiviare, le esigenze di prestazioni e scalabilità e le esigenze specifiche dell’applicazione.

PostgreSQL è una scelta popolare quando si lavora su modelli di ML che forniscono supporto per l’archiviazione e la manipolazione di dati strutturati. L’archiviazione dei modelli di ML in PostgreSQL fornisce un modo semplice per tenere traccia delle diverse versioni di un modello e gestirle in una posizione centralizzata.

Inoltre, consente una facile condivisione dei modelli tra un team o un’organizzazione. Tuttavia, è importante notare che l’archiviazione di modelli di grandi dimensioni in un database può aumentare le dimensioni del database e i tempi di interrogazione, quindi è importante considerare la capacità di archiviazione e le prestazioni del database quando si archiviano modelli in PostgreSQL.

Per salvare un modello di machine learning in un database come PostgreSQL, è necessario prima convertire il modello addestrato in un formato serializzato, come un flusso di byte (oggetto pickle) o JSON.

import pickle

# serializza il modello
model_bytes = pickle.dumps(model)

Successivamente apri una connessione al database e crea una tabella o una raccolta per memorizzare il modello serializzato. Per fare ciò, devi utilizzare la libreria psycopg2 di Python, che ti consente di connetterti al database PostgreSQL. Puoi scaricare questa libreria con l’aiuto del gestore di pacchetti di Python.

$ pip install psycopg2-binary

Successivamente devi stabilire una connessione al database per memorizzare il modello di machine learning in questo modo:

import psycopg2

# stabilisce la connessione al database
conn = psycopg2.connect(
  database="nome-database", user="nome-utente", password='tua-password', host='127.0.0.1', port='5432'
)

Per eseguire qualsiasi operazione sul database, è necessario creare un oggetto cursore che ti aiuterà a eseguire le query nel tuo programma Python.

# crea un cursore
cur = conn.cursor()

Con l’aiuto di questo cursore, puoi ora eseguire la query CREATE TABLE per creare una nuova tabella.

cur.execute("CREATE TABLE models (id INT PRIMARY KEY NOT NULL, name CHAR(50), model BYTEA)")

Nota: Assicurati che il tipo di oggetto del modello sia BYTEA.

Infine, puoi memorizzare il modello e le altre informazioni di metadati utilizzando il comando INSERT INTO.

# Inserisci il modello serializzato nel database
cur.execute("INSERT INTO models (id, name, model) VALUES (%s, %s, %s)", (1, 'classificatore-iris', model_bytes))
conn.commit()

# Chiudi la connessione al database
cur.close()
conn.close()

Una volta completate tutte le operazioni, chiudi il cursore e la connessione al database.

Infine, per leggere il modello dal database, puoi utilizzare il comando SELECT filtrando il modello sia per nome che per ID.

import psycopg2
import pickle

# Connetti al database
conn = psycopg2.connect(
  database="nome-database", user="nome-utente", password='tua-password', host='127.0.0.1', port='5432'
)

# Recupera il modello serializzato dal database
cur = conn.cursor()
cur.execute("SELECT model FROM models WHERE name = %s", ('classificatore-iris',))
model_bytes = cur.fetchone()[0]

# Deserializza il modello
model = pickle.loads(model_bytes)

# Chiudi la connessione al database
cur.close()
conn.close()

Una volta caricato il modello dal database, puoi usarlo per effettuare previsioni come segue:

# test del modello caricato
y_predict = model.predict(X_test)

# verifica i risultati
print(classification_report(y_test, y_predict)) 

Ecco fatto, hai il modello memorizzato e caricato dal database.

Vantaggi di memorizzare i modelli di machine learning in un database

  • 1
    Conservare i modelli di machine learning in un database fornisce una posizione di archiviazione centralizzata che può essere facilmente accessibile da più applicazioni e utenti.
  • 2
    Dal momento che la maggior parte delle organizzazioni ha già database, l’integrazione dei modelli di machine learning nell’infrastruttura esistente diventa più semplice.
  • 3
    I database sono ottimizzati per il recupero dei dati, il che significa che il recupero dei modelli di machine learning è più veloce ed efficiente.
  • 4
    I database sono progettati per fornire funzionalità di sicurezza robuste come autenticazione, autorizzazione e crittografia. Ciò garantisce che i modelli di machine learning memorizzati siano sicuri.

Svantaggi di memorizzare i modelli di machine learning in un database

  • 1
    I database sono progettati per archiviare dati strutturati e non sono ottimizzati per archiviare dati non strutturati come i modelli di machine learning. Di conseguenza, potrebbero esserci limitazioni in termini di dimensioni del modello, formati di file e altri aspetti dei modelli di machine learning che non possono essere gestiti dai database.
  • 2
    Memorizzare i modelli di machine learning in un database può essere complesso e richiede competenze nella gestione dei database e nell’apprendimento automatico.
  • 3
     Se i modelli di machine learning sono grandi, memorizzarli in un database può causare problemi di scalabilità. Inoltre, il recupero di modelli di grandi dimensioni può influire sulle prestazioni del database.

Mentre pickle, joblib e JSON sono modi comuni per salvare i modelli di apprendimento automatico, hanno limitazioni quando si tratta di versioning, condivisione e gestione dei modelli di apprendimento automatico. Qui entrano in gioco i registri dei modelli di apprendimento automatico e risolvono tutti i problemi incontrati dalle alternative.

Successivamente, vedrai come salvare i modelli di apprendimento automatico nel registro dei modelli può aiutarti a ottenere riproducibilità e riutilizzabilità.

Memorizzazione dei modelli di apprendimento automatico nel registro dei modelli

  • Un registro dei modelli è un repository centrale che può memorizzare, versionare e gestire i modelli di apprendimento automatico.
  • Di solito include funzioni come il versionamento del modello, il controllo dei metadati, il confronto delle esecuzioni del modello, ecc.
  • Quando si lavora su progetti di ML o DL, è possibile salvare e recuperare i modelli e i loro metadati dal registro dei modelli ogni volta che si desidera.
  • Soprattutto, i registri dei modelli consentono una grande collaborazione tra i membri del team.

Consulta questo articolo per saperne di più sul registro dei modelli.

Ci sono varie opzioni per il registro dei modelli, ad esempio neptune.ai, Mlflow, Kubeflow, ecc. Anche se tutte queste piattaforme hanno alcune caratteristiche uniche, è piuttosto saggio scegliere un registro che possa fornirti un ampio set di funzionalità.

In questo esempio, userò Neptune. Ha una funzionalità di registro dei modelli sviluppata per organizzare, memorizzare e gestire i modelli di apprendimento automatico. È un’ottima opzione per i data scientist e gli ingegneri ML che hanno bisogno di gestire i loro modelli addestrati, perché offre funzionalità di collaborazione, un’interfaccia user-friendly e capacità di versionamento del modello.

Puoi creare un account gratuito qui o saperne di più sullo strumento qui.

Registrare un modello nel registro di Neptune

Una volta creato un account gratuito, puoi fare clic sul pulsante Nuovo progetto per avviare un nuovo progetto.

Crea un nuovo progetto in Neptune | Fonte: Autore

Una volta completata la creazione del progetto, vedrai una pagina con diverse configurazioni per salvare il modello. Con Neptune, puoi lavorare con diversi framework come Scikit-Learn, Keras, Tensorflow, Pytorch e altri.

Per memorizzare i modelli nel registro dei modelli di Neptune, è necessario installare la libreria:

$ pip install neptune

Nota: Assicurati di aver salvato il tuo modello addestrato in un file utilizzando il modulo pickle o joblib per memorizzarlo nel registro dei modelli.

Una volta installata la dipendenza, è necessario importarla nel proprio programma e inizializzare il modello di Neptune fornendo un nome, una chiave univoca (in lettere maiuscole) e le credenziali di Neptune. Puoi trovare tutte queste informazioni nella scheda dei metadati del modello di un progetto di Neptune.

import neptune

# inizializza il modello
model = neptune.init_model(
name="Modello di previsione",
key="IRMOD", # dovrebbe essere diverso per il tuo progetto
project="username/nome-progetto",
api_token="la-tua-api-key", # le tue credenziali
)

Nel codice precedente, viene importata la dipendenza di Neptune e viene inizializzato un modello (che si desidera memorizzare e tracciare con il registro dei modelli di Neptune) con le credenziali di Neptune. Quindi è necessario assegnare i metadati del modello di classificazione all’oggetto del modello di Neptune.

# assegna i metadati del modello di classificazione all'oggetto del modello
model_info = {"size_limit": 7.09, "size_units": "KB"}
model["model"] = model_info

Infine, è possibile caricare il modello nel registro dei modelli di Neptune utilizzando il metodo upload() in questo modo:

# carica il modello nel registro
model["model/signature"].upload("iris_classifier_model.pkl")

Inoltre, è possibile tenere traccia della versione del dataset utilizzando il metodo track_files() fornito da neptune.

# traccia la versione del dataset
model["data/train_and_test"].track_files("iris.data")

# interrompi la sessione
model.stop()

Ecco fatto, il tuo modello e il dataset sono ora salvati nel registro. Inoltre, non dimenticare di chiudere la sessione con il metodo stop().

Verifica modello archiviato in Neptune | Fonte: Autore

Versionare un modello

Quando lavori su un progetto di intelligenza artificiale nel mondo reale, ti capita di provare molti modelli e una combinazione di parametri e iperparametri. Se non tieni traccia di questi dati, potresti non sapere tutte le cose che hai provato, e potrebbe esserci la necessità di ricominciare da capo.

Qui entra in gioco il registro dei modelli di Neptune, in quanto puoi registrare diverse versioni di un modello con poche righe di codice. Per iniziare, devi inizializzare un oggetto ModelVersion nel seguente modo:

# inizializza il ModelVersion
import neptune
model_version = neptune.init_model_version(
model="IR-IRMOD", # dovrebbe essere diverso per il tuo progetto
project="username/nomeprogetto",
api_token="tua-chiave-api", # le tue credenziali
)

In seguito, puoi opzionalmente salvare il modello e altri dettagli metadata in ogni versione del modello che stai per registrare nel registro di Neptune.

# parametri del modello
parameters = {
"algoritmo": clf_model.get_params()['algoritmo'],
"max_iter": clf_model.get_params()['dimensione_foglia'],
"solver": clf_model.get_params()['metrica'],
"metric_params": clf_model.get_params()['metrica_parametri'],
"n_jobs": clf_model.get_params()['n_lavori'],
"n_neighbors": clf_model.get_params()['n_vicini'],
"p": clf_model.get_params()['p'],
"weights": clf_model.get_params()['pesi'],
}

# registra i parametri del modello e altri metadati
model_version["modello/binario"].upload("modello_classificatore_iris.pkl")
model_version["modello/parametri"] = parameters
model_version["dati/dataset"].track_files("iris.data")
model_version["validazione/acc"] = 0.93

# interrompi la sessione
model_version.stop()

Una volta fatto, puoi interrompere la sessione con il metodo stop().

Vista delle versioni del modello nell’app di Neptune | Fonte: neptune.ai

Interrogare il modello e i metadati dal registro

Infine, è necessario accedere a questo modello salvato e ai metadati quando necessario. Puoi caricare qualsiasi versione specifica del modello che hai salvato nel registro. Per fare ciò, devi inizializzare un oggetto ModelVersion fornendogli l’id della versione del modello.

import neptune
import pickle

# specifica l'id della versione del modello
version_id = 'IR-IRMOD-1' # dovrebbe essere diverso per il tuo progetto

# inizializza l'esecuzione
model_version = neptune.init_model_version(
with_id=version_id,
project="username/nome-progetto",
api_token="tua-chiave-api", # le tue credenziali
)

Una volta fatto, puoi accedere a diversi oggetti del modello come il modello, i metadati, il dataset, ecc. che hai registrato. Per iniziare, scarichiamo il modello dal registro e lo salviamo localmente per testarne le prestazioni sui dati di test.

# salva il modello dal registro in locale
if model_version.exists("modello/binario"):
model_version["modello/binario"].download(f"modello/{version_id}_model.pkl")

# carica il modello dal file pickle salvato
with open(f"modello/{version_id}_model.pkl", 'rb') as file: 
clf_model_2 = pickle.load(file)

# valuta il modello
y_predict = clf_model_2.predict(X_test)

Puoi anche verificare le informazioni sui metadati del modello che hai salvato in Neptune.

Verifica delle informazioni sui metadati del modello salvate in Neptune | Fonte: Autore

Per scaricare questi metadati localmente, puoi utilizzare il seguente codice:

# verifica i metadati
model_version["modello/parametri"].fetch()

Ecco fatto, ora sai come archiviare e caricare modelli specifici dal registro dei modelli di Neptune.

Puoi leggere di più sul registro dei modelli di Neptune qui.

Pro del salvataggio dei modelli con il registro dei modelli

  • 1
    Una posizione centralizzata per gestire, archiviare e versionare i modelli di apprendimento automatico.
  • 2
    I metadati relativi ai modelli, come la loro versione, le metriche delle prestazioni, ecc., sono spesso inclusi nei registri dei modelli, rendendo più semplice seguire le modifiche e comprendere il passato del modello.
  • 3
    I registri dei modelli consentono ai membri del team di collaborare sui modelli e condividere il proprio lavoro facilmente.
  • 4
    Alcuni registri dei modelli offrono opzioni di distribuzione automatica, che possono semplificare il processo di distribuzione dei modelli in ambienti di produzione.
  • 5
    I registri dei modelli spesso forniscono funzionalità di sicurezza come il controllo degli accessi, la crittografia e l’autenticazione, garantendo che i modelli siano protetti e accessibili solo agli utenti autorizzati.

Contro del salvataggio dei modelli con il registro dei modelli

  • 1
    È necessaria una sottoscrizione a pagamento per alcuni registri dei modelli, il che aumenta il costo dei programmi di apprendimento automatico.
  • 2
    I registri dei modelli spesso hanno una curva di apprendimento e potrebbe richiedere tempo per familiarizzare con le loro funzionalità.
  • 3
    Utilizzare un registro dei modelli potrebbe richiedere l’integrazione con altri strumenti e sistemi, il che può creare dipendenze aggiuntive.

Hai ora visto diversi modi per salvare un modello di apprendimento automatico (il registro dei modelli è il più ottimale), è ora di esaminare alcuni modi per salvare i modelli basati su Deep Learning (DL).

Best practices

In questa sezione, vedrai alcune delle migliori pratiche per il salvataggio dei modelli di apprendimento automatico e di apprendimento profondo (DL).

  • Assicurarsi delle versioni delle librerie: Utilizzare diverse versioni delle librerie per salvare e caricare i modelli può creare problemi di compatibilità, in quanto potrebbero esserci modifiche strutturali con l’aggiornamento delle librerie. Assicurati che le versioni delle librerie utilizzate per caricare i modelli di apprendimento automatico siano le stesse versioni delle librerie utilizzate per salvare il modello.
  • Assicurarsi delle versioni di Python: È una buona pratica utilizzare la stessa versione di Python in tutte le fasi dello sviluppo del tuo pipeline di apprendimento automatico. A volte, le modifiche nella versione di Python possono causare problemi di esecuzione, ad esempio, TensorflowV1 è supportato fino a Python 3.7 e se si prova a utilizzarlo con versioni successive, si verificheranno errori.
  • Salvare sia l’architettura del modello che i pesi: Nel caso di modelli basati su DL, se si salva solo il peso del modello ma non l’architettura, non si sarà in grado di ricostruire il modello. Salvare l’architettura del modello insieme ai pesi addestrati garantisce che il modello possa essere completamente ricostruito e utilizzato successivamente.
  • Documentare il modello: Dovrebbero essere documentati l’obiettivo, gli input, gli output e le prestazioni previste del modello. Ciò può aiutare gli altri a comprendere le capacità e i vincoli del modello.
  • Utilizzare un registro dei modelli: Utilizzare un registro dei modelli come neptune.ai per tenere traccia dei modelli, delle loro versioni e dei metadati e per collaborare con i membri del team.
  • Mantenere il modello salvato in sicurezza: Mantenere il modello salvato in sicurezza crittografandolo o archiviandolo in una posizione sicura, specialmente se contiene dati sensibili.

Conclusioni

In conclusione, il salvataggio dei modelli di apprendimento automatico è un passo importante nel processo di sviluppo, poiché consente di riutilizzare e condividere i modelli con gli altri. Ci sono diversi modi per salvare i modelli di apprendimento automatico, ognuno con i propri vantaggi e svantaggi. Alcuni metodi popolari includono l’utilizzo di pickle, Joblib, JSON, TensorFlow save e PyTorch save.

È importante scegliere il formato di file appropriato per il proprio caso d’uso specifico e seguire le migliori pratiche per il salvataggio e la documentazione dei modelli, come il controllo delle versioni, garantire le versioni del linguaggio e delle librerie e testare il modello salvato. Seguendo le pratiche discusse in questo articolo, è possibile garantire che i modelli di apprendimento automatico vengano salvati correttamente, siano facili da riutilizzare e distribuire e possano essere condivisi in modo efficace con gli altri.

Riferimenti

  1. https://machinelearningmastery.com/save-load-machine-learning-models-python-scikit-learn/
  2. https://www.tensorflow.org/tutorials/keras/save_and_load
  3. https://pytorch.org/tutorials/beginner/saving_loading_models.html
  4. https://www.kaggle.com/code/prmohanty/python-how-to-save-and-load-ml-models