Kapitel 1. Ein Überblick über Ray

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: translation-feedback@oreilly.com

Einer der Gründe, warum wir effizientes verteiltes Rechnen brauchen, ist die Tatsache, dass wir immer mehr und vielfältigere Daten mit zunehmender Geschwindigkeit sammeln. Die Speichersysteme, Datenverarbeitungs- und Analyse-Engines, die im letzten Jahrzehnt entstanden sind, sind für den Erfolg vieler Unternehmen entscheidend. Interessanterweise werden die meisten "Big Data"-Technologien für (Daten-)Ingenieure entwickelt und von ihnen betrieben, die für die Sammlung und Verarbeitung von Daten zuständig sind. Der Grund dafür ist, dass Datenwissenschaftler/innen das tun können, was sie am besten können. Als Datenwissenschaftler/in möchtest du dich vielleicht auf das Training komplexer maschineller Lernmodelle, die effiziente Auswahl von Hyperparametern, die Erstellung völlig neuer und benutzerdefinierter Modelle oder Simulationen oder die Bereitstellung deiner Modelle konzentrieren, um sie zu präsentieren.

Gleichzeitig kann es unvermeidlich sein , diese Workloads auf einen Compute-Cluster zu skalieren. Dazu muss das verteilte System deiner Wahl all diese feinkörnigen "Big Compute"-Aufgaben unterstützen, möglicherweise auf spezialisierter Hardware. Idealerweise passt es auch in die Big-Data-Toolkette, die du verwendest, und ist schnell genug, um deine Latenzanforderungen zu erfüllen. Mit anderen Worten: Verteiltes Computing muss leistungsstark und flexibel genug für komplexe Data-Science-Workloads sein - und Ray kann dir dabei helfen.

Python ist heute wahrscheinlich die beliebteste Sprache für Data Science und sicherlich auch diejenige, die wir für unsere tägliche Arbeit am nützlichsten finden.Python ist mittlerweile über 30 Jahre alt, aber die Community wächst und ist immer noch sehr aktiv. Das reichhaltige PyData-Ökosystem ist ein wesentlicher Bestandteil des Werkzeugkastens eines Datenwissenschaftlers. Wie kannst du sicherstellen, dass du deine Arbeitslasten skalieren und gleichzeitig die Werkzeuge nutzen kannst, die du brauchst? Das ist ein schwieriges Problem, vor allem, weil Gemeinschaften nicht gezwungen werden können, ihren Werkzeugkasten oder ihre Programmiersprache einfach wegzuwerfen. Das bedeutet, dass verteilte Rechenwerkzeuge für Datenwissenschaftler/innen für ihre bestehende Gemeinschaft entwickelt werden müssen.

Was ist Ray?

Was uns an Ray gefällt, ist, dass es all diese Punkte erfüllt.Es ist ein flexibles, verteiltes Computing-Framework, das für die Python-Data-Science-Community entwickelt wurde.

Ray ist einfach zu bedienen und hält die Dinge einfach. Seine Kern-API ist so schlank wie nur möglich und hilft dir, effektiv über die verteilten Programme nachzudenken, die du schreiben willst. Du kannst Python-Programme auf deinem Laptop effizient parallelisieren und den Code, den du lokal getestet hast, praktisch ohne Änderungen auf einem Cluster ausführen. Die High-Level-Bibliotheken sind einfach zu konfigurieren und können nahtlos zusammen verwendet werden. Einige von ihnen, wie Rays Reinforcement-Learning-Bibliothek, haben wahrscheinlich eine große Zukunft als eigenständige Projekte, ob sie nun verteilt sind oder nicht. Obwohl der Kern von Ray in C++ entwickelt wurde, war es vom ersten Tag an ein Python-Framework,¹ Es lässt sich mit vielen wichtigen Data-Science-Tools integrieren und kann auf ein wachsendes Ökosystem zählen.

Verteiltes Python ist nicht neu, und Ray ist nicht das erste Framework in diesem Bereich (und wird auch nicht das letzte sein), aber es ist etwas Besonderes, was es zu bieten hat. Ray ist besonders stark, wenn du mehrere seiner Module kombinierst und benutzerdefinierte, maschinenlernlastige Workloads hast, die sonst schwer zu implementieren wären. Ray macht verteiltes Rechnen so einfach, dass du deine komplexen Workloads flexibel ausführen kannst, indem du die Python-Tools nutzt, die du kennst und verwenden willst. Mit anderen Worten: Wenn du Ray lernst, lernst du flexibles verteiltes Python für maschinelles Lernen kennen. Und dir zu zeigen, wie das geht, darum geht es in diesem Buch.

In diesem Kapitel bekommst du einen ersten Eindruck davon, was Ray für dich tun kann. Wir besprechen die drei Schichten, aus denen Ray besteht: die Kern-Engine, die High-Level-Bibliotheken und das Ökosystem. Im Laufe des Kapitels zeigen wir dir zunächst Code-Beispiele, damit du ein Gefühl für Ray bekommst. Du kannst dieses Kapitel als eine kurze Vorschau auf das Buch betrachten; wir verschieben eine ausführliche Behandlung der APIs und Komponenten von Ray auf spätere Kapitel.

Was führte zu Ray?

Die Programmierung verteilter Systeme ist schwierig.Sie erfordert spezielle Kenntnisse und Erfahrungen, über die du vielleicht nicht verfügst. Im Idealfall gehen dir solche Systeme aus dem Weg und bieten Abstraktionen, damit du dich auf deine Arbeit konzentrieren kannst.Aber in der Praxis sind, wie Joel Spolsky feststellt, "alle nicht-trivialen Abstraktionen bis zu einem gewissen Grad undicht", und es ist zweifellos schwierig, Computercluster dazu zu bringen, das zu tun, was du willst. Viele Softwaresysteme benötigen Ressourcen, die weit über das hinausgehen, was ein einzelner Server leisten kann. Selbst wenn ein Server ausreichen würde, müssen moderne Systeme ausfallsicher sein und Funktionen wie Hochverfügbarkeit bieten. Das bedeutet, dass deine Anwendungen möglicherweise auf mehreren Rechnern oder sogar in Rechenzentren laufen müssen, nur um sicherzustellen, dass sie zuverlässig funktionieren.

Selbst wenn du dich mit maschinellem Lernen (ML) oder künstlicher Intelligenz (KI) im Allgemeinen nicht auskennst, hast du sicher schon von den jüngsten Durchbrüchen in diesem Bereich gehört.Um nur zwei Beispiele zu nennen: Systeme wieAlphaFold von Deepmindzur Lösung des Proteinfaltungsproblems und Codex von OpenAI zur Unterstützung von Softwareentwicklern bei der Bewältigung ihrer langweiligen Arbeit haben in letzter Zeit Schlagzeilen gemacht. Vielleicht hast du auch schon davon gehört, dass ML-Systeme in der Regel große Datenmengen benötigen, um trainiert zu werden, und dass ML-Modelle tendenziell immer größer werden. OpenAI hat in seinem Papier "AI and Compute" ein exponentielles Wachstum der für das Training von KI-Modellen benötigten Rechenleistung aufgezeigt . Die Anzahl der für KI-Systeme benötigten Operationen wird in Petaflops (Tausende von Billionen Operationen pro Sekunde) gemessen und hat sich seit 2012 alle 3,4 Monate verdoppelt.

Vergleiche dies mit dem Mooreschen Gesetz,² das besagt, dass sich die Anzahl der Transistoren in Computern alle zwei Jahre verdoppeln würde. Selbst wenn du das Mooresche Gesetz für richtig hältst, kannst du sehen, dass es einen klaren Bedarf für verteiltes Rechnen in der ML gibt. Du solltest auch verstehen, dass viele Aufgaben in der ML auf natürliche Weise zerlegt werden können, um parallel zu laufen. Warum also die Dinge nicht beschleunigen, wenn du es kannst?³

