DeepChecks-tutorial: machinelearning-tests automatiseren

In deze tutorial leren we wat DeepChecks is en hoe je het gebruikt voor datavalidatie en machinelearning-tests. We gebruiken ook GitHub Actions om het testen van het model te automatiseren en de resultaten als artifacts op te slaan. 

Gaandeweg behandelen we machinelearning-tests en DeepChecks, draaien we de DeepChecks data-integriteitssuite en genereren we een uitgebreid rapport. We maken ook test­rapporten voor machine learning door een model­evaluatiesuite te draaien, leren een enkele test te draaien in plaats van een volledige suite, automatiseren onze testworkflow met GitHub Actions en slaan het test­rapport op als een GitHub Artifact. 

Afbeelding door de auteur

Wat is machinelearning-testing?

Machinelearning-testing is een cruciaal proces waarbij de prestaties van ML-modellen worden geëvalueerd en gevalideerd om hun eerlijkheid, nauwkeurigheid en robuustheid te waarborgen. Het draait niet alleen om modelnauwkeurigheid en -prestatie. We moeten ook kijken naar modelbias, false positives, false negatives, diverse prestatiemetrics, doorvoersnelheid en de afstemming van het model op AI-ethiek. 

Het testproces omvat verschillende vormen van beoordeling, zoals datavalidatie, kruisvalidatie, F1-score, verwarringsmatrix, predictiedrift, datadrift en robuustheidstests — elk bedoeld om verschillende aspecten van de prestaties en betrouwbaarheid van het model te verifiëren. 

We verdelen onze dataset ook in drie splits, zodat we het model tijdens het trainingsproces kunnen evalueren en erna op een onzichtbare dataset. 

Machinelearning-testing is een essentieel onderdeel van AI-toepassingen, en door het samen met modeltraining te automatiseren, krijgen we betrouwbare AI-systemen die voor mensen werken.

Ben je nieuw in machine learning en wil je de basis leren? Volg dan de Machine Learning Fundamentals skill track met Python. Deze cursus leert je de fundamenten van machine learning met Python, te beginnen met supervised learning met de scikit-learn-bibliotheek.

Aan de slag met DeepChecks

DeepChecks is een open-source Python-pakket dat is ontworpen om uitgebreid testen en valideren van machinelearning-modellen en -data te faciliteren. Het biedt een breed scala aan ingebouwde checks om problemen te identificeren rond modelprestaties, dataverdeling, dataintegriteit en meer. DeepChecks bevat functionaliteit voor continue validatie, zodat modellen betrouwbaar en effectief blijven wanneer ze in de praktijk worden ingezet en gebruikt.

We beginnen met het installeren van het Python-pakket met het commando pip.

%pip install deepchecks --upgrade -qMogelijk gemaakt door

De dataset laden

Voor deze tutorial gebruiken we de Loan Data uit de DataCamp-datasets. Deze bestaat uit 9578 rijen en informatie over de leningsstructuur, de lener en of de lening volledig is terugbetaald.

Laad het CSV-bestand met Pandas en geef de bovenste 5 rijen weer.

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()Mogelijk gemaakt door

De dataset voorbereiden

Maak de DeepChecks-dataset met de leningendataset, de naam van de labelkolom en de categorische featurenaam.

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"])Mogelijk gemaakt door

De DeepChecks data-integriteitssuite draaien

We gebruiken een data-integriteitssuite voor tabeldata. De suite draait alle tests autonoom en genereert een interactief rapport met de resultaten. 

Hiervoor importeren we de data-integriteitssuite, initialiseren deze en draaien de suite met de DeepChecks-leningdata. Tot slot tonen we de resultaten.

from deepchecks.tabular.suites import data_integrity

integ_suite = data_integrity()
suite_result = integ_suite.run(deep_loan_data)
suite_result.show()Mogelijk gemaakt door

Let op: we gebruiken DataLab als ontwikkelomgeving. Het gebruik van ipywidgets is uitgeschakeld, waardoor resultaten niet worden weergegeven. In plaats daarvan gebruiken we de functie 'show_in_iframe' om het resultaat als een iframe te tonen. De resultaten zijn op elk niveau hetzelfde.

suite_result.show_in_iframe()Mogelijk gemaakt door

Ons data-integriteitsrapport bevat testresultaten over:

• Feature-labelcorrelatie
• Feature-featurecorrelatie
• Enkele waarde in kolom
• Speciale tekens
• Gemengde nulls
• Gemengde datatypen
• String-afwijkingen
• Dataduplicaten
• Stringlengte buiten bereik
• Conflicterende labels
• Detectie van uitbijter­samples

Resultaten van de data-integriteitstest in de Jupyter Notebook. 

Je kunt de resultaten zelfs als een HTML-bestand opslaan en delen met je collega’s. 

suite_result.save_as_html()Mogelijk gemaakt door

'output.html'Mogelijk gemaakt door

Een enkele test draaien

De volledige suite op een grote dataset draaien is niet efficiënt, want het genereren van resultaten duurt lang. In plaats daarvan kun je een paar individuele tests draaien die relevant zijn voor jouw data en daar je eigen rapport van maken.

Om één test te draaien, importeer je de tabulaire checks, initialiseer je de check en voer je deze uit met de DeepCheck-leningdata. Laat daarna de waarden zien in plaats van een interactief rapport te genereren, met de functie results.value.

from deepchecks.tabular.checks import IsSingleValue, DataDuplicates

result = IsSingleValue().run(deep_loan_data)
result.valueMogelijk gemaakt door

Zoals je ziet, toont dit het aantal unieke waarden in elke kolom. 

{'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}Mogelijk gemaakt door

Laten we nu kijken of er duplicate samples in onze data zitten. 

result = DataDuplicates().run(deep_loan_data)
result.valueMogelijk gemaakt door

We hebben nul duplicaten in onze dataset. 

0.0Mogelijk gemaakt door

Machinelearning-tests met DeepChecks

In deze sectie combineren we meerdere modellen en trainen we ze op de verwerkte leningendataset. Vervolgens draaien we een modelevaluatiesuite op de train- en testsets om een modeltestrapport te genereren. 

Dataverwerking en modeltraining

1. Importeer essentiële functies uit de Scikit-learn-bibliotheek. 
2. Splits de dataset in train- en testsets. 
3. Zet de categorische kolom 'purpose' om naar numeriek met de labelencoder.
4. Definieer de modellen LogisticRegression, RandomForestClassifier en GaussianNB. 
5. Combineer modellen met de voting classifier. 
6. Train het ensemblemodel op de trainingsset. 

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])Mogelijk gemaakt door

Modelevaluatiesuite draaien

We draaien de DeepChecks-modelevaluatiesuite om de prestaties van het model te beoordelen. 

7. Zet zowel de train- als testset om naar de DeepCheck-dataset. 
8. Initialiseer de modelevaluatie en draai deze met de train- en testsets en het model. 
9. Toon de resultaten in de 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()Mogelijk gemaakt door

Ons modelevaluatierapport bevat testresultaten over:

• ROC-rapport
• Zwakke segmentprestaties
• Ongebruikte features
• Train-testprestaties
• Predictiedrift
• Vergelijking met simpel model
• Inference-tijd van model
• Verwarringsmatrix-rapport
• En meer

10. Gebruik de functie to_json() om het resultaat in JSON-indeling te bekijken. 

suite_result.to_json()Mogelijk gemaakt door

Een enkele test draaien

Net als bij datavalidatie kun je één enkele machinelearningtest draaien. In ons geval draaien we labeldrift op de train- en testsplit om te controleren of onze labels in de tijd zijn veranderd. 

from deepchecks.tabular.checks import LabelDrift
check = LabelDrift()
result = check.run(deep_train, deep_test)
result.valueMogelijk gemaakt door

Er is geen drift gedetecteerd in de data.

{'Drift score': 0.0, 'Method': "Cramer's V"}Mogelijk gemaakt door

Heb je moeite met het draaien van de data­validatie- en modelevaluatiesuites? Raadpleeg dan de DataLab-werkruimte op Machine Learning Testing with DeepChecks.

Ben je geïnteresseerd in "handmatig" machinelearning-testen? Volg dan de tutorial Machine Learning Experimentation en leer hoe je ML-experimenten structureert, logt en analyseert met Weights & Biases.

Machinelearning-tests automatiseren met GitHub Actions en DeepChecks

Laten we de fasen datavalidatie, modeltraining en modelevaluatie automatiseren met GitHub Actions en de resultaten als zipbestand opslaan. 

Het automatiseren van machinelearning-tests is een integraal onderdeel van de MLOps-pijplijn. Leer hier meer over in de MLOps Fundamentals skill track. In deze serie cursussen leer je de basisprincipes van het in productie brengen en monitoren van machinelearning-modellen om bedrijfswaarde te leveren.

