Een beginnersgids voor CI/CD voor machine learning

Continuous Integration (CI) en Continuous Deployment (CD) zijn praktijken die veel worden gebruikt in softwareontwikkeling om het proces van het integreren van codewijzigingen, het testen ervan en het snel uitrollen van de bijgewerkte applicatie te automatiseren. Aanvankelijk waren deze praktijken ontwikkeld voor traditionele softwareapplicaties, maar ze worden nu ook steeds relevanter in machine learning (ML)-projecten.

In deze uitgebreide gids bekijken we CI/CD voor ML en leren we hoe we onze eigen machinelearningpijplijn kunnen bouwen die het proces van het trainen, evalueren en deployen van het model automatiseert.

Deze gids presenteert een eenvoudig project dat uitsluitend GitHub Actions gebruikt om het hele proces te automatiseren. De meeste onderwerpen die we bespreken zijn bekend voor machine learning engineers en data scientists. Het enige nieuwe hier is hoe je GitHub Actions, Makefile, CML en Hugging Face CLI inzet.

Schrijf je in voor de cursus MLOps Concepts om te leren hoe je machinelearningmodellen van lokale notebooks naar productiemodellen brengt die businesswaarde leveren.

Waarom CI/CD voor machine learning?

CI/CD is een gamechanger als het gaat om het operationaliseren van je model en het gebruiken ervan om een product te ontwikkelen. Het stroomlijnen van het automatiseringsproces levert een foutloze, snelle en schaalbare oplossing op voor je ML-project, zodat je je kunt richten op het verbeteren van het model in plaats van het beheren en deployen van de oplossing.

Specifiek helpt CI/CD voor machine learning bij het volgende:

1. Automatiseert de trainingspijplijn

Met CI/CD kun je je modellen automatisch regelmatig opnieuw trainen op nieuwe data, wat tijd bespaart ten opzichte van handmatig retraining starten.

2. Vangt fouten vroegtijdig

CI-tools draaien tests en checks bij elke codecommit, wat helpt om bugs, integratieproblemen en afnames in modelprestaties te detecteren.

3. Reproduceerbaarheid

CI/CD helpt ervoor te zorgen dat modellen exact op dezelfde manier opnieuw kunnen worden opgebouwd en getraind, waardoor resultaten reproduceerbaar zijn. Omgevingen, model- en dataversiebeheer en configuraties worden gecodeerd.

4. Testen en monitoren

CI/CD maakt geautomatiseerd testen van nieuwe modellen vóór deployment mogelijk om problemen op te sporen. Het biedt ook beter monitoren van modellen na deployment via integratie met monitoringtools.

5. Snellere iteratie

Nieuwe modelversies of experimenten kunnen snel automatisch worden getraind, getest en gedeployed met CI/CD. Dit versnelt de ontwikkeling en verbetering van ML-systemen.

6. Schaalbaarheid

Naarmate het ML-project groeit in omvang en complexiteit, wordt het onpraktisch om de volledige levenscyclus handmatig te beheren. CI/CD-pijplijnen bieden een schaalbare oplossing die grote hoeveelheden data, talrijke modellen en diverse afhankelijkheden aankan, met behoud van efficiëntie en betrouwbaarheid.

Projectbeschrijving

In deze gids leiden we je door het opzetten van accounts en omgevingen, het bouwen van een CI/CD-pijplijn en het optimaliseren van het volledige proces.

We gebruiken scikit-learn-pijplijnen om ons random forest-algoritme te trainen en een medicijnclassificator te bouwen. Na het trainen automatiseren we het evaluatieproces met CML. Tot slot bouwen en deployen we de webapplicatie naar Hugging Face Hub.

Van training tot evaluatie: het hele proces wordt geautomatiseerd met GitHub Actions. Alles wat je hoeft te doen is de code naar je GitHub-repository pushen, en binnen twee minuten wordt het model geüpdatet op Hugging Face met de bijgewerkte app, het model en de resultaten.

Wil je meer leren met interactieve oefeningen? Volg dan DataCamps cursus CI/CD for Machine Learning om je ML-ontwikkeling te verbeteren met GitHub Actions en Data Version Control.

Aan de slag

In deze sectie maken we een GitHub-repository, de benodigde bestanden en mappen, en een Space in Hugging Face.

GitHub-repository

Klik op de knop “+” rechtsboven op de GitHub-startpagina en selecteer “New repository”.