Verteiltes Rechnen wird allgemein als schwierig angesehen.Aber warum ist das so? Sollte es nicht realistisch sein, gute Abstraktionen zu finden, um deinen Code auf Clustern laufen zu lassen, ohne ständig über einzelne Maschinen und deren Zusammenspiel nachdenken zu müssen? Was wäre, wenn wir uns speziell auf KI-Workloads konzentrieren würden?

Die Forscher des RISELab an der UC Berkeley haben Ray entwickelt, um diese Fragen zu klären. Sie suchten nach effizienten Möglichkeiten, ihre Arbeitslasten durch Verteilung zu beschleunigen.Die Arbeitslasten, die ihnen vorschwebten, waren recht flexibel und passten nicht in die damals verfügbaren Frameworks. Das RISELab wollte außerdem ein System entwickeln, das sich darum kümmert, wie die Arbeit verteilt wird. Mit vernünftigen Standardverhaltensweisen sollten sich die Forscher/innen auf ihre Arbeit konzentrieren können, unabhängig von den Besonderheiten ihres Rechenclusters. Und idealerweise sollten sie Zugang zu all ihren Lieblingswerkzeugen in Python haben. Aus diesem Grund wurde Ray mit dem Schwerpunkt auf hochleistungsfähige und heterogene Arbeitslasten entwickelt.⁴ Um diese Punkte besser zu verstehen, wollen wir uns die Designphilosophie von Ray genauer ansehen.

Ray's Design-Prinzipien

Bei der Entwicklung von Ray wurden mehrere Grundsätze beachtet: Die API ist auf Einfachheit und Allgemeinheit ausgelegt, das Rechenmodell auf Flexibilität.Die Systemarchitektur ist auf Leistung und Skalierbarkeit ausgelegt. Schauen wir uns jeden dieser Punkte genauer an.

Vereinfachung und Abstraktion

Die API von Ray ist nicht nur einfach, sondern auch intuitiv zu bedienen (wie du in Kapitel 2 sehen wirst). Es spielt keine Rolle, ob du alle CPU-Kerne deines Laptops oder alle Maschinen deines Clusters nutzen willst.Du musst vielleicht die eine oder andere Codezeile ändern, aber der Ray-Code, den du verwendest, bleibt im Wesentlichen der gleiche. Und wie jedes gute verteilte System verwaltet Ray die Aufgabenverteilung und -koordinierung unter der Haube. Das ist großartig, denn so musst du dich nicht mit der Mechanik des verteilten Rechnens auseinandersetzen. Eine gute Abstraktionsschicht ermöglicht es dir, dich auf deine Arbeit zu konzentrieren, und wir denken, dass Ray dir eine solche Schicht bietet.

Da die API von Ray so allgemeingültig und pythonisch ist, lässt sie sich leicht in andere Tools integrieren.Zum Beispiel können Ray-Akteure bestehende verteilte Python-Workloads aufrufen oder von ihnen aufgerufen werden. In diesem Sinne ist Ray auch ein guter "Glue Code" für verteilte Workloads, da es performant und flexibel genug ist, um zwischen verschiedenen Systemen und Frameworks zu kommunizieren.

Flexibilität und Heterogenität

Für KI-Workloads, insbesondere wenn es um Paradigmen wie Reinforcement Learning geht, brauchst du ein flexibles Programmiermodell.Rays API wurde entwickelt, um das Schreiben von flexiblem und komponierbarem Code zu erleichtern. Einfach ausgedrückt: Wenn du deinen Workload in Python ausdrücken kannst, kannst du ihn mit Ray verteilen. Natürlich musst du trotzdem sicherstellen, dass du genügend Ressourcen zur Verfügung hast und darauf achten, was du verteilen willst. Aber Ray schränkt die Möglichkeiten nicht ein, die du damit hast.

Ray ist auch flexibel, wenn es um die Heterogenität von Berechnungen geht. Nehmen wir an, du arbeitest an einer komplexen Simulation.Simulationen lassen sich in der Regel in mehrere Aufgaben oder Schritte zerlegen. Einige dieser Schritte können Stunden dauern, andere nur ein paar Millisekunden, aber sie müssen immer schnell geplant und ausgeführt werden. Manchmal kann eine einzelne Aufgabe in einer Simulation sehr lange dauern, aber andere, kleinere Aufgaben sollten parallel laufen können, ohne sie zu blockieren. Außerdem können nachfolgende Aufgaben vom Ergebnis einer vorgelagerten Aufgabe abhängen. Deshalb brauchst du ein Framework, das eine dynamische Ausführung ermöglicht und gut mit Aufgabenabhängigkeiten umgehen kann.Ray bietet dir volle Flexibilität bei der Ausführung solcher heterogenen Workflows.

Du musst auch sicherstellen, dass du bei der Ressourcennutzung flexibel bist, und Ray unterstützt heterogene Hardware. Manche Aufgaben müssen zum Beispiel auf einem Grafikprozessor laufen, während andere am besten auf ein paar CPU-Kernen laufen. Ray bietet dir diese Flexibilität.

Geschwindigkeit und Skalierbarkeit

Ein weiteres Konstruktionsprinzip von Ray ist die Geschwindigkeit, mit der Ray seine Aufgaben ausführt.Es kann Millionen von Aufgaben pro Sekunde bewältigen, und die Latenzzeiten sind sehr gering. Ray ist so konstruiert, dass es seine Aufgaben mit nur einer Millisekunde Latenzzeit ausführt.

Damit ein verteiltes System schnell ist, muss es auch gut skalierbar sein. Ray verteilt und plant deine Aufgaben effizient und fehlertolerant auf deinem Compute-Cluster. Wie du in Kapitel 9 im Detail erfährst, unterstützen Ray-Cluster die Autoskalierung, um hochelastische Arbeitslasten zu unterstützen.Der Autoscaler von Ray versucht, die Maschinen in deinem Cluster entsprechend der aktuellen Nachfrage zu starten oder zu stoppen. Das hilft, die Kosten zu minimieren und stellt sicher, dass dein Cluster über genügend Ressourcen verfügt, um deine Arbeitslast auszuführen.

In verteilten Systemen ist es keine Frage, ob, sondern wann etwas schief geht. Eine Maschine könnte ausfallen, eine Aufgabe abbrechen oder einfach in Flammen aufgehen.⁵ In jedem Fall ist Ray so konzipiert, dass es sich schnell von Ausfällen erholt, was zu seiner Gesamtgeschwindigkeit beiträgt.

Da wir noch nicht über die Architektur von Ray gesprochen haben(in Kapitel 2 wirst du sie kennenlernen), können wir dir noch nicht sagen, wie diese Designprinzipien umgesetzt werden. Lenken wir stattdessen unsere Aufmerksamkeit darauf, was Ray in der Praxis für dich tun kann.

Drei Ebenen: Kern, Bibliotheken und Ökosystem

Nachdem du nun weißt, warum Ray entwickelt wurde und was seine Schöpfer vorhatten, wollen wir uns die drei Ebenen von Ray ansehen.Diese Darstellung ist nicht die einzige, aber für dieses Buch die sinnvollste:

Ein verteiltes Low-Level-Computing-Framework für Python mit einer übersichtlichen Kern-API und einem Tool für die Bereitstellung von Clustern namens Ray Core.⁶
Eine Reihe von High-Level-Bibliotheken, die von den Entwicklern von Ray entwickelt und gepflegt werden. Dazu gehört die sogenannte Ray AIR , um diese Bibliotheken mit einer einheitlichen API in gängigen Machine-Learning-Workloads zu verwenden.
Ein wachsendes Ökosystem von Integrationen und Partnerschaften mit anderen bemerkenswerten Projekten, die viele Aspekte der ersten beiden Ebenen umfassen.

