Zephyrnet-logo

Een stapsgewijze handleiding voor het maken en implementeren van een pijplijn voor machine learning met Kubeflow

Datum:

troductie

Ontgrendel de kracht van data met machine learning! Met Kubeflow, creëren en implementeren ML-pijplijnen is niet langer ingewikkeld en tijdrovend. Zeg maar dag tegen het gedoe van het beheren van ML-workflows en hallo tegen de eenvoud van Kubeflow.

Kubeflow is een open-sourceplatform dat het gemakkelijk maakt om uw gegevens om te zetten in waardevolle inzichten. Kubeflow is gebouwd bovenop het populaire containerorkestratieplatform Kubernetes en biedt een one-stop-shop voor al uw ML-behoeften.

Kubeflow: Kubeflow installeren en starten op uw lokale computer | door Fernando López | Op weg naar datawetenschap

Ga samen met mij op een spannend avontuur terwijl ik je door de stappen leid van het maken en implementeren van een krachtige ML-pijplijn met Kubeflow. Ontketen het potentieel van uw gegevens en bereik nieuwe niveaus van gegevensgestuurde inzichten en resultaten. Maak je klaar om je ML-mogelijkheden naar een hoger niveau te tillen!

leerdoelen

  • De basisconcepten en voordelen begrijpen van het gebruik van Kubeflow voor het maken en implementeren van ML-pijplijnen
  • Om de s Kubeflow te leren
  • Praktische ervaring opdoen met het gebruik van Kubeflow om ML-workflows en -implementaties te beheren
  • Het belang begrijpen van retd-evaluatie in de ML-pips en hoe hiermee om te gaan met Kubeflow
  • De voordelen waarderen van het gebruik van Kubeflow ten opzichte van traditionele ML-pijplijnontwikkelings- en implementatieprocessen.

Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Inhoudsopgave

  1. Introductie
  2. Een diepgaande blik op de machine learning-pijplijn
    2.1 Voorverwerking
    2.2 Training en afstemming van hyperparameters op CMLE
    2.3 Lokaal trainen op Kubernetes
    2.4 Implementeren naar Cloud ML Engine
    2.5 De ​​Kubeflow ML-pijplijn compileren met DSL Compiler
  3. Upload Kubeflow ML-pijplijn naar de gebruikersinterface
  4. Experimenteren, ontwikkelen, omscholen en evalueren
    4.1 Omscholingsmodel
    4.2 Evalueren en monitoren van modelprestaties met notebooks
  5. Conclusie

een Kubernetes-cluster met permanente Kubeflow-pijplijninstallatie

Om KFP uit te voeren, is een Kubernetes-cluster vereist. De volgende opdracht kan worden gebruikt om een ​​Google Kubernetes Engine (GKE)-cluster te maken en KFP in staat te stellen dit te beheren (create_cluster.sh in de repository):

#!/bin/bash CLUSTERNAME=mykfp ZONE=us-central1-bgcloud configuratie set compute/zone $ZONE gcloud beta container clusters creëren $CLUSTERNAME --cluster-version 1.11.2-gke.18 --enable-autoupgrade --zone $ZONE --scopes cloud-platform --enable-cloud-logging --enable-cloud-monitoring --machine-type n1-standard-2 --num-nodes 4kubectl create clusterrolebinding ml-pipeline-admin-binding --clusterrole =cluster-admin --user=$(gcloud config get-value account)

Het maken van een GKE-cluster kan tot 3 minuten duren. Daarom wordt aanbevolen om naar het GKE-gedeelte van de GCP-console te navigeren om ervoor te zorgen dat het cluster is gestart en gereed is.

Zodra het cluster actief is, kunt u doorgaan met het installeren van de ML-pipelines op het GKE-cluster met behulp van de volgende opdracht.

#!/bin/bash PIPELINE_VERSION=0.1.3 kubectl create -f https://storage.googleapis.com/ml-pipeline/release/$PIPELINE_VERSION/bootstrapper.yaml

