Een Iris-bloemclassificatiemodel trainen en deployen met TrueFoundry

In dit voorbeeld trainen we een model dat een bloem van het geslacht iris kan classificeren in een van de drie soorten op basis van de afmetingen van het kroonblad en het kelkblad.

U kunt dit voorbeeld ook volgen in een Google Colaboratory notebook.

De Iris dataset bevat drie verschillende soorten:

• Iris Setosa
• Iris Versicolor
• Iris Virginica

We moeten een classifier bouwen die de soort van de bloem kan identificeren op basis van de volgende parameters:

• Sepal Length (kelkbladlengte)
• Sepal Width (kelkbladbreedte)
• Petal Length (kroonbladlengte)
• Petal Width (kroonbladbreedte)

Over TrueFoundry

TrueFoundry biedt twee libraries om uw ML-workflows te vereenvoudigen:

MLFoundry

De mlfoundry library wordt gebruikt om ML-trainingsexperimenten te tracken.

Waarom hebt u experiment tracking nodig? Als u meerdere ML-modellen traint om een probleem op te lossen, zult u waarschijnlijk meerdere modellen trainen met verschillende frameworks, hyper-parameters en meerdere datasets. Het tracken van uw experiment met een library zoals mlfoundry helpt u uw ML-experimenten te organiseren.

U kunt MLFoundry gebruiken om hyper-parameters, metrics, datasets en modellen te loggen. U kunt vervolgens verschillende experimenten vergelijken op het TrueFoundry dashboard en een model kiezen om in productie te deployen of besluiten om het model opnieuw te trainen.

We gebruiken in dit voorbeeld 5 verschillende API's van MLFoundry. Dit zijn:

1. log_params - gebruik dit om hyper-parameters van het huidige experiment te loggen
2. log_dataset - gebruikt om de gehele dataset te loggen
3. log_metrics - log metrics zoals accuracy scores, f1 scores
4. set_tags - voeg tags toe aan uw experiment om later eenvoudig te filteren
5. log_model - om een model inclusief de getrainde weights op te slaan

ServiceFoundry

Met de servicefoundry library kunt u een model eenvoudig verpakken, containerizen en deployen naar een Kubernetes-cluster.

Laten we een model trainen en loggen met MLFoundry

Open een IPython notebook - u kunt lokaal op uw machine Jupyter gebruiken of een Google Colab notebook dat in de cloud draait.

Installeer de vereiste libraries.

 
!pip install mlfoundry
!pip install pandas
!pip install sklearn

Log in bij TrueFoundry. Maak en kopieer een API key vanaf de instellingenpagina. Gebruik deze API key om de MLFoundry client te initialiseren en een run aan te maken. Een run is een entiteit die een enkel experiment vertegenwoordigt.

 
import mlfoundry as mlf
client = mlf.get_client(api_key='')
run = client.create_run('iris-classifier'))

Haal de Iris dataset op met behulp van de sklearn.datasets module. Vervolgens splitsen we deze in test- en train-datasets.

 
from sklearn import datasets
from sklearn.model_selection import train_test_split

data = datasets.load_iris()

X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, stratify=y, random_state=42)

Laten we kijken naar de target-namen. We gebruiken dit om de integer-output van het model te koppelen aan de daadwerkelijke namen van de soorten.

 
print(data.target_names)

# Output
# ['setosa' 'versicolor' 'virginica']

Initialiseer een model. Gebruik vervolgens MLFoundry om de parameters van het model te loggen en enkele tags aan te maken voor deze huidige experimentele run.

 
from sklearn.svm import SVC

clf = SVC(gamma='scale', kernel='rbf', probability=True, C=1.2)

run.set_tags({
	'framework': 'sklearn',
  'task': 'classification'
})

run.log_params(clf.get_params())

Vervolgens trainen we het model op onze train-dataset. Zodra de training is voltooid, berekenen we de verschillende metrics en loggen deze in MLFoundry via log_metrics.

 
from sklearn.svm import SVC

clf = SVC(gamma='scale', kernel='rbf', probability=True, C=1.2)

run.set_tags({
	'framework': 'sklearn',
  'task': 'classification'
})

run.log_params(clf.get_params())

 
clf.fit(X_train, y_train)

y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)