Hier gibt es eine Menge zu entdecken, und wir werden uns im weiteren Verlauf dieses Kapitels jede dieser Ebenen einzeln ansehen.

Man kann sich die Ray Core Engine mit ihrer API als das Herzstück vorstellen, auf dem alles andere aufbaut. Die Ray Data Science Libraries bauen auf Ray Core auf und bieten eine domänenspezifische Abstraktionsschicht.⁷ In der Praxis werden viele Data Scientists diese Bibliotheken direkt nutzen, während ML- oder Plattform-Ingenieure ihre Tools als Erweiterungen der Ray Core API entwickeln. Ray AIR kann als Dach gesehen werden, das die Ray-Bibliotheken miteinander verbindet und ein konsistentes Framework für den Umgang mit gängigen KI-Workloads bietet. Und die wachsende Zahl von Drittanbieter-Integrationen für Ray ist ein weiterer großartiger Einstiegspunkt für erfahrene Praktiker. Schauen wir uns die einzelnen Schichten nacheinander an.

Ein Rahmen für verteiltes Rechnen

Im Kern ist Ray ein verteiltes Computing-Framework.Wir stellen dir hier nur die grundlegenden Begriffe vor und gehen in Kapitel 2 ausführlich auf die Architektur von Ray ein. Kurz gesagt: Ray richtet Computercluster ein und verwaltet sie, damit du verteilte Aufgaben auf ihnen ausführen kannst.Ein Ray-Cluster besteht aus Knoten, die über ein Netzwerk miteinander verbunden sind. Du programmierst gegen den sogenannten Treiber, die Programmwurzel, die sich auf dem Hauptknoten befindet. Der Treiber kann Aufträge (Jobs) ausführen, eine Sammlung von Aufgaben, die auf den Knoten des Clusters ausgeführt werden.Konkret werden die einzelnen Aufgaben eines Jobs von Worker-Prozessen auf Worker-Knoten ausgeführt.Abbildung 1-1 zeigt die grundlegende Struktur eines Ray Clusters. Beachte, dass wir uns noch nicht mit der Kommunikation zwischen den Knoten beschäftigen; dieses Diagramm zeigt lediglich den Aufbau eines Ray Clusters.

Interessant ist, dass ein Ray Cluster auch ein lokaler Cluster sein kann, also ein Cluster, der nur aus deinem eigenen Computer besteht.In diesem Fall gibt es nur einen Knoten, nämlich den Head Node, auf dem der Treiberprozess und einige Worker-Prozesse laufen. Die Standardanzahl der Worker-Prozesse entspricht der Anzahl der verfügbaren CPUs auf deinem Computer.

Mit diesem Wissen in der Hand ist es an der Zeit, sich die Hände schmutzig zu machen und deinen ersten lokalen Ray-Cluster zu starten.Die Installation von Ray auf einem der wichtigsten Betriebssysteme sollte mit pip problemlos funktionieren:

pip install "ray[rllib, serve, tune]==2.2.0"

Mit einem einfachen pip install ray installierst du nur die Grundlagen von Ray. Da wir einige fortgeschrittene Funktionen erforschen wollen, installieren wir die "Extras" rllib, serve und tune, die wir gleich besprechen werden.⁸ Je nach deiner Systemkonfiguration brauchst du die Anführungszeichen in diesem Installationsbefehl vielleicht nicht.

Als Nächstes startest du eine Python-Sitzung. Du könntest zum Beispiel den Interpreter ipython verwenden, der sich oft zum Nachvollziehen einfacher Beispiele eignet.In deiner Python-Sitzung kannst du nun ganz einfach Ray importieren und initialisieren:

import ray
ray.init()

Hinweis

Wenn du keine Lust hast, die Befehle selbst einzutippen, kannst du auch in das Jupyter-Notizbuch für dieses Kapitel springen und den Code dort ausführen. Die Wahl bleibt dir überlassen, aber bitte erinnere dich in jedem Fall daran, Python ab Version 3.7 oder zu verwenden.⁹

Mit diesen beiden Codezeilen hast du einen Ray-Cluster auf deinem lokalen Rechner gestartet. Dieser Cluster kann alle verfügbaren Kerne deines Computers als Worker nutzen. Im Moment macht dein Ray-Cluster noch nicht viel, aber das wird sich bald ändern.

Die Funktion init, mit der du den Cluster startest, ist einer der sechs grundlegenden API-Aufrufe, die du in Kapitel 2 ausführlich kennenlernen wirst. Insgesamt ist die Ray Core API sehr zugänglich und einfach zu bedienen. Da es sich aber auch um eine recht einfache Schnittstelle handelt, braucht es Zeit, um damit interessante Beispiele zu erstellen.In Kapitel 2 findest du ein umfangreiches erstes Beispiel, das dir den Einstieg in die Ray Core API erleichtert, und in Kapitel 3 wirst du sehen, wie du eine interessantere Ray-Anwendung für das Reinforcement Learning erstellen kannst.

Im vorangegangenen Code hast du der Funktion ray.init(...) keine Argumente übergeben. Wenn du Ray auf einem "echten" Cluster ausführen möchtest, musst du init weitere Argumente übergeben. Dieser Aufruf init wird oft genannt und dient dazu, sich interaktiv mit einem bestehenden Ray-Cluster zu verbinden.¹⁰ In der Ray-Dokumentation erfährst du mehr darüber, wie du dich mit dem Ray Client mit deinen Produktionsclustern verbinden kannst.

Wenn du schon einmal mit Compute-Clustern gearbeitet hast, weißt du natürlich, dass es viele Fallstricke und Schwierigkeiten gibt. Du kannst Ray-Anwendungen zum Beispiel auf Clustern einsetzen, die von Cloud-Providern wie Amazon Web Services (AWS), Google Cloud Platform (GCP) oder Microsoft Azure gehostet werden - und jede dieser Optionen erfordert gute Werkzeuge für die Bereitstellung und Wartung. Du kannst auch einen Cluster auf deiner eigenen Hardware einrichten oder Tools wie Kubernetes verwenden, um deine Ray-Cluster einzusetzen.In Kapitel 9 (nach den Kapiteln mit konkreten Ray-Anwendungen) werden wir auf das Thema der Skalierung von Arbeitslasten mit Ray-Clustern zurückkommen.

Bevor wir uns den übergeordneten Bibliotheken von Ray zuwenden, fassen wir kurz die beiden grundlegenden Komponenten von Ray als verteiltem Berechnungsrahmen zusammen:

Strahlenbündel: Diese Komponente ist dafür zuständig, Ressourcen zuzuweisen, Knoten zu erstellen und sicherzustellen, dass sie in Ordnung sind. Ein guter Weg, um mit Ray Clusters anzufangen, ist die spezielle Schnellstartanleitung.
Strahlenkern: Sobald dein Cluster in Betrieb ist, kannst du mit der Ray Core API darauf programmieren. Du kannst mit Ray Core anfangen, indem du demoffiziellen Walk-Throughfür diese Komponente folgst.

Eine Reihe von Bibliotheken für die Datenwissenschaft

In diesem Abschnitt stellen wir dir kurz alle Bibliotheken vor, die Ray für die Datenwissenschaft bereithält.Dazu müssen wir uns zunächst einmal aus der Vogelperspektive ansehen, was es bedeutet, Datenwissenschaft zu betreiben. Sobald du diesen Kontext verstehst, ist es viel einfacher, die übergeordneten Bibliotheken von Ray zu betrachten und zu sehen, wie sie für dich nützlich sein können.

