Guida per Principianti a CI/CD per il Machine Learning

Continuous Integration (CI) e Continuous Deployment (CD) sono pratiche comunemente usate nello sviluppo software per automatizzare l’integrazione delle modifiche al codice, testarli e distribuire rapidamente l’applicazione aggiornata. Inizialmente pensate per le applicazioni software tradizionali, oggi sono sempre più rilevanti anche nei progetti di machine learning (ML).

In questa guida completa, daremo uno sguardo a CI/CD per ML e impareremo a costruire una nostra pipeline di machine learning che automatizzi il processo di training, valutazione e deployment del modello.

Questa guida presenta un progetto semplice che utilizza solo le GitHub Actions per automatizzare l’intero processo. La maggior parte degli argomenti trattati sono ben noti a machine learning engineer e data scientist. L’unica novità qui è come usare GitHub Actions, Makefile, CML e Hugging Face CLI.

Iscriviti al corso MLOps Concepts per imparare a portare i modelli di machine learning dai notebook locali a modelli in produzione che generano valore di business.

Perché CI/CD per il Machine Learning?

La CI/CD cambia le regole del gioco quando si tratta di operazionalizzare il tuo modello e usarlo per sviluppare un prodotto. Snellire l’automazione fornisce una soluzione priva di bug, veloce e scalabile per il tuo progetto ML, permettendoti di concentrarti sul miglioramento del modello piuttosto che sulla gestione e il deployment della soluzione.

In particolare, la CI/CD per il machine learning aiuta in:

1. Automatizza la pipeline di training

Con la CI/CD, puoi riaddestrare automaticamente i tuoi modelli su nuovi dati a cadenza regolare, risparmiando tempo rispetto all’innesco manuale del retraining.

2. Intercetta gli errori in anticipo

Gli strumenti CI eseguono test e controlli a ogni commit di codice, aiutando a intercettare bug, problemi di integrazione e cali di performance del modello.

3. Riproducibilità

La CI/CD aiuta a garantire che i modelli possano essere ricostruiti e riaddestrati esattamente allo stesso modo, consentendo la riproducibilità dei risultati. Ambienti, versionamento di modelli e dati e configurazioni sono codificati.

4. Test e monitoraggio

La CI/CD consente test automatizzati dei nuovi modelli prima del deployment per individuare problemi. Permette anche un migliore monitoraggio dei modelli post-deployment tramite integrazione con strumenti di monitoring.

5. Iterazione più rapida

Nuove versioni di modelli o esperimenti possono essere addestrati, testati e distribuiti rapidamente in modo automatizzato con CI/CD. Questo accelera lo sviluppo e il miglioramento dei sistemi ML.

6. Scalabilità

Man mano che il progetto ML cresce in dimensioni e complessità, gestire manualmente l’intero ciclo di vita diventa impraticabile. Le pipeline CI/CD offrono una soluzione scalabile in grado di gestire grandi volumi di dati, numerosi modelli e dipendenze eterogenee mantenendo efficienza e affidabilità.

Descrizione del Progetto

In questa guida, ti accompagneremo nella configurazione di account e ambienti, nella creazione di una pipeline CI/CD e nell’ottimizzazione dell’intero processo.

Useremo le pipeline di scikit-learn per addestrare il nostro algoritmo random forest e costruire un classificatore di farmaci. Dopo l’addestramento, automatizzeremo il processo di valutazione usando CML. Infine, costruiremo e distribuiremo l’applicazione web su Hugging Face Hub.

Dal training alla valutazione, l’intero processo sarà automatizzato usando le GitHub Actions. Tutto ciò che devi fare è pushare il codice sul tuo repository GitHub e, in due minuti, il modello sarà aggiornato su Hugging Face insieme all’app, al modello e ai risultati aggiornati.

Se vuoi imparare di più con esercizi interattivi, prova il corso di DataCamp CI/CD for Machine Learning per portare lo sviluppo di machine learning al livello successivo con GitHub Actions e Data Version Control.