Voeg de naam en beschrijving van de repository toe, vink het README-bestand aan en stel .gitignore in op Python.

Na het aanmaken van de repository moeten we de URL kopiëren. Open vervolgens de terminal of bash en navigeer naar de map waar we de projectmap willen opslaan.

Kloon tot slot de repository door het volgende commando uit te voeren:

git clone https://github.com/kingabzpro/CICD-for-Machine-Learning.git

Om te beginnen open je de lokale repository in je favoriete IDE. Voor dit project raden we VSCode aan. Zodra je de IDE start, zie je een VSCode-werkruimte met bestanden zoals README en LICENSE.

Hugging Face Spaces

Laten we een Hugging Face Space maken die we gebruiken om onze applicatie met het modelbestand te deployen.

1. Klik op je profielfoto en selecteer "New Space".

2. Voeg de naam van de Space, de licentie, het SDK-type toe en klik op Create Space.

3. Om het README.md-bestand te bewerken, klik je op de drie puntjes linksboven, selecteer je Files en maak je de benodigde wijzigingen.

4. We kopiëren de metadata uit het README-bestand van de Space en plakken die in ons lokale README-bestand dat in de App-map komt te staan.

Essentiële bestanden

We moeten de nodige map en het bestand aanmaken voordat we gaan experimenteren en pijplijnen bouwen. Dit helpt ons op de lange termijn om de werkruimte schoon te houden.

Mappen maken

1. App: voor het toevoegen van het webapp-classificatorbestand, de app-README met metadata en requirement.txt voor het installeren van benodigde pakketten.
2. Data: voor al onze CSV-bestanden.
3. Model: voor getrainde modelbestanden.
4. Results: voor het opslaan van metrics en resultaten in PNG-bestanden.

App-map

Maak een Python-bestand met de naam drug_app.py, samen met een README.md-bestand en een requirements.txt-bestand, en verplaats al deze bestanden naar de App-map. Dit helpt ons om alle noodzakelijke bestanden die nodig zijn om de app te draaien beter te organiseren.

Bewerk vervolgens het README.md-bestand in de App-map en zorg dat alle metadata-versies waar nodig zijn aangepast. Zo kun je eenvoudig verwijzen naar de locatie van de app-bestanden, kleuren wijzigen, de SDK-versie instellen en licentie-informatie toevoegen.

---
title: Drug Classification
emoji: 💊
colorFrom: yellow
colorTo: red
sdk: gradio
sdk_version: 4.16.0
app_file: drug_app.py
pinned: false
license: apache-2.0
---

Bewerk het requirement.txt-bestand in de App-map door de ontbrekende Python-pakketten toe te voegen:

scikit-learn
skops

Let op: de requirement- en README-bestanden verschillen voor de GitHub-repository en de Hugging Face Space.

Data-map

Download de Drug Classification-dataset van Kaggle, extraheer het CSV-bestand en verplaats het naar de Data-map.

Model- en Results-map

Zowel de Model- als de Results-mappen blijven leeg, omdat ze worden gevuld door het Python-script dat we draaien.

Repositorybestanden

1. Maak een Makefile om het draaien van het script in de GitHub Action-workflow te vereenvoudigen.
2. Maak een Jupyter Notebook met de naam notebook.ipynb. In dit notebook experimenteren we met onze algoritmes en verwerkingspijplijnen.
3. Maak een bestand met de naam requirements.txt. Dit wordt gebruikt om de omgeving in te richten tijdens het draaien van de CI-workflowjobs.
4. Maak een bestand met de naam train.py. Dit bevat Python-code voor het laden en verwerken van data, evenals het trainen, evalueren en opslaan van het model en de prestatiemetingen.

Zo zou onze mappenstructuur eruit moeten zien:

Trainen en evalueren van het medicijnclassificatiemodel

In dit gedeelte experimenteren we met Python-code die data verwerkt en een model traint met een scikit-learn-pijplijn. Daarna evalueren we het en slaan we de resultaten en het model op.

De dataset laden

We gebruiken pandas om ons CSV-bestand te laden, schudden de rijen met de sample-functie en tonen de bovenste drie rijen.

import pandas as pd

drug_df = pd.read_csv("Data/drug.csv")
drug_df = drug_df.sample(frac=1)
drug_df.head(3)

Train-test-split

Maak een afhankelijke en een onafhankelijke variabele. Splits ze daarna in trainings- en testsets. Dit helpt je de prestaties van je model te evalueren.