Ray AIR und der Data Science Workflow

Der etwas schwer zu fassende Begriff "Data Science" (DS) hat sich in den letzten Jahren stark weiterentwickelt, und du kannst im Internet viele Definitionen mit unterschiedlichem Nutzen finden.¹¹ Für uns ist es die Praxis der Gewinnung von Erkenntnissen und der Entwicklung von realen Anwendungen durch die Nutzung von Daten. Das ist eine ziemlich weit gefasste Definition eines praktischen und angewandten Fachgebiets, in dem es darum geht, Dinge zu bauen und zu verstehen. In diesem Sinne ist die Bezeichnung "Datenwissenschaftler/innen" für Praktiker/innen dieses Fachgebiets ungefähr so falsch wie die Bezeichnung "Informatiker/innen" für Hacker/innen.¹²

In groben Zügen ist Data Science ein iterativer Prozess, der die Entwicklung von Anforderungen, die Sammlung und Verarbeitung von Daten, die Erstellung von Modellen und deren Auswertung sowie den Einsatz von Lösungen umfasst.Maschinelles Lernen ist nicht notwendigerweise Teil dieses Prozesses, aber oft. Wenn ML involviert ist, kannst du einige Schritte weiter spezifizieren:

Datenverarbeitung: Um ML-Modelle zu trainieren, brauchst du Daten in einem Format, das dein ML-Modell versteht. Der Prozess der Umwandlung und Auswahl der Daten, die in dein Modell eingespeist werden sollen, wird oft als Feature Engineering bezeichnet. Dieser Schritt kann chaotisch sein. Es ist von großem Vorteil, wenn du dich auf gängige Tools verlassen kannst, die diese Aufgabe übernehmen.
Model Ausbildung: Beim ML musst du deine Algorithmen auf Daten trainieren, die im vorherigen Schritt verarbeitet wurden. Dazu gehört auch, dass du den richtigen Algorithmus für die Aufgabe auswählst, und es ist hilfreich, wenn du aus einer großen Auswahl wählen kannst.
Hyperparameter-Abstimmung: Modelle für maschinelles Lernen haben Parameter, die beim Training des Modells eingestellt werden. Die meisten ML-Modelle haben noch eine weitere Gruppe von Parametern, die sogenannten Hyperparameter, die vor dem Training verändert werden können. Diese Parameter können die Leistung deines ML-Modells stark beeinflussen und müssen daher richtig eingestellt werden. Es gibt gute Tools, mit denen sich dieser Prozess automatisieren lässt.
Modell serviert: Ausgebildete Modelle müssen eingesetzt werden. Ein Modell zur Verfügung zu stellen bedeutet, es mit allen erforderlichen Mitteln denjenigen zugänglich zu machen, die es benötigen. In Prototypen werden oft einfache HTTP-Server verwendet, aber es gibt auch viele spezialisierte Softwarepakete für die Bereitstellung von ML-Modellen.

Diese Liste ist keineswegs vollständig, und es gibt noch viel mehr über die Entwicklung von ML-Anwendungen zu sagen.¹³ Es stimmt jedoch, dass diese vier Schritte für den Erfolg eines Data Science-Projekts mit ML entscheidend sind.

Ray verfügt über spezielle Bibliotheken für jeden der vier ML-spezifischen Schritte, die wir gerade aufgelistet haben.Konkret kannst du deine Daten mit Ray Datasets verarbeiten, verteiltes Modelltraining mit Ray Train durchführen, deine Reinforcement-Learning-Workloads mit Ray RLlib ausführen, deine Hyperparameter mit Ray Tune effizient abstimmen und deine Modelle mit Ray Serve ausliefern. Und so wie Ray aufgebaut ist, sind all diese Bibliotheken von vornherein verteilt- ein Punkt, den wir nicht genug betonen können.

Hinzu kommt, dass all diese Schritte Teil eines Prozesses sind und selten isoliert angegangen werden. Du willst nicht nur, dass alle beteiligten Bibliotheken nahtlos zusammenarbeiten, sondern es kann auch ein entscheidender Vorteil sein, wenn du während des gesamten Data-Science-Prozesses mit einer einheitlichen API arbeiten kannst. Genau dafür wurde Ray AIR entwickelt: eine gemeinsame Laufzeit und API für deine Experimente und die Möglichkeit, deine Workloads zu skalieren, wenn du bereit bist.Abbildung 1-2 zeigt einen schnellen Überblick über alle Komponenten von AIR.

Die Vorstellung der Ray AI Runtime API würde den Rahmen dieses Kapitels sprengen (du kannst dafür zu Kapitel 10 springen), aber wir stellen dir alle Bausteine vor, die in sie einfließen. Gehen wir die DS-Bibliotheken von Ray einzeln durch.

Datenverarbeitung mit Ray-Datensätzen

Die erste Bibliothek von Ray, über die wir sprechen werden, ist Ray Datasets. Diese Bibliothek enthält eine Datenstruktur namens Dataset, eine Vielzahl von Konnektoren zum Laden von Daten aus verschiedenen Formaten und Systemen, eine API zum Umwandeln solcher Datensätze, eine Möglichkeit, Datenverarbeitungspipelines damit zu erstellen, und viele Integrationen mit anderen Datenverarbeitungsframeworks.Die Dataset Abstraktion baut auf dem leistungsstarken Arrow-Framework auf.¹⁴

Um Ray-Datensätze zu verwenden, musst du Arrow für Python installieren, indem du zum Beispielpip install pyarrow ausführst. Das folgende einfache Beispiel erstellt einen verteilten Dataset auf deinem lokalen Ray-Cluster aus einer Python-Datenstruktur. Konkret erstellst du ein Dataset aus einem Python-Wörterbuch, das einen String name und einen Integer-Wert data für 10.000 Einträge enthält:

import ray

items = [{"name": str(i), "data": i} for i in range(10000)]
ds = ray.data.from_items(items)   
ds.show(5)

: Erstelle eine Dataset, indem du from_items aus dem Modul ray.data verwendest.
: Drucken der ersten fünf Punkte der Dataset.

show eine Dataset bedeutet, dass du einige ihrer Werte ausgibst. Du solltest genau fünf Elemente in deiner Befehlszeile sehen, etwa so:

{'name': '0', 'data': 0}
{'name': '1', 'data': 1}
{'name': '2', 'data': 2}
{'name': '3', 'data': 3}
{'name': '4', 'data': 4}

Toll, jetzt hast du ein paar Zeilen, aber was kannst du mit diesen Daten machen? Die Dataset API setzt stark auf funktionale Programmierung, da dieses Paradigma gut für Datentransformationen geeignet ist.

Obwohl Python 3 einige seiner funktionalen Programmierfähigkeiten versteckt hat, bist du wahrscheinlich mit Funktionen wie map, filter, flat_map und anderen vertraut. Falls nicht, ist es ganz einfach:map wandelt jedes Element deines Datensatzes parallel in etwas anderes um;filter entfernt Datenpunkte anhand einer booleschen Filterfunktion; und die etwas aufwändigere flat_map ordnet Werte zunächst ähnlich wie map zu, "glättet" dann aber auch das Ergebnis. Wenn map zum Beispiel eine Liste von Listen erzeugt, glättet flat_map die verschachtelten Listen und liefert dir nur noch eine Liste.Mit diesen drei funktionalen API-Aufrufen ausgestattet,¹⁵ wollen wir mal sehen, wie einfach du deinen Datensatz ds umwandeln kannst:

squares = ds.map(lambda x: x["data"] ** 2)  

evens = squares.filter(lambda x: x % 2 == 0)  
evens.count()

