Addestrare e Monitorare più modelli di machine learning insieme

Quando si lavora a un progetto di machine learning si possono incontrare tantissimi problemi. Soprattutto quando dobbiamo andare a selezionare il modello...

Però i data scientist più navigati sanno che può capitare che un modello che inizialmente sembrava preformare meglio degli altri nel lungo periodo può essere battuto da un altro. Ma come fare ad allenare e monitorare più di un modello insieme ?

Oggi parleremo proprio di questo. Vedremo praticamente ( con il codice ) come allenare e monitorare le prestazioni di due modelli allenati su uno stesso dataset ! E ti mostrerò quanto è semplice.

Addestrare e Monitorare più modelli di machine learning insieme

introduzione , perchè Addestrare e Monitorare più modelli di machine learning insieme ?

È possibile che ogni modello abbia caratteristiche o parametri unici. La valutazione e lo sfruttamento di questi modelli senza adeguati strumenti di monitoraggio delle prestazioni e di controllo della versione del modello diventa complicato. Anche condividere questi modelli con il resto del team per i test è impegnativo. Se abbiamo uno strumento che possiamo usare per tenere traccia dei nostri modelli, diventa più conveniente. Una piattaforma che semplifica la collaborazione tra i team per lo sviluppo di pipeline di machine learning automatizzate efficaci.

In questo articolo impareremo sull'apprendimento automatico collaborativo e su come addestrare, tracciare e condividere i nostri modelli di apprendimento automatico utilizzando una piattaforma chiamata "Layer"

Procedure consigliate da ricordare mentre si lavora su un progetto ML in un team.

1. Archiviazione centralizzata dei dati: è necessario un archivio centralizzato dei dati a cui un membro del team possa accedere per salvare e utilizzare il set di dati per il progetto. Per risparmiare tempo nell'esecuzione dell'intero processo di pulizia per gli altri membri del team, tutti i dati puliti e preelaborati devono essere salvati in un'unica posizione.

2. Convalida dei dati: le proprietà statistiche dei dati possono variare nel tempo man mano che vengono aggiunti sempre più campioni. Questo è fondamentale poiché può influire sulla precisione del modello nel tempo.

3. Accessibilità del modello: il modello addestrato deve essere archiviato da qualche parte per essere caricato durante la creazione di previsioni. Dovrebbe essere utile per altri membri del team da utilizzare per la sperimentazione nei loro progetti.

4. Monitoraggio del modello: come menzionato nella convalida dei dati, le proprietà dei dati possono cambiare nel tempo, influenzando l'accuratezza del modello. Quindi le prestazioni del modello dovrebbero essere monitorate continuamente per rilevare il degrado delle sue prestazioni.

5. Versioning del modello: durante l'addestramento del modello, è possibile utilizzare funzionalità, modelli o iperparametri diversi per creare modelli diversi. Diventa quindi fondamentale tracciare questi modelli per misurarne le prestazioni e migliorarne l'accessibilità a chi li utilizza.

Cos'è Layer e perchè ci aiuta a Addestrare e Monitorare più modelli di machine learning insieme?

Layer è una piattaforma per la creazione di pipeline di machine learning a livello di produzione. Dopo aver caricato i nostri dati e il nostro modello su questa piattaforma, possiamo facilmente addestrare e riqualificare i nostri modelli. Supporta perfettamente il controllo della versione del modello e il monitoraggio delle prestazioni. Possiamo condividere dati e modelli, rendendola una semplice piattaforma di machine learning collaborativa. I membri del team possono rivedere e valutare i cicli di sviluppo del modello dei loro colleghi utilizzando il controllo delle versioni del modello.

A causa della mancanza di coordinamento, i team spesso trascorrono del tempo a svolgere lavori ridondanti. Layer funziona come un repository centrale per dati e modelli, consentendo ai membri del team di accedere ai dati utilizzati nel processo senza doverli preelaborare nuovamente, riducendo gli sforzi ripetitivi. Il controllo automatico della versione consente di tornare rapidamente alle versioni precedenti del modello e ricreare i risultati acquisiti in precedenza.

La cosa meravigliosa di Layer è che non dobbiamo modificare i nostri attuali metodi o piattaforme di programmazione. Possiamo usare le capacità di Layer con poche righe di codice.

Addestrare e Monitorare più modelli di machine learning insieme con Python e Layer

Utilizzeremo il set di dati sulla qualità dell'acqua per addestrare un modello di classificazione per sondare la potabilità dell'acqua utilizzando fattori come pH, durezza e altre proprietà chimiche nel nostro progetto di apprendimento automatico.

per scaricare il set di dati clicca qui o l'immagine e segui i passaggi nella foto quì sotto

Dataset Progetto

Durante la riqualificazione del nostro modello, cambieremo alcuni parametri. Nella maggior parte dei casi, le versioni precedenti del modello vengono perse durante questa procedura. Tuttavia, in questo caso, utilizzeremo la piattaforma Layer per facilitare il controllo della versione del modello e confrontare le prestazioni di diverse versioni del modello.

Per installare Layer, digita questo codice sul terminale

!pip install -U layer -q

Registrati e accedi è GRATIS

Layer richiede prima la registrazione e l'accesso. Quando si esegue il codice seguente, verrà visualizzato un messaggio per incollare una chiave e verrà visualizzato anche il collegamento alla chiave. Copia e incolla l'URL nel tuo browser, quindi accedi al tuo account Layer per trovare la chiave; copia questa chiave e inseriscila nel prompt.