from sklearn.model_selection import train_test_split

X = drug_df.drop("Drug", axis=1).values
y = drug_df.Drug.values

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=125
)

Machine learning-pijplijnen

We bouwen een verwerkingspijplijn met ColumnTransformer, die categorische waarden omzet naar getallen, missende waarden invult en de numerieke kolommen schaalt.

Daarna maken we een trainingspijplijn die de getransformeerde data gebruikt en een random forest-classifier traint.

Tot slot trainen we het model.

Met pijplijnen borgen we reproduceerbaarheid, modulariteit en duidelijkheid in onze code.

from sklearn.compose import ColumnTransformer
from sklearn.ensemble import RandomForestClassifier
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OrdinalEncoder, StandardScaler

cat_col = [1,2,3]
num_col = [0,4]

transform = ColumnTransformer(
    [
        ("encoder", OrdinalEncoder(), cat_col),
        ("num_imputer", SimpleImputer(strategy="median"), num_col),
        ("num_scaler", StandardScaler(), num_col),
    ]
)
pipe = Pipeline(
    steps=[
        ("preprocessing", transform),
        ("model", RandomForestClassifier(n_estimators=100, random_state=125)),
    ]
)
pipe.fit(X_train, y_train)

Model-evaluatie

Evalueer de prestaties van het model door zowel de accuracy als de F1-score te berekenen.

from sklearn.metrics import accuracy_score, f1_score

predictions = pipe.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
f1 = f1_score(y_test, predictions, average="macro")

print("Accuracy:", str(round(accuracy, 2) * 100) + "%", "F1:", round(f1, 2))

Ons model presteerde uitzonderlijk goed.

Accuracy: 95.0% F1: 0.91

Maak het metrics-bestand en sla het op in de Results-map.

with open("Results/metrics.txt", "w") as outfile:
    outfile.write(f"\nAccuracy = {accuracy.round(2)}, F1 Score = {f1.round(2)}.")

We maken vervolgens de confusion matrix en slaan de afbeelding op in de Results-map.

import matplotlib.pyplot as plt
from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix

cm = confusion_matrix(y_test, predictions, labels=pipe.classes_)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=pipe.classes_)
disp.plot()
plt.savefig("Results/model_results.png", dpi=120)

Het model opslaan

We slaan ons model nu op met het Python-pakket skops. Hiermee kunnen we zowel de scikit-learn-pijplijn als het model opslaan.

import skops.io as sio

sio.dump(pipe, "Model/drug_pipeline.skops")

Je kunt de volledige pijplijn laden en die werkt direct, zonder je data apart te verwerken of de code aan te passen.

sio.load("Model/drug_pipeline.skops", trusted=True)

Kopieer en plak de volledige code in het 'train.py'-bestand. Dit wordt het gestandaardiseerde trainingsscript dat in de CI-workflow draait zodra er een wijziging in de data of code is.

Voordat je aan je MLOps-carrière begint, lees de MLOps Roadmap: A Complete Career Guide.

Stappen om je Continuous Integration-pijplijn te bouwen

In deze sectie behandelen we CML, Makefile en het instellen van GitHub Action-workflows om de training, evaluatie en versiebeheer van ons project te automatiseren.

CI-pijplijn

CML

Continuous Machine Learning (CML) is een open-sourcelibrary waarmee je continuous integration in je machinelearningprojecten kunt implementeren. We gebruiken de GitHub Action "iterative/setup-cml" die CML-functies in de workflow inzet om automatisch het modelevaluatierapport te genereren.

Wat betekent dit? Telkens wanneer je wijzigingen naar GitHub pusht, wordt er een rapport gegenereerd bij de commit en ontvang je een e-mail met prestatiemetingen en een confusion matrix.

Makefile

Een Makefile is een bestand met een set instructies die door het make-commando worden gebruikt om allerlei taken te automatiseren, zoals code compileren, tests draaien, omgevingen opzetten, data preprocessen, modellen trainen en evalueren, en modellen deployen.

We kunnen make-commando's gebruiken om meerdere scripts te draaien en zo het CI-workflowbestand schoon en eenvoudig te houden. De Makefile bevat de naam van de commandosets en het script om die commando's te draaien.

Hier is onze Makefile:

install:
    pip install --upgrade pip &&\
        pip install -r requirements.txt

format:
    black *.py

train:
    python train.py