cubes = evens.flat_map(lambda x: [x, x**3])  
sample = cubes.take(10)  
print(sample)

: Wir map jede Zeile von ds, um nur den quadratischen Wert des Eintrags data zu behalten.
: filter Dann haben wir die squares, um nur gerade Zahlen zu behalten (insgesamt fünftausendElemente).
: Wir verwenden dann flat_map, um die verbleibenden Werte mit ihren jeweiligen Würfeln zu ergänzen.
: take insgesamt 10 Werte bedeutet, dass wir Ray verlassen und eine Python-Liste mit diesen Werten zurückgeben, die wir ausdrucken können.

Der Nachteil von Dataset Transformationen ist, dass jeder Schritt synchron ausgeführt wird. In diesem Beispiel ist das kein Problem, aber für komplexe Aufgaben, die z. B. das Lesen von Dateien und die Verarbeitung von Daten mischen, möchtest du eine Ausführung, bei der sich die einzelnen Aufgaben überschneiden können.DatasetPipeline macht genau das. Lass uns das vorherige Beispiel in eine Pipeline umschreiben:

pipe = ds.window()  
result = pipe\
    .map(lambda x: x["data"] ** 2)\
    .filter(lambda x: x % 2 == 0)\
    .flat_map(lambda x: [x, x**3])  
result.show(10)

: Du kannst eine Dataset in eine Pipeline verwandeln, indem du .window() aufrufst.
: Pipelineschritte können verkettet werden, um das gleiche Ergebnis wie zuvor zu erzielen.

Es gibt noch viel mehr über Ray Datasets zu sagen, vor allem über die Integration mit namhaften Datenverarbeitungssystemen, aber wir verschieben eine ausführliche Diskussion auf Kapitel 6.

Model Ausbildung

Kommen wir nun zu den nächsten Bibliotheken. Wir wollen uns die verteilten Trainingsmöglichkeiten von Ray ansehen.Dafür stehen dir zwei Bibliotheken zur Verfügung. Die eine ist speziell für das Reinforcement Learning gedacht, die andere hat einen anderen Anwendungsbereich und ist vor allem für Aufgaben des überwachten Lernens gedacht.

Verstärkungslernen mit Ray RLlib

Beginnen wir mit Ray RLlib für Reinforcement Learning (RL). Diese Bibliothek basiert auf den modernen ML-Frameworks TensorFlow und PyTorch, und du kannst dir aussuchen, welches du verwenden möchtest. Beide Frameworks scheinen sich konzeptionell immer mehr anzunähern, also kannst du dir das aussuchen, das dir am besten gefällt, ohne dabei viel zu verlieren.Im gesamten Buch verwenden wir sowohl TensorFlow- als auch PyTorch-Beispiele, damit du ein Gefühl für beide Frameworks bekommst, wenn du Ray verwendest.

Für diesen Abschnitt installierst du jetzt TensorFlow mit pip install tensorflow.¹⁶ Um das Codebeispiel auszuführen, musst du auch die gym Bibliothek mit pip install "gym==0.25.0" installieren.

Eine der einfachsten Möglichkeiten, Beispiele mit RLlib auszuführen, ist die Verwendung von , dem Kommandozeilen-Tool rllib, das wir bereits implizit installiert haben, als wir pip install "ray[rllib]" ausgeführt haben. Sobald du komplexere Beispiele in Kapitel 4 ausführst, wirst du dich hauptsächlich auf die Python-API verlassen, aber für den Moment wollen wir einen ersten Vorgeschmack auf die Ausführung von RL-Experimenten mit RLlib bekommen.

Wir betrachten ein klassisches Steuerungsproblem, bei dem es darum geht, eine Stange auf einem Wagen zu balancieren. Stell dir vor, du hast eine Stange wie in Abbildung 1-3, die an einem Gelenk eines Wagens befestigt ist und der Schwerkraft unterliegt. Der Wagen bewegt sich frei auf einer reibungsfreien Bahn, und du kannst den Wagen manipulieren, indem du ihn mit einer festen Kraft von links oder rechts anschiebst. Wenn du das gut genug machst, bleibt die Stange aufrecht stehen. Für jeden Zeitschritt, in dem die Stange nicht umgefallen ist, erhalten wir eine Belohnung von 1. Unser Ziel ist es, eine hohe Belohnung zu erhalten, und die Frage ist, ob wir einem Verstärkungslernalgorithmus beibringen können, dies für uns zu tun.

Konkret wollen wir einen Reinforcement-Learning-Agenten trainieren, der zwei Aktionen ausführen kann, nämlich nach links oder nach rechts schieben, beobachten, was passiert, wenn er auf diese Weise mit der Umgebung interagiert, und aus den Erfahrungen lernen, indem er die Belohnung maximiert.

Um dieses Problem mit Ray RLlib zu lösen, können wir ein sogenanntes abgestimmtes Beispiel verwenden, das ein vorkonfigurierter Algorithmus ist, der für ein bestimmtes Problem gut läuft. Du kannst ein abgestimmtes Beispiel mit einem einzigen Befehl ausführen.RLlib wird mit vielen solchen Beispielen geliefert, und du kannst sie alle mit rllib example list auflisten.

Eines der verfügbaren Beispiele ist cartpole-ppo, ein abgestimmtes Beispiel, das den PPO-Algorithmus verwendet, um das Cart-Pole-Problem zu lösen, genauer gesagt, die Umgebung CartPole-v1 von OpenAI Gym. Du kannst dir die Konfiguration dieses Beispiels ansehen, indem du rllib example get cartpole-ppo eingibst, das zuerst die Beispieldatei von GitHub herunterlädt und dann die Konfiguration ausgibt.Diese Konfiguration ist im YAML-Dateiformat kodiert und lautet wie folgt:

cartpole-ppo:
    env: CartPole-v1  
    run: PPO  
    stop:
        episode_reward_mean: 150  
        timesteps_total: 100000
    config: 
        framework: tf
        gamma: 0.99
        lr: 0.0003
        num_workers: 1
        observation_filter: MeanStdFilter
        num_sgd_iter: 6
        vf_loss_coeff: 0.01
        model:
            fcnet_hiddens: [32]
            fcnet_activation: linear
            vf_share_layers: true
        enable_connectors: True

: Die Umgebung CartPole-v1 simuliert das Problem, das wir gerade beschrieben haben.
: Verwende einen leistungsstarken RL-Algorithmus namens Proximal Policy Optimization (PPO).
: Sobald wir eine Belohnung von 150 erreicht haben, beende das Experiment.
: PPO braucht eine RL-spezifische Konfiguration, damit es bei diesem Problem funktioniert.

Die Details dieser Konfigurationsdatei sind an dieser Stelle nicht so wichtig, also lass dich davon nicht ablenken. Wichtig ist, dass du die Umgebung Cartpole-v1 und eine ausreichende RL-spezifische Konfiguration angibst, um sicherzustellen, dass das Training funktioniert. Die Ausführung dieser Konfiguration erfordert keine spezielle Hardware und ist in wenigen Minuten abgeschlossen.Um dieses Beispiel zu trainieren, musst du die PyGame-Abhängigkeit mit pip install pygameinstallieren und dann einfach ausführen:

rllib example run cartpole-ppo

Wenn du dies ausführst, erstellt RLlib ein benanntes Experiment und protokolliert wichtige Metriken wie die reward oder die episode_reward_mean für dich. In der Ausgabe des Trainingslaufs solltest du auch Informationen über die Maschine (loc, d.h. Hostname und Port) sowie den Status deiner Trainingsläufe sehen. Wenn dein Lauf TERMINATED ist, du aber nie ein erfolgreiches RUNNING Experiment im Protokoll gesehen hast, muss etwas schief gelaufen sein. Hier ist ein Beispielschnipsel eines Trainingslaufs:

+-----------------------------+----------+----------------+
| Trial name                  | status   | loc            |
|-----------------------------+----------+----------------|
| PPO_CartPole-v0_9931e_00000 | RUNNING  | 127.0.0.1:8683 |
+-----------------------------+----------+----------------+

Wenn der Trainingslauf beendet ist und alles gut gelaufen ist, solltest du die folgende Ausgabe sehen:

Your training finished.
Best available checkpoint for each trial:
  <checkpoint-path>/checkpoint_<number>

Du kannst jetzt deinen trainierten Algorithmus von einem beliebigen Kontrollpunkt aus bewerten, indem du ihn zum Beispiel ausführst:

╭─────────────────────────────────────────────────────────────────────────╮
│   rllib evaluate <checkpoint-path>/checkpoint_<number> --algo PPO       │
╰─────────────────────────────────────────────────────────────────────────╯

Dein lokaler Ray-Checkpoint-Ordner ist standardmäßig ~/ray-results. Für die von uns verwendete Trainingskonfiguration sollte dein <checkpoint-path> die Form ~/ray_results/cartpole-ppo/PPO_CartPole-v1_<experiment_id> haben. Während des Trainings werden deine Zwischen- und Endmodell-Checkpoints in diesem Ordner erstellt.

Um die Leistung deines trainierten RL-Algorithmus zu bewerten, kannst du ihn jetztvom Kontrollpunkt aus bewerten, indem du den Befehl kopierst, den der vorherige Beispiel-Trainingslauf ausgegeben hat:

rllib evaluate <checkpoint-path>/checkpoint_<number> --algo PPO

Wenn du diesen Befehl ausführst, werden die Ergebnisse der Auswertung ausgegeben, d.h. die Belohnungen, die dein trainierter RL-Algorithmus in der Umgebung CartPole-v1 erzielt hat.

Es gibt noch viel mehr, was du mit der RLlib machen kannst, und wir werden in Kapitel 4 mehr darüber erfahren. Dieses Beispiel sollte dir zeigen, wie einfach du mit der RLlib und dem Kommandozeilentool rllib loslegen kannst, indem du einfach die Befehle example und evaluate verwendest.

Verteiltes Training mit Ray Train

Ray RLlib ist auf Reinforcement Learning ausgerichtet, aber was machst du, wenn du Modelle für andere Arten des maschinellen Lernens trainieren musst, wie z.B. überwachtes Lernen? In diesem Fall kannst du eine andere Ray-Bibliothek für verteiltes Training verwenden: Ray Train. An dieser Stelle haben wir nicht genug Wissen über Frameworks wie TensorFlow, um dir ein kurzes und informatives Beispiel für Ray Train zu geben. Wenn du dich für verteiltes Training interessierst, kannst du zu Kapitel 6 springen.

Hyperparameter-Abstimmung

Dinge zu benennen ist schwierig, aber Ray Tune, mit dem du alle möglichen Parameter abstimmen kannst, trifft den Nagel auf den Kopf. Es wurde speziell entwickelt, um gute Hyperparameter für Modelle des maschinellen Lernens zu finden.Der typische Aufbau ist wie folgt:

Du willst eine extrem rechenintensive Trainingsfunktion ausführen. Bei ML ist es nicht ungewöhnlich, dass Trainingsverfahren Tage, wenn nicht sogar Wochen dauern, aber nehmen wir mal an, es geht nur um ein paar Minuten.
Als Ergebnis des Trainings berechnest du eine sogenannte Zielfunktion. Normalerweise willst du entweder deine Gewinne maximieren oder deine Verluste minimieren, was die Leistung deines Experiments angeht.
Das Tückische daran ist, dass deine Trainingsfunktion von bestimmten Parametern, den sogenannten Hyperparametern, abhängen kann, die den Wert deiner Zielfunktion beeinflussen.
Du hast vielleicht eine Ahnung, wie die einzelnen Hyperparameter aussehen sollten, aber es kann schwierig sein, sie alle einzustellen. Selbst wenn du diese Parameter auf einen sinnvollen Bereich beschränken kannst, ist es in der Regel unerschwinglich, eine große Anzahl von Kombinationen zu testen. Deine Trainingsfunktion ist einfach zu teuer.

Was kannst du tun, um Hyperparameter effizient zu sampeln und "gute" Ergebnisse für dein Ziel zu erhalten? Das Gebiet, das sich mit der Lösung dieses Problems befasst, heißt Hyperparameter-Optimierung (HPO), und Ray Tune verfügt über eine enorme Anzahl von Algorithmen, um dieses Problem anzugehen.Schauen wir uns ein Beispiel für Ray Tune an, das für die gerade erläuterte Situation verwendet wird. Der Fokus liegt wieder auf Ray und seiner API, nicht auf einer bestimmten ML-Aufgabe (die wir im Moment einfach simulieren):

from ray import tune
import math
import time


def training_function(config):  
    x, y = config["x"], config["y"]
    time.sleep(10)
    score = objective(x, y)
    tune.report(score=score)  


def objective(x, y):
    return math.sqrt((x**2 + y**2)/2)  


result = tune.run(  
    training_function,
    config={
        "x": tune.grid_search([-1, -.5, 0, .5, 1]),  
        "y": tune.grid_search([-1, -.5, 0, .5, 1])
    })

print(result.get_best_config(metric="score", mode="min"))

: Simuliere eine teure Trainingsfunktion, die von zwei Hyperparametern, x und y, abhängt, die aus einer config gelesen werden.
: Nachdem er 10 Sekunden lang geschlafen hat, um das Training zu simulieren und das Ziel zu berechnen, wird das Ergebnis an tune gemeldet.
: Das Ziel berechnet den Mittelwert der Quadrate von x und y und gibt die Quadratwurzel dieses Terms zurück. Diese Art von Zielvorgabe ist in ML ziemlich verbreitet.
: Verwenden Sie tune.run, um die Hyperparameter-Optimierung auf unserertraining_function.
: Ein wichtiger Teil ist die Bereitstellung eines Parameterraums für x und y, in dem tune suchen kann.

Die Ausgabe dieses Laufs ähnelt strukturell der des RLlib-Beispiels. Das ist kein Zufall, denn RLlib nutzt (wie viele andere Ray-Bibliotheken) Ray Tune unter der Haube. Wenn du genau hinsiehst, siehst du PENDING Läufe, die auf die Ausführung warten, sowieRUNNING und TERMINATED Läufe. Tune kümmert sich automatisch um die Auswahl, Planung und Ausführung deiner Trainingsläufe.

Konkret findet dieses Tune-Beispiel die bestmögliche Wahl der Parameter x und y für ein training_function mit einem gegebenen objective, das wir minimieren wollen. Auch wenn die Zielfunktion zunächst etwas einschüchternd aussehen mag, da wir die Summe der Quadrate von x und y berechnen, werden alle Werte nicht negativ sein. Das bedeutet, dass der kleinste Wert bei x=0 und y=0 erreicht wird, was die Zielfunktion zu 0 evaluiert.

Wir führen eine sogenannte Rastersuche über alle möglichen Parameterkombinationen durch. Da wir für x und y jeweils 5 mögliche Werte eingeben, sind das insgesamt 25 Kombinationen, die in die Trainingsfunktion eingespeist werden.Da wir training_function anweisen, 10 Sekunden lang zu schlafen, würde das sequentielle Testen aller Hyperparameterkombinationen insgesamt mehr als 4 Minuten dauern. Da Ray diesen Arbeitsaufwand intelligent parallelisiert, hat das ganze Experiment bei uns nur etwa 35 Sekunden gedauert, aber je nachdem, wo du es ausführst, kann es auch viel länger dauern.