Configurazione

In questa sezione, creeremo un repository GitHub, i file e le cartelle necessari e uno Space su Hugging Face.

Repository GitHub

Clicca sul pulsante “+” in alto a destra nella pagina principale di GitHub e seleziona “New repository”.

Aggiungi il nome e la descrizione del repository, seleziona il file README e imposta .gitignore su Python.

Dopo aver creato il repository, dobbiamo copiarne l’URL. Poi apri il terminale o la bash e vai nella directory in cui vuoi salvare la cartella del progetto.

Infine, clona il repository eseguendo il seguente comando:

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

Per iniziare, usa il tuo IDE preferito per aprire il repository locale. Per questo progetto consigliamo VSCode. Una volta avviato l’IDE, vedrai un workspace VSCode con file come README e LICENSE.

Hugging Face Spaces

Creiamo uno Space su Hugging Face che useremo per distribuire la nostra applicazione con il file del modello.

1. Clicca sulla tua immagine del profilo e seleziona "New Space".

2. Aggiungi il nome dello Space, la licenza, il tipo di SDK e crea lo Space.

3. Per modificare il file README.md, clicca sui tre puntini in alto a sinistra, seleziona Files e apporta le modifiche necessarie.

4. Copia i metadati dal README dello Space e incollali nel nostro README locale che resterà nella cartella App.

File essenziali

Dobbiamo creare la cartella e i file necessari prima di iniziare a sperimentare e a costruire le pipeline. Questo ci aiuterà a mantenere pulito l’ambiente di lavoro.

Crea le cartelle

1. App: per aggiungere il file del classificatore web app, il README dell’app con i metadati e requirement.txt per installare i pacchetti necessari.
2. Data: per tutti i nostri file CSV.
3. Model: per i file dei modelli addestrati.
4. Results: per salvare metriche e risultati in file PNG.

Cartella App

Crea un file Python chiamato drug_app.py, insieme a un file README.md e un file requirements.txt, e sposta tutti questi file nella cartella App. Questo ci aiuterà a organizzare meglio tutti i file necessari per eseguire l’app.

Poi modifica il file README.md nella cartella App e assicurati che tutte le versioni dei metadati siano state aggiornate di conseguenza. Questo ti permetterà di puntare facilmente alla posizione dei file dell’app, cambiare i colori, impostare la versione dell’SDK e aggiungere le informazioni sulla licenza.

---
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
---

Modifica il file requirement.txt nella cartella App aggiungendo i pacchetti Python mancanti:

scikit-learn
skops

Nota: i file requirement e README saranno diversi per il repository GitHub e per lo Space su Hugging Face.

Cartella Data

Scarica il dataset Drug Classification da Kaggle, estrai il file CSV e spostalo nella cartella Data.

Cartelle Model e Results

Sia la cartella Model sia la cartella Results resteranno vuote perché verranno popolate dallo script Python che eseguiamo.

File del repository

1. Crea un Makefile per semplificare l’esecuzione dello script nel workflow di GitHub Actions.
2. Crea un Jupyter Notebook chiamato notebook.ipynb. In questo notebook sperimenteremo con algoritmi e pipeline di processamento.
3. Crea un file chiamato requirements.txt. Sarà usato per configurare l’ambiente durante l’esecuzione dei job del workflow CI.
4. Crea un file chiamato train.py. Conterrà codice Python per il caricamento e processamento dei dati, oltre al training, alla valutazione e al salvataggio del modello e delle metriche di performance.

Ecco come dovrebbe apparire la nostra directory:

Training e Valutazione del Modello di Classificazione dei Farmaci

In questa parte, sperimenteremo la creazione di codice Python che processa i dati e addestra un modello usando una pipeline di scikit-learn. Poi lo valuteremo e salveremo risultati e modello.

Caricamento del dataset

Useremo pandas per caricare il nostro file CSV, rimescolarlo usando la funzione sample e mostrare le prime tre righe.

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

