Machine learning-pijplijnen bouwen en uitrollen

Introductie

Bij het bouwen van een machine learning-model vergeet je soms rekening te houden met de infrastructuur die nodig is om het model in productie te trainen en te serven. Voor end-to-end machine learning-workflows is het een uitdaging om alle applicatie-, platform- en resourceaspecten te beheren. 

In vergelijking met conventionele webdeployments hebben machine learning-applicaties een andere footprint. Zo is een trainingsfase resource-intensief, terwijl een inferentiefase lichtgewicht en snel is. Je hebt ook de tools en frameworks nodig om al deze onderdelen te draaien. Een zeer populair open-source framework dat je kunt gebruiken om een standaard te ontwikkelen voor het leveren van end-to-end machine learning-applicaties is Kubeflow.

Wat is Kubeflow?

Kubeflow is een open-source project met een zorgvuldig samengestelde set tools en frameworks. Het primaire doel van Kubeflow is om het eenvoudig te maken om portable, schaalbare machine learning-workflows te ontwikkelen, uit te rollen en te beheren. 

Kubeflow is gebouwd bovenop Kubernetes, een open-sourceplatform voor het draaien en orkestreren van containers. Kubernetes is ontworpen om consistent te draaien in verschillende omgevingen, wat essentieel is voor hoe Kubeflow werkt. Kubeflow is zo ontworpen dat Kubernetes kan doen waar het goed in is, zodat jij je kunt richten op het definiëren en draaien van ML-workflows, inclusief databeheer, notebooks draaien, modellen trainen en serven. 

Kubeflow is geëvolueerd uit Google’s interne project TensorFlow Extended. Het begon als een eenvoudigere manier om TensorFlow-jobs op Kubernetes te draaien, maar is sindsdien uitgegroeid tot een multi-architectuur, multi-cloud framework voor het draaien van end-to-end machine learning-workflows. 

Kubeflow en machine learning-workflows

Kubeflow is een platform voor data scientists en machine learning-engineers met het beste van beide werelden. Data scientists kunnen Kubeflow gebruiken om te experimenteren met ML-modellen en hun experimenten zo efficiënt mogelijk op Kubernetes te orkestreren. 

Machine learning-engineers kunnen Kubeflow gebruiken om ML-systemen uit te rollen naar verschillende omgevingen voor development, testen en productie.

Het onderstaande diagram toont twee verschillende fasen in een machine learning-project: (i) de experimenteerfase en (ii) de productiephase. 

Kubeflow heeft veel verschillende componenten die bijna alle stappen in de pijplijn hieronder ondersteunen. Voor het afstemmen van de hyperparameters van het model heeft Kubeflow bijvoorbeeld een component genaamd “Katib.” We bespreken de belangrijkste componenten van Kubeflow later in deze tutorial.

Kubeflow - machine learning-workflow

Kubeflow installeren

Er zijn twee manieren om snel met Kubeflow aan de slag te gaan:

1. Installeer het met een gepackaged distributie (simpel en rechttoe rechtaan).
2. Installeer het met manifests (geavanceerd).

Gepackagede distributies worden ontwikkeld en ondersteund door de respectieve beheerders. Zo wordt Kubeflow op Azure onderhouden door Microsoft. Zie de volledige lijst met distributies in de onderstaande tabel:

Kubeflow-gepackagede distributies

Drie principes van Kubeflow

Composability

Composability is een systeemontwerpprincipe om om te gaan met de onderlinge relaties van componenten. Kubeflow is sterk composable, zodat je indien nodig eenvoudig verschillende versies van TensorFlow kunt gebruiken voor verschillende delen van je machine learning-pijplijn. 

Portabiliteit

Portabiliteit betekent dat je je volledige machine learning-project overal kunt draaien waar je Kubeflow draait. Het is platformonafhankelijk en abstraheert alle moeilijkheden voor de gebruiker. Je hoeft je code maar één keer te schrijven, en Kubeflow regelt de abstractie zodat je de code op je laptop of op een cluster in de cloud kunt draaien.

Schaalbaarheid

Schaalbaarheid betekent dat je project meer resources kan gebruiken wanneer dat nodig is en ze kan vrijgeven wanneer dat niet zo is. Elke omgeving kan verschillende compute-resources hebben, zoals CPU’s, GPU’s en TPU’s.

Kubeflow-conceptuele entiteiten

Kubeflow-componenten

Kubeflow-componenten zijn logische bouwstenen die samen Kubeflow vormen. In het algemeen zul je in een machine learning-project één of meer componenten gebruiken.

Dashboard

Bovenal biedt het centrale dashboard snelle toegang tot andere Kubeflow-componenten. Enkele nuttige componenten zijn:

• Notebooks: Voor het beheren van Notebook-servers.
• Pipelines: Voor het beheren van Kubeflow-pijplijnen.
• Experiments: Voor het beheren van Katib-experimenten.