Installatie

1. Ga naar je GitHub-account en maak een nieuwe repository met alle benodigde informatie. 

2. Kloon de repository op het lokale systeem.
3. Verander de directory naar de repository. 
4. Maak een nieuwe map “data” en verplaats het CSV-bestand met leningdata van de map "Downloads" naar de repositorymap. 
5. Maak de datavalidatie in Python en start VSCode (geïntegreerde ontwikkelomgeving). 

$ 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.pyMogelijk gemaakt door

Datavalidatiebestand

6. In het datavalidatiebestand laad je het CSV-bestand, zet je het om naar de DeepChecks-dataset, initialiseer je de data-integratiesuite en draai je deze op de leningendataset. 
7. Maak de nieuwe map “results” en sla het als HTML-bestand op. 

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")Mogelijk gemaakt door

Modeltestbestand

8. Maak een Python-bestand voor datavalidatie met daarin dataverwerking, modelbouw, training en evaluatie. Dit bestand moet ook het omzetten van de dataset naar een DeepChecks-dataset bevatten, het draaien van de modelevaluatiesuite en het opslaan als HTML-bestand in de map "results".

$ code -r train_validation.pyMogelijk gemaakt door

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")Mogelijk gemaakt door

GitHub Actions gebruiken

Ben je nieuw met GitHub Actions? Voltooi dan eerst de tutorial "GitHub Actions and MakeFile: A Hands-on Introduction" voordat je met de automatisering begint. Deze tutorial geeft een gedetailleerd begrip van hoe GitHub Actions werkt, met codevoorbeelden.

9. Om GitHub Actions te initialiseren, moet je de wijzigingen stagen en committen en naar de remote GitHub-repository pushen. 

$ git add .
$ git commit -m "Data and Validation files"  
$ git pushMogelijk gemaakt door

10. Ga naar de GitHub-repository en klik op het tabblad “Actions” en daarna op de blauwe tekst “set up a workflow yourself”. 

11. We worden doorgestuurd naar het workflowbestand main.yml. Kopieer en plak de volgende code. De code hieronder zet eerst de omgeving op en installeert het DeepChecks-pakket. Daarna maakt het de map aan, draait datavalidatie en modelevaluatie en slaat de resultaten op als een GitHub Artifact.

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.htmlMogelijk gemaakt door

12. Commit de wijzigingen met het bericht. 

Door de wijzigingen naar de mainbranch te committen, wordt de workflowrun gestart. Om het runlog te bekijken, ga je naar het tabblad "Actions" en klik je op de huidige workflowrun die hoort bij het commitbericht.

13. Wanneer de workflowrun is voltooid, scroll dan naar beneden en download het zipbestand onder de sectie “Artifacts”.

14. Open het zipbestand lokaal en bekijk de resultaten van data- en modelvalidatie. 

Bekijk zeker de kingabzpro/Automating-Machine-Learning-Testing GitHub-repository als gids. Deze bevat data, Python-code, workflowbestanden en andere noodzakelijke bestanden om volledig geautomatiseerde tests te draaien. 

Het automatiseren van de volledige machinelearningpijplijn vereist kennis van verschillende processen en tools. Wil je hierover leren? Volg dan een MLOps Deployment and Lifecycle-cursus. Deze cursus verkent moderne MLOps-frameworks, met focus op de levenscyclus en uitrol van ML-modellen.

Conclusie

Door het testproces te automatiseren kunnen ontwikkelaars snel en efficiënt de nauwkeurigheid en robuustheid van modellen valideren op grote en complexe datasets. Geautomatiseerd testen helpt om vroegtijdig problemen te ontdekken, zoals datainconsistenties, datadrift en modelbias — zaken die bij handmatig testen mogelijk niet opvallen. Dit bespaart tijd en vergroot het vermogen van het model om eerlijke en nauwkeurige voorspellingen te doen.

In deze tutorial hebben we geleerd over machinelearning-tests en hoe je DeepChecks gebruikt voor datavalidatie en machinelearning-tests. We hebben ook data- en modeltesten geautomatiseerd en de resultaten als artifacts opgeslagen met GitHub Actions. 

Vond je de tutorial leuk en wil je een carrière in machine learning starten? Overweeg dan om je in te schrijven voor de Machine Learning Scientist with Python career track. Rond alle cursussen binnen 3 maanden af om de skills op te doen die je nodig hebt voor een baan als machinelearning-scientist.