Tutorial DeepChecks: automatizzare i test di Machine Learning

In questo tutorial vedremo cos’è DeepChecks e come usarlo per eseguire la validazione dei dati e il testing di machine learning. Useremo anche GitHub Actions per automatizzare i test del modello e salvare i risultati come artifact.

Man mano che procediamo, conosceremo il testing di machine learning e DeepChecks, eseguiremo la suite di integrità dei dati di DeepChecks e genereremo un report completo. Creeremo inoltre report di testing del modello eseguendo una suite di valutazione, impareremo a far girare un singolo test invece di un’intera suite, automatesremo il flusso di lavoro con GitHub Actions e salveremo il report di testing del modello come Artifact di GitHub.

Immagine dell’autore

Che cos’è il testing di Machine Learning?

Il testing di machine learning è un processo fondamentale che prevede la valutazione e la validazione delle prestazioni dei modelli per garantirne equità, accuratezza e robustezza. Non si tratta solo di accuratezza e prestazioni del modello. Dobbiamo considerare bias del modello, falsi positivi, falsi negativi, varie metriche di performance, throughput del modello e allineamento del modello con l’etica dell’IA.

Il processo di testing include vari tipi di valutazioni come data validation, cross-validation, F1-score, matrice di confusione, prediction drift, data drift e robustness testing, ciascuno pensato per verificare aspetti diversi delle prestazioni e dell’affidabilità del modello.

Suddividiamo inoltre il dataset in tre parti così da poter valutare il modello durante il training e dopo l’addestramento su un dataset non visto.

Il testing di machine learning è una parte essenziale delle applicazioni di IA e automatizzarlo insieme all’addestramento del modello ci permette di ottenere sistemi affidabili che funzionano per le persone.

Se sei alle prime armi con il machine learning e vuoi imparare le basi, segui lo skill track Fondamenti di Machine Learning con Python. Questo corso ti insegnerà i fondamenti del machine learning con Python, a partire dall’apprendimento supervisionato con la libreria scikit-learn.

Primi passi con DeepChecks

DeepChecks è un pacchetto Python open source progettato per facilitare test e validazioni complete di modelli e dati di machine learning. Fornisce un’ampia gamma di check integrati per individuare problemi legati alle prestazioni del modello, alla distribuzione dei dati, all’integrità dei dati e altro. DeepChecks include funzionalità per la validazione continua, assicurando che i modelli rimangano affidabili ed efficaci quando vengono distribuiti e usati in scenari reali.

Inizieremo installando il pacchetto Python usando il comando pip.

%pip install deepchecks --upgrade -qOfferto da

Caricare il dataset

Per questo tutorial, usiamo i Loan Data dai dataset di DataCamp. È composto da 9578 righe e informazioni sulla struttura del prestito, sul mutuatario e sul fatto che il prestito sia stato rimborsato per intero.

Carica il file CSV con Pandas e mostra le prime 5 righe.

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()Offerto da

Preparare il dataset

Crea il dataset DeepChecks usando il dataset dei prestiti, il nome della colonna etichetta e il nome della feature categorica.

from sklearn.model_selection import train_test_split
from deepchecks.tabular import Dataset

label_col = 'not.fully.paid'

deep_loan_data = Dataset(loan_data, label=label_col, cat_features=["purpose"])Offerto da

Eseguire la suite di integrità dei dati di DeepChecks

Useremo una suite di integrità dei dati per dati tabellari. La suite eseguirà tutti i test in autonomia e genererà un report interattivo con i risultati.

Per farlo, importeremo la suite di integrità dei dati, la inizializzeremo e poi la eseguiremo fornendole i dati dei prestiti in DeepChecks. Infine, mostreremo i risultati.

from deepchecks.tabular.suites import data_integrity

integ_suite = data_integrity()
suite_result = integ_suite.run(deep_loan_data)
suite_result.show()Offerto da

Nota: stiamo usando DataLab come ambiente di sviluppo. L’uso di ipywidgets è stato disabilitato, impedendone la visualizzazione dei risultati. Invece, useremo la funzione 'show_in_iframe' per mostrare il risultato come iframe. I risultati saranno gli stessi a tutti i livelli.

suite_result.show_in_iframe()Offerto da

Il nostro report di integrità dei dati include i risultati dei test su:

• Correlazione Feature-Etichetta
• Correlazione Feature-Feature
• Valore singolo in colonna
• Caratteri speciali
• Null misti
• Tipi di dato misti
• Disallineamento di stringhe
• Duplicati nei dati
• Lunghezza stringa fuori dai limiti
• Etichette in conflitto
• Rilevamento di campioni outlier