Crea una variabile dipendente e una indipendente. Poi dividile in set di training e di test. Questo ti aiuterà a valutare le prestazioni del modello.

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
)

Pipeline di Machine Learning

Costruiremo una pipeline di processamento usando ColumnTransformer, che convertirà i valori categorici in numeri, riempirà i valori mancanti e scalerà le colonne numeriche.

Dopodiché, creeremo una pipeline di training che prenderà i dati trasformati e addestrerà un classificatore random forest.

Infine, alleneremo il modello.

Usando le pipeline, garantiamo riproducibilità, modularità e chiarezza del codice.

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)

Valutazione del modello

Valuta le prestazioni del modello calcolando sia l’accuracy che l’F1 score.

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))

Il nostro modello ha ottenuto risultati eccellenti.

Accuracy: 95.0% F1: 0.91

Crea il file delle metriche e salvalo nella cartella Results.

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

Creeremo poi la matrice di confusione e salveremo l’immagine nella cartella Results.

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)

Salvataggio del modello

Ora salveremo il nostro modello usando il pacchetto Python skops. Questo ci aiuterà a salvare sia la pipeline di scikit-learn sia il modello.

import skops.io as sio

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

Puoi caricare l’intera pipeline e funzionerà subito senza processare i dati o modificare il codice.

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

Copia e incolla l’intero codice nel file 'train.py'. Questo sarà lo script di training standardizzato che verrà eseguito nel workflow CI ogni volta che ci sono modifiche ai dati o al codice.

Prima di iniziare la tua carriera in MLOps engineering, leggi la MLOps Roadmap: A Complete Career Guide.

Passi per costruire la tua pipeline di Continuous Integration

In questa sezione tratteremo CML, Makefile e la configurazione dei workflow di GitHub Actions per automatizzare training, valutazione e versioning del nostro progetto.

Pipeline CI

CML

Continuous Machine Learning (CML) è una libreria open-source che ti permette di implementare la continuous integration nei tuoi progetti di machine learning. Useremo la GitHub Action "iterative/setup-cml" che sfrutta funzioni CML nel workflow per automatizzare la generazione del report di valutazione del modello.

Cosa significa? Ogni volta che fai push di modifiche su GitHub, verrà generato un report sotto il commit e riceverai un’email con le metriche di performance e la matrice di confusione.

Makefile

Un Makefile è un file che contiene un insieme di istruzioni usate dal comando make per automatizzare varie attività, come compilare codice, eseguire test, configurare ambienti, preprocessare dati, addestrare e valutare modelli e distribuire modelli.

Possiamo usare i comandi make per eseguire più script e mantenere il file del workflow CI pulito e semplice. Il Makefile contiene il nome degli insiemi di comandi e lo script per eseguirli.

Ecco il nostro 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

Abbiamo comandi per installare i pacchetti Python (install), formattare il codice (format), eseguire gli script di training (train) e generare report CML (eval).

Dopodiché aggiungeremo le modifiche, creeremo un commit e faremo push delle modifiche sul server remoto di GitHub.

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

GitHub Actions

Per automatizzare training e valutazione, dobbiamo creare un workflow di GitHub Actions. Per farlo, vai alla scheda “Actions” del nostro repository kingabzpro/CICD-for-Machine-Learning e clicca sul testo blu “set up a workflow yourself.”

Rinomina il file .yml in “ci” e inizia ad aggiungere i comandi della GitHub Action.

1. Aggiungi il nome del workflow.
2. Imposta il trigger in modo che il workflow giri su push o pull request al branch main o su esecuzione manuale.
3. Costruisci un ambiente per il job. Caricheremo l’ultimo server Linux.
4. Attiva le GitHub Actions che useremo nel workflow.
5. Inizia ad aggiungere diversi run usando vari comandi make.
6. Attiva il workflow facendo commit delle modifiche. GitHub Actions eseguirà tutti i passaggi della pipeline uno per uno.

