Machine Learning, pipelines, deployment en MLOps-tutorial

Introductie

Pipelines, deployment en MLOps zijn vandaag de dag cruciale concepten voor data scientists. Een model bouwen in een notebook is niet genoeg. Het uitrollen van pipelines en het beheren van end-to-endprocessen met MLOps-best practices krijgt bij veel bedrijven steeds meer aandacht. Deze tutorial behandelt verschillende belangrijke concepten zoals Pipeline, CI/CD, API, Container, Docker en Kubernetes. Je leert ook over MLOps-frameworks en -bibliotheken in Python. Tot slot laat de tutorial een end-to-end implementatie zien van het containerizen van een Flask-gebaseerde ML-webapplicatie en het deployen op Microsoft Azure-cloud.

Belangrijke concepten

MLOps

MLOps staat voor Machine Learning Operations. MLOps richt zich op het stroomlijnen van het proces om machinelearningmodellen in productie te brengen en ze vervolgens te onderhouden en te monitoren. MLOps is een gezamenlijke functie, vaak bestaande uit data scientists, ML-engineers en DevOps-engineers. Het woord MLOps is een samentrekking van twee verschillende domeinen: machine learning en DevOps uit de software-engineering.

MLOps kan alles omvatten van de datapipeline tot de productie van het machinelearningmodel. Soms zie je dat MLOps alleen wordt toegepast voor de deployment van het model, maar er zijn ook organisaties die MLOps implementeren in veel verschillende onderdelen van de ML-levenscyclus, zoals Exploratory Data Analysis (EDA), datavoorbewerking, modeltraining, enzovoort.

Hoewel MLOps begon als een set best practices, ontwikkelt het zich geleidelijk tot een zelfstandige benadering van ML-lifecyclemanagement. MLOps is van toepassing op de hele levenscyclus — van integratie met modelgeneratie (software development lifecycle en continuous integration/continuous delivery), orkestratie en deployment tot gezondheid, diagnostiek, governance en businessmetrics.

Waarom MLOps?

Bedrijven willen met MLOps verschillende doelen bereiken. Veelvoorkomende zijn:

• Automatisering
• Schaalbaarheid
• Reproduceerbaarheid
• Monitoring
• Governance

MLOps vs DevOps

DevOps is een iteratieve aanpak om softwareapplicaties in productie te brengen. MLOps leent dezelfde principes om machinelearningmodellen naar productie te brengen. Of het nu DevOps of MLOps is, het uiteindelijke doel is hogere kwaliteit en beter beheer van softwareapplicaties/ML-modellen.

CI/CD: continuous integration, continuous delivery en continuous deployment

CI/CD is een praktijk afgeleid van DevOps en verwijst naar een doorlopend proces van problemen herkennen, herbeoordelen en de machinelearningmodellen automatisch bijwerken. De belangrijkste concepten binnen CI/CD zijn continuous integration, continuous delivery en continuous deployment. Het automatiseert de machinelearningpipeline (bouwen, testen en deployen) en vermindert sterk de noodzaak voor data scientists om handmatig in te grijpen, waardoor het proces efficiënt, snel en minder foutgevoelig wordt.

Pipeline

Een machinelearningpipeline is een manier om de workflow te sturen en te automatiseren die nodig is om een machinelearningmodel te produceren. Machinelearningpipelines bestaan uit meerdere opeenvolgende stappen die alles doen van data-extractie en voorbewerking tot modeltraining en deployment.

Machinelearningpipelines zijn iteratief, omdat elke stap wordt herhaald om de nauwkeurigheid van het model continu te verbeteren en het einddoel te bereiken.

De term pipeline wordt algemeen gebruikt om de onafhankelijke reeks stappen te beschrijven die samen worden gezet om een taak uit te voeren. Die taak kan machine learning zijn, maar dat hoeft niet. Machinelearningpipelines komen veel voor, maar zijn niet het enige type pipeline. Data-orkestratiepipelines zijn een ander voorbeeld. Volgens de Microsoft-docs zijn er drie scenario’s:

Deployment

De deployment van machinelearningmodellen (of pipelines) is het proces waarbij modellen beschikbaar worden gemaakt in productie, zodat webapplicaties, bedrijfssoftware (ERP’s) en API’s het getrainde model kunnen gebruiken door nieuwe gegevens aan te leveren en voorspellingen te krijgen.