Risultati dei test di integrità dei dati nel Jupyter Notebook.

Puoi anche salvare i risultati come file HTML e condividerli con i colleghi.

suite_result.save_as_html()Offerto da

'output.html'Offerto da

Eseguire un singolo test

Eseguire l’intera suite su un dataset di grandi dimensioni non è efficiente, perché richiederà molto tempo per generare i risultati. In alternativa, puoi eseguire alcuni test individuali rilevanti per i tuoi dati e generare autonomamente un report.

Per eseguire un singolo test, importa i check tabellari, inizializza il check ed eseguilo con i dati dei prestiti in DeepCheck. Successivamente, visualizza i valori invece di generare un report interattivo usando la funzione results.value.

from deepchecks.tabular.checks import IsSingleValue, DataDuplicates

result = IsSingleValue().run(deep_loan_data)
result.valueOfferto da

Come possiamo vedere, mostra il numero di valori unici presenti in ogni colonna.

{'credit.policy': 2,
 'purpose': 7,
 'int.rate': 249,
 'installment': 4788,
 'log.annual.inc': 1987,
 'dti': 2529,
 'fico': 44,
 'days.with.cr.line': 2687,
 'revol.bal': 7869,
 'revol.util': 1035,
 'inq.last.6mths': 28,
 'delinq.2yrs': 11,
 'pub.rec': 6,
 'not.fully.paid': 2}Offerto da

Proviamo a verificare i campioni duplicati nei nostri dati.

result = DataDuplicates().run(deep_loan_data)
result.valueOfferto da

Non ci sono duplicati nel nostro dataset.

0.0Offerto da

Testing di Machine Learning con DeepChecks

In questa sezione effettueremo un ensemble di più modelli e li alleneremo sul dataset di prestiti processato. Poi, per generare un report di testing del modello, eseguiremo una suite di valutazione del modello sui dataset di training e test.

Elaborazione dei dati e training del modello

1. Importa le funzioni essenziali dalla libreria Scikit-learn.
2. Dividi il dataset in train e test set.
3. Converti la colonna categorica 'purpose' in numerica usando il label encoder.
4. Definisci i modelli LogisticRegression, RandomForestClassifier e GaussianNB.
5. Crea un ensemble dei modelli usando il voting classifier.
6. Allena il modello ensemble sul training set.

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.preprocessing import LabelEncoder

# Train test split
df_train, df_test = train_test_split(loan_data, stratify=loan_data[label_col], random_state=0)

# Encode the 'purpose' column
label_encoder = LabelEncoder()
df_train['purpose'] = label_encoder.fit_transform(df_train['purpose'])
df_test['purpose'] = label_encoder.fit_transform(df_test['purpose'])

# Define models
model_1 = LogisticRegression(random_state=1, max_iter=10000)
model_2 = RandomForestClassifier(n_estimators=50, random_state=1)
model_3 = GaussianNB()

# Create the VotingClassifier
clf_model = VotingClassifier(
    estimators=[('lr', model_1), ('rf', model_2), ('svc', model_3)],
    voting='soft'
)

# Train the model
clf_model.fit(df_train.drop(label_col, axis=1), df_train[label_col])Offerto da

Eseguire la suite di valutazione del modello

Eseguiremo la suite di valutazione del modello di DeepChecks per valutarne le prestazioni.

7. Converti sia i train che i test set in dataset DeepCheck.
8. Inizializza la valutazione del modello ed eseguila usando train, test set e modello.
9. Mostra i risultati nell’iframe.

from deepchecks.tabular.suites import model_evaluation

deep_train = Dataset(df_train, label=label_col, cat_features=[])
deep_test =  Dataset(df_test,  label=label_col, cat_features=[])

evaluation_suite = model_evaluation()
suite_result = evaluation_suite.run(deep_train, deep_test, clf_model)
suite_result.show_in_iframe()Offerto da

Il nostro report di valutazione del modello include i risultati dei test su:

• Report ROC
• Prestazioni su segmenti deboli
• Feature non utilizzate
• Prestazioni Train-Test
• Prediction Drift
• Confronto con un modello semplice
• Tempo di inferenza del modello
• Report matrice di confusione
• E altro

10. Per visualizzare il risultato in formato JSON, usa la funzione to_json().

suite_result.to_json()Offerto da

Eseguire un singolo test