eval:
    echo "## Model Metrics" > report.md
    cat ./Results/metrics.txt >> report.md
   
    echo '\n## Confusion Matrix Plot' >> report.md
    echo '![Confusion Matrix](./Results/model_results.png)' >> report.md
   
    cml comment create report.md

We hebben commando's om Python-pakketten te installeren (install), code te formatteren (format), trainingsscripts te draaien (train) en CML-rapporten te genereren (eval).

Daarna voegen we de wijzigingen toe, maken een commit en pushen de wijzigingen naar de GitHub-remote server.

git commit -am "new changes"
git push origin main

GitHub Actions

Om training en evaluatie te automatiseren, moeten we een GitHub Action-workflow maken. Ga hiervoor naar het tabblad “Actions” in onze repository kingabzpro/CICD-for-Machine-Learning en klik op de blauwe tekst “set up a workflow yourself.”

Hernoem het .yml-bestand naar “ci” en begin met het toevoegen van de GitHub Action-commando's.

1. Voeg de naam van de workflow toe.
2. Stel de trigger in zodat de workflow draait bij een push of pull request naar de main-branch of bij een handmatige run.
3. Bouw een omgeving voor de job. We laden de nieuwste Linux-server.
4. Activeer de GitHub Actions die we in de workflow gaan gebruiken.
5. Voeg verschillende runs toe met diverse make-commando's.
6. Trigger de workflow door wijzigingen te committen. GitHub Action zal alle stappen in de pijplijn één voor één uitvoeren.

Je zult fouten tegenkomen bij het uitzoeken van errors en syntax. Daarom is het belangrijk om de Workflow-syntaxis voor GitHub Actions te lezen voordat je met GitHub Action aan de slag gaat.

We hebben alle fouten en problemen met de workflow succesvol opgelost en hebben nu de definitieve versie van het `ci.yml`-bestand die soepel draait.

Zoals je ziet zet de workflow eerst de omgeving op en laadt de benodigde actions. Daarna draaien we elke stap één voor één met het make-commando, dat op de achtergrond verschillende Python- en Bash-scripts aanroept.

Er zijn echter twee belangrijke zaken om in gedachten te houden bij het werken met CML-actions. Ten eerste moeten we aan het begin de schrijfrechten instellen. Ten tweede moeten we een GitHub-token aan een CML-job meegeven, dat we via de secrets kunnen benaderen.

name: Continuous Integration
on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]
  workflow_dispatch:
  
permissions: write-all
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: iterative/setup-cml@v2
      - name: Install Packages
        run: make install
      - name: Format
        run: make format
      - name: Train
        run: make train
      - name: Evaluation
        env:
          REPO_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: make eval

De metrics en resultaten verschijnen onder het commitbericht.

Je ontvangt ook een e-mail met de resultaten.

De resultaten opslaan in een nieuwe branch

We genereren het evaluatierapport, maar we doen geen versiebeheer van het model en de resultaten. Om de wijzigingen op te slaan maken we een nieuwe branch met de naam "update" en pushen we het bijgewerkte model en de resultaten daarheen.

Maak de branch "update" aan door op de main-branchknop te klikken, "update" als branchtitel te typen en vervolgens "create branch update from main" te selecteren.

Repositorysecret aanmaken

Om met Git-commando wijzigingen te committen en pushen, moeten we een gebruikersnaam en e-mailadres opgeven. Je kunt die rechtstreeks toevoegen, maar GitHub-secrets gebruiken is een betere optie. Volg deze stappen:

1. Ga naar Settings en klik op "Secrets and variables".
2. Selecteer "Actions" en klik op de groene knop met het label "New repository secret."
3. Voeg de naam en waarden toe. Dit lijkt op het instellen van een omgevingsvariabele op je lokale machine.

Dat is alles!

Makefile en ci.yml updaten

Om het opslaan van de wijzigingen naar de nieuwe branch te automatiseren, moeten we de Makefile en ci.yml bijwerken.

Makefile:

We configureren de gebruikersnaam en het e-mailadres, committen de wijzigingen en slaan ze op naar de update-branch.

update-branch:
	git config --global user.name $(USER_NAME)
	git config --global user.email $(USER_EMAIL)
	git commit -am "Update with new results"
	git push --force origin HEAD:update

ci.yml:

De Makefile gebruikt een omgevingsvariabele om het script te draaien. Daarvoor moeten we eerst de waarde van de omgevingsvariabele uit de secrets halen en vervolgens de omgevingsvariabele aan het einde van het make-commando meegeven.

    - name: Update Branch
        env:
          NAME: ${{ secrets.USER_NAME }}
          EMAIL: ${{ secrets.USER_EMAIL }}
        run: make update-branch USER_NAME=$NAME USER_EMAIL=$EMAIL

Zodra je de bestanden hebt bijgewerkt en de wijzigingen naar de main-branch hebt gepusht, zie je de magie realtime gebeuren. Er wordt een analytisch rapport gegenereerd, samen met een bijgewerkt model dat in het gedeelte over continuous deployment kan worden gedeployed naar Hugging Face.

Stappen om je Continuous Deployment-pijplijn te bouwen

In het gedeelte over Continuous Deployment ontdekken we hoe we het proces van het deployen van zowel het model als de applicatie automatiseren. Dit houdt in: de bijgewerkte model- en applicatiebestanden ophalen uit de `update`-branch, inloggen bij Hugging Face CLI met een token, de model- en applicatiebestanden pushen en tot slot de applicatie deployen.

De Gradio-app bouwen

Om ons model te deployen en te kunnen gebruiken, moeten we een Gradio-app maken. Deze app bevat:

1. Het laden van de scikit-learn-pijplijn en het model.
2. Een Python-functie om medicijnlabels te voorspellen op basis van invoer van de gebruiker.
3. Een invoer-UI met Gradio-sliders voor floatwaarden en Gradio-radio voor categorische waarden.
4. Voorbeeldinvoer om het model eenvoudig te testen.
5. De titel van de applicatie, een korte beschrijving van de functies en werking, en een footer met relevante informatie.
6. We geven al deze variabelen en de predictiefunctie door aan de Gradio-Interface-functie en starten die.
7. Om onze webapp modern te laten ogen, gebruiken we een standaard soft-thema.

import gradio as gr
import skops.io as sio

pipe = sio.load("./Model/drug_pipeline.skops", trusted=True)