Stell dir vor, jeder Trainingslauf hätte mehrere Stunden gedauert und wir hätten 20 statt 2 Hyperparameter. Das macht die Gittersuche undurchführbar, vor allem, wenn du keine fundierten Schätzungen über den Parameterbereich hast. In solchen Situationen musst du die aufwändigeren HPO-Methoden von Ray Tune verwenden, wie in Kapitel 5 beschrieben.

Modell Servieren

Die letzte von Rays High-Level-Bibliotheken, die wir besprechen werden, ist auf das Model Serving spezialisiert und heißt einfach Ray Serve.Um ein Beispiel dafür zu sehen, wie es funktioniert, brauchst du ein trainiertes ML-Modell, das du bedienen kannst. Zum Glück kannst du heutzutage viele interessante Modelle im Internet finden, die bereits für dich trainiert wurden. Hugging Face bietet zum Beispiel eine Vielzahl von Modellen an, die du direkt in Python herunterladen kannst.Das Modell, das wir verwenden werden, ist ein Sprachmodell namens GPT-2, das Text als Eingabe annimmt und Text produziert, um die Eingabe fortzusetzen oder zu vervollständigen.Du kannst zum Beispiel eine Eingabeaufforderung stellen und GPT-2 wird versuchen, sie zu vervollständigen.

Das Servieren eines solchen Modells ist eine gute Möglichkeit, es zugänglich zu machen. Du weißt vielleicht nicht, wie du ein TensorFlow-Modell auf deinen Computer laden und ausführen kannst, aber du weißt, wie du eine Frage in einfachem Englisch stellen kannst. Das Servieren eines Modells verbirgt die Implementierungsdetails einer Lösung und ermöglicht es den Nutzern, sich darauf zu konzentrieren, Eingaben zu machen und die Ausgaben eines Modells zu verstehen.

Um fortzufahren, musst du pip install transformers ausführen, um die Hugging Face-Bibliothek zu installieren, die das Modell enthält, das wir verwenden wollen.¹⁷ Damit können wir nun eine Instanz von Rays serve Bibliothek importieren und starten, ein GPT-2-Modell laden und einsetzen und es nach dem Sinn des Lebens fragen, etwa so:

from ray import serve
from transformers import pipeline
import requests

serve.start()  


@serve.deployment  
def model(request):
    language_model = pipeline("text-generation", model="gpt2")  
    query = request.query_params["query"]
    return language_model(query, max_length=100)  


model.deploy()  

query = "What's the meaning of life?"
response = requests.get(f"http://localhost:8000/model?query={query}")  
print(response.text)

: Starte serve vor Ort.
: Der @serve.deployment Dekorator verwandelt eine Funktion mit einem request Parameter in einen serve Einsatz.
: Das Laden von language_model innerhalb der model Funktion für jede Anfrage ist ineffizient, aber es ist der schnellste Weg, um dir einen Einsatz zu zeigen.
: Bitte das Modell, uns höchstens 100 Zeichen zu geben, damit wir unsere Abfrage fortsetzen können.
: Setze das Modell formell ein, damit es Anfragen über HTTP empfangen kann.
: Nutze die unentbehrliche Anfragebibliothek, um eine Antwort auf jede Frage zu erhalten.

In Kapitel 9 erfährst du, wie du Modelle in verschiedenen Szenarien richtig einsetzt, aber für den Moment möchten wir dich ermutigen, mit diesem Beispiel herumzuspielen und verschiedene Abfragen zu testen. Wenn du die letzten beiden Codezeilen wiederholt ausführst, wirst du praktisch jedes Mal andere Antworten erhalten. Hier ist ein düsteres, poetisches Juwel, das weitere Fragen aufwirft, aus einer Abfrage, die wir für minderjährige Leser leicht zensiert haben:

[{
    "generated_text": "What's the meaning of life?\n\n
     Is there one way or another of living?\n\n
     How does it feel to be trapped in a relationship?\n\n
     How can it be changed before it's too late?
     What did we call it in our time?\n\n
     Where do we fit within this world and what are we going to live for?\n\n
     My life as a person has been shaped by the love I've received from others."
}]

Damit beenden wir unsere Rundreise durch die Data Science-Bibliotheken von Ray, der zweiten Schicht von Ray. Alle in diesem Kapitel vorgestellten High-Level-Bibliotheken von Ray sind Erweiterungen der Ray Core API. Mit Ray ist es relativ einfach, neue Erweiterungen zu erstellen, und es gibt noch ein paar mehr, die wir in diesem Buch nicht vollständig besprechen können. Zum Beispiel gibt es seit kurzem Ray Workflows, mit denen du mit Ray langlaufende Anwendungen definieren und ausführen kannst.

Bevor wir dieses Kapitel abschließen, werfen wir noch einen kurzen Blick auf die dritte Ebene, das wachsende Ökosystem um Ray.

Ein wachsendes Ökosystem

Rays High-Level-Bibliotheken sind mächtig und verdienen eine ausführlichere Behandlung im ganzen Buch.Obwohl ihr Nutzen für den Lebenszyklus von Data Science-Experimenten unbestreitbar ist, wollen wir nicht den Eindruck erwecken, dass Ray von nun an alles ist, was du brauchst. Es ist keine Überraschung, dass die besten und erfolgreichsten Frameworks diejenigen sind, die sich gut in bestehende Lösungen und Ideen integrieren lassen. Es ist besser, sich auf deine Kernstärken zu konzentrieren und andere Tools für das zu nutzen, was in deiner Lösung fehlt, und das macht Ray ziemlich gut.

Im Laufe des Buches und insbesondere in Kapitel 11 werden wir viele nützliche Bibliotheken von Drittanbietern besprechen, die auf Ray aufsetzen. Das Ray-Ökosystem bietet auch viele Integrationen mit bestehenden Tools. Ein Beispiel dafür ist Ray Datasets, die Datenlade- und Berechnungsbibliothek von Ray. Wenn du ein bestehendes Projekt hast, das bereits Datenverarbeitungs-Engines wie Spark oder Dask nutzt, kannst du diese Tools mit Ray verwenden,¹⁸ Du kannst das gesamte Dask-Ökosystem mit dem Zeitplannungsprogramm Dask-on-Ray auf einem Ray-Cluster laufen lassen oder du kannst das Spark-on-Ray-Projekt nutzen, um deine Spark-Workloads in Ray zu integrieren. Das Modin-Projekt ist ein verteilter Ersatz für Pandas DataFrames, der Ray (oder Dask) als verteilte Ausführungsmaschine nutzt ("Pandas on Ray").

Der gemeinsame Nenner ist, dass Ray nicht versucht, all diese Tools zu ersetzen, sondern sich mit ihnen integriert, während du weiterhin Zugriff auf die eigene Ray-Datensatz-Bibliothek hast. In Kapitel 11 werden wir ausführlicher auf die Beziehung zwischen Ray und anderen Tools im breiteren Ökosystem eingehen.

Ein wichtiger Aspekt vieler Ray-Bibliotheken ist, dass sie gängige Tools als Backends nahtlos integrieren.Ray schafft oft gemeinsame Schnittstellen, anstatt zu versuchen, neue Standards zu schaffen.¹⁹ Diese Schnittstellen ermöglichen es dir, Aufgaben verteilt auszuführen, eine Eigenschaft, die die meisten der jeweiligen Backends nicht oder nicht im gleichen Maße haben. Ray RLlib und Train werden zum Beispiel von der vollen Leistungsfähigkeit von TensorFlow und PyTorch unterstützt. Und Ray Tune unterstützt Algorithmen von praktisch jedem namhaften HPO-Tool, das es gibt, darunter Hyperopt, Optuna, Nevergrad, Ax, SigOpt und viele andere. Keines dieser Tools ist standardmäßig verteilt, aber Tune vereint sie in einer gemeinsamen Schnittstelle für verteilte Workloads.