Proprio come per la validazione dei dati, puoi eseguire un singolo test di machine learning. Nel nostro caso, eseguiremo il label drift su train e test split per verificare se le etichette sono cambiate nel tempo.

from deepchecks.tabular.checks import LabelDrift
check = LabelDrift()
result = check.run(deep_train, deep_test)
result.valueOfferto da

Non è stato rilevato alcun drift nei dati.

{'Drift score': 0.0, 'Method': "Cramer's V"}Offerto da

Se riscontri difficoltà nell’eseguire le suite di validazione dei dati e valutazione del modello, consulta lo spazio di lavoro DataLab all’indirizzo Machine Learning Testing with DeepChecks.

Se ti interessa il testing di machine learning "manuale", segui il tutorial Machine Learning Experimentation per imparare a strutturare, registrare e analizzare i tuoi esperimenti di machine learning usando Weights & Biases.

Automatizzare il testing di Machine Learning con GitHub Actions e DeepChecks

Automatizziamo la validazione dei dati, il training del modello e la valutazione del modello con GitHub Actions e salviamo i risultati come file zip.

Automatizzare il testing di machine learning è parte integrante della pipeline MLOps. Per saperne di più, segui lo skill track Fondamenti di MLOps. In questa serie di corsi imparerai i principi fondamentali per mettere in produzione modelli di machine learning e monitorarli per generare valore di business.

Configurazione

1. Vai sull’account GitHub e crea un nuovo repository con tutte le informazioni necessarie.

2. Clona il repository sul sistema locale.
3. Spostati nella directory del repository.
4. Crea una nuova cartella, “data”, e sposta il file CSV dei prestiti dalla cartella "Downloads" alla cartella del repository.
5. Crea la validazione dei dati in Python e avvia VSCode (ambiente di sviluppo integrato).

$ cd C:\Repository\GitHub\
$ git clone https://github.com/kingabzpro/Automating-Machine-Learning-Testing.git

$ cd .\Automating-Machine-Learning-Testing\
$ mkdir data
$ mv -v ".Downloads\loan_data.csv" ".\Automating-Machine-Learning-Testing\data"
$ code -r data_validation.pyOfferto da

File di validazione dei dati

6. Nel file di validazione dei dati, caricherai il file CSV, lo convertirai in un dataset DeepChecks, inizializzerai la suite di integrazione dei dati e la eseguirai sul dataset dei prestiti.
7. Crea la nuova cartella “results” e salva il tutto come file HTML.

import pandas as pd
from deepchecks.tabular import Dataset
from deepchecks.tabular.suites import data_integrity

# Load the loan data from a CSV file
loan_data = pd.read_csv("data/loan_data.csv")

# Define the label column
label_col = "not.fully.paid"

# Create a Deepchecks Dataset object with the loan data
deep_loan_data = Dataset(loan_data, label=label_col, cat_features=["purpose"])

# Initialize the data integrity suite
integ_suite = data_integrity()

# Run the data integrity suite on the dataset
suite_result = integ_suite.run(deep_loan_data)

# Save the results of the data integrity suite as an HTML file
suite_result.save_as_html("results/data_validation.html")Offerto da

File di testing del modello

8. Crea un file Python per la validazione che includa data processing, costruzione del modello, training e valutazione. Il file dovrebbe anche includere la conversione del dataset in un dataset DeepChecks, l’esecuzione della suite di valutazione del modello e il salvataggio come file HTML nella cartella "results".

$ code -r train_validation.pyOfferto da

import pandas as pd
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.preprocessing import LabelEncoder, StandardScaler
from deepchecks.tabular import Dataset
from deepchecks.tabular.suites import model_evaluation

# Load the loan data from a CSV file
loan_data = pd.read_csv("data/loan_data.csv")

# Define the label column
label_col = "not.fully.paid"

# Train test split
df_train, df_test = train_test_split(
    loan_data, stratify=loan_data[label_col], random_state=0
)

# Encode the 'purpose' column
label_encoder = LabelEncoder()
df_train["purpose"] = label_encoder.fit_transform(df_train["purpose"])
df_test["purpose"] = label_encoder.transform(df_test["purpose"])

# Standardize the features
scaler = StandardScaler()
df_train[df_train.columns.difference([label_col])] = scaler.fit_transform(df_train[df_train.columns.difference([label_col])])
df_test[df_test.columns.difference([label_col])] = scaler.transform(df_test[df_test.columns.difference([label_col])])