Kubeflow Dashboard UI-weergave

Notebooks

Kubeflow wordt geleverd met een geïntegreerde Jupyter-notebookomgeving. Notebooks zijn handig voor snelle tests, modelontwikkeling en zelfs het schrijven van ML-applicaties. 

Het is niet ongebruikelijk dat ML-engineers en data scientists hun notebooks lokaal draaien en beperkt worden door resources. Notebooks in het cluster maken het eenvoudig om jobs te draaien waar resources dynamisch kunnen schalen. 

Kubeflow Notebooks

Pipelines

Kubeflow Pipelines is een krachtige Kubeflow-component voor het bouwen van end-to-end portable en schaalbare machine learning-pijplijnen op basis van Docker-containers. 

Machine learning-pijplijnen zijn een reeks stappen die alles aankunnen, van het verzamelen van data tot het serven van machine learning-modellen. Elke stap in een pijplijn is een Docker-container en dus portable en schaalbaar. Elke stap in de pijplijn is onafhankelijk, waardoor je pijplijncomponenten kunt hergebruiken. 

Kubeflow Pipelines UI

In deze tutorial lopen we de Kubeflow Pipelines-component in detail door en bekijken we een codevoorbeeld van hoe je met Kubeflow een machine learning-pijplijn bouwt en uitvoert.

Katib

Katib is een Kubeflow-component die is ontworpen voor geautomatiseerde hyperparameterafstemming op schaal. Hyperparameter tuning speelt een grote rol bij het ontwikkelen van goede modellen, omdat het handmatig doorzoeken van een hyperparameterspace veel moeite kan kosten. 

Katib helpt je je hyperparameterewaarden te optimaliseren rond een gedefinieerde metric (zoals AUC of RMSE). Het is een handige manier om de optimale configuratie te vinden en te visualiseren om je model productierijp te maken. 

Kubeflow Katib UI

Kubeflow Pipelines

Een machine learning-workflow kan veel stappen omvatten, van datavoorbereiding tot modeltraining, modelevaluatie en meer. Het is lastig om dit ad hoc bij te houden. 

Experimenteerlogging en modelversiebeheer zonder goede tooling is een andere uitdaging voor data scientists. Met Kubeflow Pipelines kunnen data scientists machine learning-workflows ontwikkelen volgens standaarden die composable, deelbaar en reproduceerbaar zijn.

Kubeflow is een Kubernetes-native oplossing die data scientists helpt een gedisciplineerde pijplijnmentaliteit aan te nemen bij het ontwikkelen van machine learning-code en het opschalen naar de cloud. De ultieme doelen van Kubeflow Pipelines zijn:

• Orkestratie van machine learning-pijplijnen op schaal vereenvoudigen 
• Sneller experimenteren, reproduceerbaarheid en samenwerking mogelijk maken via multi-tenancy. In de Kubeflow-UI kun je groepen maken en gebruikers aan groepen toevoegen met toegangsbeheer.
• Herbruikbaarheid bieden en standaardisatie van verschillende ML-componenten (stappen in pijplijnen).

Met Kubeflow kun je end-to-end machine learning-oplossingen bouwen zonder telkens opnieuw te hoeven beginnen, als bouwstenen. Kubeflow ondersteunt ook zaken als uitvoeringsbewaking, workflows plannen, metadata-logging en versiebeheer.

Kubeflow-architectuuroverzicht

Belangrijke concepten in Kubeflow Pipelines

Pijplijn

Een pijplijn is een reeks duidelijk gedefinieerde stappen in een machine learning (ML)-workflow. De pijplijn moet een definitie hebben van de invoer (parameters) die nodig zijn om de pijplijn te draaien en van de input en output van elke component. Elke component in een pijplijn neemt input, verwerkt die en levert de output aan de volgende component.

Een heel belangrijk concept hier is dat elke stap (component) in een Kubeflow-pijplijn in wezen een Docker-container is. Wanneer je een pijplijn uitvoert, start Kubeflow één of meer Kubernetes-pods die overeenkomen met de componenten in de pijplijn. De pods starten vervolgens de Docker-container, die op zijn beurt de code uitvoert die je in de component hebt geschreven.

Component

Een pijplijncomponent is zelfstandige code die één stap in de machine learning-workflow uitvoert, zoals het imputeren van missende waarden, schalen van data of het fitten van een machine learning-model.

Een component in een Kubeflow-pijplijn lijkt op een functie. Elke component heeft dan ook een naam, inputparameters en een output. 

Elke component in een pijplijn moet worden verpakt als een Docker-image zodat elke stap in de pijplijn onafhankelijk is van de andere, en je verschillende frameworks en tools kunt mixen en matchen in verschillende delen van je ML-workflows.