Zusammenfassung

Abbildung 1-4 gibt dir einen Überblick über die drei Schichten von Ray, so wie wir sie aufgebaut haben. Die Ray Core API ist eine vielseitige Bibliothek für verteiltes Computing, und Ray Clusters ermöglichen es dir, deine Workloads auf verschiedene Weise einzusetzen.

Für praktische Data-Science-Workflows kannst du Ray Datasets für die Datenverarbeitung, Ray RLlib für das Reinforcement Learning, Ray Train für das verteilte Modelltraining, Ray Tune für das Tuning von Hyperparametern und Ray Serve für das Servieren von Modellen verwenden. Du hast Beispiele für jede dieser Bibliotheken gesehen und eine Vorstellung davon bekommen, was ihre APIs beinhalten. Ray AIR bietet eine einheitliche API für alle anderen Ray ML-Bibliotheken und wurde mit Blick auf die Bedürfnisse von Data Scientists entwickelt.

Darüber hinaus gibt es in Rays Ökosystem viele Erweiterungen, Integrationen und Backends, auf die wir später noch näher eingehen werden. Vielleicht erkennst du in Abbildung 1-4 schon ein paar Tools, die du kennst und magst?

Die Ray Core API befindet sich im Zentrum von Abbildung 1-4, umgeben von den Bibliotheken RLlib, Ray Tune, Ray Train, Ray Serve, Ray Datasets und den vielen Integrationen von Drittanbietern, die hier nicht alle aufgeführt werden können.

¹ Mit "Python-first" meinen wir, dass alle höheren Bibliotheken in Python geschrieben sind und dass die Entwicklung neuer Funktionen von den Bedürfnissen der Python-Community bestimmt wird. Allerdings wurde Ray so konzipiert, dass es mehrere Sprachbindungen unterstützt und zum Beispiel eine Java-API enthält. Es ist also nicht ausgeschlossen, dass Ray auch andere Sprachen unterstützt, die für das Data Science Ökosystem wichtig sind.

² Das Mooresche Gesetz galt lange Zeit, aber es gibt Anzeichen dafür, dass es sich verlangsamt. Manche sagen sogar, es sei tot. Wir sind nicht hier, um über diese Punkte zu streiten. Wichtig ist nicht, dass unsere Computer generell immer schneller werden, sondern das Verhältnis zu der Menge an Rechenleistung, die wir benötigen.

³ Es gibt viele Möglichkeiten, das ML-Training zu beschleunigen, von einfach bis anspruchsvoll. Wir werden uns zum Beispiel ausführlich mit der verteilten Datenverarbeitung in Kapitel 6 und dem verteilten Modelltraining in Kapitel 7 beschäftigen.

⁴ Anyscale, das Unternehmen hinter Ray, baut eine verwaltete Ray-Plattform auf und bietet gehostete Lösungen für deine Ray-Anwendungen an.

⁵ Das mag drastisch klingen, aber es ist kein Scherz. Um nur ein Beispiel zu nennen: Im März 2021 brannte ein französisches Rechenzentrum, das Millionen von Websites mit Strom versorgt, komplett nieder. Wenn dein ganzer Cluster abbrennt, kann Ray dir leider nicht helfen.

⁶ Da dies ein Python-Buch ist, konzentrieren wir uns ausschließlich auf Python, aber du solltest wissen, dass Ray auch eine Java-API hat, die noch nicht so ausgereift ist wie ihr Python-Pendant.

⁷ Einer der Gründe, warum so viele Bibliotheken auf Ray Core aufbauen, ist, dass es so schlank und einfach zu verstehen ist. Eines der Ziele dieses Buches ist es, dich dazu zu inspirieren, deine eigenen Anwendungen oder sogar Bibliotheken mit Ray zu schreiben.

⁸ In diesem Buch stellen wir Abhängigkeiten in der Regel nur dann vor, wenn wir sie brauchen, was es einfacher machen sollte, dem Text zu folgen. Im Gegensatz dazu bieten dir die Notizbücher auf GitHub die Möglichkeit, alle Abhängigkeiten im Voraus zu installieren, damit du dich stattdessen auf die Ausführung des Codes konzentrieren kannst.

⁹ Zum Zeitpunkt der Erstellung dieses Buches gibt es noch keine Unterstützung für Python 3.10, also solltest du dich an eine Version zwischen 3.7 und 3.9 halten, um diesem Buch zu folgen.

¹⁰ Es gibt noch andere Möglichkeiten, mit Ray Clusters zu interagieren, z.B. das Ray Aufträge CLI.

¹¹ Wir mochten nie die Kategorisierung von Datenwissenschaft als eine Kreuzung von Disziplinen wie Mathematik, Programmierung und Wirtschaft. Letztlich sagt das nichts darüber aus, was Praktiker/innen tun.

¹² Als unterhaltsame Übung empfehlen wir, Paul Grahams berühmten Aufsatz "Hackers and Painters" zu diesem Thema zu lesen und "Computer Science" durch "Data Science" zu ersetzen. Wie würde Hacking 2.0 aussehen?

¹³ Wenn du mehr über die ganzheitliche Betrachtung des Data-Science-Prozesses bei der Erstellung von ML-Anwendungen erfahren möchtest, widmet sich Building Machine Learning Powered Applications von Emmanuel Ameisen (O'Reilly) ganz diesem Thema.

¹⁴ In Kapitel 6 werden wir dich in die Grundlagen der Funktionsweise von Ray Datasets einführen, einschließlich der Verwendung von Arrow. Jetzt wollen wir uns erst einmal auf die API und die konkreten Nutzungsmuster konzentrieren.

¹⁵ Wir werden in späteren Kapiteln, insbesondere in Kapitel 6, näher darauf eingehen, aber beachte, dass Ray Datasets nicht als Allzweckbibliothek für die Datenverarbeitung gedacht ist. Tools wie Spark haben eine ausgereiftere und optimierte Unterstützung für die Verarbeitung großer Datenmengen.

¹⁶ Wenn du einen Mac verwendest, musst du tensorflow-macos installieren. Wenn du Probleme bei der Installation von Ray oder seinen Abhängigkeiten auf deinem System hast, schaue bitte in der Installationsanleitung nach.

¹⁷ Je nachdem, welches Betriebssystem du verwendest, musst du eventuell zuerst den Rust-Compiler installieren, damit das funktioniert. Auf einem Mac kannst du ihn zum Beispiel mit brew install rust installieren.

¹⁸ Spark wurde von einem anderen Labor in Berkeley, AMPLab, entwickelt. Das Internet ist voll von Blogbeiträgen, in denen behauptet wird, dass Ray daher als Ersatz für Spark angesehen werden sollte. Es ist besser, sie als Werkzeuge mit unterschiedlichen Stärken zu betrachten, die beide wahrscheinlich bleiben werden.

¹⁹ Bevor das Deep-Learning-Framework Keras offizieller Bestandteil von TensorFlow wurde, diente es zunächst als praktische API-Spezifikation für verschiedene untergeordnete Frameworks wie Theano oder CNTK. In diesem Sinne hat Ray RLlib die Chance, "Keras für RL" zu werden, und Ray Tune könnte "Keras für HPO" sein. Das fehlende Element für eine größere Akzeptanz könnte eine elegantere API für beide sein.

Get Lernstrahl now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Lernstrahl by Max Pumperla, Edward Oakes, Richard Liaw