Kapitel 1. Terminologie und Konzepte des verteilten maschinellen Lernens

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

Erinnerst du dich an , als Datenwissenschaftler ihre Algorithmen für maschinelles Lernen auf Datensätzen laufen ließen, die in den Speicher eines Laptops passten? Oder ihre eigenen Daten generierten? Das lag nicht daran, dass es in der Welt an Daten mangelte; wir waren bereits in der Zettabyte-Ära angekommen.1 Für viele waren die Daten zwar vorhanden, aber sie waren in den Produktionssystemen eingeschlossen, die Daten in großem Umfang erstellten, erfassten, kopierten und verarbeiteten. Datenwissenschaftler/innen wussten, dass sie durch den Zugriff auf die Daten bessere und tiefgreifendere Modelle für maschinelles Lernen erstellen konnten. Aber das war nicht das einzige Problem - was war mit der Berechnung? In vielen Fällen hatten Datenwissenschaftler/innen keinen Zugang zu ausreichender Rechenleistung oder Werkzeugen, um Algorithmen für maschinelles Lernen auf großen Datensätzen auszuführen. Deshalb mussten sie ihre Daten stichprobenartig erfassen und mit CSV- oder Textdateien arbeiten.

Als die öffentliche Cloud-Revolution um 2016-2017 stattfand, konnten wir endlich die gewünschte Rechenkapazität in Anspruch nehmen. Alles, was wir brauchten, war eine Kreditkarte in der einen und eine Computermaus in der anderen Hand. Ein Mausklick und schon standen uns Hunderte von Rechnern zur Verfügung! Aber uns fehlten immer noch die richtigen Open-Source-Tools, um große Datenmengen zu verarbeiten. Wir brauchten verteilte Datenverarbeitung und automatisierte Werkzeuge mit einem gesunden Ökosystem.

Das Wachstum der Digitalisierung, bei der Unternehmen digitale Technologien nutzen, um ihr Geschäftsmodell zu verändern und neue Einnahmequellen und Wertschöpfungsmöglichkeiten zu schaffen, hat die Frustration der Datenwissenschaftler/innen erhöht. Die Digitalisierung führte dazu, dass immer größere Datenmengen zur Verfügung standen, aber die Datenwissenschaftler/innen konnten nicht schnell genug mit diesen Daten arbeiten, weil sie nicht über die entsprechenden Werkzeuge verfügten. Der mühsame Prozess, tagelang zu warten, um einen Algorithmus für maschinelles Lernen auszuprobieren oder eine Stichprobe von Produktionsdaten zu erhalten, hinderte viele daran, ihr Potenzial voll auszuschöpfen. Das Bedürfnis nach Verbesserung und Automatisierung wuchs.

Kleine Unternehmen sahen, wie sich größere Unternehmen positiv auf ihr Geschäft auswirkten, indem sie ihren Kunden automatisierte, personalisierte Lösungen anboten, die die Stimmung verbesserten und den Umsatz steigerten. Aus der Fantasie heraus wurde das maschinelle Lernen zu einer heißen Ware. Die Unternehmen erkannten, dass sie, um die Vorteile des maschinellen Lernens nutzen zu können, mehr Tools und engagierte Teams für die Entwicklung dieser Tools im eigenen Haus brauchen würden, was wiederum die Nachfrage nach Ingenieuren erhöhte, die zuverlässige, skalierbare, beschleunigte und leistungsstarke Tools zur Unterstützung von maschinellen Lernprozessen entwickeln.

Netflix, das weltweit führende Internetfernsehnetzwerk, das täglich Hunderte Millionen Stunden an Inhalten streamt, hat erklärt, dass es maschinelles Lernen in allen Bereichen des Unternehmens einsetzt. Dazu gehören die Empfehlung personalisierter Inhalte für Kunden, die Optimierung der Produktionsprozesse von Filmen und Serien in den Netflix-Studios, die Optimierung der Video- und Audiocodierung sowie die Verbesserung der Werbeausgaben und der Werbekreativität, um neue potenzielle Kunden zu erreichen.

Maschinelles Lernen findet nicht nur in technologieorientierten Unternehmen, sondern in einer Vielzahl von Branchen Anwendung. Die Datenwissenschaftler und Analyseteams des multinationalen Öl- und Gasunternehmens Shell plc nutzen maschinelles Lernen für große Datensätze, um das Unternehmen mit Erkenntnissen über Produktmöglichkeiten und Prozessoptimierungen zu unterstützen und die Wirksamkeit verschiedener Maßnahmen zu testen. Ein Beispiel ist das Bestandsvorhersagemodell, das über 10.000 Simulationen für alle Teile und Anlagen durchführt, um die Nachfrage vorherzusagen und die Lagerhaltung zu verbessern. Shell nutzt maschinelles Lernen auch, um eine Empfehlungsmaschine für sein Kundenbindungsprogramm Go+ zu betreiben, das personalisierte Angebote und Belohnungen für einzelne Kunden bietet. Dieser Ansatz bietet Shell ein verbessertes Kundenbindungsmodell, das auf die spezifischen Bedürfnisse der Kunden eingeht und sie an das Unternehmen bindet.

Andere Branchen nutzen maschinelles Lernen zur Betrugserkennung, für Empfehlungssysteme, zur Patientendiagnose und vieles mehr. Wirf einen Blick auf Abbildung 1-1, um eine Vorstellung davon zu bekommen, wie du in deiner Branche Innovationen durch maschinelles Lernen vorantreiben kannst.

Wie diese Beispiele zeigen, hat die Möglichkeit, große Datenmengen zu nutzen, um Lösungen mit nachgewiesenen Auswirkungen auf das Geschäft zu entwickeln, vielen Unternehmen die Augen geöffnet, die ihr Geschäft ausbauen und ihren Umsatz steigern wollen.

Abbildung 1-1. Einige der vielen Anwendungen von maschinellem Lernen in verschiedenen Branchen

Die Forschungsgemeinschaften der Informatik und der Ingenieurwissenschaften haben wesentlich dazu beigetragen, skalierbares maschinelles Lernen zu ermöglichen. In den letzten Jahren haben akademische Forscher Hunderte, wenn nicht Tausende von Studien zur Nutzung von maschinellem Lernen, verteilten Berechnungen und Datenbanken durchgeführt und intelligentere, effizientere Algorithmen zur Unterstützung des verteilten maschinellen Lernens entwickelt. Infolgedessen sind verteilte Allzweckplattformen entstanden, wie z. B. das äußerst beliebte Apache Spark. Apache Spark ist eine skalierbare, universell einsetzbare Engine für Analysen und maschinelles Lernen. Gleichzeitig arbeiten die Teams, die hinter den verschiedenen Bibliotheken für maschinelles Lernen stehen, unermüdlich daran, Backend-Unterstützung für die Ausführung in einer verteilten Umgebung bereitzustellen. Um nur einige Beispiele zu nennen: Googles TensorFlow, das tiefe neuronale Netzwerke vereinfacht, und Facebooks PyTorch, das für Computer Vision und die Verarbeitung natürlicher Sprache verwendet wird, wurden um zusätzliche Funktionen zur Unterstützung verteilten maschinellen Lernens erweitert.

In diesem Buch konzentrieren wir uns auf die Verwendung von Apache Spark und ich zeige dir, wie du mit TensorFlow und PyTorch eine Brücke zum verteilten maschinellen Lernen schlagen kannst. Das Buch schließt mit einer Diskussion über Einsatzmuster für maschinelles Lernen in Kapitel 10 ab. Um dir den Einstieg zu erleichtern, bietet dieses Kapitel eine Einführung in die grundlegenden Konzepte, die Terminologie und die Bausteine des verteilten maschinellen Lernens. Wir behandeln die Grundlagen der folgenden Themen:

  • Der Workflow für maschinelles Lernen

  • Spark MLlib

  • Verteiltes Rechnen

  • Verteilte Systeme

Bist du mit diesen Konzepten vertraut? In Kapitel 2 werden wir eine Einführung in Spark und PySpark geben und in Kapitel 3 den Lebenszyklus von Machine Learning verwalten.

Aufgeregt? Lass uns eintauchen!

Die Phasen des Machine Learning Workflows

Viele Anwendungen auf werden heute durch maschinelles Lernen gesteuert und nutzen maschinelle Lernmodelle, um Fragen wie diese zu beantworten: Wie kann sich meine Anwendung automatisch an die Bedürfnisse des Kunden anpassen? Wie kann ich diesen mühsamen Prozess automatisieren, damit meine Mitarbeiter mehr mit ihrer Zeit anfangen können? Wie kann ich meinen Datenberg sinnvoll nutzen, ohne das ganze Jahr damit zu verbringen, ihn zu durchforsten? Als Datenexperten haben wir jedoch nur eine Frage zu beantworten: Wie können wir den Prozess zur Beantwortung dieser Fragen ermöglichen?

Die kurze Antwort lautet maschinelles Lernen. Eine umfassendere Antwort ist der maschinelle Lern-Workflow.

Der Workflow des maschinellen Lernens umfasst eine Reihe von Schritten, die uns dabei helfen, das Ziel zu erreichen, ein maschinelles Lernmodell in der Produktion laufen zu haben, das ein Geschäftsproblem löst. Was ist ein maschinelles Lernmodell? Gute Frage! Ein maschinelles Lernmodell ist die Ausgabe eines maschinellen Lernalgorithmus. Von nun an werden wir es einfach als Modell bezeichnen. Die Automatisierung dieses Arbeitsablaufs wird als Pipeline für maschinelles Lernen bezeichnet. Um die Genauigkeit des Modells zu verbessern, ist der Arbeitsablauf iterativ. So haben wir die vollständige Kontrolle über das Modell - einschließlich der Automatisierung, Überwachung und Bereitstellung - und seine Ergebnisse.