Kort gezegd: deployment in machine learning is de manier waarop je een machinelearningmodel integreert in een bestaande productieomgeving om praktische zakelijke beslissingen op basis van data te nemen. Het is de laatste fase in de machinelearninglevenscyclus.

Vaak wordt de term modeldeployment gebruikt om de uitrol van de volledige machinelearningpipeline te beschrijven, waarbij het model zelf slechts één component van de pipeline is.

Zoals je in het bovenstaande voorbeeld ziet, bevat deze pipeline een Logistic Regression-model. Er zijn verschillende stappen in de pipeline die eerst moeten worden uitgevoerd voordat de training kan beginnen, zoals het imputeren van missende waarden, one-hot encoding, schalen en Principalecomponentenanalyse (PCA).

Application Programming Interface (API)

Een Application Programming Interface (API) is een software-tussenlaag die twee applicaties met elkaar laat communiceren. Simpel gezegd is een API een contract tussen twee applicaties dat stelt: als de gebruiker invoer levert in een vooraf gedefinieerd formaat, dan levert de API de uitkomst terug. Met andere woorden, een API is een endpoint waar je de getrainde machinelearningmodellen/(pipelines) host voor gebruik. In de praktijk ziet dat er zo uit:

Container

Heb je weleens gehad dat je Python-code (of andere code) prima werkt op jouw computer, maar dat het bij een vriend met exact dezelfde code niet werkt? Als je vriend precies dezelfde stappen herhaalt, zouden de resultaten hetzelfde moeten zijn, toch? De simpele verklaring is dat de Python-omgeving van je vriend anders is dan die van jou.

Wat zit er in een omgeving?

Python (of een andere taal die je gebruikt) en alle bibliotheken en afhankelijkheden die zijn gebruikt om die applicatie te bouwen.

Als we een omgeving kunnen creëren die we kunnen overzetten naar andere machines (bijv. de computer van je vriend of een cloudprovider zoals Microsoft Azure, AWS of GCP), kunnen we de resultaten overal reproduceren. Een container is een type software dat een applicatie en al zijn afhankelijkheden verpakt, zodat de applicatie betrouwbaar kan draaien van de ene naar de andere omgeving.

De meest intuïtieve manier om containers in data science te begrijpen, is te denken aan containers op een schip. Het doel is om de inhoud van de ene container te isoleren van de andere, zodat ze niet door elkaar raken. Precies daarvoor worden containers in data science ook gebruikt.

Nu we de metafoor achter containers begrijpen, kijken we naar alternatieve opties om een geïsoleerde omgeving voor onze applicatie te creëren. Eén simpele optie is een aparte machine voor elk van je applicaties.

Een aparte machine gebruiken is eenvoudig, maar weegt niet op tegen de voordelen van containers, want meerdere machines per applicatie onderhouden is duur, lastig te beheren en moeilijk op te schalen. Kortom, in veel praktijksituaties is het niet haalbaar.

Een ander alternatief om een geïsoleerde omgeving te maken, is virtuele machines gebruiken. Containers hebben ook hier de voorkeur omdat ze minder resources vragen, zeer draagbaar zijn en sneller opstarten.

Kun je de verschillen tussen virtuele machines en containers aanwijzen? Met containers heb je geen guest-besturingssystemen nodig. Stel je 10 applicaties voor die op een virtuele machine draaien. Dat vereist 10 guest-besturingssystemen, tegenover geen bij het gebruik van containers.

Docker

Docker is een bedrijf dat software levert (ook Docker genoemd) waarmee gebruikers containers kunnen bouwen, draaien en beheren. Hoewel Docker-containers het meest gangbaar zijn, bieden minder bekende alternatieven zoals LXD en LXC ook containeroplossingen.

Docker is een tool die het makkelijker maakt om applicaties te bouwen, te deployen en te draaien met behulp van containers. Containers worden gebruikt om een applicatie te verpakken met alle benodigde componenten, zoals bibliotheken en andere afhankelijkheden, en dat geheel als één pakket te distribueren.

De hype doorprikken

Uiteindelijk is Docker gewoon een bestand met een paar regels instructies dat je onder je projectmap opslaat met de naam "Dockerfile".

Je kunt een Dockerfile ook zien als een recept dat je zelf in je keuken hebt ontwikkeld. Als je dat recept deelt en iemand volgt exact dezelfde instructies, dan krijgt diegene hetzelfde gerecht. Op dezelfde manier kun je je Dockerfiles delen met anderen, die vervolgens images kunnen maken en containers kunnen draaien op basis van die Dockerfile.