Incontrerai errori mentre sistemi problemi e sintassi, perciò è importante leggere la sintassi dei workflow per GitHub Actions prima di tuffarti nelle Actions.

Abbiamo corretto con successo tutti gli errori e i problemi del workflow, e ora abbiamo la versione finale del file `ci.yml` che gira senza intoppi.

Come puoi vedere, il workflow prima configura l’ambiente e carica le Actions necessarie. Poi eseguiamo ogni step uno alla volta usando il comando make, che richiama vari script Python e Bash in backend.

Tuttavia, ci sono due cose importanti da tenere a mente quando si lavora con le Actions CML. Primo, bisogna impostare i permessi di scrittura all’inizio. Secondo, fornire un token GitHub a un job CML, a cui possiamo accedere usando i secrets.

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

Le metriche e i risultati compaiono sotto il messaggio di commit.

Riceverai anche un’email con i risultati.

Salvare i risultati in un nuovo branch

Stiamo generando il report di valutazione, ma non stiamo versionando il modello e i risultati. Per salvare le modifiche, creeremo un nuovo branch chiamato "update" e vi effettueremo il push del modello e dei risultati aggiornati.

Crea il branch "update" cliccando sul pulsante del branch main, digitando "update" come nome del branch e poi selezionando "create branch update from main".

Creazione di un secret del repository

Per fare commit e push delle modifiche usando il comando Git, dobbiamo fornire uno username e un’email. Puoi aggiungerli direttamente, ma usare i secrets di GitHub è un’opzione migliore. Segui questi passaggi:

1. Vai su Settings e clicca su "Secrets and variables".
2. Seleziona "Actions" e clicca il pulsante verde "New repository secret".
3. Aggiungi nome e valori. È simile a impostare una variabile d’ambiente sulla tua macchina locale.

Tutto qui!

Aggiornamento di Makefile e ci.yml

Per automatizzare il salvataggio delle modifiche nel nuovo branch, dobbiamo aggiornare il Makefile e il ci.yml.

Makefile:

Configuriamo username ed email, facciamo il commit delle modifiche e le salviamo sul branch update.

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:

Il Makefile usa una variabile d’ambiente per eseguire lo script. Per questo, dobbiamo prima estrarre il valore della variabile d’ambiente dai secrets, poi impostare la variabile d’ambiente alla fine del comando make.

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

Una volta aggiornati i file e pushate le modifiche sul branch main, potrai vedere la magia in tempo reale. Verrà generato un report analitico, insieme a un modello aggiornato che può essere distribuito su Hugging Face nella parte di continuous deployment.

Passi per costruire la tua pipeline di Continuous Deployment

Nella sezione Continuous Deployment, vedremo come automatizzare il deployment sia del modello sia dell’applicazione. Questo comporta il pull del modello aggiornato e del file dell’applicazione dal branch `update`, l’accesso alla Hugging Face CLI tramite token, il push dei file del modello e dell’applicazione e infine il deployment dell’app.

Costruisci l’app Gradio

Per distribuire il nostro modello e accedervi, dobbiamo creare un’app Gradio. Questa app includerà:

1. Caricamento della pipeline di scikit-learn e del modello.
2. Una funzione Python per prevedere le etichette dei farmaci in base all’input dell’utente.
3. Creazione di un’interfaccia di input usando slider di Gradio per i valori float e radio di Gradio per i valori categorici.
4. Creazione di input di esempio per testare facilmente il modello.
5. Fornisci il titolo dell’applicazione, una breve descrizione delle sue funzionalità e un footer con eventuali informazioni rilevanti.
6. Forniremo tutte queste variabili e la funzione di previsione alla funzione Interface di Gradio e la lanceremo.
7. Per dare alla nostra web app un aspetto moderno, useremo un tema soft predefinito.

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()