def predict_drug(age, sex, blood_pressure, cholesterol, na_to_k_ratio):
    ""Predict drugs based on patient features.

    Args:
        age (int): Age of patient
        sex (str): Sex of patient 
        blood_pressure (str): Blood pressure level
        cholesterol (str): Cholesterol level
        na_to_k_ratio (float): Ratio of sodium to potassium in blood

    Returns:
        str: Predicted drug label
    """
    features = [age, sex, blood_pressure, cholesterol, na_to_k_ratio]
    predicted_drug = pipe.predict([features])[0]

    label = f"Predicted Drug: {predicted_drug}"
    return label


inputs = [
    gr.Slider(15, 74, step=1, label="Age"),
    gr.Radio(["M", "F"], label="Sex"),
    gr.Radio(["HIGH", "LOW", "NORMAL"], label="Blood Pressure"),
    gr.Radio(["HIGH", "NORMAL"], label="Cholesterol"),
    gr.Slider(6.2, 38.2, step=0.1, label="Na_to_K"),
]
outputs = [gr.Label(num_top_classes=5)]

examples = [
    [30, "M", "HIGH", "NORMAL", 15.4],
    [35, "F", "LOW", "NORMAL", 8],
    [50, "M", "HIGH", "HIGH", 34],
]


title = "Drug Classification"
description = "Enter the details to correctly identify Drug type?"
article = "This app is a part of the Beginner's Guide to CI/CD for Machine Learning. It teaches how to automate training, evaluation, and deployment of models to Hugging Face using GitHub Actions."


gr.Interface(
    fn=predict_drug,
    inputs=inputs,
    outputs=outputs,
    examples=examples,
    title=title,
    description=description,
    article=article,
    theme=gr.themes.Soft(),
).launch()

Open de terminal en draai de app lokaal om problemen op te lossen voordat je wijzigingen naar de remote repository pusht.

python ./App/drug_app.py 

Running on local URL:  http://127.0.0.1:7860

To create a public link, set `share=True` in `launch()`.

Hugging Face-token instellen

We genereren nu het Hugging Face-token en geven het door aan ons Makefile-script. We moeten er echter voor zorgen dat het token vertrouwelijk blijft en niet uitlekt. Hiervoor gebruiken we GitHub-secrets.

Klik eerst op je Hugging Face-profielfoto en selecteer de optie Settings. Kies vervolgens "Access Tokens" en klik op de knop "New Token" om het token te genereren. Zorg er tijdens het genereren voor dat het token schrijfrechten heeft.

Kopieer het token en maak een repositorysecret aan, net zoals we deden met gebruikersnaam en e-mail.

CD-workflow

In dit gedeelte voegen we drie nieuwe commando's toe om bestanden te maken en creëren we nog een GitHub-workflow genaamd "Continuous Deployment". Deze workflow helpt bij het automatiseren van het ophalen en deployen van bestanden.

Makefile

• Haal de bijgewerkte model- en resultaatbestanden op uit de update-branch en schakel over naar de update-branch.
• Voor het inloggen moeten we de Hugging Face CLI installeren en vervolgens inloggen met het token.
• We pushen de App-map naar de basisdirectory van de Space, zodat die het Python-bestand, de README en de requirement.txt-bestanden bevat om de omgeving te bouwen en de applicatie te draaien.
• We uploaden ook de Model- en Results-mappen.
• Het deploy-commando draait eerst hf-login en daarna push-hub.

hf-login:
    git pull origin update
    git switch update
    pip install -U "huggingface_hub[cli]"
    huggingface-cli login --token $(HF) --add-to-git-credential

push-hub:
    huggingface-cli upload kingabzpro/Drug-Classification ./App --repo-type=space --commit-message="Sync App files"
    huggingface-cli upload kingabzpro/Drug-Classification ./Model /Model --repo-type=space --commit-message="Sync Model"
    huggingface-cli upload kingabzpro/Drug-Classification ./Results /Metrics --repo-type=space --commit-message="Sync Model"

deploy: hf-login push-hub

Onze applicatie heeft dan toegang tot een bijgewerkt model, applicatiebestand en resultaten, zodat we wijzigingen in de Hugging Face Space kunnen volgen.

cd.yml

Om onze workflow écht CI/CD te maken, moeten we een ander bestand maken met de naam cd.yml, vergelijkbaar met ons ci.yml-bestand. Zodra de CI-pijplijn is voltooid, start deze het cd.yml-workflowbestand via het on-argument met de parameter workflow_run.

Deze workflow bouwt de omgeving en voert het make deploy-commando uit met behulp van het Hugging Face-token om de laatste wijzigingen naar de Hugging Face Hub te deployen.

name: Continuous Deployment
on:
  workflow_run:
    workflows: ["Continuous Integration"]
    types:
      - completed

  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Deployment To Hugging Face
        env:
          HF: ${{ secrets.HF }}
        run: make deploy HF=$HF

Wanneer we de wijzigingen naar de main-branch pushen, start de CI-workflow.

Na voltooiing van de CI-workflow begint de CD-workflow, zoals hieronder te zien is.

We kunnen de live-logs van elke functie bekijken door de run-optie in de workflowbuild te selecteren. Onze bestanden zijn succesvol geüpload naar de Hugging Face-server.

Na ontvangst van het bijgewerkte bestand begint de Hugging Face Space de omgeving te bouwen en draait de app binnen enkele seconden.

Onze Drug Classification-applicatie werkt naadloos en heeft een mooie interface.

Probeer verschillende gegevens in te voeren om de prestaties van het model te ervaren.

Afbeelding bron

Conclusie

Deze gids schetst hoe we de processen voor training, evaluatie, versiebeheer en deployment hebben geautomatiseerd, zodat elke wijziging in data of algoritmen dit proces automatisch en foutloos triggert. Deze aanpak helpt ons om snelle, schaalbare en productieklare applicaties te bouwen.

Houd er rekening mee dat we in realistische projecten meerdere MLOps-tools gebruiken om machinelearningapplicaties te orkestreren, te versies, te deployen en te monitoren. Wil je meer leren over deze tools? Bekijk dan Top MLOps Tools You Need to Know, met populaire technologieën die door grote techbedrijven worden gebruikt om hun ML-applicaties te stroomlijnen.

Om je CI/CD-pijplijn te optimaliseren, is het cruciaal om tools als Docker, Kubernetes, Azure Cloud en andere MLOps-technologieën te leren. Volg een tutorial over Machine Learning, Pipelines, Deployment en MLOps om vertrouwd te raken met industriestandaarden en aan geavanceerde projecten te werken.

Projectbronnen

• GitHub-repository: kingabzpro/CICD-for-Machine-Learning
• Hugging Face Space: Drug Classification - een Hugging Face Space door kingabzpro
• Kaggle-dataset: Drug Classification