Kubernetes

Ontwikkeld door Google in 2014 is Kubernetes een krachtig, open-source systeem voor het beheren van gecontaineriseerde applicaties. Simpel gezegd is Kubernetes een systeem om gecontaineriseerde applicaties te draaien en te coördineren over een cluster van machines. Het is een platform dat is ontworpen om de volledige levenscyclus van gecontaineriseerde applicaties te beheren.

Functies

• Load balancing: verdeelt automatisch de belasting over containers.
• Schaalbaarheid: schaalt automatisch op of af door containers toe te voegen of te verwijderen wanneer de vraag verandert, zoals in piekuren en in weekenden en vakanties.
• Opslag: houdt opslag consistent bij meerdere instanties van een applicatie.

Waarom heb je Kubernetes nodig als je Docker hebt?

Stel je voor dat je meerdere Docker-containers op meerdere machines moet draaien om een ML-applicatie op ondernemingsniveau te ondersteunen met wisselende workloads, dag en nacht. Zo eenvoudig als het klinkt, is het handmatig erg veel werk.

Je moet de juiste containers op het juiste moment starten, regelen hoe ze met elkaar communiceren, opslag overwegen en omgaan met falende containers of hardware. Dit is het probleem dat Kubernetes oplost, door grote aantallen containers harmonieus te laten samenwerken en de operationele last te verminderen.

Google Kubernetes Engine is een implementatie van Google’s open-source Kubernetes op Google Cloud Platform. Andere populaire alternatieven voor GKE zijn Amazon ECS en de Microsoft Azure Kubernetes Service.

Snelle samenvatting van termen:

• Een container is een type software dat een applicatie en alle afhankelijkheden verpakt zodat de applicatie betrouwbaar draait van de ene naar de andere omgeving.
• Docker is software om containers te bouwen en te beheren.
• Kubernetes is een open-sourcesysteem om gecontaineriseerde applicaties te beheren in een clusteromgeving.

MLOps-frameworks en -bibliotheken in Python

MLflow

MLflow is een open-sourceplatform om de ML-levenscyclus te beheren, inclusief experimentatie, reproduceerbaarheid, deployment en een centrale modelregistry. MLflow biedt momenteel MLflow Tracking, MLflow Projects, MLflow Models en Model Registry.

Metaflow

Metaflow is een gebruiksvriendelijke Python-bibliotheek die wetenschappers en engineers helpt echte data science-projecten te bouwen en te beheren. Metaflow is oorspronkelijk bij Netflix ontwikkeld om de productiviteit van data scientists te verhogen die aan uiteenlopende projecten werken, van klassieke statistiek tot state-of-the-art deep learning. Metaflow biedt een uniforme API naar de infrastructuurstack die nodig is om data science-projecten uit te voeren, van prototype tot productie.

Kubeflow

Kubeflow is een open-source machinelearningplatform, ontworpen om ML-pipelines te laten orkestreren op complexe workflows die op Kubernetes draaien. Kubeflow is gebaseerd op Google’s interne methode om TensorFlow-modellen te deployen, genaamd TensorFlow Extended.

Kedro

Kedro is een open-source Python-framework voor het schrijven van reproduceerbare, onderhoudbare en modulaire data science-code. Het leent concepten uit best practices van software-engineering en past die toe op machinelearningcode; toegepaste concepten zijn onder meer modulariteit, scheiding van verantwoordelijkheden en versiebeheer.

FastAPI

FastAPI is een webframework voor het ontwikkelen van RESTful API’s in Python. FastAPI is gebaseerd op Pydantic en type hints om data te valideren, te serialiseren en te deserialiseren, en genereert automatisch OpenAPI-documenten.

ZenML

ZenML is een uitbreidbaar, open-source MLOps-framework om production-ready machinelearningpipelines te maken. Gebouwd voor data scientists, met een eenvoudige, flexibele syntax, cloud- en tool-agnostisch, en met interfaces/abstracties die aansluiten op ML-workflows.

Voorbeeld: end-to-end pipelineontwikkeling, deployment en MLOps

Probleemstelling

Een verzekeringsmaatschappij wil de cashflowprognoses verbeteren door patiëntkosten beter te voorspellen, op basis van demografische gegevens en basisgezondheidsrisico’s op het moment van opname.