Apri il terminale ed esegui l’app in locale per risolvere eventuali problemi prima di pushare le modifiche sul repository remoto.

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()`.

Impostazione del token Hugging Face

Ora genereremo il token di Hugging Face e lo forniremo al nostro script Makefile. Tuttavia, dobbiamo assicurarci che il token resti confidenziale e non venga divulgato a nessuno. Per farlo, useremo i secrets di GitHub.

Per prima cosa, clicca sulla tua immagine del profilo Hugging Face e seleziona l’opzione delle impostazioni. Poi scegli "Access Tokens" e clicca sul pulsante "New Token" per generare il token. Durante la generazione del token, assicurati che abbia i permessi di scrittura.

Copia il token e crea un secret del repository, proprio come abbiamo fatto con username ed email.

Workflow CD

In questa sezione aggiungeremo tre nuovi comandi per creare file e un altro workflow GitHub chiamato "Continuous Deployment". Questo workflow aiuterà ad automatizzare il processo di pull e deployment dei file.

Makefile

• Effettuare il pull dei file aggiornati del modello e dei risultati dal branch update e passare al branch update.
• Prima di effettuare il login, dobbiamo installare la Hugging Face CLI e poi fare login usando il token.
• Effettueremo il push della cartella App nella directory base dello Space in modo che abbia il file Python, il README e i requirement.txt per costruire l’ambiente ed eseguire l’applicazione.
• Caricheremo anche le cartelle Model e Results.
• Il comando deploy eseguirà prima hf-login e poi 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

La nostra applicazione avrà accesso a un modello aggiornato, al file dell’applicazione e ai risultati, permettendoci di tracciare i cambiamenti nello Space di Hugging Face.

cd.yml

Per rendere il nostro workflow veramente CI/CD, dobbiamo creare un altro file chiamato cd.yml simile al nostro ci.yml. Una volta completata la pipeline CI, questa avvierà il workflow cd.yml usando l’argomento on con il parametro workflow_run.

Questo workflow costruirà l’ambiente ed eseguirà il comando make deploy usando il token di Hugging Face per distribuire le ultime modifiche su Hugging Face Hub.

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

Quando facciamo push delle modifiche sul branch main, inizierà il workflow CI.

Dopo il completamento del workflow CI, inizierà il workflow CD, come mostrato di seguito.

Possiamo osservare i log in tempo reale di ogni funzione selezionando l’opzione run nella build del workflow. I nostri file sono stati caricati con successo sul server di Hugging Face.

Dopo aver ricevuto il file aggiornato, lo Space di Hugging Face inizierà a costruire l’ambiente e l’app inizierà a girare in pochi secondi.

La nostra applicazione Drug Classification funziona senza problemi e ha un’interfaccia bellissima.

Prova a inserire dati diversi per sperimentare le prestazioni del modello.

Immagine Fonte

Conclusione

Questa guida illustra come abbiamo automatizzato i processi di training, valutazione, versioning e deployment, garantendo che qualsiasi modifica ai dati o agli algoritmi attivi automaticamente questo processo senza errori. Questo approccio ci aiuta a costruire applicazioni veloci, scalabili e pronte per la produzione.

Tieni presente che nei progetti reali usiamo molteplici strumenti MLOps per orchestrare, versionare, distribuire e monitorare le applicazioni di machine learning. Per saperne di più su questi strumenti, dai un’occhiata a Top MLOps Tools You Need to Know, che presenta le tecnologie popolari usate dalle big tech per ottimizzare le loro applicazioni ML.

Per ottimizzare la tua pipeline CI/CD, è fondamentale imparare strumenti come Docker, Kubernetes, Azure Cloud e altre tecnologie MLOps. Segui un tutorial su Machine Learning, Pipelines, Deployment e MLOps per acquisire familiarità con le pratiche standard del settore e lavorare su progetti avanzati.

Risorse del progetto

• Repository GitHub: kingabzpro/CICD-for-Machine-Learning
• Hugging Face Space: Drug Classification - uno Space di Hugging Face di kingabzpro
• Dataset Kaggle: Drug Classification