import layer
layer.login()

Ora crea un nuovo file e copia e incolla il codice ( tutto in un unico file, oppure se utilizzi Jupyter o Coolab copia il codice diviso nelle varie sezioni ) seguendo la spiegazione.

Importa le librerie necessarie

from layer.decorators import dataset, model,resources
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np
import layer
from layer import Dataset

Inizializza il tuo progetto di primo livello

È ora di iniziare a lavorare sul tuo primo progetto Layer. L'intero progetto può essere trovato su app.layer.ai

layer.init("new_project")

Carica il set di dati

Per caricare i dati nel progetto Layer, utilizzeremo il decoratore @dataset e specificheremo il nome del set di dati e il percorso ad esso utilizzando il decoratore @resources.

@dataset("water_dataset")
@resources(path="./")
def create_dataset():
    data = pd.read_csv('water_potability.csv')
    return data

Esegui questo per creare il set di dati nel tuo progetto di livello

layer.run([create_dataset])

Puoi navigare all'interno del tuo progetto per accedere al set di dati.

Addestrare e Monitorare più modelli di machine learning insieme

Difiniamo e Alleniamo i nostri modelli

Alla nostra funzione di training train(), aggiungeremo il decoratore @model per registrarlo con Layer. Per fare ciò, la funzione deve restituire l'oggetto modello. La funzione layer.log() registra tutti i parametri definiti nella dashboard Layer.

@model(name='classification_model',dependencies=[Dataset('water_dataset')])
def train():
    import seaborn as sns
    import matplotlib.pyplot as plt
    from sklearn.metrics import accuracy_score
    from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
    from sklearn.metrics import average_precision_score, roc_auc_score, roc_curve,precision_recall_curve
    parameters = {
        "test_size": 0.20,
        "random_state": 20,
        "n_estimators": 150
    }
    layer.log(parameters)
    # load the dataset from layer
    df = layer.get_dataset("water_dataset").to_pandas()
    df.dropna(inplace=True)
    features_x = df.drop(["Potability"], axis=1)
    target_y = df["Potability"]
    X_train, X_test, y_train, y_test = train_test_split(features_x, target_y, test_size=parameters["test_size"], random_state=parameters["random_state"])
    random_forest = RandomForestClassifier(n_estimators=parameters["n_estimators"])
    random_forest.fit(X_train, y_train)
    
    y_pred = random_forest.predict(X_test)
    layer.log({"accuracy":accuracy_score(y_test, y_pred)})
    cm = confusion_matrix(y_test, y_pred, labels=random_forest.classes_)
    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=random_forest.classes_)
    disp.plot()
    layer.log({"Confusion metrics" : plt.gcf()})
    probs = random_forest.predict(X_test)
    # Calculate ROC AUC
    auc = roc_auc_score(y_test, probs)
    layer.log({"AUC":f'{auc:.4f}'})
    sample_preds = X_test
    sample_preds["predicted"] = y_pred
    layer.log({"Sample predictions":sample_preds.head(100)})
    return random_forest

Per registrare il parametro e caricare il modello addestrato, passare la funzione di training a Layer useremo questa linea di codice.

layer.run([train])

Confronto dei risultati dei modelli allenati

Apri il progetto Layer lì vedrai i modelli caricati e i set di dati. Tutti i parametri e i grafici che hai registrato saranno lì, insieme alla versione del modello. Ogni volta che si esegue la funzione di training, viene caricata una nuova versione del modello insieme a tutti i parametri registrati. In questo modo è facile confrontare le prestazioni di tutti i modelli e utilizzare la versione precedente.

Possiamo confrontare i parametri e i risultati registrati come la dimensione dei dati del test, gli iperparametri, l'accuratezza e il punteggio ROC-AUC.

Addestrare e Monitorare più modelli di machine learning insieme

Addestrare e Monitorare più modelli di machine learning insieme

È inoltre possibile visualizzare e confrontare i grafici registrati di diverse versioni del modello.

Addestrare e Monitorare più modelli di machine learning insieme

Di seguito vengono mostrate le previsioni di esempio.

Addestrare e Monitorare più modelli di machine learning insieme

Scaricare i modelli da Layer

Dopo aver formato e caricato il modello sulla piattaforma Layer, è possibile caricare la versione desiderata del modello per fare previsioni. Con l'aiuto di questo codice, possiamo ottenere la versione del modello necessaria dall'app di livello.

import layer
model = layer.get_model("IAItlia/new_project/models/classification_model:2.1").get_train()

Questo oggetto modello può essere un modello normale per eseguire previsioni basate sui dati di input.

Conclusione

In questo articolo, abbiamo appreso i numerosi problemi che i team possono incontrare nel settore dell'apprendimento automatico durante la collaborazione e la gestione delle versioni del modello. Successivamente, abbiamo visto alcune delle migliori pratiche per lavorare su progetti ML in gruppo. In questo post, abbiamo progettato un progetto Layer che considera tutte le sfide che i team devono affrontare in un progetto ML. Premesse importanti da questo articolo:

• Abbiamo imparato a utilizzare Layer, una piattaforma ML collaborativa.

• Abbiamo utilizzato il controllo automatico della versione del modello con l'aiuto di questa piattaforma.

• Registrando i parametri del modello e i risultati, potremmo confrontare i risultati di diverse versioni del modello.