# Define models
model_1 = LogisticRegression(random_state=1, max_iter=10000)
model_2 = RandomForestClassifier(n_estimators=50, random_state=1)
model_3 = GaussianNB()

# Create the VotingClassifier
clf_model = VotingClassifier(
    estimators=[("lr", model_1), ("rf", model_2), ("gnb", model_3)], voting="soft"
)

# Train the model
clf_model.fit(df_train.drop(label_col, axis=1), df_train[label_col])

# Calculate the accuracy score using the .score function
accuracy = clf_model.score(df_test.drop(label_col, axis=1), df_test[label_col])

# Print the accuracy score
print(f"Accuracy: {accuracy:.2f}")

# Create Deepchecks datasets
deep_train = Dataset(df_train, label=label_col, cat_features=["purpose"])
deep_test = Dataset(df_test, label=label_col, cat_features=["purpose"])

# Run the evaluation suite
evaluation_suite = model_evaluation()
suite_result = evaluation_suite.run(deep_train, deep_test, clf_model)

# Save the results as HTML
suite_result.save_as_html("results/model_validation.html")Offerto da

Usare GitHub Actions

Se sei nuovo su GitHub Actions, completa prima il tutorial "GitHub Actions e MakeFile: un’introduzione pratica" prima di iniziare il processo di automazione. Questo tutorial fornirà una comprensione dettagliata di come funzionano le GitHub Actions con esempi di codice.

9. Per inizializzare le GitHub Actions, devi mettere in stage e fare commit delle modifiche e poi fare push sul repository remoto su GitHub.

$ git add .
$ git commit -m "Data and Validation files"  
$ git pushOfferto da

10. Vai al repository GitHub, clicca sulla scheda “Actions” e poi sul testo blu “set up a workflow yourself”.

11. Verrai reindirizzato al file del workflow main.yml. Copia e incolla il codice seguente. Il codice qui sotto prima imposterà l’ambiente e installerà il pacchetto DeepChecks. Poi creerà la cartella, eseguirà la validazione dei dati e la valutazione del modello e salverà i risultati come Artifact di GitHub.

name: Model Training and Validation

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Set up Python 3.10
        uses: actions/setup-python@v5
        with:
          python-version: '3.10'

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install deepchecks
          
      - name: Create a folder
        run: |
          mkdir -p results
          
      - name: Validate Data
        run: |
          python data_validation.py
      - name: Validate Model Performance
        run: |
          python train_validation.py
      - name: Archive Deepchecks Results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: deepchecks results
          path: results/*_validation.htmlOfferto da

12. Fai il commit delle modifiche con un messaggio.

Facendo il commit sulla branch principale, l’esecuzione del workflow verrà avviata. Per vedere il log di esecuzione, vai alla scheda "Actions" e clicca sull’esecuzione corrente del workflow associata al messaggio di commit.

13. Al termine dell’esecuzione del workflow, scorri verso il basso e scarica il file zip nella sezione “Artifacts”.

14. Apri lo zip in locale e visualizza i risultati di validazione dei dati e del modello.

Dai un’occhiata al repository GitHub kingabzpro/Automating-Machine-Learning-Testing come guida. Contiene dati, codice Python, file di workflow e altri file necessari per eseguire test completamente automatizzati.

Automatizzare l’intera pipeline di machine learning richiede conoscenze di vari processi e strumenti. Per approfondire, valuta di seguire il corso MLOps Deployment and Lifecycle. Questo corso esplora i moderni framework MLOps, con focus sul ciclo di vita e il deployment dei modelli di machine learning.

Conclusione

Automatizzando il processo di testing, gli sviluppatori possono validare rapidamente ed efficacemente l’accuratezza e la robustezza dei modelli su dataset grandi e complessi. Il testing automatico aiuta a identificare precocemente problemi come incoerenze nei dati, data drift e bias del modello, che potrebbero non emergere con test manuali. Questo fa risparmiare tempo e migliora la capacità del modello di fornire previsioni corrette ed eque.

In questo tutorial abbiamo visto il testing di machine learning e come usare DeepChecks per la validazione dei dati e il testing dei modelli. Abbiamo anche automatizzato i test su dati e modello e salvato i risultati come artifact usando GitHub Actions.

Se ti è piaciuto il tutorial e sei interessato a intraprendere una carriera nel machine learning, valuta l’iscrizione al career track Machine Learning Scientist with Python. Completa tutti i corsi in 3 mesi per acquisire le competenze necessarie per lavorare come machine learning scientist.