Die Arbeitsabläufe des maschinellen Lernens bestehen aus mehreren Phasen, von denen einige übersprungen und einige wiederholt werden können:

  1. Daten sammeln und laden/testen. Die erste Phase von besteht darin, die für den Prozess benötigten Daten zu sammeln und sie in die Umgebung zu laden, in der du dein Experiment zum maschinellen Lernen durchführen wirst.

  2. Untersuche und validiere die Daten. Als Nächstes musst du die gesammelten Daten untersuchen und ihre Qualität bewerten. In dieser Phase wird oft statistisch geprüft, wie gut die Trainingsdaten reale Ereignisse, ihre Verteilung und die Vielfalt des Datensatzes repräsentieren. Dies wird auch als explorative Datenanalyse (EDA) bezeichnet.

  3. Bereinige die Daten und verarbeite sie vor. Nach Stufe 2 könntest du zu dem Schluss kommen, dass die Daten verrauscht sind. Ein verrauschter Datensatz ist ein Datensatz mit Spalten, die überhaupt nicht zum Training beitragen, z. B. Zeilen mit Nullwerten oder langen String-Werten. Sie erfordern mehr Rechenleistung, verbessern aber nicht die Modellgenauigkeit. In dieser Phase führen Datenwissenschaftler/innen statistische Tests mit den Daten durch, um die Korrelation zwischen den Merkmalen zu überprüfen und zu analysieren, welche Merkmale bereits wertvoll sind, welche mehr Vorverarbeitung oder Technik erfordern und welche überflüssig sind.

  4. Extrahiere Merkmale / führe Feature Engineering durch. In der vorherigen Phase werden die Datenspalten als Merkmale ausgegeben. Dies sind die Deskriptoren der Daten, die als Input für das maschinelle Lernmodell verwendet werden. Die Merkmale beim maschinellen Lernen sind oft außerhalb der Originaldaten, d. h. wir müssen die vorhandenen Daten mit Daten aus anderen Quellen anreichern. Das bedeutet, dass wir einen Code entwickeln müssen, um diese Merkmale zu berechnen und zu erzeugen und den Datensatz mit ihnen anzureichern, bevor wir das Modell trainieren. Es gibt viele Möglichkeiten, dies zu tun, und oft ist dafür Fachwissen erforderlich. Oder die Merkmale sind bereits in einem anderen Datensatz vorhanden. In diesem Fall müssen wir die beiden Datensätze nur zu einem zusammenführen, bevor wir das Modell trainieren.

  5. Teile die Daten in einen Trainings- und einen Validierungssatz auf. Der Trainingsdatensatz wird zum Trainieren des maschinellen Lernmodells verwendet, während der Validierungsdatensatz dazu dient, die Leistung des Modells bei ungesehenen Daten zu bewerten.

  6. Trainiere und stimme das Modell ab. Füttere den Algorithmus für maschinelles Lernen mit den Trainingsdaten und passe die Parameter an, um die Leistung zu verbessern. Überprüfe das Ergebnis mit einem speziellen Validierungsdatensatz. Der Validierungsprozess findet in der Entwicklungsumgebung statt, entweder lokal auf deinem Computer oder in einer Entwicklungs-/Experimentierumgebung in der Cloud. Das Ergebnis dieser Phase ist das Modell.

  7. Evaluiere das Modell mit Testdaten. Die Seite ist die letzte Testphase, bevor das Modell in die Produktion überführt wird. In dieser Phase misst du erneut die Leistung des Modells anhand von Daten, die du zuvor nicht gesehen hast, und testest es diesmal in einer produktionsähnlichen Umgebung. Nach dieser Phase solltest du vielleicht noch einmal zu Phase 6 zurückkehren.

  8. Bereitstellen des Modells. Unter verpacken Data Scientists zusammen mit Machine Learning- und Produktionsingenieuren das Modell und setzen es mit allen Anforderungen in der Produktion ein.

  9. Überwache das Modell. In der Produktion muss das Modell ständig auf Abweichungen überwacht werden (die verschiedenen Arten der Abweichung werden in Kapitel 10 behandelt). Es ist wichtig, den Wert des Modells für das Unternehmen kontinuierlich zu bewerten und zu wissen, wann es ersetzt werden muss.

Jede dieser Phasen ist für sich wiederholbar, und es kann sein, dass du angesichts eines bestimmten Ergebnisses den gesamten Prozess noch einmal durchlaufen willst. Im Fall der Modelldrift sind die Daten und das Modell zum Beispiel nicht repräsentativ für das Geschäftsproblem, und du musst den Prozess von vorne beginnen.

Jede Phase ist einzigartig und hängt stark von den Daten, den Systemanforderungen, deinem Wissen, den verwendeten Algorithmen, der vorhandenen Infrastruktur und dem gewünschten Ergebnis ab.

Die Stufen 3 bis 6 werden oft als die experimentelle Phase des maschinellen Lernens bezeichnet. Du wirst wiederholt iterieren und mehrere Versionen der Daten und des Modells erstellen wollen, bis du die beste Version des Modells gefunden hast.