Experiment

Een experiment stelt je in staat verschillende configuraties van dezelfde pijplijn te draaien en de resultaten te vergelijken en analyseren. Normaal gesproken moet je in machine learning verschillende parameters proberen om te zien wat het beste werkt. Kubeflow Pipeline Experiment is hiervoor ontworpen.

Grafiek

Een grafiek is een visuele weergave in de Kubeflow-UI. Het toont de stappen die een pijplijnrun heeft uitgevoerd of aan het uitvoeren is, met pijlen die de ouder/kind-relaties aangeven tussen de pijplijncomponenten die door elke stap worden weergegeven. 

Drie manieren om pijplijnen in Kubeflow te bouwen 

Hopelijk is nu duidelijk wat Kubeflow-pijplijnen zijn en wat de voordelen zijn van dit framework voor het ontwerpen en uitrollen van machine learning-workflows in productie. Laten we snel drie manieren doornemen waarop je Kubeflow kunt gebruiken om pijplijnen te bouwen en te deployen.

Gebruikersinterface (UI)

Je kunt de Kubeflow-UI gebruiken om pijplijnen te draaien, pijplijnen te uploaden die iemand met je heeft gedeeld, artefacten en uitvoer van runs te bekijken en geautomatiseerde runs te plannen. Zo ziet de Pipeline-UI eruit:

Kubeflow Pipeline-interfaces

Officiële Python-SDK

Kubeflow biedt een set Python-bibliotheken waarmee je programmatisch ML-pijplijnen kunt ontwikkelen en uitvoeren. Dit is de meest gebruikelijke manier om Kubeflow-pijplijnen te gebruiken.

REST API

Kubeflow biedt ook REST-API’s voor continuous integration/deployment-systemen. Stel je een use-case voor waarin je een van de Kubeflow Pipeline-functionaliteiten wilt integreren in downstream enterprise-systemen of -processen.

Kubeflow Pipeline-tutorial

De eenvoudigste manier om met Kubeflow te beginnen is met een gepackagede distributie, wat in feite een managed service in de cloud is. Hier gebruiken we Kubeflow-service op GCP. Je kunt deze officiële handleiding volgen om te leren hoe je de service op GCP uitrolt. 

Zodra de uitrol is geslaagd, kun je dit dashboard openen via je GCP-endpoint.

Kubeflow-dashboard - deployment op GCP

Kubeflow Pipelines wordt geleverd met een paar voorbeeldpijplijnen. Laten we een basale datapreprocessing-pijplijn in Python proberen. Klik op Pipelines in de toolbar aan de linkerkant.

Kubeflow Pipelines - deployment op GCP

Klik op create experiment: 

Kubeflow Pipelines - deployment op GCP

Volg de prompts en klik vervolgens op de startknop op het run-scherm om de pijplijn te draaien.

Kubeflow Pipelines - deployment op GCP

Het experiment verschijnt in het dashboard:

Kubeflow Pipelines - deployment op GCP

Klik op het experiment om de output te bekijken zodra de run is voltooid:

Kubeflow Pipelines - deployment op GCP

Nu je weet hoe je pijplijnen uitvoert met de Kubeflow-UI. Elke component in de bovenstaande pijplijn is slechts een eenvoudige, zelfstaande Python-script. In het bovenstaande voorbeeld zijn de stappen simpel, zoals “Print Text” of “Sum Numbers.” 

Laten we een complexer voorbeeld bekijken van hoe je deze componenten in Python kunt coderen en compileren.

Een Kubeflow-pijplijn bouwen via de Python-SDK

In dit voorbeeld maken we een Kubeflow-pijplijn met twee componenten: 

• Download het gezipte tar-bestand op basis van de url die als input wordt doorgegeven,
• Extraheer alle csv-bestanden en maak één enkele pandas-dataframe met de functie `pd.concat`. 

Theoretisch kunnen we in plaats van deze pijplijn in twee stappen op te delen ook één functie maken die de url aanneemt, het gezipte bestand downloadt en vervolgens alle csv-bestanden samenvoegt tot één bestand. 

Het voordeel van het in twee stappen doen is echter dat je een stap voor het downloaden van het gezipte bestand kunt maken, die je ook in andere projecten kunt hergebruiken. 

In Kubeflow kun je de component definiëren als een yaml-bestand en de functie `kfp.components.load_component_from_url` gebruiken om de component direct vanaf de url te laden. 

Voor de eerste stap laden we de component van deze open-source url.

```

web_downloader_op = kfp.components.load_component_from_url(

    'https://raw.githubusercontent.com/kubeflow/pipelines/master/components/web/Download/component-sdk-v2.yaml')

```

Voor de tweede stap definiëren we een Python-functie:

```

@component(

    packages_to_install=['pandas==1.1.4'],

    output_component_file='component.yaml'

)

def merge_csv(tar_data: Input[Artifact], output_csv: Output[Dataset]):

  import glob

  import pandas as pd

  import tarfile




  tarfile.open(name=tar_data.path, mode="r|gz").extractall('data')

  df = pd.concat(

      [pd.read_csv(csv_file, header=None) 

       for csv_file in glob.glob('data/*.csv')])

  df.to_csv(output_csv.path, index=False, header=False)




```

Zoals je ziet is de functie voorzien van de annotatie `kfp.dsl.component`. Met deze annotatie kunnen we het containerimage definiëren, eventuele packagedependencies (in dit voorbeeld pandas[1.1.4]) en de locatie om de component-specificatie op te slaan (component.yaml)

Nu kun je deze twee componenten aan elkaar koppelen in een pijplijn met de  `pipeline`-operator. 

Definieer een pijplijn en maak een task van een component:

@dsl.pipeline(

    name='my-pipeline',

    # You can optionally specify your own pipeline_root

    # pipeline_root='gs://my-pipeline-root/example-pipeline',

)

def my_pipeline(url: str):

  web_downloader_task = web_downloader_op(url=url)

  merge_csv_task = merge_csv(tar_data=web_downloader_task.outputs['data'])

  # The outputs of the merge_csv_task can be referenced using the

  # merge_csv_task.outputs dictionary: merge_csv_task.outputs['output_csv']

```

Zodra de pijplijn is gedefinieerd, kunnen we deze compileren. Dat kan op twee manieren. De eerste is via de Kubeflow-UI.

```

kfp.compiler.Compiler(mode=kfp.dsl.PipelineExecutionMode.V2_COMPATIBLE).compile(

    pipeline_func=my_pipeline,

    package_path='pipeline.yaml')

```

We kunnen dit bestand `pipeline.yaml` nu uploaden en draaien via de gebruikersinterface van Kubeflow Pipelines. Als alternatief kunnen we de pijplijn draaien met de SDK-client van Kubeflow Pipelines.

```

client = kfp.Client()




client.create_run_from_pipeline_func(

    my_pipeline,

    mode=kfp.dsl.PipelineExecutionMode.V2_COMPATIBLE,

    # You can optionally override your pipeline_root when submitting the run too:

    # pipeline_root='gs://my-pipeline-root/example-pipeline',

    arguments={

        'url': 'https://storage.googleapis.com/ml-pipeline-playground/iris-csv-files.tar.gz'

    })

```

Als we deze pijplijn willen uitbreiden met een machine learning-model, maken we een Python-functie die `Input[Dataset]` accepteert en het model fit met elk gewenst framework, bijvoorbeeld sklearn, TensorFlow of PyTorch. 

Zodra een functie is gemaakt, moeten we de functie `my_pipeline` aanpassen om de derde taak op te nemen en de pijplijn vervolgens opnieuw compileren met `kfp.Client` of via de UI.

Tutorial gereproduceerd van Kubeflow Official.

Conclusie

Experimenteren in een Jupyter Notebook met een paar miljoen rijen data is één ding. Een machine learning-model trainen op miljarden rijen op afstand in de cloud is iets heel anders. Machine learning wordt echt lastig wanneer het aankomt op het trainen van grote modellen in een schaalbare en gedistribueerde omgeving. 

Kubernetes is een van de populairste en meest gebruikte orkestratieframeworks voor machine learning-jobs; en Kubeflow is een framework bovenop Kubernetes dat voor gebruikers veel lastige details abstraheert. Het is echter goed om te weten dat dit niet je enige optie is. Net als met alles zijn er alternatieven. 

Een voorbeeld van dit soort platform is Databricks. Het heeft zijn eigen propriëtaire orkestratiemotor (die verschilt van Kubernetes) en wordt geleverd met een fraaie UI die Notebooks, Experiment Logging, Model Registry, Job Scheduling en Monitoring ondersteunt. 

Amazon Sagemaker is een ander voorbeeld van een alternatief voor Kubernetes / Kubeflow. Amazon SageMaker is een volledig beheerde machine learning-service die data scientists en ontwikkelaars kunnen gebruiken om snel en eenvoudig machine learning-modellen te bouwen en te trainen en ze direct uit te rollen in een productierijpe gehoste omgeving. Het biedt een geïntegreerde Jupyter Notebook-omgeving voor verkenning en analyse.

Voel je je overweldigd door alle continu evoluerende engineeringconcepten? Geen zorgen, Datacamp biedt een Understanding Data Engineering cursus. In deze cursus leer je over de kerntaken van een data engineer, hoe die verschillen van die van data scientists en hoe ze de datastroom door een organisatie faciliteren. Daarnaast leer je hoe data engineers het fundament leggen dat data science voor data scientists mogelijk maakt. Geen codeerwerk betrokken!