Ons doel is een webapplicatie te bouwen en te deployen waarin demografische en gezondheidsgegevens van een patiënt via een webformulier worden ingevoerd, waarna een voorspelde kostenpost wordt uitgegeven. Om dit te bereiken doen we het volgende:

• Een machinelearningpipeline trainen en ontwikkelen voor deployment (simpel lineair regressiemodel).
• Een webapp bouwen met het Flask-framework. Deze gebruikt de getrainde ML-pipeline om in realtime voorspellingen te genereren voor nieuwe datapunten (front-endcode is niet de focus van deze tutorial).
• Een Docker-image en -container maken.
• De container publiceren naar de Azure Container Registry (ACR).
• De webapp in de container deployen door te publiceren op ACR. Na deployment is deze publiek beschikbaar en toegankelijk via een web-URL.

Machinelearningpipeline

Ik gebruik PyCaret in Python voor het trainen en ontwikkelen van een machinelearningpipeline die onderdeel wordt van onze webapp. Je kunt elk framework gebruiken dat je wilt; de vervolgstappen hangen hier niet van af.

# load dataset
from pycaret.datasets import get_data
insurance = get_data('insurance')

# init environment
from pycaret.regression import *
r1 = setup(insurance, target = 'charges', session_id = 123,
           normalize = True,
           polynomial_features = True, trigonometry_features = True,
           feature_interaction=True,
           bin_numeric_features= ['age', 'bmi'])

# train a model
lr = create_model('lr')

# save pipeline/model
save_model(lr, model_name = 'c:/username/pycaret-deployment-azure/deployment_28042020')

Wanneer je in PyCaret een model opslaat, wordt de volledige transformatiepipeline aangemaakt op basis van de configuratie in de setup-functie. Alle onderlinge afhankelijkheden worden automatisch georkestreerd. Zie de pipeline en het model die zijn opgeslagen in de variabele 'deployment_28042020':

Front-end webapplicatie

Deze tutorial richt zich niet op het bouwen van een Flask-applicatie. Dit komt hier alleen aan bod voor de volledigheid. Nu onze machinelearningpipeline klaar is, hebben we een webapplicatie nodig die onze getrainde pipeline kan inlezen om nieuwe datapunten te voorspellen. Deze applicatie heeft twee delen:

• Front-end (ontworpen met HTML)
• Back-end (ontwikkeld met Flask)

Zo ziet de front-end eruit:

De front-end van deze applicatie is simpele HTML met wat CSS-styling. Wil je de code bekijken, ga dan naar deze repo. Nu we een volledig functionele webapp hebben, kunnen we de applicatie gaan containerizen met Docker.

Back-end van de applicatie

De back-end van de applicatie is een Python-bestand genaamd app.py. Het is gebouwd met het Flask-framework.

from flask import Flask,request, url_for, redirect, render_template, jsonify
from pycaret.regression import *
import pandas as pd
import pickle
import numpy as np

app = Flask(__name__)

model = load_model('deployment_28042020')
cols = ['age', 'sex', 'bmi', 'children', 'smoker', 'region']

@app.route('/')
def home():
    return render_template("home.html")

@app.route('/predict',methods=['POST'])
def predict():
    int_features = [x for x in request.form.values()]
    final = np.array(int_features)
    data_unseen = pd.DataFrame([final], columns = cols)
    prediction = predict_model(model, data=data_unseen, round = 0)
    prediction = int(prediction.Label[0])
    return render_template('home.html',pred='Expected Bill will be {}'.format(prediction))

@app.route('/predict_api',methods=['POST'])
def predict_api():
    data = request.get_json(force=True)
    data_unseen = pd.DataFrame([data])
    prediction = predict_model(model, data=data_unseen)
    output = prediction.Label[0]
    return jsonify(output)

if __name__ == '__main__':
    app.run(debug=True)

Docker-container

Als je Windows gebruikt, moet je Docker installeren voor Windows. Als je Ubuntu gebruikt, wordt Docker standaard meegeleverd en is geen installatie nodig.

De eerste stap in het containerizen van je applicatie is een Dockerfile schrijven in dezelfde map/directory als je applicatie. Een Dockerfile is simpelweg een bestand met een set instructies. De Dockerfile voor dit project ziet er zo uit:

FROM python:3.7

RUN pip install virtualenv
ENV VIRTUAL_ENV=/venv
RUN virtualenv venv -p python3
ENV PATH="VIRTUAL_ENV/bin:$PATH"

WORKDIR /app
ADD . /app

# install dependencies
RUN pip install -r requirements.txt