Wenn du mehr über Workflows für maschinelles Lernen und deren Automatisierung mithilfe von Pipelines mit TensorFlow und TensorBoard erfahren möchtest, lies Building Machine Learning Pipelines von Hannes Hapke und Catherine Nelson (O'Reilly).

Tools und Technologien in der Machine Learning Pipeline

Abbildung 1-2 zeigt einen Überblick über die Pipeline des maschinellen Lernens und einige der Tools, die in jeder Phase verwendet werden können.

Abbildung 1-2. Ein Überblick über die Pipeline des maschinellen Lernens und die in jeder Phase verwendeten Tools

In den Tutorials in diesem Buch werden wir verschiedene Tools und Plattformen verwenden, um die verschiedenen Phasen zu durchlaufen (du kannst natürlich jedes dieser Tools durch ein anderes deiner Wahl ersetzen). Für das Experimentieren mit der Datenaufnahme, der Vorverarbeitung und dem Feature Engineering werden wir Jupyter verwenden, das eine Benutzeroberfläche und einen Backend-Server bereitstellt. Wir schreiben den Code in einem Notizbuch in der Benutzeroberfläche, und das Backend verpackt ihn und sendet ihn an die Spark-Engine.

In der Phase der Modellerstellung (die den Phasen 6 und 7 im oben beschriebenen Workflow für maschinelles Lernen entspricht) trainieren, validieren und optimieren wir das Modell. In dieser Phase verwenden wir mehrere Server und Backends, darunter Jupyter, PyTorch, TensorFlow, Horovod, Petastorm und MLflow, um Operationen zu orchestrieren, die Daten zwischenzuspeichern und den Workflow von einem Spark-Cluster zu einem Deep-Learning-Cluster zu übertragen.

Schließlich werden wir Spark und MLflow verwenden, um unsere Modelle bereitzustellen und auszuliefern. Wir laden das Modell vom MLflow-Speicherserver und stellen es mit Spark oder als REST-API mit einer Python-Funktion bereit.

Hinweis

In den meisten Unternehmen erfordert die Entwicklung einer durchgängigen Pipeline für maschinelles Lernen ein engagiertes Team, dessen Mitglieder über unterschiedliche Fähigkeiten verfügen, sowie eine integrierte Entwicklungsumgebung (IDE) wie PyCharm, die umfangreiche Entwicklertools und automatische Codevervollständigung, spezielle Skripte für die kontinuierliche Integration/kontinuierliche Bereitstellung (CI/CD) und vieles mehr bietet. In diesem Buch beschränken wir uns auf die Jupyter-Notebooks.

Modelle für verteiltes Rechnen

Verteiltes Rechnen ist die Nutzung verteilter Systeme, in denen mehrere Rechner als eine Einheit zusammenarbeiten, um ein Rechenproblem zu lösen. Ein Programm, das in einem solchen System läuft, wird als verteiltes Programm bezeichnet, und der Prozess, ein solches Programm zu schreiben, wird als verteilte Programmierung bezeichnet. Genau das werden wir in diesem Buch tun. Unser Ziel ist es, den besten Weg zu finden, um ein Problem in einzelne Aufgaben aufzuteilen, die mehrere Maschinen durch Nachrichtenkommunikation parallel lösen können. Es gibt verschiedene verteilte Computermodelle für maschinelles Lernen, die wir in zwei Gruppen einteilen können: Allzweckmodelle, die wir anpassen können, um verteilte maschinelle Lernanwendungen zu unterstützen, und spezielle Computermodelle, die speziell für die Ausführung von maschinellen Lernalgorithmen entwickelt wurden.

Allzweck-Modelle

Allzweckmodelle für verteiltes Rechnen ermöglichen es den Nutzern, einen benutzerdefinierten Datenverarbeitungsablauf unter Verwendung einer definierten Abstraktion zu schreiben. Apache Spark ist eine Allzweck-Engine für verteiltes Rechnen, die im Kern das MapReduce-Programmiermodell implementiert und in jüngerer Zeit um das Barrier-Modell erweitert wurde. In diesem Abschnitt erfährst du mehr über diese beiden Modelle sowie über einige andere Modelle für verteiltes Rechnen (MPI [Message Passing Interface] und Shared Memory), die mit TensorFlow und PyTorch verfügbar sind.

MapReduce

Das Programmiermodell MapReduce wurde durch das Paradigma der funktionalen Programmierung inspiriert. Google stellte den MapReduce-Algorithmus 2004 in einem Forschungspapier vor, in dem erörtert wurde, wie seine Suchmaschine große Datenmengen verarbeitet. Als Entwickler oder Data-Science-Praktiker legen wir eine Map-Funktion fest, die ein Schlüssel/Wert-Paar verarbeitet, um eine Reihe von Schlüssel/Wert-Zwischenpaaren zu erzeugen, und eine Reduce-Funktion, die alle Zwischenwerte zusammenführt, die mit demselben Zwischenschlüssel verbunden sind. Dieser Ansatz ist eine Erweiterung der Split-Apply-Combine-Strategie für die Datenanalyse. In der Praxis wird jede Aufgabe in mehrere Map- und Reduce-Funktionen aufgeteilt. Die Daten werden partitioniert und auf verschiedene Knoten/Maschinen verteilt, und jedes Datenpaket wird auf einem eigenen Knoten verarbeitet. Viele Lösungen zielen darauf ab, die Datenlokalität so weit wie möglich zu erhalten, d.h. die partitionierten Daten sind lokal auf dem Knoten, der sie verarbeitet. Eine logische Funktion wird auf die Daten an diesem Knoten angewendet, dann werden die Daten über das Netzwerk verschoben, um die Daten von den verschiedenen Knoten zu kombinieren, und die kombinierte Ausgabe der Mapper wird reduziert.

Falls nötig, kann dann eine weitere Split-Apply-Combine-Runde mit der Ausgabe des Reducers durchgeführt werden. Beispiele für Open-Source-Lösungen, die diese Konzepte auf die eine oder andere Weise umsetzen, sind Apache Spark, Hadoop MapReduce und Apache Flink. Auf das MapReduce-Modell werden wir im Laufe des Buches noch genauer eingehen.

MPI

Ein weiteres interessantes Allzweckmodell für verteiltes Rechnen ist das Message Passing Interface (MPI) Programmiermodell. Es ist das flexibelste Modell, das heute verfügbar ist, und wurde für leistungsstarkes, skalierbares und portables verteiltes Rechnen entwickelt. MPI ist eine Schnittstelle für die Weitergabe von Nachrichten, die ein paralleles Programm auf einem verteilten Speichersystem modelliert. Sie standardisiert die Kommunikation zwischen einer Reihe von Prozessoren, indem sie die Datentypen definiert, die zwischen den Prozessoren übertragen werden können. Jeder Prozessor hat eine eindeutige Kennung, und jeder Kommunikator ist eine Gruppe von Prozessoren, die in einer bestimmten Topologie angeordnet sind. MPI ist ein Low-Level-Standard, der in Hardware, Compilern, Wrappern usw. implementiert werden kann. Verschiedene Versionen davon wurden von HP, Intel, Microsoft und anderen kommerziell implementiert.

MPI bietet Funktionen wie MPI_Bcast , die eine Nachricht an alle Prozessoren im Kommunikator sendet und die Daten gemeinsam nutzt; MPI_Alltoall , die alle Daten an alle Knoten sendet; und MPI_Reduce und MPI_Allreduce, die den Funktionen von MapReduce und Apache Spark reduce ähneln. Du kannst dir die Schnittstelle als eine Reihe von Bausteinen für verteilte Frameworks vorstellen, die Funktionen für verteiltes maschinelles Lernen bieten.

Der Nachteil von MPI liegt darin, dass es auf niedriger Ebene zu viele Möglichkeiten bietet. Es kann ziemlich arbeitsintensiv und fehleranfällig sein, komplexe Operationen mit MPI auszuführen und zu implementieren; es erfordert eine explizite Verwaltung der Datentypverteilung, der Sende- und Empfangsfunktionalität und der Fehlertoleranz und verlangt vom Entwickler generell, dass er über verteilte Arrays, Datenrahmen, Hashtabellen, Bäume usw. nachdenkt. MPI wird häufig für Deep Learning Workloads verwendet. Die Kernfunktionen von Horovod basieren auf MPI-Konzepten, wie size, rank, local_rank, allreduce, allgather und broadcast. Für verteiltes Rechnen bietet TensorFlow als Teil seines Kommunikationsprotokolls Unterstützung für MPI.

Barriere

Eine Barriere ist eine Synchronisationsmethode, die häufig im parallelen Computing verwendet wird und in verteilten Computing-Frameworks wie Apache Spark implementiert ist. Eine Aufgabe oder ein Job wird in abhängige Phasen oder Teilaufgaben aufgeteilt, die abgeschlossen werden müssen, bevor die Verarbeitung in der nächsten Phase fortgesetzt werden kann. Eine Barriere sorgt dafür, dass eine Gruppe von Maschinen an einem bestimmten Punkt anhält und wartet, bis der Rest der Maschinen seine Berechnungen beendet hat, bevor sie gemeinsam zur nächsten Stufe der Berechnungslogik übergehen können. Barrieremodelle können in Hardware und Software implementiert werden, und die Stufen können viele Formen annehmen, von gerichteten azyklischen Graphen (DAGs) bis zu Bäumen oder sequentiellen Operationen.

Obwohl es sich bei um ein universelles Modell für verteiltes Rechnen handelt, ermöglicht das Barrieremodell verschiedene verteilte Algorithmen für maschinelles Lernen. Beim Deep Learning zum Beispiel ist jede Schicht im gestapelten künstlichen neuronalen Netz eine Stufe, und die Berechnungen jeder Stufe hängen von der Ausgabe der vorherigen Stufe ab. Barrieremodelle ermöglichen in diesem Fall die Verwaltung von vielen Trainingsschichten.

Gemeinsamer Speicher

Gemeinsame Speichermodelle haben eine lange Geschichte: Sie haben ihren Ursprung in Betriebssystemen wie POSIX und Windows, wo Prozesse, die auf demselben Rechner laufen, über einen gemeinsamen Adressraum kommunizieren mussten. Verteilte Shared-Memory-Modelle versuchen, denselben Bedarf zu decken, wenn mehrere Knoten/Benutzer in einer verteilten Umgebung über das Netzwerk kommunizieren und von verschiedenen Rechnern aus auf dieselben Daten zugreifen müssen. Heutzutage gibt es keinen partitionierten globalen Adressraum mehr, sondern eine In-Memory- oder schnelle Datenbank, die eine starke Konsistenz bietet.

Starke Konsistenz in einer verteilten Shared-Memory-Umgebung bedeutet, dass alle Zugriffe auf die Daten durch alle Prozesse und Knoten konsistent sind. Dies zu gewährleisten, ist keine leichte Aufgabe. Eine der verteilten Strategien von TensorFlow implementiert ein Shared-Memory-Modell; du wirst alles über dieses Modell und seine Vor- und Nachteile in Kapitel 8 erfahren.

Dedizierte Modelle für verteiltes Rechnen

Dedizierte verteilte Rechenmodelle sind Modelle, die entwickelt wurden, um einen bestimmten Bedarf im Entwicklungszyklus des maschinellen Lernens zu unterstützen. Oft nutzen sie die Allzweckmodelle als Bausteine, um ein benutzerfreundlicheres Framework zu erstellen, das Data Science-Praktiker sofort einsetzen können. Du kannst sie mit TensorFlow und PyTorch nutzen.

Ein Beispiel für ein dediziertes verteiltes Computermodell für maschinelles Lernen ist ein Parameterserver. TensorFlow implementiert diesen als Teil seiner Verteilungsstrategie für Trainingsmodelle. Parameter-Server nutzen den Shared-Memory-Ansatz: Du hast eine dedizierte Gruppe von Servern, die eine starke Konsistenz der Daten garantiert und den Workern konsistente Informationen liefert. Bei den Parametern handelt es sich um die Gewichte und vorberechneten Merkmale, die der Algorithmus für maschinelles Lernen während seines Trainings- und Retrainingszyklus benötigt. In manchen Fällen passen die Parameter in den Speicher einer einzigen Maschine, aber in realen Anwendungsfällen, in denen es Milliarden von Parametern gibt, ist ein Cluster von Parameterservern erforderlich. Wir werden uns das genauer ansehen, wenn wir in Kapitel 8 die verschiedenen TensorFlow-Strategien für verteiltes Rechnen besprechen.

Da Forschung und Industrie viel in verteiltes maschinelles Lernen investieren, ist es nur eine Frage der Zeit, bis weitere Modelle entwickelt werden. Es ist immer eine gute Übung, nach neuen Entwicklungen Ausschau zu halten. Wir hoffen, dass du am Ende dieses Buches über alle Werkzeuge und Informationen verfügst, die du brauchst, um eine fundierte Entscheidung darüber zu treffen, welches der verschiedenen Modelle für verteiltes Rechnen du einsetzen willst und wie du es für die technologischen Anforderungen deines Unternehmens nutzen kannst.

Jetzt, wo du mit diesen Konzepten vertraut bist, lass uns einen Blick auf das Gesamtbild der Architektur des verteilten maschinellen Lernens werfen und wo jedes dieser Konzepte ins Spiel kommt.

Einführung in die Architektur verteilter Systeme

Wir beginnen mit einer kurzen Diskussion über Netzwerktopologien. Topologien sind die Art und Weise, wie wir Computer organisieren, um verteilte Systeme zu bilden. Es gibt zwei Arten von Topologien: physische Topologien, die beschreiben, wie die Computer angeordnet und verbunden sind, und logische Topologien, die beschreiben, wie die Daten im System fließen und wie die Computer Informationen über das Netzwerk austauschen. Mehrknoten-Computer-Topologien werden in der Regel physisch skaliert, indem weitere Computer (auch Knoten genannt) hinzugefügt werden.

Ingenieure diskutieren oft Topologien in der abschließenden Architekturdiskussion. Die Anforderungen an die Architektur ergeben sich aus den Projektzielen, den Daten, dem Systemverhalten und den vorhandenen Softwaretools. Für Datenwissenschaftler/innen geht es vor allem darum, die Methoden für das Training verteilter Modelle zu definieren und festzulegen, wie die Modelle eingesetzt und bedient werden sollen.

Hinweis

In manchen Fällen kann es vorkommen, dass die verfügbaren Softwaretools die Anforderungen des Projekts nicht gut genug erfüllen oder zu komplex sind, um sie in deine Lösung zu integrieren, so dass du neue Tools beschaffen oder entwickeln musst. Dies ist ein fortgeschrittenes Szenario, das wir in diesem Buch nicht behandeln werden.

Die Knoten, die die Topologie eines verteilten Systems bilden, sind durch ein Netzwerk in einem bestimmten Architekturmuster verbunden, das die Belastungsfähigkeit verbessern und die Geschwindigkeit und Ressourcennutzung optimieren soll. Die architektonischen Entscheidungen, die in der Entwurfsphase getroffen werden, wirken sich auf die Rolle jedes Knotens in der Topologie, auf die Art und Weise, wie sie kommunizieren, und auf die Ausfallsicherheit des Gesamtsystems aus.

Du solltest nicht nur die physische Topologie eines verteilten Systems verstehen, sondern auch die Unterschiede zwischen zentralen und dezentralen Systemen, die Art der Interaktion zwischen den Maschinen, die unterstützten Kommunikationsarten und den Umgang des Systems mit Sicherheit und Fehlern kennen. Das sind die Bausteine, die du bei der Entwicklung deines Systems berücksichtigen solltest.

Zentralisierte versus dezentralisierte Systeme

In einem zentralisierten System hängen alle Knotenpunkte von einem einzigen Knotenpunkt ab, der die Entscheidungen trifft. Ein solches System hat den Vorteil, dass es mehr Kontrolle über die Entscheidungen hat, ist aber auch anfälliger für Ausfälle, da der Knotenpunkt, der die Entscheidungen trifft, zu einem Single Point of Failure wird, der das gesamte System zum Einsturz bringen kann.

In einer dezentralen Systemtopologie sind die Knotenpunkte unabhängig und treffen ihre eigenen Entscheidungen. Jeder Knotenpunkt speichert und bearbeitet seine eigenen Daten, so dass es keinen Single Point of Failure gibt. Das bedeutet, dass das System toleranter gegenüber Störungen ist, aber es bedeutet auch, dass die Entscheidungen der einzelnen Knoten koordiniert und abgestimmt werden müssen.

Dezentrale Systeme können von einer Multicloud-/Hybrid-Cloud-Architektur profitieren, bei der sich Maschinenknoten in verschiedenen Regionen und bei verschiedenen Cloud-Providern befinden. Ein Beispiel ist ein Netzwerk aus verbundenen Internet of Things (IoT)-Geräten: Jedes Gerät ist unabhängig, teilt aber je nach Internetverbindung Daten über das Netzwerk mit anderen Geräten und/oder der Cloud. Die von dir gewählte Topologie hat Auswirkungen auf die Kommunikationsmethoden, die die Geräte nutzen können, und auf ihre möglichen Rollen innerhalb des Netzwerks. Wenn es um das Training von Modellen geht, bedeutet ein dezentraler Ansatz, dass jedes Modell für sich selbst trainiert wird. Wir werden später in diesem Kapitel, wenn wir uns mit Ensemble-Methoden beschäftigen, mehr über die Auswirkungen dieser Entscheidung erfahren.

Interaktionsmodelle

Die Architektur des Interaktionsmodells legt fest, wie die Knotenpunkte in einem System über das Netzwerk kommunizieren, welche Rollen sie im System einnehmen und welche Verantwortlichkeiten mit diesen Rollen verbunden sind. In diesem Abschnitt werden wir uns drei mögliche Architekturen ansehen: Client/Server, Peer-to-Peer und Geodistribution. Es gibt noch weitere Architekturen, die hier nicht behandelt werden, aber das sind die, denen du am ehesten begegnen wirst.

Client/Server

Im Client/Server-Interaktionsmodell gibt es eine klare Definition der Zuständigkeiten. Die Aufgaben werden zwischen Clients, die Anfragen stellen, und Servern, die die Antworten auf diese Anfragen liefern, aufgeteilt. Die Rolle eines Knotens kann sich je nach Struktur und Bedarf des Systems ändern, aber das hängt davon ab, ob die Server zustandslos (sie speichern keinen Zustand) oder zustandsorientiert (sie speichern einen Zustand, auf dem die nächsten Operationen basieren) sind.

Peer-to-Peer

Bei der Peer-to-Peer (P2P) Interaktion wird die Arbeitslast zwischen den Knoten oder Peers aufgeteilt. Alle Knotenpunkte haben die gleichen Rechte und können Informationen direkt austauschen, ohne sich auf einen zentralen Server verlassen zu müssen. Jeder Peer kann sowohl ein Client als auch ein Server sein. Diese Topologie ist freizügiger und billiger zu implementieren, da es nicht nötig ist, einen Rechner an eine bestimmte Aufgabe zu binden. Sie hat jedoch auch einige Nachteile: Jeder Knotenpunkt muss über eine vollständige Kopie der Daten verfügen, und da alle Daten über das Netzwerk ohne einen speziellen Koordinator ausgetauscht werden, können mehrere Kopien denselben Knotenpunkt erreichen.

Geodistribution

Das geo-distributive Interaktionsmodell ist am häufigsten in geo-distributiven Cloud-Rechenzentren anzutreffen. Es zielt darauf ab, Herausforderungen wie den Datenschutz und die Ressourcenzuweisung zu lösen. Ein Problem ist, dass die Latenzzeit der Peer-to-Peer-Kommunikation im geo-distributiven Modell je nach Entfernung zwischen den Knoten hoch sein kann. Deshalb müssen wir bei der Entwicklung von verteilten Machine-Learning-Workloads, die auf diesem Interaktionsmodell basieren, klar definieren, wie die Knoten kommunizieren und in welchen Fällen. Ein Beispiel dafür, wann das geodistributive Interaktionsmodell eine gute Wahl ist, ist das föderierte Lernen mit IoT-/Edge-Geräten, bei denen die Daten nicht in einem einzigen Rechenzentrum zentralisiert werden können. Die Entwicklung eines Systems, das ein Modell auf jedem Gerät über mehrere dezentrale Knoten trainiert und die Ergebnisse zu einem zusammenhängenden Modell zusammenfügt, ermöglicht es uns, von den Datenerkenntnissen aller Geräte zu profitieren, ohne private Informationen auszutauschen.

Kommunikation in einem verteilten Umfeld

Die Art und Weise, wie unsere Knoten in einer verteilten Umgebung kommunizieren, hat einen erheblichen Einfluss auf Ausfallmechanismen, Sicherheit und Durchsatz. Die Kommunikation kann synchron oder asynchron erfolgen, je nach den Anforderungen des verteilten Berechnungsmodells. Zum Beispiel kann ein Parameterserver (ein spezielles Rechenmodell für maschinelles Lernen, das bereits in diesem Kapitel erwähnt wurde) mit asynchroner oder synchroner Kommunikation implementiert werden, und TensorFlow unterstützt sowohl synchrones als auch asynchrones Training, um das Training mit Datenparallelität zu verteilen.

Die Verteilung von maschinellem Lernen auf mehr als eine Maschine erfordert eine Partitionierung der Daten und/oder des Programms selbst, um die Arbeitslast gleichmäßig auf alle Maschinen zu verteilen. Die Entscheidung, ob asynchrone oder synchrone Kommunikation zwischen den Rechnern verwendet wird, wirkt sich auf die Rechenzeit aus und kann zu Engpässen führen. Die Umverteilung von Daten über das Netzwerk kann zum Beispiel die Genauigkeit verbessern und eine Überanpassung verhindern. Beim Shuffling werden die Daten jedoch oft erst auf die lokale Festplatte geschrieben, bevor sie über das Netzwerk gesendet werden. Dies führt zu mehr Ein-/Ausgabeoperationen (E/A), wodurch sich die Gesamtrechenzeit erhöht und ein Engpass auf der lokalen Festplatte entsteht, sowie zu einem großen Kommunikationsaufwand. Bei solchen Aufgaben musst du den Kommunikationsansatz, den du wählst, sorgfältig prüfen.

Asynchron

Der zugrunde liegende Mechanismus für asynchrone Kommunikation ist eine Warteschlange. Anfragen an einen bestimmten Knoten werden in eine Warteschlange gestellt, um ausgeführt zu werden, und können schließlich ein Ergebnis liefern oder nicht. Dieser Mechanismus ist in Systemen nützlich, in denen der Informationsaustausch nicht von der Zeit abhängt, da es nicht notwendig ist, sofort eine Antwort zu erhalten. Du kannst dir das wie eine SMS vorstellen: Du schickst eine SMS an deinen Freund und fragst ihn, ob er am nächsten Samstag mit dir essen gehen will, und weißt, dass du wahrscheinlich eine Antwort erhalten wirst, aber du brauchst sie nicht sofort. Asynchrone Kommunikation ermöglicht einen Nachrichtenfluss in einem verteilten System, ohne dass Prozesse blockiert werden, während man auf eine Antwort wartet.

Synchron

Die Anforderung für synchrone Kommunikation ergibt sich aus dem Funktionsstapel der Informatik, bei dem Funktionen in einer bestimmten Reihenfolge ausgeführt werden müssen - das heißt, wenn ein Knoten eine Anfrage an einen anderen Knoten sendet, kann er nicht mit der Verarbeitung weiterer Funktionslogik fortfahren, während er auf die Antwort wartet. Du kannst die synchrone Kommunikation für bestimmte Fälle des verteilten maschinellen Lernens nutzen und bei Bedarf spezielle Hardware wie z. B. spezielle Netzwerkkabel einsetzen (bei einigen Cloud-Anbietern kannst du die Netzwerkbandbreite konfigurieren2). Angenommen, du willst dich heute Abend mit deinem Freund zum Essen verabreden. Was du tust, hängt von den Essensvorlieben und der Verfügbarkeit deines Freundes sowie der Verfügbarkeit des von dir gewählten Restaurants ab. Du weißt, dass es keinen Platz mehr gibt, wenn du dich für ein beliebtes Restaurant entscheidest und nicht sofort einen Tisch reservierst. Was tust du also? Anstatt eine SMS zu schicken, nimmst du den Hörer in die Hand und rufst deinen Freund an, um die Informationen synchron zu sammeln; ihr beide seid jetzt blockiert, während ihr telefoniert. Du erhältst die nötigen Informationen und gehst zum nächsten Schritt über, nämlich der Kontaktaufnahme mit dem Restaurant.

Nachdem du nun eine Vorstellung von einigen der wichtigsten architektonischen Überlegungen in einer verteilten Topologie für maschinelles Lernen hast, wollen wir einen Blick auf eine Technik werfen, die in den letzten Jahren bei maschinellen Lernanwendungen immer beliebter geworden ist: das Ensemble-Lernen.

Einführung in Ensemble-Methoden

Ensemble-Maschinen Lernmethoden nutzen mehrere maschinelle Lernalgorithmen, um ein einziges Modell mit besserer Leistung und geringerer Verzerrung und Varianz zu erstellen, als es die einzelnen Algorithmen für sich allein erreichen könnten. Ensemble-Methoden sind oft auf überwachtes Lernen ausgelegt und erfordern eine klare Definition der Modellaggregation, die während der Vorhersagezeit verwendet werden kann. Wir werden zunächst untersuchen, warum diese Methoden nützlich sind, und uns dann die wichtigsten Arten von Ensemble-Methoden im maschinellen Lernen und einige spezifische Beispiele ansehen.

Hohe vs. niedrige Verzerrung

Voreingenommenheit ist ein großes Problem beim maschinellen Lernen, und die Verringerung der Voreingenommenheit ist eines der Hauptziele der Ingenieure für maschinelles Lernen. Ein Modell mit einem hohen Bias macht zu viele Annahmen über die Ergebnisse, was zu einer Überanpassung an die Trainingsdaten führt. Ein solches Modell hat Schwierigkeiten, genaue Vorhersagen über neue Daten zu treffen, die nicht genau mit den Daten übereinstimmen, die es bereits gesehen hat, und wird bei Testdaten und in der Produktion schlecht abschneiden. Ein Modell mit geringer Voreingenommenheit geht dagegen von weniger Annahmen über die Daten aus. Im Extremfall kann dies auch problematisch sein, denn es kann zu einer Unteranpassung führen, bei der das Modell nicht genug über die Daten lernt, um sie genau zu klassifizieren. Modelle mit einer hohen Verzerrung haben in der Regel eine niedrige Varianz und andersherum. Du kannst dir die Varianz als die Fähigkeit eines Algorithmus für maschinelles Lernen vorstellen, mit Schwankungen in den Daten umzugehen.3

Oftmals kann die Verzerrung auch aus dem Algorithmus des maschinellen Lernens selbst resultieren. Die lineare Regression zum Beispiel ist ein einfacher Algorithmus, der schnell lernt, aber häufig eine hohe Verzerrung aufweist, vor allem wenn er verwendet wird, um die Beziehung zwischen zwei Variablen zu modellieren, zwischen denen keine echte lineare (oder annähernd lineare) Korrelation besteht. Alles hängt von der zugrunde liegenden Beziehung zwischen den Merkmalen ab.

Arten von Ensemble-Methoden

In vielen Fällen ( ) erweisen sich Ensemble-Methoden als genauer als Einzelmodelle; durch die Kombination der einzelnen Vorhersagen aller Komponentenmodelle können sie robustere Ergebnisse liefern. In Ensembles wird jedes Modell als Lerner bezeichnet. Wir definieren die Beziehung zwischen den Lernern anhand des gewünschten Ziels.

Wenn wir die Varianz reduzieren wollen, bauen wir oft Abhängigkeiten zwischen den Lernern auf, indem wir sie nacheinander trainieren. Zum Beispiel können wir einen Entscheidungsbaum nach dem anderen trainieren, wobei jeder neue Baum die Fehler der vorherigen Bäume in der Reihe korrigieren soll. Diese Strategie, bei der mehrere Lerner mit dem Ziel trainiert werden, die Fehler der vorherigen Lerner zu reduzieren, wird als Boosting bezeichnet. Das Ensemble-Modell trifft seine endgültigen Vorhersagen, indem es die Stimmen gewichtet, die Mehrheitsstimme berechnet oder eine Gesamtsumme ermittelt, die als Vorhersage oder Klassifizierung dient. Ein Beispiel ist der Gradient-Boosted-Trees-Klassifikator (GBTClassifier), der in Spark MLlib implementiert ist. Dabei handelt es sich um eine Ensemble-Technik, bei der Entscheidungsbäume mithilfe eines deterministischen Mittelwertbildungsprozesses iterativ kombiniert werden; Ziel des Algorithmus ist es, den Informationsverlust beim Training/Fehler zu minimieren (mehr dazu in Kapitel 5). Es ist jedoch wichtig zu wissen, dass die iterative Kombination der Bäume manchmal zu einer Überanpassung führen kann.

Um eine Überanpassung zu vermeiden, sollten wir die Lerner unabhängig voneinander parallel trainieren und ihre Vorhersagen mithilfe von Bagging oder Stacking kombinieren. Bei der Bagging-Technik (kurz für Bootstrap-Aggregation) trainieren wir jeden Lerner (in der Regel mit demselben Machine-Learning-Algorithmus) auf einem anderen Teil des Datensatzes, um die Varianz und die Überanpassung zu reduzieren und die Genauigkeit der Vorhersagen auf zuvor ungesehenen Daten zu verbessern. Das Ergebnis dieser Ensemble-Methode ist ein kombiniertes Modell, bei dem jeder Lernende seine Vorhersage unabhängig macht und der Algorithmus alle Stimmen sammelt und eine endgültige Vorhersage erstellt. Ein Beispiel ist die in Spark MLlib implementierte Random​Forest​Classi⁠fier (Random Forest ist eine Ensemble-Methode zur Kombination unabhängiger Entscheidungsbäume).

Stacking ähnelt dem Bagging, bei dem eine Reihe unabhängiger Lerner gebildet und ihre Vorhersagen mit Hilfe einer Ensemble-Funktion kombiniert werden, die die Ergebnisse aller Lerner zu einer einzigen Punktzahl zusammenfasst. Beim Stacking sind die Lerner jedoch in der Regel unterschiedlich und verwenden nicht alle denselben Lernalgorithmus, was bedeutet, dass sie unterschiedliche Annahmen treffen und weniger wahrscheinlich dieselben Fehler machen. Du kannst jede Art von maschinellem Lernmodell als Kombinator verwenden, der die Vorhersagen zusammenfasst. Häufig wird ein lineares Modell verwendet, aber es kann auch nichtlinear sein und die Ergebnisse der Lernenden zusammen mit den gegebenen Daten berücksichtigen, z. B. ein neuronales Netzwerk, bei dem die Basis-Lernenden Entscheidungsbäume sind. Dieser Ansatz ist fortschrittlicher und kann helfen, tiefere Beziehungen zwischen den Variablen aufzudecken.

Tipp

Die Methoden des Ensembles werden als homogen bezeichnet, wenn die Lernenden denselben Basislernalgorithmus haben. Ensembles, deren Lernende unterschiedliche Basis-Lernalgorithmen haben, werden als heterogene Ensembles bezeichnet. Boosting und Bagging gelten als homogene Ensemble-Methoden, während Stacking eine heterogene Methode ist.

Verteilte Ausbildungstopologien

Du kannst Clustertopologien nutzen, um das Training und den Einsatz von Ensemble-Modellen zu verbessern. Schauen wir uns ein paar Beispiele an.

Zentralisiertes Ensemble-Lernen

Zentralisierte Systeme verwenden oft eine Client/Server-Architektur, bei der die Client-Knoten direkt mit den zentralen Server-Knoten kommunizieren. Sie ähnelt einer Sterntopologie in Computernetzwerken. Bei einem verteilten Ansatz für maschinelles Lernen bedeutet dies, dass alle Anfragen für Vorhersagen, Klassifizierungen usw. von den verteilten Modellen über die Hauptserver laufen.

Unabhängig davon, ob es einen oder mehrere Serverknoten gibt, die als endgültige Entscheidungsträger fungieren, gibt es eine streng hierarchische Logik für die Aggregation auf Serverebene, die an einem zentralen Ort stattfindet. Diese Topologie ist speziell für ein verteiltes Modell gedacht und kann nicht universell eingesetzt werden. Betrachten wir zum Beispiel das Random-Forest-Ensemble-Lernverfahren. RandomForest ist ein Bagging-Algorithmus, der je nach Art der Daten für Klassifizierung oder Regression verwendet werden kann und darauf abzielt, die oben beschriebene Überanpassung zu vermeiden. Ein Random Forest besteht aus einer Sammlung von Entscheidungsbäumen. Wenn du dich für RandomForest als Algorithmus entscheidest, interagiert das Programm, das die Abfragen stellt, wie ein Client mit den wichtigsten Serverknoten. Diese Serverknoten senden die Abfragen an die Baumknoten, sammeln die Antworten (die Ergebnisse des Modells) von den Bäumen, fassen die Ergebnisse auf der Grundlage der Ensemble-Logik zusammen und senden die Antworten an den Client zurück. Die einzelnen Bäume des Ensembles können auf völlig unterschiedlichen oder sich überschneidenden Datensätzen trainiert werden.

Dezentrale Entscheidungsbäume

Entscheidung Bäume können auch in einer dezentralen Topologie eingesetzt werden. Dieser Ansatz bietet sich an, wenn du Antworten auf Kanten-Geräten bereitstellen willst und durch Datenschutzbedenken, Internet-Bandbreite und strenge Zeitvorgaben für die Antworten eingeschränkt bist. Dezentrale Entscheidungsbäume eignen sich für Edge AI, wo der Algorithmus verarbeitet und das Modell lokal auf dem Gerät bereitgestellt wird. Jeder Knoten muss nicht permanent mit dem Netzwerk verbunden sein, kann aber das Netzwerk nutzen, um die Genauigkeit seiner Vorhersagen zu verbessern und eine Überanpassung zu vermeiden. Wenn ein Kanten-Knoten eine Anfrage erhält, die ihn zu einer Vorhersage auffordert, sendet er die Anfrage an seine Eltern- und Kind-Knoten, die wiederum die Anfrage an ihre Eltern und Kinder weiterleiten, und jeder Knoten berechnet und sendet seine Antwort. Jeder Knoten verfügt über seine eigene Aggregationsfunktion und kann entscheiden, ob er sie verwendet oder nicht, je nachdem, ob seine Antwort innerhalb der vorgegebenen Zeitspanne verfügbar ist. Um den Kommunikationsaufwand so gering wie möglich zu halten, kannst du die Anzahl der "Hops" begrenzen, um festzulegen, wie weit eine Abfrage gehen kann. Diese Beschränkung erzwingt eine Knoten-Nachbarschaft. Die Nachbarschaft eines Knotens kann sich je nach Verfügbarkeit des Netzwerks und der Kantengeräte ändern.

Zentralisiertes, verteiltes Training mit Parameterservern

In einer zentralisierten verteilten Ausbildungstopologie wird der gesamte Arbeitsaufwand in einem Rechenzentrum verarbeitet. Die Rechner sind gut miteinander verbunden und kommunizieren über ein gemeinsames Netzwerk. Der Datensatz und das Trainingspensum werden auf die Client-Knoten verteilt, und die Server-Knoten verwalten die weltweit gemeinsamen Parameter. Die Serverknoten fungieren als Parameterserver, auf die alle Clientknoten gemeinsam zugreifen und von denen sie Informationen abrufen - ein globaler gemeinsamer Speicher. Sie müssen schnell auf die Informationen zugreifen können und nutzen oft In-Memory-Datenstrukturen. Eine Familie von Algorithmen des maschinellen Lernens, die diese Topologie nutzen kann, sind Deep-Learning-Algorithmen. Bei diesem Ansatz werden die Parameter an alle Rechner verteilt und repliziert, und jeder Client-Knoten berechnet separat seinen eigenen Teil der Hauptfunktion. Die Variablen werden auf den Parameterservern erstellt und in jedem Schritt von den Client- oder Worker-Knoten geteilt und aktualisiert.

In Kapitel 8 wird diese Strategie im Detail besprochen, mit Codebeispielen, die die Nutzung dieser Topologie mit TensorFlow veranschaulichen.

Zentralisierte, verteilte Ausbildung in einer P2P-Topologie

In einer Peer-to-Peer-Topologie gibt es keine Client- und Server-Rollen. Alle Knoten können mit allen anderen Knoten kommunizieren, und jeder Knoten hat seine eigene Kopie der Parameter. Dies ist nützlich, um die Datenparallelität zu nutzen, wenn es eine feste Anzahl von Parametern gibt, die in den Speicher der Knoten passen, die Logik selbst sich nicht ändert und die Knoten ihre Ergebnisse in einer Peer-to-Peer-Weise teilen können. Gossip Learning ist ein Beispiel für eine Methode, die diesen Ansatz verwendet. Jeder Knotenpunkt berechnet sein Modell auf der Grundlage des ihm zur Verfügung stehenden Datensatzes und ruft unabhängig davon seine Peers im Netzwerk an, um sein Modell mit ihnen zu teilen. Die Knoten kombinieren dann jeweils ihr aktuelles Modell mit den Modellen ihrer Nachbarn. Wie bei Entscheidungsbäumen in einer dezentralen Einsatzumgebung sollte diese Topologie durch Zeitbeschränkungen eingeschränkt werden und die maximale Anzahl der Kanten, an die jeder Knoten die Informationen weitergibt, sollte festgelegt werden. Mit der P2P-Topologie kannst du auch ein Protokoll wie MPI festlegen, um die Arbeitslast zu standardisieren .

Die Herausforderungen verteilter maschineller Lernsysteme

Rom wurde nicht an einem Tag erbaut, aber sie haben jede Stunde Ziegelsteine gelegt.

-John Heywood

Obwohl du gerade erst mit dem verteilten maschinellen Lernen beginnst, ist es wichtig, dass du dir einiger der Herausforderungen bewusst bist, die vor dir liegen. Die Arbeit mit verteiltem maschinellem Lernen unterscheidet sich deutlich von der Entwicklung von maschinellem Lernen, das auf einem einzigen Rechner läuft, und letztendlich liegt es in deiner Verantwortung, ein System zu entwickeln, das die festgelegten Anforderungen erfüllt. Erfahrene Praktiker/innen werden dir jedoch sagen, dass alle Anforderungen verhandelbar sind und was fehlschlagen kann, wird auch fehlschlagen. Beides ist wahr und sollte bei der Abwägung deiner Bemühungen während des gesamten Prozesses beachtet werden.

Leistung

Die Verbesserung der Leistung ist das grundlegende Ziel der Implementierung eines verteilten Systems. Ein höherer Durchsatz und eine schnellere Durchführung von End-to-End-Berechnungen für maschinelles Lernen sind wichtige Argumente für verteilte maschinelle Lernsysteme. Es gibt viele Ansätze, um die Leistung zu verbessern, abhängig von deinem Ziel, deinen Daten und dem Verhalten deines Systems. Werfen wir einen Blick auf einige der Dinge, die du berücksichtigen solltest, und auf einige Probleme, mit denen du wahrscheinlich konfrontiert wirst.

Datenparallelität versus Modellparallelität

In der Informatik Wissenschaft geht verteiltes Rechnen oft Hand in Hand mit parallelem Rechnen. Paralleles Rechnen auf einem einzelnen Knoten/Computer bedeutet, dass die mehreren Prozessoren dieses Knotens genutzt werden, um verschiedene Aufgaben gleichzeitig zu erledigen. Dies wird auch als task-parallele Verarbeitung bezeichnet. Im Vergleich dazu bedeutet paralleles Rechnen im Kontext des verteilten Rechnens, dass zahlreiche Knotenpunkte zur Ausführung von Aufgaben genutzt werden, wobei jeder Knotenpunkt parallel arbeitet. Wenn wir über verteiltes Rechnen sprechen, ist paralleles Rechnen eine Selbstverständlichkeit und wird nicht explizit erwähnt.

Eine der wichtigsten Quellen für Verwirrung, wenn es um verteiltes maschinelles Lernen geht, ist das Fehlen einer klaren Vorstellung davon, was genau auf die Knotenpunkte verteilt wird. Im Workflow/Lebenszyklus des maschinellen Lernens verarbeitest du deine Daten vor, führst ein Feature Engineering durch, um relevante Merkmale zu extrahieren, reicherst die Daten an und gibst sie schließlich zusammen mit einer Reihe von Hyperparametern (Parameter, deren Werte zur Steuerung des Lernprozesses verwendet werden, auch bekannt als Tuning-Parameter des maschinellen Lernalgorithmus) in deinen Algorithmus ein. Während des Lernprozesses werden die Werte/Daten von den Hyperparametern beeinflusst. Daher ist es empfehlenswert, eine Vielzahl von Hyperparametern auszuprobieren, um sicherzustellen, dass du das bestmögliche Modell für den Einsatz in der Produktion findest.

Der Umgang mit einer großen Datenmenge und einer großen Anzahl von Tuning-Parametern wirft die Frage auf, wie du deine Ressourcen und den Trainingsprozess effizient verwalten kannst. Generell gibt es zwei Ansätze, um Algorithmen für maschinelles Lernen in großem Maßstab zu trainieren. Du kannst denselben Algorithmus mit denselben Hyperparametern auf allen Knotenpunkten duplizieren, wobei jede Maschine dieselbe Logik auf ihrem eigenen Teil der Daten ausführt. Umgekehrt kann jeder Knotenpunkt einen anderen Teil des Algorithmus auf denselben Datensatz anwenden. Abbildung 1-3 veranschaulicht den Unterschied zwischen diesen Ansätzen: Bei der Datenparallelität werden die Daten in Scherben oder Partitionen aufgeteilt und diese Partitionen werden auf die Knoten verteilt, während bei der Modellparallelität das Modell selbst in Teile aufgeteilt und auf die Maschinen verteilt wird.

Abbildung 1-3. Datenparallelität und Modellparallelität

Bei der Datenparallelität führt jeder Knoten die gleiche Berechnungslogik aus, was bedeutet, dass auch der Code auf die Knoten verteilt werden muss. Die Dateneingabe ändert sich von Knotenpunkt zu Knotenpunkt, aber alle Knotenpunkte führen denselben Code aus, wie in Abbildung 1-4 dargestellt.

Abbildung 1-4. Datenparallelität: Dieselbe Logik wird auf alle Maschinen verteilt, und jede Maschine führt die Logik mit ihren lokalen Daten aus

Bei der Modellparallelität führen mehrere Knoten jeweils verschiedene Teile des Algorithmus für maschinelles Lernen aus, und die verteilten Ergebnisse werden dann zu dem Modell selbst zusammengefügt. Dieser Ansatz eignet sich für Algorithmen, die parallelisiert werden können, indem sie in einem gerichteten azyklischen Graphen dargestellt werden, bei dem die Eckpunkte die Berechnungen und die Kanten den Datenfluss darstellen.

Eine Herausforderung bei der Bereitstellung eines bestehenden Modells ist, dass das Modell selbst manchmal nicht in den Speicher eines Rechners passt und angepasst werden muss, um optimal bereitgestellt zu werden. Denke an die Random-Forest-Ensemble-Methode. Es kann sein, dass der gesamte Wald in den Speicher eines einzelnen Rechners passt, aber was ist, wenn der Wald aus Milliarden von Bäumen besteht? Eine Option (für die spezielle Tools und Hardware erforderlich sind) besteht darin, das Modell in Teilmengen aufzuteilen und jede Teilmenge auf einem anderen Rechner zu platzieren, wobei die Rechner auf eine genau definierte Weise miteinander kommunizieren, um das Modell effizient zu bedienen. Dieser Ansatz wird häufig von Deep-Learning-Frameworks wie PyTorch und TensorFlow verwendet.

Kombination von Datenparallelität und Modellparallelität

Die Kombination von Daten- und Modellparallelität ist alles andere als einfach. Das liegt an der Beschaffenheit der vorhandenen Open-Source-Tools und an der Komplexität des Aufbaus eines eigenen Systems, das beide nutzen kann. Doch während wir uns in der Vergangenheit zwischen Datenparallelitätstools wie Apache Spark und Modellparallelitätstools wie PyTorch entscheiden mussten, unterstützen sich heute viele dieser Tools gegenseitig, entweder nativ oder durch Erweiterungen wie Petastorm, Horovod und andere.

Die Notwendigkeit, beide Arten der Parallelität zu kombinieren, kann sich erheblich darauf auswirken, wie lange es dauert, ein neues Modell zu erstellen, es zu bedienen und für Vorhersagen zu nutzen. GPT-3 (Generative Pre-trained Transformer 3), ein von OpenAI entwickeltes Modell, nutzt beispielsweise Deep Learning, um menschenähnlichen Text zu erzeugen. Bei seiner maximalen Kapazität von 175 Milliarden Parametern würde es schätzungsweise 355 Jahre dauern und 4,6 Millionen Dollar kosten, dieses Modell mit einem Tesla v100 Grafikprozessor zu trainieren. Für die meisten Unternehmen ist das selbst bei einer viel geringeren Anzahl von Parametern eine teure und extrem langsame Option. Außerdem braucht es mehrere Versuche, um geeignete Hyperparameter zu finden, die zu genauen Ergebnissen führen. Wir werden in diesem Buch nicht weiter auf dieses GPT-3 eingehen, aber es ist wichtig zu wissen, dass es existiert .

Deep Learning

Deep Lernalgorithmen stellen eine besondere Herausforderung für die verteilte maschinelle Lernleistung dar. Deep Learning basiert auf einem künstlichen neuronalen Netzwerk (ANN) mit Feature-Learning, was bedeutet, dass das System die Features automatisch aus den Rohdaten entdeckt. Das Training eines Deep-Learning-Modells erfordert Vorwärtsberechnungen und/oder Rückwärtspropagation. Bei der Vorwärtsberechnung werden die Daten in das neuronale Netz (NN) eingespeist, um das Ergebnis zu berechnen. Bei der Rückwärtspropagation ( Backpropagation) wird der "Verlust" der Genauigkeit rückwärts durch die Schichten in das neuronale Netz eingespeist, um zu verstehen, wie viel von diesem Verlust auf jeden Knoten entfällt, und um die Gewichte der Schichten des neuronalen Netzes entsprechend zu aktualisieren. Vereinfacht kann man sich das so vorstellen, dass Ungenauigkeiten in das Modell zurückgespeist werden, um sie zu korrigieren.

Sowohl die Vorwärtsberechnung als auch die Backpropagation erfordern von Natur aus eine sequenzielle Berechnung. Jede Schicht oder Stufe muss auf die Eingabe der vorherigen Stufe warten. Wir können zwar jede Stufe für sich verteilen, aber das Modelltraining als Ganzes ist sequentiell. Daher brauchen wir eine Orchestrierung, um eine Reihenfolge oder eine Art automatisierte Pipeline während der Ausbildung zu erzwingen. Ein Zeitplanungsalgorithmus, mit dem wir verteilte Deep Learning-Workloads ausführen können, ist das Gang Scheduling. Basierend auf diesem Algorithmus hat die Community in Apache Spark 2.4 den Barrier Execution Mode eingeführt, der es uns ermöglicht, Gruppen von Maschinen zu bilden, die gemeinsam an einer Phase arbeiten und erst dann zur nächsten Phase übergehen, wenn alle fertig sind. Der Barriere-Ausführungsmodus ist Teil des Projekts Hydrogen, das eine größere Vielfalt an verteilten Machine-Learning-Workloads auf dem universellen Apache Spark-Framework ermöglichen soll.

Ressourcenmanagement

Die Entscheidung über die Aufteilung der Cluster-Ressourcen ist eine der größten Herausforderungen in einem verteilten System. Wenn dann noch verteilte Machine Learning Workloads hinzukommen, wird es noch komplizierter. Der Grund dafür ist die Notwendigkeit, die Leistung zu verbessern, indem die Software mit spezieller Hardware gekoppelt wird. Dabei geht es nicht nur um GPUs oder CPUs - heute stellen Intel, NVIDIA, Google und andere Unternehmen Maschinen her, die mit speziellen Hardware-Chips für KI ausgestattet sind. Diese KI-Beschleuniger sind für hochleistungsfähige, massiv-parallele Berechnungen ausgelegt, die über die traditionellen Threading-Algorithmen hinausgehen. Außerdem werden viele Algorithmen für maschinelles Lernen immer noch weiterentwickelt. Das ist der Grund, warum Microsoft im Rahmen des Project Catapult FPGA-Chips (Field-Programmable Gate Array) in seine Cloud integriert hat, um schnelle Echtzeit-KI für Deep Learning zu ermöglichen. FPGAs haben ein rekonfigurierbares Design, das es einfacher macht, die Hardware nach Software-Updates nach Bedarf anzupassen.

Die gemeinsame Nutzung von Ressourcen ist auch in einer verteilten Umgebung eine Herausforderung, wenn es konkurrierende Arbeitsbelastungen gibt. Wenn 10 Maschinen benötigt werden, aber nur 5 zur Verfügung stehen, kann die Software entweder das nutzen, was sie hat, oder darauf warten, dass mehr Maschinen verfügbar werden. Dadurch entsteht ein Engpass, der zu großen Problemen führen kann. Stell dir ein Szenario vor, in dem du maschinelles Lernen in einer Produktionsumgebung trainierst, um Ressourcen zu sparen, und deine Trainingsworkloads mit den Echtzeitworkloads deines Produkts um Ressourcen konkurrieren. An diesem Punkt könntest du Probleme mit deinen Kunden bekommen. Deshalb ist es am besten, wenn du mehrere Umgebungen für kritische Workloads und langfristige/offline Workloads hast. Was aber, wenn dein Modell kritisch ist und du durch das Training mit frischen Daten einen unvorhergesehenen Echtzeittrend in der Branche entdecken könntest (und wenn du diesen verpasst, könnte das zu Umsatzeinbußen führen)? Möglicherweise musst du zwei Umgebungen für kritische Workloads unterhalten, was jedoch kostspielig sein kann und zu einer geringen Kapitalrendite (ROI) führt.

Die Rekonfiguration und die gemeinsame Nutzung von Ressourcen sind nur ein Teil des Problems. Eine weitere Herausforderung besteht darin, die Entscheidung zu automatisieren, wann GPUs und wann CPUs oder FPGAs und andere auf dem Markt erhältliche Hardwareoptionen eingesetzt werden sollen. Mit der Cloud und einem ausreichenden Budget können wir all die Hardware bekommen, die wir brauchen, aber auch hier müssen wir über den ROI nachdenken. Was sollen wir tun? Wie können wir diese Entscheidung automatisieren? Es gibt noch keine endgültige Antwort auf diese Frage, aber die gute Nachricht ist, dass immer mehr Software- und Hardwarelösungen sich gegenseitig unterstützen. Unter hat NVIDIA zum Beispiel RAPIDS entwickelt, eine Reihe von Open-Source-Bibliotheken, die auf den NVIDIA CUDA-Prozessoren aufsetzen. CUDA ermöglicht die GPU-Beschleunigung von Data Science-Prozessen. Mit der Unterstützung von RAPIDS für Apache Spark 3.0, das nicht nur Data Science Workloads, sondern auch ETL/Datenaufbereitung beschleunigt, können wir potenziell einen Cluster aufbauen, der sowohl die Datenaufbereitung als auch das Modelltraining und -serving unterstützt und so einen automatischen Ressourcenwechsel überflüssig macht (auch wenn die Frage nach dem ROI bleibt).

Fehlertoleranz

Fehlertoleranz sorgt dafür, dass ein verteiltes System im Falle eines Ausfalls weiterhin ordnungsgemäß funktioniert. Beim verteilten maschinellen Lernen können Ausfälle zwei Formen annehmen:

  • Typischer Ausfall einer Maschine, der erkannt und abgemildert werden kann

  • Unentdeckter Ausfall einer Maschine, die eine schlechte Leistung produziert

Beginnen wir mit der ersten. Um die Notwendigkeit eines fehlertoleranten Verfahrens besser zu verstehen, frage dich: Wenn wir unsere Arbeitslast auf einen Cluster mit 1.000 Rechenknoten verteilen, was passiert dann, wenn einer dieser Knoten ausfällt? Gibt es eine andere Möglichkeit, den Fehler zu beheben, als den Auftrag von Anfang an neu zu starten?

Wenn eine der Phasen fehlschlägt, müssen wir dann alles neu berechnen? Die Antwort ist nein. Heutzutage haben viele Frameworks für verteilte Berechnungen ein eingebautes Verfahren für Fehlertoleranz: Sie erreichen dies, indem sie die Daten replizieren und Informationen zwischen den Phasen auf die Festplatte schreiben, um die Wiederherstellung zu beschleunigen. Andere Frameworks überlassen es uns, diesen Mechanismus zu definieren. Wenn zum Beispiel bei TensorFlow mit synchronem Training einer der Worker ausfällt und wir kein Verfahren zur Fehlertoleranz vorgesehen haben, wird der gesamte Cluster fehlschlagen. Deshalb müssen wir bei der Entscheidung über die TensorFlow-Verteilungsstrategie auf den Fehlertoleranzmechanismus achten. Apache Spark hingegen legt uns diese Entscheidung nicht offen. Vielmehr verfügt es über einen eingebauten, versteckten Mechanismus, den wir nicht über die API für maschinelles Lernen selbst beeinflussen können. Wenn wir uns an den automatischen Mechanismus für die Fehlertoleranz von datenparallelen Workloads in Spark halten, sparen wir eine Menge Zeit, weil wir nicht über mögliche Fehlerfälle und Lösungen nachdenken müssen.

Die zweite Art von Fehlern ist spezifisch für das verteilte maschinelle Lernen, da sie sich direkt auf die Leistung des maschinellen Lernalgorithmus selbst auswirkt. In diesem Fall können wir uns das so vorstellen, als hätten wir eine byzantinische Gegenmaschine oder einen absichtlich oder unabsichtlich fehlerhaften Agenten. Fehlerhafte Agenten (oder Widersacher) können die Leistung des maschinellen Lernmodells beeinträchtigen, indem sie fehlerhafte Daten preisgeben. Es ist schwer, ein solches Verhalten abzuschwächen, und die Auswirkungen hängen stark von dem verwendeten Algorithmus ab. Die Erkennung solcher Fehler ist ein Grund, warum es wichtig ist, Modelle für maschinelles Lernen zu überwachen, wie in Kapitel 10 beschrieben.

Datenschutz

Die Diskussionen über den Datenschutz beim maschinellen Lernen konzentrieren sich im Allgemeinen auf den Schutz der von den Nutzern/Kunden gesammelten Daten oder den Schutz des Modells und der Parameter selbst. Das Modell und seine Parameter können das geistige Eigentum des Unternehmens sein, und es kann wichtig sein, sie geheim zu halten (zum Beispiel in einem Finanzmarktsystem).

Eine Möglichkeit, den Datenschutz durchzusetzen, besteht darin, die Einschränkungen der Zentralisierung von Daten zu vermeiden. Das heißt, wir wollen ein Modell erstellen, ohne die Trainingsdaten der Mitglieder auf zentrale Server hochzuladen. Zu diesem Zweck können wir Techniken wie das föderierte Lernen nutzen. Bei diesem Ansatz trainieren wir den Algorithmus auf den Kantengeräten, wobei jedes Gerät seine eigenen Daten verwendet. Die Geräte tauschen dann jeweils eine Zusammenfassung des von ihnen erstellten Modells mit anderen Geräten oder einem speziellen Server aus. Dieser Ansatz ist jedoch nicht narrensicher. Während des Trainings kann ein Angreifer in den Besitz einiger oder aller Daten oder der Ergebnisse des Trainings gelangen. Das kann beim föderierten Lernen leicht passieren, wenn der Angreifer über seine Kantengeräte aktiv am Trainingsprozess teilnimmt.

Nehmen wir an, wir haben einen Weg gefunden, die Daten sicher zu zentralisieren oder die Modelle zu trainieren, ohne dies zu tun. Es besteht immer noch die Möglichkeit, dass ein böswilliger Akteur Informationen über die Daten (Statistiken über eine bestimmte Population, Klassifizierungsklassen und mehr), die wir zum Trainieren des Modells verwendet haben, durch Interaktion mit dem Modell selbst auslesen kann. Wie du wahrscheinlich schon gemerkt hast, gibt es keine Einheitslösung, wenn es darum geht, den Datenschutz beim maschinellen Lernen zu gewährleisten - es sind spezielle Technologien und Architekturen erforderlich. Obwohl der Datenschutz beim verteilten maschinellen Lernen ein faszinierendes, aber auch umfangreiches Thema ist, werden wir es in diesem Buch nicht weiter behandeln.

Tragbarkeit

Die Portabilität steht im Zusammenhang mit den allgemeinen Herausforderungen eines verteilten Systems. Wenn wir dedizierte Computerhardware, wie z. B. mehrere Arten von Grafikprozessoren, zusammen mit der von uns entwickelten Software einsetzen, wird es schwieriger, die Arbeitslasten von einem Cluster auf einen anderen zu übertragen. In den Anfängen der Cloud nutzten viele Unternehmen die "Lift and Shift"-Migrationsstrategie und verlagerten ihre Arbeitslasten und Anwendungen in die Cloud, ohne sie neu zu gestalten. In vielen Fällen führte dies jedoch zu höheren Kosten, da sie die Funktionen der Umgebung nicht nutzten. In der Cloud wurden nämlich native Funktionen mit Optimierungen für bestimmte Arbeitslasten entwickelt. Das Gleiche passiert bei einem verteilten Ansatz für maschinelles Lernen: Die verschiedenen verfügbaren Hardwaretypen, die Anforderungen und die Notwendigkeit, den ROI durch die Senkung der Entwicklungs-, Speicher- und Rechenkosten zu verbessern, können sich auf die Portabilität auswirken.

Es gibt noch weitere Herausforderungen, die verteilten Systemen innewohnen, die nicht direkt mit maschinellem Lernen zu tun haben, aber dennoch Auswirkungen auf maschinelles Lernen haben können, wie z.B. Trust- oder Zero-Trust-Systeme, Netzwerk-Overhead, Sicherstellung der Konsistenz und mehr. Wir werden diese Themen in diesem Buch nicht behandeln, aber du solltest sie bei der Entwicklung deiner Produktstrategie berücksichtigen.

Einrichten deiner lokalen Umgebung

Jetzt du die Landschaft besser verstehst, machen wir dich fit für den Erfolg! Viele der Codebeispiele in diesem Buch stehen dir im GitHub-Repository des Buches zur Verfügung. Um praktische Erfahrungen mit ihnen zu sammeln, solltest du eine Lernumgebung einrichten, die du lokal auf deinem Rechner ausführen kannst.

Du solltest diesen Einrichtungsprozess zweimal durchlaufen, zuerst für die Tutorials in den Kapiteln 2-6 und dann für die Tutorials in den Kapiteln 7-10.

Kapitel 2-6 Tutorials Umgebung

Um zusammen mit den Tutorials in den Kapiteln 2 bis 6 zu folgen, stelle sicher, dass du die neueste Version von Docker auf deinem Rechner installiert hast und befolge diese Schritte:

  1. Starte Docker.

  2. Führe in einem Terminalfenster/einer Kommandozeile den folgenden Befehl aus:

    $ docker run -it -p 8888:8888 adipolak/ml-with-apache-spark

    Hier siehst du das Bild eines PySpark Jupyter-Notizbuchs mit Apache Spark 3.1.1, das die meisten der Bibliotheken enthält, die wir verwenden werden. Wie du den Rest hinzufügst, erfährst du später. Nachdem du diesen Befehl ausgeführt hast, erhältst du eine Antwort wie diese:

    [I 13:50:03.885 NotebookApp] Serving notebooks from local directory: 
/home/jovyan
[I 13:50:03.885 NotebookApp] Jupyter Notebook 6.3.0 is running at:
[I 13:50:03.885 NotebookApp] http://6cb805089793:8888/?token=e14171684af
c305b4702cbda99ae879d3faecf5db6bea37d
[I 13:50:03.885 NotebookApp] or http://127.0.0.1:8888/?token=e14171684af
c305b4702cbda99ae879d3faecf5db6bea37d
[I 13:50:03.885 NotebookApp] Use Control-C to stop this server and shut 
down all kernels (twice to skip confirmation).
[C 13:50:03.891 NotebookApp]

    To access the notebook, open this file in a browser:
        file:///home/jovyan/.local/share/jupyter/runtime/nbserver-8-open
		.html
    Or copy and paste one of these URLs:
        http://6cb805089793:8888/?token=e14171684afc305b4702cbda99ae879d
		3faecf5db6bea37d
     or http://127.0.0.1:8888/?token=e14171684afc305b4702cbda99ae879d3fa
	 ecf5db6bea37d
^C[I 13:50:27.037 NotebookApp] interrupted
Serving notebooks from local directory: /home/jovyan
0 active kernels
Jupyter Notebook 6.3.0 is running at:
http://6cb805089793:8888/?token=e14171684afc305b4702cbda99ae879d3faecf5d
b6bea37d
 or
http://127.0.0.1:8888/?token=e14171684afc305b4702cbda99ae879d3faecf5db6b
ea37d
    Tipp

    Du bekommst eine Fehlermeldung über AMD? Verwende stattdessen diesen Befehl:

    $ docker run -p 8888:8888 \ 
	adipolak/amd-ml-with-apache-spark

  3. Kopiere die letzte URL mit dem Parameter token. Sie wird in etwa so aussehen, aber du wirst dein eigenes Token haben:

    http://127.0.0.1:8888/?token=43143a485357351ef522a1840f8c8c141a1be2bcf5f
9b4de

    Füge sie in deinen Browser ein. Dies wird deine Jupyter-Tutorial-Umgebung sein.

  4. Klone oder lade das Repo des Buches herunter.

  5. Extrahiere (entpacke) die Dateien und lade die Notizbücher und Datendateien über die Schaltfläche Hochladen in Jupyter hoch (siehe Abbildung 1-5).

Abbildung 1-5. Schaltfläche Jupyter Upload

Das pyspark-notebook Docker-Image ist in diesem Stadium sehr einfach: Es enthält lediglich Jupyter und PySpark, die wichtigsten Werkzeuge, die in diesem Buch verwendet werden. Abbildung 1-6 zeigt, wie die Images in Jupyter Docker Stacks gestapelt werden.

Abbildung 1-6. Jupyter Docker Stacks Bilder

Kapitel 7-10 Tutorials Umgebung

Für die Tutorien in den Kapiteln 7-10 benötigst du PySpark, PyTorch, Petastorm, TensorFlow und alles, was mit dem Erstellen, Bereitstellen und Ausliefern des Lebenszyklus von Machine Learning zu tun hat. Um eine Umgebung für diese Kapitel einzurichten, kannst du dieselben Schritte befolgen, die im vorherigen Abschnitt beschrieben wurden. Um mit PyTorch zu arbeiten, musst du es direkt über das Jupyter-Terminal installieren. Abbildung 1-7 zeigt dir, wie du das mit dem folgenden conda-Befehl unter macOS machst (beachte, dass du während dieses Prozesses möglicherweise aufgefordert wirst, einige Fragen zur Installation zu beantworten):

$ conda install pytorch==1.12.1 torchvision==0.13.1 -c pytorch
Abbildung 1-7. Installation von PyTorch in deiner Umgebung

Für die Tutorials in diesen Kapiteln benötigst du möglicherweise zusätzliche Ressourcen - zum Beispiel mehr Arbeitsspeicher für eine schnellere Ausführung. Um dies zu konfigurieren, kannst du den Befehl docker mit den Tags --memory und --memory-swap verwenden. Achte darauf, dass du die Mengen entsprechend den Möglichkeiten deines Computers festlegst:

$ sudo docker run -it --memory="16g" --memory-swap="24g" -p 8888:8888 \ 
	adipolak/amd-ml-with-apache-spark

Zusammenfassung

In diesem Kapitel haben wir die Grundlagen des verteilten maschinellen Lernens behandelt und eine Reihe komplexer Themen gestreift: maschinelle Lernabläufe, verteilte Rechenmodelle, Netzwerktopologien, verteiltes Training und Serving und vieles mehr. Wie du weißt, unterstützt Apache Spark die parallele Datenverarbeitung auf Clustern oder Computerprozessoren in Echtzeit. Das Framework basiert auf dem MapReduce-Paradigma, das zahlreiche Vorteile hat, wenn es um die Verarbeitung von Daten, Analysen und Algorithmen für maschinelles Lernen geht. Es hat jedoch auch einige Einschränkungen, insbesondere im Hinblick auf Deep Learning Workloads (deshalb zeige ich dir in Kapitel 7, wie du eine Brücke von Spark zu Deep Learning Frameworks schlagen kannst).

Das nächste Kapitel bietet eine kurze Einführung in PySpark, um dich auf den neuesten Stand zu bringen oder dir zu helfen, die Grundlagen aufzufrischen. In Kapitel 3 lernst du das Lebenszyklusmanagement für maschinelles Lernen mit MLflow kennen und erfährst, wie du deine Experimente verpacken kannst, damit du den Tutorials im Rest des Buches folgen kannst. In den Kapiteln 4, 5 und 6 lernst du, wie du PySpark für deine Bedürfnisse beim maschinellen Lernen nutzen kannst.

1 Je nachdem, wie du es definierst, begann diese Ära der Informatikgeschichte entweder 2012 oder 2016 - die geschätzte Menge an digitalen Daten auf der Welt überstieg 2012 ein Zettabyte, und Cisco Systems gab bekannt, dass der weltweite IP-Verkehr 2016 1,2 Zettabyte erreichte.

2 Die Bandbreite gibt an, wie viele Daten über eine Netzwerkverbindung in einer bestimmten Zeit über eine kabelgebundene oder drahtlose Verbindung übertragen werden können.

3 Wenn die Varianz des Modells gering ist, liegen die Stichprobendaten nahe an dem, was das Modell vorhergesagt hat. Ist die Varianz hoch, schneidet das Modell bei den Trainingsdaten gut ab, aber nicht bei den neuen Daten.

Get Skalierung von Machine Learning mit Spark 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