metrics = {
  'train/accuracy_score': accuracy_score(y_train, y_pred_train),
  'train/f1_weighted': f1_score(y_train, y_pred_train, average='weighted'),
  'train/f1_micro': f1_score(y_train, y_pred_train, average='micro'),
  'train/f1_macro': f1_score(y_train, y_pred_train, average='macro'),
  'test/accuracy_score': accuracy_score(y_test, y_pred_test),
  'test/f1_weighted': f1_score(y_test, y_pred_test, average='weighted'),
  'test/f1_micro': f1_score(y_test, y_pred_test, average='micro'),
  'test/f1_macro': f1_score(y_test, y_pred_test, average='macro'),
}

run.log_metrics(metrics)

Als we tevreden zijn met de accuracy scores en andere metrics, kunnen we ervoor kiezen om het huidige model te deployen. Daarvoor moeten we het model opslaan en de huidige run id kopiëren.

 
run.log_model(clf, framework=mlf.ModelFramework.SKLEARN)
print(run.run_id)
run.end()

U kunt al uw runs bekijken en metrics vergelijken via het TrueFoundry experiment tracking dashboard.

Ons model deployen als een API-service

Om het model te deployen met ServiceFoundry, moeten we een Python-bestand maken met de functie die we als endpoint willen blootstellen.

In dat Python-bestand halen we het model op dat we zojuist hebben getraind en opgeslagen met behulp van de run id, via mlfoundry. Merk op dat de API key die vereist is door mlfoundry beschikbaar zal zijn als de omgevingsvariabele TFY_API_KEY.

Maak in uw IPython notebook een blok aan met de volgende inhoud en voer dit uit om een Python-bestand genaamd predict.py te maken. We gebruiken het Jupyter magic command %%writefile om het bestand in de notebook-omgeving aan te maken.

 
%%writefile predict.py
import os
import json
import pandas as pd
import mlfoundry as mlf

client = mlf.get_client(api_key=os.environ.get('TFY_API_KEY'))
run = client.get_run('79e71482643f46dfa5bfef256dba5dc5') # replace with your run id
model = run.get_model()

def species(features):
 features = json.loads(features)
 df = pd.DataFrame.from_dict([features])
 prediction = model.predict(df)[0]
 return ['setosa', 'versicolor', 'virginica'][prediction]

In de species-functie laden we de features in een pandas DataFrame en maken we de voorspelling met het model. We vertalen de integer class naar soortnamen met de target_names die we tijdens de training hebben geprint.

Dat is vrijwel al het werk dat u moet doen. Laten we dit model nu deployen als een API-service. Installeer en importeer eerst servicefoundry in uw notebook. Log in bij servicefoundry.

 
!pip install servicefoundry
import servicefoundry.core as sfy
sfy.login()

Ga naar het TrueFoundry dashboard en maak een workspace aan om de service te deployen. Workspaces zijn een manier om gerelateerde projecten binnen TrueFoundry te groeperen. Zodra de workspace is aangemaakt, kopieert u de FQN zodat we servicefoundry kunnen vertellen waar het model gedeployed moet worden.

‍Met de servicefoundry library kunt u alle afhankelijkheden van het bestand dat u zojuist hebt gemaakt verzamelen met de gather_requirements functie.

 
requirements = sfy.gather_requirements("predict.py")

Maak nu een sfy.Service object aan, geef de workspace FQN op en deploy het door .deploy() aan te roepen.

 
auto_service = sfy.Service("predict.py", requirements, sfy.Parameters( name="iris-service", workspace="" )) auto_service.deploy()

U kunt de voortgang van deze deployment volgen op het dashboard. Zodra de deployment is voltooid, kunt u vanuit daar toegang krijgen tot de gedeployde service en deze uitproberen.

Het TrueFoundry dashboard linkt ook naar metrics en logs die standaard worden geleverd bij TrueFoundry-deployments in de vorm van Grafana-dashboards. U kunt hier meer over lezen hier.

Meer functionaliteiten

U kunt ook eenvoudig interactieve UI-applicaties en Gradio-applicaties deployen vanuit een IPython notebook met behulp van servicefoundry. Lees deze gids om te zien hoe.

We werken aan een nog strakkere integratie tussen experiment tracking en deployment om de ervaring nog aangenamer te maken. U kunt meer lezen over wat u met TrueFoundry kunt doen in onze documentatie. Als u machine learning-modellen traint om een probleem op te lossen, helpt TrueFoundry u verschillende experimenten te tracken en maakt het het eenvoudig en intuïtief om modellen volgens best practices te deployen en binnen enkele minuten beschikbaar te maken voor openbaar gebruik.