Kurs
Einführung in Python
4 Std.
7M
Einführung
Wenn du ein Machine-Learning-Modell entwickelst, gerät die nötige Infrastruktur für Training und Bereitstellung in der Produktion schnell aus dem Blick. Bei End-to-End-ML-Workflows ist es anspruchsvoll, alle Aspekte von Applikation, Plattform und Ressourcen im Griff zu behalten.
Im Vergleich zu klassischen Web-Deployments haben ML-Anwendungen ein anderes Profil: Das Training ist ressourcenintensiv, während Inferenz leichtgewichtig und schnell ist. Außerdem brauchst du passende Tools und Frameworks, um all diese Bausteine zu betreiben. Ein sehr populäres Open-Source-Framework, mit dem du End-to-End-ML-Anwendungen standardisiert entwickeln und ausliefern kannst, ist Kubeflow.
Was ist Kubeflow?
Kubeflow ist ein Open-Source-Projekt mit einer kuratierten Sammlung von Tools und Frameworks. Das Hauptziel von Kubeflow ist es, die Entwicklung, Bereitstellung und Verwaltung portabler, skalierbarer Machine-Learning-Workflows zu vereinfachen.
Kubeflow baut auf Kubernetes auf, einer Open-Source-Plattform zum Ausführen und Orchestrieren von Containern. Kubernetes läuft konsistent in unterschiedlichen Umgebungen – der Schlüssel dafür, wie Kubeflow funktioniert. Kubeflow ist so konzipiert, dass Kubernetes seine Stärken ausspielen kann. Du konzentrierst dich auf das Definieren und Ausführen von ML-Workflows: Daten verwalten, Notebooks betreiben, Modelle trainieren und serven.
Kubeflow ist aus Googles internem Projekt TensorFlow Extended hervorgegangen. Anfangs diente es lediglich dazu, TensorFlow-Jobs einfacher auf Kubernetes auszuführen. Mittlerweile hat es sich zu einem Multi-Architektur- und Multi-Cloud-Framework für End-to-End-ML-Workflows entwickelt.
Kubeflow und Machine-Learning-Workflows
Kubeflow ist eine Plattform für Data Scientists und ML Engineers und vereint die Stärken beider Welten. Data Scientists können mit Kubeflow Modelle experimentell entwickeln und ihre Experimente effizient auf Kubernetes orchestrieren.
ML Engineers können ML-Systeme in unterschiedliche Umgebungen für Entwicklung, Testing und Produktion ausrollen.
Die folgende Abbildung zeigt zwei Phasen eines ML-Projekts: (i) die Experimentierphase und (ii) die Produktionsphase.
Kubeflow bringt viele Komponenten mit, die nahezu jeden Schritt der Pipeline unten abdecken. Für das Tuning von Hyperparametern gibt es zum Beispiel die Komponente „Katib“. Auf die wichtigsten Komponenten gehen wir später im Tutorial ein.
Kubeflow – Machine-Learning-Workflow
Kubeflow installieren
Es gibt zwei Möglichkeiten, schnell mit Kubeflow zu starten:
- Installation über eine Packaged Distribution (einfach und unkompliziert).
- Installation über Manifeste (fortgeschritten).
Packaged Distributions werden von den jeweiligen Anbietern entwickelt und unterstützt. Kubeflow auf Azure wird beispielsweise von Microsoft gepflegt. Eine vollständige Liste der Distributionen findest du in der Tabelle unten:
Kubeflow Packaged Distributions
Drei Prinzipien von Kubeflow
Komponierbarkeit
Komponierbarkeit ist ein Prinzip der Systemgestaltung, das die Wechselwirkungen von Komponenten adressiert. Kubeflow ist hochgradig komponierbar. So kannst du bei Bedarf unterschiedliche TensorFlow-Versionen in verschiedenen Teilen deiner ML-Pipeline einsetzen.
Portabilität
Portabilität bedeutet, dass du dein gesamtes ML-Projekt überall dort ausführen kannst, wo Kubeflow läuft. Es ist plattformagnostisch und kapselt die Komplexität für die Nutzenden. Du schreibst deinen Code einmal, Kubeflow übernimmt die Abstraktion – egal ob auf dem Laptop oder im Cluster in der Cloud.
Skalierbarkeit
Skalierbarkeit heißt, dass dein Projekt bei Bedarf mehr Ressourcen nutzen und sie wieder freigeben kann, wenn sie nicht benötigt werden. Jede Umgebung bietet unterschiedliche Rechenressourcen wie CPUs, GPUs und TPUs.
Kubeflow – Konzeptionelle Entitäten
Kubeflow-Komponenten
Kubeflow-Komponenten sind die logischen Bausteine, aus denen Kubeflow besteht. In ML-Projekten nutzt du in der Regel eine oder mehrere dieser Komponenten.
Dashboard
Das zentrale Dashboard bietet vor allem schnellen Zugriff auf andere Kubeflow-Komponenten. Nützliche Bestandteile sind unter anderem:
- Notebooks: Verwaltung von Notebook-Servern.
- Pipelines: Verwaltung von Kubeflow-Pipelines.
- Experiments: Verwaltung von Katib-Experimenten.
Kubeflow Dashboard – UI-Ansicht
Notebooks
Kubeflow bringt eine integrierte Jupyter-Notebook-Umgebung mit. Notebooks eignen sich für schnelle Tests, die Modellentwicklung und sogar das Schreiben kompletter ML-Anwendungen.
Oft laufen Notebooks lokal und stoßen dabei an Ressourcenlimits. Läuft das Notebook im Cluster, können Jobs dort mit dynamisch skalierbaren Ressourcen ausgeführt werden.
Pipelines
Kubeflow Pipelines ist eine leistungsstarke Komponente, um End-to-End-portable und skalierbare ML-Pipelines auf Basis von Docker-Containern aufzubauen.
ML-Pipelines bestehen aus Schritten, die alles vom Datensammeln bis zum Serven von Modellen abdecken. Jeder Schritt ist ein Docker-Container – damit portabel und skalierbar. Die Schritte sind unabhängig, sodass du Pipeline-Komponenten wiederverwenden kannst.
In diesem Tutorial gehen wir die Komponente Kubeflow Pipelines im Detail durch und sehen uns am Codebeispiel an, wie du eine ML-Pipeline mit Kubeflow baust und ausführst.
Katib
Katib ist eine Kubeflow-Komponente für automatisiertes Hyperparameter-Tuning in großem Maßstab. Hyperparameter-Tuning ist zentral für gute Modelle – die manuelle Suche im Hyperparameterraum ist jedoch sehr aufwendig.
Katib hilft dir, Hyperparameterwerte anhand einer Zielmetrik (etwa AUC oder RMSE) zu optimieren. So findest und visualisierst du die optimale Konfiguration, um dein Modell produktionsreif zu machen.
Kubeflow Pipelines
Ein ML-Workflow umfasst viele Schritte – von der Datenaufbereitung über das Training bis zur Evaluation. Ad hoc ist das kaum sauber nachzuverfolgen.
Auch Experiment-Logging und Modellversionierung sind ohne passende Tools eine Herausforderung. Kubeflow Pipelines ermöglichen es Data Scientists, ML-Workflows standardisiert, komponierbar, teilbar und reproduzierbar zu entwickeln.
Kubeflow ist eine Kubernetes-native Lösung, die Data Scientists hilft, beim Entwickeln von ML-Code eine konsequente Pipeline-Denkweise zu etablieren und diesen in die Cloud zu skalieren. Die Ziele von Kubeflow Pipelines sind:
- Orchestrierung von ML-Pipelines in großem Maßstab vereinfachen.
- Schnelleres Experimentieren, Reproduzierbarkeit und Zusammenarbeit durch Multi-Tenancy. In der Kubeflow-UI kannst du Gruppen erstellen, Nutzende hinzufügen und Zugriffe steuern.
- Wiederverwendbarkeit und Standardisierung der verschiedenen ML-Komponenten (Schritte in Pipelines).
Mit Kubeflow baust du End-to-End-ML-Lösungen wie mit Bausteinen – ohne jedes Mal von vorn zu beginnen. Außerdem unterstützt Kubeflow Ausführungsmonitoring, Workflow-Scheduling, Metadaten-Logging und Versionierung.
Kubeflow – Architekturüberblick
Wichtige Konzepte in Kubeflow Pipelines
Pipeline
Eine Pipeline ist eine Abfolge klar definierter Schritte in einem ML-Workflow. Die Pipeline definiert die Eingaben (Parameter) für die Ausführung sowie die Ein- und Ausgaben jeder Komponente. Jede Komponente nimmt eine Eingabe, verarbeitet sie und gibt das Ergebnis an die nächste Komponente weiter.
Wichtig zu verstehen: Jeder Schritt (jede Komponente) in einer Kubeflow-Pipeline ist im Kern ein Docker-Container. Beim Ausführen einer Pipeline startet Kubeflow ein oder mehrere Kubernetes-Pods, die zu den Komponenten der Pipeline gehören. Die Pods starten dann die Docker-Container, die wiederum den in der Komponente geschriebenen Code ausführen.
Komponente
Eine Pipeline-Komponente ist ein in sich geschlossener Codebaustein, der einen Schritt im ML-Workflow übernimmt, zum Beispiel Missing-Value-Imputation, Skalierung oder das Fitten eines ML-Modells.
Eine Komponente in einer Kubeflow-Pipeline ähnelt einer Funktion. Entsprechend hat jede Komponente einen Namen, Eingabeparameter und eine Ausgabe.
Jede Komponente muss als Docker-Image paketiert sein. So bleiben die Schritte unabhängig, und du kannst in verschiedenen Teilen deines Workflows unterschiedliche Frameworks und Tools kombinieren.
Experiment
Ein Experiment ermöglicht es, verschiedene Konfigurationen derselben Pipeline auszuführen und die Ergebnisse zu vergleichen und zu analysieren. In der Regel testest du in ML-Projekten verschiedene Parameter, um die beste Variante zu finden. Genau dafür ist das Kubeflow-Pipeline-Experiment gedacht.
Graph
Ein Graph ist die visuelle Darstellung in der Kubeflow-UI. Er zeigt die Schritte, die ein Pipeline-Run ausgeführt hat oder gerade ausführt, mit Pfeilen, die die Eltern/Kind-Beziehungen zwischen den Komponenten verdeutlichen.
Drei Wege, in Kubeflow Pipelines zu bauen
Du weißt jetzt, was Kubeflow-Pipelines sind und welche Vorteile sie bei Design und Betrieb produktiver ML-Workflows bieten. Hier sind drei Wege, wie du mit Kubeflow Pipelines erstellst und ausrollst.
User Interface (UI)
Über die Kubeflow-UI kannst du Pipelines ausführen, hochladen, Artefakte und Run-Ausgaben ansehen und automatische Runs planen. So sieht die Pipeline-UI aus:
Offizielles Python-SDK
Kubeflow stellt Python-Bibliotheken bereit, mit denen du ML-Pipelines programmatisch entwickeln und ausführen kannst. Das ist der gängigste Weg, Kubeflow Pipelines zu nutzen.
REST-API
Kubeflow bietet außerdem REST-APIs für Continuous-Integration/-Deployment-Systeme. So kannst du Funktionen von Kubeflow Pipelines in nachgelagerte Unternehmenssysteme oder -prozesse integrieren.
Kubeflow-Pipeline-Tutorial
Am einfachsten startest du mit einer Packaged Distribution – im Prinzip ein Managed Service in der Cloud. Hier verwenden wir den Kubeflow-Service auf GCP. Folge dieser offiziellen Anleitung, um den Service auf GCP zu deployen.
Sobald das Deployment erfolgreich war, erreichst du das Dashboard über deinen GCP-Endpunkt.
Kubeflow Dashboard – Deployment auf GCP
Kubeflow Pipelines enthalten einige Beispiel-Pipelines. Probieren wir eine einfache Datenvorverarbeitung in Python. Klicke in der linken Seitenleiste auf „Pipelines“.
Kubeflow Pipelines – Deployment auf GCP
Klicke auf „Experiment erstellen“.
Kubeflow Pipelines – Deployment auf GCP
Folge den Eingabemasken und klicke dann im Run-Bildschirm auf „Start“, um die Pipeline auszuführen.
Kubeflow Pipelines – Deployment auf GCP
Das Experiment erscheint anschließend im Dashboard:
Kubeflow Pipelines – Deployment auf GCP
Klicke auf das Experiment, um nach Abschluss des Runs die Ausgabe zu sehen:
Kubeflow Pipelines – Deployment auf GCP
Jetzt weißt du, wie du Pipelines über die Kubeflow-UI ausführst. Jede Komponente in der Pipeline oben ist ein einfacher, isolierter Python-Skriptbaustein. In diesem Beispiel heißen die Schritte etwa „Print Text“ oder „Sum Numbers“.
Schauen wir uns ein komplexeres Beispiel an und wie du diese Komponenten in Python codest und kompilierst.
Kubeflow-Pipeline über das Python-SDK bauen
In diesem Beispiel erstellen wir eine Kubeflow-Pipeline mit zwei Komponenten:
- Lade eine gezippte TAR-Datei anhand der als Eingabe übergebenen URL herunter,
- extrahiere alle CSV-Dateien und erstelle mit der Funktion `pd.concat` ein einziges pandas-DataFrame.
Theoretisch könnten wir statt zweier Schritte auch eine Funktion schreiben, die die URL entgegennimmt, die ZIP-Datei lädt und anschließend alle CSVs zu einer Datei zusammenführt.
Der Vorteil der Zweiteilung: Du kannst den Download-Schritt als wiederverwendbare Komponente auch in anderen Projekten nutzen.
In Kubeflow kannst du eine Komponente als YAML-Datei definieren und mit `kfp.components.load_component_from_url` direkt per URL laden.
Für den ersten Schritt laden wir die Komponente aus dieser 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')
```Für den zweiten Schritt definieren wir eine Python-Funktion:
```
@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)
```Wie du siehst, ist die Funktion mit der Annotation `kfp.dsl.component` versehen. Darüber definierst du das Container-Image, Paketabhängigkeiten (hier pandas[1.1.4]) und den Speicherort für die Komponentenspezifikation (component.yaml).
Jetzt kannst du beide Komponenten mit dem `pipeline`-Decorator zu einer Pipeline verbinden.
Definiere eine Pipeline und erzeuge aus der Komponente eine Task:
@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']
```Sobald die Pipeline definiert ist, können wir sie kompilieren. Dafür gibt es zwei Wege. Der erste führt über die Kubeflow-UI.
```
kfp.compiler.Compiler(mode=kfp.dsl.PipelineExecutionMode.V2_COMPATIBLE).compile(
pipeline_func=my_pipeline,
package_path='pipeline.yaml')
```Die Datei `pipeline.yaml` können wir jetzt in der Kubeflow-Pipelines-UI hochladen und ausführen. Alternativ starten wir die Pipeline über den SDK-Client von 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'
})
```Wenn wir die Pipeline um ein ML-Modell erweitern möchten, erstellen wir eine Python-Funktion, die `Input[Dataset]` entgegennimmt und das Modell mit einem beliebigen Framework trainiert, zum Beispiel sklearn, TensorFlow oder PyTorch.
Nach dem Erstellen fügen wir in `my_pipeline` eine dritte Task hinzu und kompilieren die Pipeline erneut – per `kfp.Client` oder UI.
Tutorial wiedergegeben nach Kubeflow Official.
Fazit
Mit ein paar Millionen Zeilen in einem Jupyter Notebook zu experimentieren, ist das eine. Ein ML-Modell mit Milliarden von Zeilen remote in der Cloud zu trainieren, ist etwas ganz anderes. Machine Learning wird vor allem dann komplex, wenn große Modelle in einer skalierbaren, verteilten Umgebung trainiert werden sollen.
Kubernetes ist eines der beliebtesten Orchestrierungsframeworks für ML-Jobs; Kubeflow baut darauf auf und nimmt Nutzerinnen und Nutzern viele komplexe Details ab. Es ist jedoch nicht die einzige Option – es gibt Alternativen.
Ein Beispiel für eine solche Plattform ist Databricks. Die Plattform hat eine eigene Orchestrierungs-Engine (anders als Kubernetes) und bietet eine ansprechende UI mit Notebooks, Experiment-Logging, Model Registry, Job Scheduling und Monitoring.
Amazon Sagemaker ist ein weiteres Beispiel für eine Alternative zu Kubernetes/Kubeflow. Amazon SageMaker ist ein vollständig gemanagter ML-Service, mit dem Data Scientists und Entwicklerinnen und Entwickler schnell und einfach ML-Modelle erstellen, trainieren und direkt in einer produktionsreifen, gehosteten Umgebung bereitstellen können. Er bietet eine integrierte Jupyter-Notebook-Umgebung für Exploration und Analyse.
Fühlst du dich von den ständig neuen Engineering-Konzepten erschlagen? Keine Sorge, Datacamp bietet den Kurs Understanding Data Engineering an. Darin lernst du die Kernaufgaben von Data Engineers kennen, wie sie sich von Data Scientists unterscheiden und den Datenfluss im Unternehmen ermöglichen. Außerdem erfährst du, wie Data Engineers die Grundlage schaffen, auf der Data Scientists arbeiten können. Kein Coding erforderlich!