Terwijl de software-installatie bezig is, kunt u doorgaan met lezen voor meer informatie over de komende stappen in het proces

2. Een diepgaande blik op de Machine Learning-pijplijn

Er zijn verschillende methoden voor het maken van pijplijnen, waaronder het gebruik van Python3 en Docker (een "dev-ops"-benadering) of Jupyter-notebooks (een meer data-wetenschapper-vriendelijke benadering). In dit bericht zullen we het Python3-Docker-mechanisme verkennen, dat een dieper inzicht kan geven in de onderliggende processen met behulp van de Jupyter-notebookmethode.

Als voorbeeld zullen we de pijplijn demonstreren met behulp van een machine-learningmodel om het gewicht van een baby te voorspellen. De pijplijn omvat de volgende stappen: (a) gegevens extraheren uit BigQuery, deze transformeren en de getransformeerde gegevens opslaan in Cloud Storage. (b) Een TensorFlow Estimator API-model trainen en hyperparameterafstemming uitvoeren. (c) Zodra de optimale leersnelheid, batchgrootte, enz. zijn bepaald, wordt het model voor een langere duur en met meer gegevens getraind met behulp van die parameters. (d) Het getrainde model implementeren in Cloud ML Engine.

preprocess = dsl.ContainerOp( naam='voorbewerken', afbeelding='gcr.io/cloud-training-demos/babyweight-pipeline-bqtocsv:latest', argumenten=[ '--project', projecten, '--modus', 'wolk', '--emmer', emmer], file_outputs={'emmer': '/output.txt'} )hparam_train = dsl.ContainerOp( naam='hypertrein', afbeelding='gcr.io/cloud-training-demos/babyweight-pipeline-hypertrain:latest', argumenten=[ preprocess.outputs['emmer'] ], file_outputs={'taaknaam': '/output.txt'} )train_tuned = dsl.ContainerOp( naam='getraind', afbeelding='gcr.io/cloud-training-demos/babyweight-pipeline-traintuned-trainer:latest', argumenten=[ hparam_train.outputs['taaknaam'], emmer], file_outputs={'trein': '/output.txt'} ) train_tuned.set_memory_request('2G') train_tuned.set_cpu_request('1')deploy_cmle = dsl.ContainerOp( naam='implementeer cmle', afbeelding='gcr.io/cloud-training-demos/babyweight-pipeline-deploycmle:latest', argumenten=[ train_tuned.outputs['trein'], # modeldir 'babygewicht', 'mlp' ], file_outputs={ 'model': '/model.txt', 'versie': '/versie.txt' } )

Stappen in dit proces worden weergegeven als Docker-containers, die een gerichte acyclische grafiek vormen waarbij de uitvoer van de ene container dient als invoer voor de volgende. Dit wordt weergegeven als een verbonden pijplijn wanneer deze wordt bekeken in de gebruikersinterface van de pijplijn

Machine learning-pijplijn met kubeflow

Bovendien moet een vijfde stap van het implementeren van een webapplicatie met een gebruiksvriendelijke interface voor interactie met het model ook worden geïmplementeerd om de volledige end-to-end-oplossing te voltooien

Onderzoek de voorbewerkingsfase:

preprocess = dsl.ContainerOp( naam='voorbewerken', afbeelding='gcr.io/cloud-training-demos/babyweight-pipeline-bqtocsv:latest', argumenten=[
'--project', projecten,
'--modus', 'wolk',
'--emmer', emmer], file_outputs={'emmer': '/output.txt'} )

Het is belangrijk op te merken dat de preprers, het project en de bucket, de voorverwerkte gegevens uitvoeren in /output.txt.

Vervolgens haalt de tweede stap de bucketnaam op uit de uitvoer van de preprocessing-stap, vertegenwoordigd door preprocessing. uitgangen['emmer']. De uitvoer van deze stap, de taaknaam van de meest effectieve hyperparameter afstemmingsproef, wordt vervolgens gebruikt door de derde stap als hparam_train.outputs['jobname'].

Dit proces is relatief eenvoudig.

Het roept echter twee vragen op: waar krijgt de eerste stap het vereiste project en de benodigde emmer, en hoe worden de afzonderlijke stappen geïmplementeerd?

Het antwoord op deze vragen ligt in de pijplijnparameters, die de project- en bucket-invoer leveren voor de eerste stap

def train_and_deploy( project='cloud-training-demos', bucket='cloud-training-demos-ml'):

In wezen zullen de project- en bucketparameters door de eindgebruiker worden aangeleverd op het moment dat de pijplijn wordt uitgevoerd. De gebruikersinterface wordt vooraf geconfigureerd met standaardwaarden die eerder zijn opgegeven:

In het volgende gedeelte wordt dieper ingegaan op de implementatie van elke stap. Zoals eerder vermeld, zal deze uitleg zich concentreren op de implementatiemethode Python3-Docker. Voor degenen die de voorkeur geven aan een op Jupyter gebaseerde aanpak, zal in de toekomst een apart artikel worden gepubliceerd om dit aan te pakken. Als u er zeker van bent dat de Docker-route niet geschikt voor u is, blader dan gerust door dit gedeelte of ga direct door naar hoofdstuk 3.

2.1 Voorbewerking

In elke stap van de pijplijn is het noodzakelijk om een ​​Docker-container te maken. Deze container bevat een op zichzelf staand programma (zoals een bash-script, Python-code, C++ of een andere taal) samen met de benodigde afhankelijkheden, waardoor het door KFP op het cluster kan worden uitgevoerd.

Voor dit voorbeeld is de voorbewerking code is een op zichzelf staand Python-programma dat Apache Beam gebruikt en bedoeld is om op Cloud Dataflow te draaien. De volledige code is opgenomen in een enkel opdrachtregelprogramma met de naam transform.py.

Voorverwerking van gegevens in pijplijn

De Dockerfile moet alle vereiste afhankelijkheden voor het programma specificeren. Gelukkig biedt KFP een reeks voorbeeldcontainers, waarvan er één alle benodigde afhankelijkheden bevat voor dit voorbeeld. Om de inspanning te minimaliseren, erft de Dockerfile van deze bestaande container, wat resulteert in een beknopt bestand van 4 regels.

VAN gcr.io/ml-pipeline/ml-pipeline-dataflow-tft:latest RUN mkdir /babyweight COPY transform.py /babyweight ENTRYPOINT ["python", "/babyweight/transform.py"]

De Dockerfile kopieert het transform.py-bestand naar de container en stelt het in als het ingangspunt, wat betekent dat het bestand wordt uitgevoerd wanneer de container wordt uitgevoerd.

Zodra de Dockerfile is voltooid, kan de Docker-container worden gebouwd en gepubliceerd naar het gcr.io-register binnen het project met behulp van het build.sh-script.

CONTAINER_NAME=babyweight-pipeline-bqtocsv
docker-build -t ${CONTAINER_NAME} . docker-tag ${CONTAINER_NAME} gcr.io/${PROJECT_ID}/${CONTAINER_NAME}:${TAG_NAME} docker-push gcr.io/${PROJECT_ID}/${CONTAINER_NAME}:${TAG_NAME}

Dit verwijst naar de specifieke afbeeldingsnaam die is opgegeven voor de voorverwerkingsstap.

2.2 Training en afstemming van hyperparameters op CMLE

       Hyperparameterafstemming in Model | Kubeflow

De training en hyperparameter stemming wordt uitgevoerd op Cloud ML Engine

gcloud ml-engine jobs dien training in $JOBNAME --region=$REGION --module-name=trainer.task --package-path=${CODEDIR}/babyweight/trainer --job-dir=$OUTDIR --staging- bucket=gs://$BUCKET --scale-tier=STANDARD_1 --config=hyperparam.yaml --runtime-version=$TFVERSION  --stream-logboeken -- --bucket=${BUCKET} --output_dir=${OUTDIR} --eval_steps=10 --train_examples=20000# schrijf uitvoerbestand voor volgende stap in pijplijn echo $JOBNAME > /output.txt

Het is belangrijk op te merken dat de optie –stream-logs wordt gebruikt in de gcloud-opdracht. Dit zorgt ervoor dat de opdracht wacht op voltooiing. Bovendien bevat de opdrachtuitvoer de taaknaam, die essentieel is voor de communicatie tussen deze stap en de volgende stap in de pijplijn.

Voor deze stap erft de Dockerfile van een container waarin gcloud is geïnstalleerd. De trainercode wordt verkregen door de relevante repository te klonen met behulp van het git clone-commando.

VAN google/cloud-sdk:latestRUN mkdir -p /babyweight/src && cd /babyweight/src && git clone https://github.com/GoogleCloudPlatform/training-data-analyst
COPY train.sh hyperparam.yaml ./ ENTRYPOINT ["bash", "./train.sh"]

2.3 Lokaal trainen op Kubernetes

De vorige stappen van voorverwerking en hyperparameterafstemming maakten gebruik van beheerde services, waarbij KFP alleen verantwoordelijk was voor het verzenden van taken en het toestaan ​​van de beheerde services om het proces af te handelen.

De volgende trainingsstap kan echter lokaal worden uitgevoerd op het KFP-draaiende GKE-cluster door een Docker-container uit te voeren die rechtstreeks een Python-programma uitvoert. Dit zorgt voor afwisseling en toont de flexibiliteit van KFP.

NEMBEDS=$(gcloud ml-engine jobs beschrijven $HYPERJOB --format 'value(trainingOutput.trials.hyperparameters.nembeds.slice(0))') TRIALID=$(gcloud ml-engine jobs beschrijven $HYPERJOB --format 'value (trainingOutput.trials.trialId.slice(0))')...OUTDIR=gs://${BUCKET}/babyweight/hyperparam/$TRIALID python3 -m trainer.task --job-dir=$OUTDIR -- bucket=${BUCKET} --output_dir=${OUTDIR} --eval_steps=10 --nnsize=$NNSIZE --batch_size=$BATCHSIZE --nembeds=$NEMBEDS --train_examples=200000

Bij het uitvoeren van een taak op het KFP-cluster is het belangrijk om rekening te houden met het huidige resourcegebruik. De bewerking train-turned-container reserveert de benodigde hoeveelheid geheugen en CPU-resources om ervoor te zorgen dat het cluster voldoende resources heeft voor de taak. KFP plant de taak alleen wanneer de vereiste bronnen beschikbaar zijn, waardoor een efficiënt gebruik van de bronnen van het cluster wordt gegarandeerd.

train_tuned.set_memory_request('2G') train_tuned.set_cpu_request('1')

2.4 Implementeren naar Cloud ML Engine

De implementatie naar Cloud ML Engine maakt gebruik van gcloud, waardoor het implementatieproces vergelijkbaar is met de vorige stappen, zoals te zien is in de deploy.sh- en build.sh-scripts in die directory.

gcloud ml-engine versies maken ${MODEL_VERSION} --model ${MODEL_NAME} --origin ${MODEL_LOCATION} --runtime-versie $TFVERSIONecho $MODEL_NAME > /model.txt echo $MODEL_VERSION > /version.txt

en

VAN google/cloud-sdk: nieuwste RUN mkdir -p /babyweight/src && cd /babyweight/src && git clone https://github.com/GoogleCloudPlatform/training-data-analyst
KOPIE deploy.sh ./ ENTRYPOINT ["bash", "./deploy.sh"]

Evenzo kan de implementatie ook op het Kubernetes-cluster zelf worden uitgevoerd, zoals hieruit blijkt component voorbeeld

2.5 De ​​Kubeflow ML-pijplijn compileren met DSL Compiler

Om de setup van de pijplijn te voltooien, moet de pijplijncode worden gecompileerd in een domeinspecifieke taal (DSL)-indeling. Dit wordt gedaan met behulp van de DSL-compileertool die wordt geleverd met de KFP Python3 SDK. Voordat u de pijplijn compileert, moet u de SDK installeren door het script uit te voeren 3_install_sdk.sh

pip3 installeer python-dateutil
https://storage.googleapis.com/ml-pipeline/release/0.1.2/kfp.tar.gz --upgrade

Compileer nu de Domain-Specific-Language (DSL) met behulp van de volgende opdracht.

python3 mlp_babyweight.py mlp_babyweight.tar.gz

U kunt ook de map met dsl-compile aan uw PATH toevoegen door de volgende stappen uit te voeren:”

exporteer PATH=”$PATH:`python -m site --user-base`/bin

En roep de compiler aan door de volgende opdracht uit te voeren:

dsl-compileren --py mlp_babyweight.py --output mlp_babyweight.tar.gz

Het resultaat van het compileren van het Python3-bestand van de pijplijn is een tar-archiefbestand, dat u vervolgens uploadt naar de gebruikersinterface van ML Pipelines in de volgende stap (sectie 3).

3. Upload Kubeflow ML Pipeline naar de gebruikersinterface

Het tot stand brengen van een verbinding tussen het GKE-cluster en uw lokale computer kan worden bereikt door middel van port forwarding. Hiermee krijgt u toegang tot de gebruikersinterfaceserver, die draait op poort 80 op het GKE-cluster, vanaf uw laptop op poort 8085.

Het opzetten van deze verbinding kan worden uitgevoerd met behulp van het script 4_start_ui.sh.

export NAMESPACE=kubeflow kubectl port-forward -n ${NAMESPACE} $(kubectl get pods -n ${NAMESPACE} --selector=service=ambassadeur -o jsonpath='{.items[0].metadata.name}') 8085:80

Om een ​​experiment te maken en een pijplijn uit te voeren, gaat u naar de KFP-gebruikersinterface op http://localhost:8085/pipeline en ga naar het tabblad Pijplijnen. Upload het bestand tar.gz dat is samengesteld in Sectie 2e. Als u een experiment wilt starten, maakt u een nieuw experiment en geeft u het een naam, bijvoorbeeld 'blog'.

Maak vervolgens binnen het experiment een nieuwe run en geef deze een naam, zoals "try1". Stel ten slotte de pijplijn in op degene die eerder is geüpload.

Kubeflow

4. Experimenteren, ontwikkelen, omscholen en evalueren

De volledige broncode voor deze pijplijnimplementatie bevat verschillende aspecten die in de vorige stappen niet volledig zijn uitgelegd. Het is gebruikelijk dat de code meerdere iteraties en aanpassingen vereist voordat deze naadloos wordt uitgevoerd.

Om het foutopsporings- en testproces te stroomlijnen, is de pijplijn ontworpen om bij elke stap te kunnen beginnen en ervoor te zorgen dat elke stap afhankelijk is van de uitvoer van de vorige. Er is een oplossing bedacht om aan deze eis te voldoen.

als start_step <= 2: hparam_train = dsl.ContainerOp( name='hypertrain', # afbeelding moet een tekenreeks voor compileren zijn image='gcr.io/cloud-training-demos/babyweight-pipeline-hypertrain:latest', arguments=[ preprocess.outputs ['bucket'] ], file_outputs={'jobname': '/output.txt'} ) else: hparam_train = ObjectDict({ 'outputs': { 'jobname': 'babyweight_181008_210829' } })

In wezen wordt de containerbewerking alleen uitgevoerd als de start_step kleiner is dan of gelijk is aan 2. Als deze groter is dan 2, wordt in plaats daarvan een woordenboek gemaakt met een vooraf gedefinieerde uitvoer van de vorige stap. Dit zorgt voor een efficiëntere ontwikkeling, aangezien u de start_step kunt instellen op 4 en kunt beginnen bij de vierde stap terwijl u nog steeds beschikt over de benodigde invoer van de vorige stappen.

Mijn experiment bestond uit verschillende runs:

             Kubeflow

Mijn experiment bestond uit verschillende iteraties, elk met verschillende configuraties en parameters. Zo mislukte het uitvoeren van 'try1' na het succesvol uitvoeren van drie stappen en moest ik beginnen bij stap 4. Het kostte me twee pogingen om stap 4 correct uit te voeren. Daarna voegde ik stap 5 toe, waarbij een AppEngine-applicatie werd geïmplementeerd om de webservice te hosten. Vervolgens heb ik stap 3 opnieuw bekeken en geëxperimenteerd met verschillende variaties.

4.1 Omscholingsmodel

 

omscholingsmodel | Kubeflow

Natuurlijk stopt de training van een model niet na een enkele run. Naarmate er meer gegevens beschikbaar komen, moet het model opnieuw worden getraind. In ons babygewichtsmodel kan bijvoorbeeld omscholing plaatsvinden zodra we een extra jaar aan gegevens hebben. Ik heb een starter als invoerparameter opgenomen om dit in de pijplijn op te nemen.

def train_and_deploy( project=dsl.PipelineParam(name='project', value='cloud-training-demos'), bucket=dsl.PipelineParam(name='bucket', value='cloud-training-demos-ml') , startYear=dsl.PipelineParam(name='startYear', value='2000') ):

De voorverwerkingscode in de stap "bqtocsv" filtert alle rijen uit die voorkomen vóór het opgegeven startjaar. Hierdoor kan het model opnieuw worden getraind op basis van bijgewerkte gegevens door simpelweg de invoerparameter voor het startjaar aan te passen.

WHERE jaar >= start_jaar

En benoemt de uitvoerbestanden zodanig dat ze eerdere uitvoer niet overschrijven.

os.path.join(OUTPUT_DIR, 'train_{}.csv', start_jaar)

Het afhandelen van omscholing is een belangrijk aspect van Machine Learning-pijplijnen. In ons geval filtert de preprocessing-code in de bqtocsv-stap alleen de gegevens uit het opgegeven startjaar, zodat de training plaatsvindt op een grotere en recentere dataset. De uitvoerbestanden krijgen ook een naam om te voorkomen dat ze eerdere uitvoer overschrijven.

4.2 Evaluatie en bewaking van modelprestaties met notebooks

Voordat een getraind model in productie wordt genomen, is het van cruciaal belang om een ​​goede evaluatie uit te voeren en eventueel A/B-testen uit te voeren. Het evaluatieproces helpt de betrouwbaarheid en effectiviteit van het model te waarborgen voordat het volledig wordt geïmplementeerd. In het geval van het babygewichtsmodel was de code eenvoudig te Dockeriseren omdat deze grotendeels in Python was geschreven. Veel machine learning-modellen zijn echter ontwikkeld met behulp van Jupyter-notebooks.

Het proces van het evalueren van modellen die zijn ontwikkeld in Jupyter-notebooks en het omzetten ervan in pijplijnen is een onderwerp dat een aparte schijf verdient

Conclusie

Kortom, Kubeflow is een open-sourceplatform dat een set tools en kaders biedtorks voor het bouwen, implementeren en beheren van ML-pijplijnen. Het platform is bovenop Kubernetes gebouwd, waardoor het eenvoudig is om de pijplijnen te beheren en te schalen. Met behulp van deze handleiding zou u nu een duidelijk begrip moeten hebben van de stappen die nodig zijn voor het maken en implementeren van een ML-pijplijn met Kubeflow.

Sleutelfaciliteiten:

  • Kubeflow is een open-sourceplatform voor het beheer van ML-pijplijnen.
  • Het platform is bovenop Kubernetes gebouwd, waardoor het schaalbaar en eenvoudig te beheren is.
  • De gids behandelt de stappen voor het maken en implementeren van een ML-pijplijn met Kubeflow.
  • Het proces omvat training, evaluatie, implementatie en hertraining van het model.
  • Kubeflow Pipelines (KFP) is een belangrijk hulpmiddel voor het operationaliseren van machine learning-modellen.

Voel je vrij om contact met mij op te nemen  Linkedin.

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.

spot_img

Mobile

Laatste intelligentie

spot_img