# expose port
EXPOSE 5000

# run application
CMD ["python", "app.py"]

Dockerfile is hoofdlettergevoelig en moet in de projectmap staan met de andere projectbestanden. Een Dockerfile heeft geen extensie en kan met elke editor worden gemaakt. Wij hebben Visual Studio Code gebruikt om hem te maken.

Cloud-deployment

Nadat de Dockerfile correct is ingesteld, schrijven we een paar commando’s om hieruit een Docker-image te maken, maar eerst hebben we een service nodig om dat image te hosten. In dit voorbeeld gebruiken we Microsoft Azure om onze applicatie te hosten.

Azure Container Registry

Als je geen Microsoft Azure-account hebt of het nog niet hebt gebruikt, kun je je gratis aanmelden. Wanneer je je voor het eerst aanmeldt, krijg je de eerste 30 dagen gratis tegoed. Dat tegoed kun je gebruiken om een webapp op Azure te bouwen en te deployen. Volg na het aanmelden deze stappen:

• Log in op https://portal.azure.com
• Klik op Create a resource
• Zoek op Container Registry en klik op Create
• Selecteer Subscription, Resource group en Registry name (in ons geval: pycaret.azurecr.io is onze registry-naam)

Als de registry is aangemaakt, is de eerste stap een Docker-image bouwen via de commandline. Navigeer naar de projectmap en voer de volgende code uit:

docker build -t pycaret.azurecr.io/pycaret-insurance:latest .

• pycaret.azurecr.io is de naam van de registry die je krijgt wanneer je een resource aanmaakt in het Azure-portaal
• pycaret-insurance is de naam van het image en latest is de tag; dit mag je zelf bepalen

Container draaien vanaf Docker-image

Nu het image is aangemaakt, draaien we lokaal een container en testen we de applicatie voordat we deze naar Azure Container Registry pushen. Voer hiervoor het volgende commando uit:

docker run -d -p 5000:5000 pycaret.azurecr.io/pycaret-insurance

Je kunt de app in actie zien door in je browser naar localhost:5000 te gaan. Er zou een webapp moeten openen.

Als je dit ziet, betekent het dat de applicatie nu lokaal draait en is het alleen nog een kwestie van naar de cloud pushen. Lees verder voor deployment op Azure:

Azure-credentials authenticeren

Een laatste stap voordat je de container naar ACR kunt uploaden, is het authenticeren van Azure-gegevens op je lokale machine. Voer hiervoor het volgende commando uit in de commandline:

docker login pycaret.azurecr.io

Je wordt om een gebruikersnaam en wachtwoord gevraagd. De gebruikersnaam is de naam van je registry (in dit voorbeeld is de gebruikersnaam "pycaret"). Je vindt je wachtwoord onder de access keys van de Azure Container Registry-resource die je hebt aangemaakt.

Container pushen naar Azure Container Registry

Nu je geauthenticeerd bent bij ACR, kun je de container die je hebt gemaakt naar ACR pushen met het volgende commando:

docker push pycaret.azurecr.io/pycaret-insurance:latest

Afhankelijk van de grootte van de container kan het push-commando even duren om de container naar de cloud over te zetten.

Webapplicatie

Volg deze stappen om een webapp op Azure te maken:

• Log in op het Azure-portaal
• Klik op Create a resource
• Zoek op Web App en klik op Create
• Koppel je ACR-image aan je applicatie

De applicatie draait nu op Azure Web Services.

Conclusie

MLOps helpt ervoor te zorgen dat gedeployde modellen goed worden onderhouden, presteren zoals verwacht en geen nadelige effecten op de business hebben. Deze rol is cruciaal om het bedrijf te beschermen tegen risico’s door modeldrift in de tijd, of door modellen die wel gedeployed maar niet onderhouden of gemonitord worden.

MLOps voerde LinkedIn’s lijst met opkomende banen aan, met een groei van 9,8 keer in vijf jaar.

Bekijk de nieuwe Skill Track MLOps Fundamentals bij DataCamp, die de volledige levenscyclus van een machinelearningapplicatie behandelt, van het verzamelen van zakelijke requirements tot de ontwerp-, ontwikkel-, deployment-, operatie- en onderhoudsfase. Datacamp heeft ook een geweldige cursus Understanding Data Engineering. Schrijf je vandaag nog in en ontdek hoe data engineers het fundament leggen dat data science mogelijk maakt, zonder dat je hoeft te coderen.