Kapitel 1. Big Data analysieren

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

Wenn die Leute sagen, dass wir im Zeitalter von Big Data leben, meinen sie damit, dass wir über Werkzeuge verfügen, mit denen wir Informationen in einem bisher ungekannten Ausmaß sammeln, speichern und verarbeiten können. Die folgenden Aufgaben hätten vor 10 oder 15 Jahren einfach nicht bewältigt werden können:

  • Erstelle ein Modell zur Erkennung von Kreditkartenbetrug anhand von Tausenden von Merkmalen und Milliarden von Transaktionen

  • Intelligente Empfehlungen für Millionen von Produkten für Millionen von Nutzern

  • Schätze das finanzielle Risiko durch Simulationen von Portfolios, die Millionen von Instrumenten umfassen

  • Genomische Daten von Tausenden von Menschen einfach bearbeiten, um genetische Zusammenhänge mit Krankheiten zu erkennen

  • Bewertung der landwirtschaftlichen Bodennutzung und der Ernteerträge für eine bessere Politikgestaltung durch die regelmäßige Verarbeitung von Millionen von Satellitenbildern

Hinter diesen Fähigkeiten steht ein Ökosystem von Open-Source-Software, die Servercluster zur Verarbeitung riesiger Datenmengen nutzen kann. Die Einführung/Veröffentlichung von Apache Hadoop im Jahr 2006 hat zu einer weit verbreiteten Nutzung des verteilten Rechnens geführt. Das Big-Data-Ökosystem und die Tools haben sich seitdem rasant weiterentwickelt. In den letzten fünf Jahren wurden auch viele Open-Source-Bibliotheken für maschinelles Lernen (ML) und Deep Learning eingeführt und genutzt. Diese Tools zielen darauf ab, die riesigen Datenmengen zu nutzen, die wir heute sammeln und speichern.

Aber genau wie ein Meißel und ein Steinblock keine Statue ergeben, gibt es eine Lücke zwischen dem Zugang zu diesen Werkzeugen und all diesen Daten und der Möglichkeit, etwas Nützliches daraus zu machen. Oft bedeutet "etwas Nützliches tun", ein Schema über Tabellendaten zu legen und SQL zu verwenden, um Fragen zu beantworten wie: "Wie viele der unzähligen Nutzer, die es bis zur dritten Seite unseres Registrierungsprozesses geschafft haben, sind älter als 25 Jahre?" Es gibt viele Möglichkeiten, die Speicherung und Organisation von Daten (Data Warehouses, Data Lakes usw.) so zu gestalten, dass solche Fragen leicht zu beantworten sind, aber in diesem Buch werden wir die Feinheiten weitgehend vermeiden.

Manchmal erfordert "etwas Nützliches zu tun" ein wenig zusätzliche Arbeit. SQL mag zwar immer noch das Herzstück des Ansatzes sein, aber um Eigenheiten in den Daten zu umgehen oder komplexe Analysen durchzuführen, brauchen wir ein flexibleres Programmierparadigma mit umfangreicheren Funktionen in Bereichen wie maschinelles Lernen und Statistik. Hier kommt die Datenwissenschaft ins Spiel, über die wir in diesem Buch sprechen werden.

In diesem Kapitel führen wir zunächst in das Konzept von Big Data ein und erörtern einige der Herausforderungen, die bei der Arbeit mit großen Datensätzen auftreten. Anschließend stellen wir Apache Spark, ein Open-Source-Framework für verteiltes Rechnen, und seine wichtigsten Komponenten vor. Unser Schwerpunkt liegt auf PySpark, der Python-API von Spark, und wie sie sich in ein größeres Ökosystem einfügt. Anschließend werden wir die Änderungen von Spark 3.0 besprechen, der ersten größeren Version des Frameworks seit vier Jahren. Zum Schluss werden wir kurz darauf eingehen, wie PySpark die Herausforderungen der Datenwissenschaft meistert und warum es eine großartige Ergänzung deines Kompetenzspektrums ist.

In früheren Ausgaben dieses Buches wurde die Scala-API von Spark für Codebeispiele verwendet. Wir haben uns entschieden, stattdessen PySpark zu verwenden, weil Python in der Data-Science-Community so beliebt ist und das Spark-Kernteam sich verstärkt um eine bessere Unterstützung der Sprache bemüht. Am Ende dieses Kapitels wirst du diese Entscheidung sicher zu schätzen wissen.

Arbeiten mit Big Data

Viele unserer bevorzugten Tools für kleine Daten stoßen bei der Arbeit mit großen Daten an ihre Grenzen. Bibliotheken wie Pandas sind nicht in der Lage, mit Daten umzugehen, die nicht in unseren Arbeitsspeicher passen. Wie sollte dann ein gleichwertiger Prozess aussehen, der Cluster von Computern nutzen kann, um bei großen Datensätzen die gleichen Ergebnisse zu erzielen? Die Herausforderungen des verteilten Rechnens erfordern, dass wir viele der grundlegenden Annahmen überdenken, auf die wir uns bei Systemen mit nur einem Knoten verlassen. Da die Daten auf viele Knoten in einem Cluster verteilt werden müssen, leiden Algorithmen mit großen Datenabhängigkeiten unter der Tatsache, dass die Netzwerkübertragungsraten um Größenordnungen langsamer sind als die Speicherzugriffe. Je mehr Rechner an einem Problem arbeiten, desto höher ist die Wahrscheinlichkeit eines Ausfalls. Diese Tatsachen erfordern ein Programmierparadigma, das auf die Eigenschaften des zugrundeliegenden Systems eingeht: ein Paradigma, das schlechte Entscheidungen verhindert und es einfach macht, Code zu schreiben, der hochgradig parallel ausgeführt werden kann.

Single-Machine-Tools, die in letzter Zeit in der Software-Gemeinschaft an Bedeutung gewonnen haben, sind nicht die einzigen Werkzeuge, die für die Datenanalyse verwendet werden. Wissenschaftliche Bereiche wie die Genomik, die mit großen Datenmengen arbeiten, nutzen schon seit Jahrzehnten parallele Rechnerumgebungen. Die meisten, die heute in diesen Bereichen Daten verarbeiten, sind mit einer Cluster-Computing-Umgebung vertraut, die HPC (High-Performance Computing) genannt wird. Während die Schwierigkeiten mit Python und R in ihrer mangelnden Skalierbarkeit liegen, liegen die Schwierigkeiten mit HPC in der relativ geringen Abstraktionsebene und der schwierigen Nutzung. Um zum Beispiel eine große Datei mit DNA-Sequenzierungs-Reads parallel zu verarbeiten, müssen wir sie manuell in kleinere Dateien aufteilen und für jede dieser Dateien einen Auftrag an das Zeitplannungsprogramm des Clusters senden. Wenn einige dieser Jobs fehlschlagen, muss der Benutzer den Fehler erkennen und sie manuell erneut einreichen. Wenn die Analyse alle Operationen erfordert, wie z. B. das Sortieren des gesamten Datensatzes, muss der große Datensatz über einen einzigen Knoten gestreamt werden, oder der Wissenschaftler muss auf verteilte Frameworks auf niedrigerer Ebene wie MPI zurückgreifen, die ohne umfassende Kenntnisse in C und verteilten/vernetzten Systemen schwer zu programmieren sind.

Tools, die für HPC-Umgebungen entwickelt wurden, schlagen oft fehl, um die In-Memory-Datenmodelle von den darunter liegenden Speichermodellen zu entkoppeln. Viele Tools wissen zum Beispiel nur, wie man Daten aus einem POSIX-Dateisystem in einem einzigen Stream liest, was es schwierig macht, Tools auf natürliche Weise zu parallelisieren oder andere Speicher-Backends wie Datenbanken zu nutzen. Moderne Frameworks für verteiltes Rechnen bieten Abstraktionen, die es den Nutzern ermöglichen, einen Cluster von Computern eher wie einen einzelnen Computer zu behandeln - um Dateien automatisch aufzuteilen und die Speicherung auf viele Rechner zu verteilen, die Arbeit in kleinere Aufgaben aufzuteilen und diese verteilt auszuführen und sich von Ausfällen zu erholen. Sie können einen Großteil der Arbeit mit großen Datenmengen automatisieren und sind viel billiger als HPC.

Eine einfache Art, sich verteilte Systeme vorzustellen, ist, dass es sich um eine Gruppe von unabhängigen Computern handelt, die für den Endbenutzer wie ein einziger Computer erscheinen. Sie ermöglichen eine horizontale Skalierung. Das bedeutet, dass mehr Computer hinzugefügt werden, anstatt ein einzelnes System aufzurüsten (vertikale Skalierung). Letzteres ist relativ teuer und reicht oft nicht aus, um große Arbeitslasten zu bewältigen. Verteilte Systeme eignen sich hervorragend für Skalierung und Zuverlässigkeit, bringen aber auch Komplexität mit sich, wenn es um Design, Aufbau und Fehlersuche geht. Man sollte diesen Kompromiss verstehen, bevor man sich für ein solches Tool entscheidet.

Einführung in Apache Spark und PySpark

Apache Spark ( ) ist ein Open-Source-Framework, das eine Engine für die Verteilung von Programmen über Cluster von Rechnern mit einem eleganten Modell für das Schreiben von Programmen auf dieser Engine kombiniert. Spark wurde an der University of California, Berkeley, im AMPLab entwickelt und ist seitdem in die Apache Software Foundation eingeflossen. Als es veröffentlicht wurde, war es wohl die erste Open-Source-Software, die verteilte Programmierung für Datenwissenschaftler/innen wirklich zugänglich machte.

Komponenten

Abgesehen von der Kernberechnungs-Engine (Spark Core) besteht Spark aus vier Hauptkomponenten. Spark-Code, der von einem Benutzer mithilfe einer der APIs geschrieben wurde, wird in den JVMs (Java Virtual Machines) der Worker im Cluster ausgeführt (siehe Kapitel 2). Diese Komponenten sind als unterschiedliche Bibliotheken verfügbar, wie in Abbildung 1-1 dargestellt:

Spark SQL und Datenrahmen + Datensätze

Ein Modul für die Arbeit mit strukturierten Daten.

MLlib

Eine skalierbare Bibliothek für maschinelles Lernen.

Strukturiertes Streaming

Das macht es leicht, skalierbare, fehlertolerante Streaming-Anwendungen zu entwickeln.

GraphX (Legacy)

GraphX ist die Bibliothek von Apache Spark für Graphen und grafisch-parallele Berechnungen. Für die Graphenanalyse wird jedoch GraphFrames anstelle von GraphX empfohlen, das nicht so aktiv entwickelt wird und keine Python-Anbindung hat. GraphFrames ist eine Open-Source-Bibliothek für die allgemeine Graphenverarbeitung, die GraphX von Apache Spark ähnelt, aber DataFrame-basierte APIs verwendet.

aaps 0101
Abbildung 1-1. Apache Spark-Komponenten

PySpark

PySpark ist die Python-API von Spark. Einfacher ausgedrückt: PySpark ist ein Python-basierter Wrapper über dem Spark-Kernframework, das hauptsächlich in Scala geschrieben ist. PySpark bietet eine intuitive Programmierumgebung für Data Science-Experten und verbindet die Flexibilität von Python mit den verteilten Verarbeitungsmöglichkeiten von Spark.

PySpark ermöglicht es uns, mit verschiedenen Programmiermodellen zu arbeiten. Ein gängiges Muster ist zum Beispiel die Durchführung umfangreicher Extraktions-, Transformations- und Ladevorgänge (ETL) mit Spark und das anschließende Sammeln der Ergebnisse auf einem lokalen Rechner, gefolgt von der Bearbeitung mit Pandas. In den kommenden Kapiteln werden wir solche Programmiermodelle beim Schreiben von PySpark-Code erkunden. Hier ist ein Codebeispiel aus der offiziellen Dokumentation, um dir einen Eindruck zu vermitteln, was dich erwartet:

from pyspark.ml.classification import LogisticRegression

# Load training data
training = spark.read.format("libsvm").load("data/mllib/sample_libsvm_data.txt")

lr = LogisticRegression(maxIter=10, regParam=0.3, elasticNetParam=0.8)

# Fit the model
lrModel = lr.fit(training)

# Print the coefficients and intercept for logistic regression
print("Coefficients: " + str(lrModel.coefficients))
print("Intercept: " + str(lrModel.intercept))

# We can also use the multinomial family for binary classification
mlr = LogisticRegression(maxIter=10, regParam=0.3, elasticNetParam=0.8,
                         family="multinomial")

# Fit the model
mlrModel = mlr.fit(training)

# Print the coefficients and intercepts for logistic regression
# with multinomial family
print("Multinomial coefficients: " + str(mlrModel.coefficientMatrix))
print("Multinomial intercepts: " + str(mlrModel.interceptVector))

Ökosystem

Spark ist so etwas wie ein Schweizer Taschenmesser , das wir im Big-Data-Ökosystem haben. Darüber hinaus lässt es sich gut in das übrige Ökosystem integrieren und ist erweiterbar. Im Gegensatz zu Apache Hadoop und den zuvor beschriebenen HPC-Systemen entkoppelt Spark Speicherung und Berechnung. Das bedeutet, dass wir mit Spark Daten aus vielen Quellen - Apache Hadoop, Apache Cassandra, Apache HBase, MongoDB, Apache Hive, RDBMSs und anderen - lesen und im Speicher verarbeiten können. Die DataFrameReader- und DataFrameWriter-APIs von Spark können auch erweitert werden, um Daten aus anderen Quellen wie Apache Kafka, Amazon Kinesis, Azure Storage und Amazon S3 zu lesen, mit denen Spark arbeiten kann. Außerdem unterstützt es mehrere Bereitstellungsmodi, von lokalen Umgebungen bis hin zu Apache YARN und Kubernetes-Clustern.

Es gibt auch eine große Gemeinschaft, die sich damit beschäftigt. Dies hat dazu geführt, dass viele Pakete von Drittanbietern erstellt wurden. Eine von der Community erstellte Liste mit solchen Paketen findest du hier. Die großen Cloud-Provider(AWS EMR, Azure Databricks, GCP Dataproc) bieten auch Optionen von Drittanbietern für den Betrieb von verwalteten Spark-Workloads an. Darüber hinaus gibt es spezielle Konferenzen und lokale Meetup-Gruppen, auf denen du interessante Anwendungen und bewährte Methoden kennenlernen kannst.

Spark 3.0

Im Jahr 2020 veröffentlichte Apache Spark seine erste größere Version seit 2016, als Spark 2.0 veröffentlicht wurde - Spark 3.0. Die letzte Ausgabe dieser Reihe, die 2017 erschien, behandelte die Änderungen, die Spark 2.0 mit sich brachte. Spark 3.0 führt nicht so viele große API-Änderungen ein wie die letzte große Version. Der Schwerpunkt dieser Version liegt auf Verbesserungen der Leistung und der Benutzerfreundlichkeit, ohne dass eine wesentliche Rückwärtskompatibilität eingeführt wird.

Das SQL-Modul von Spark hat wichtige Leistungsverbesserungen in Form von adaptiver Abfrageausführung und dynamischem Partition Pruning erfahren. Einfacher ausgedrückt: Sie ermöglichen es Spark, einen physischen Ausführungsplan während der Laufzeit anzupassen und Daten zu überspringen, die in den Ergebnissen einer Abfrage nicht benötigt werden. Diese Optimierungen verringern den Aufwand, den die Nutzer/innen bisher für die manuelle Abstimmung und Optimierung betreiben mussten. Spark 3.0 ist bei TPC-DS, einem branchenüblichen Benchmark für die analytische Verarbeitung, fast doppelt so schnell wie Spark 2.4. Da die meisten Spark-Anwendungen von der SQL-Engine unterstützt werden, haben alle übergeordneten Bibliotheken, einschließlich MLlib und Structured Streaming, und übergeordneten APIs, einschließlich SQL und DataFrames, davon profitiert. Die Einhaltung des ANSI-SQL-Standards macht die SQL-API benutzerfreundlicher.

Python hat sich als Spitzenreiter in Bezug auf die Akzeptanz im Data Science Ökosystem durchgesetzt. Folglich ist Python heute die am meisten verwendete Sprache auf Spark. PySpark hat mehr als fünf Millionen monatliche Downloads auf PyPI, dem Python Package Index. Spark 3.0 verbessert die Funktionalitäten und die Benutzerfreundlichkeit. pandas user-defined functions (UDFs) wurden umgestaltet, um Python-Typ-Hinweise und Iteratoren als Argumente zu unterstützen. Es wurden neue pandas UDF-Typen aufgenommen und die Fehlerbehandlung ist jetzt pythonischer. Python-Versionen unter 3.6 sind veraltet. Ab Spark 3.2 ist die Unterstützung von Python 3.6 ebenfalls veraltet.

In den letzten vier Jahren hat sich auch das Data-Science-Ökosystem in rasantem Tempo verändert. Es wird immer mehr Wert darauf gelegt, Machine-Learning-Modelle in die Produktion zu bringen. Deep Learning hat bemerkenswerte Ergebnisse geliefert und das Spark-Team experimentiert derzeit damit, dass das Zeitplannungsprogramm des Projekts Beschleuniger wie GPUs nutzen kann.

PySpark stellt sich den Herausforderungen der Datenwissenschaft

Damit ein System, das komplexe Analysen großer Datenmengen ermöglichen soll, erfolgreich sein kann, muss es einige grundlegende Herausforderungen berücksichtigen, mit denen Datenwissenschaftler/innen konfrontiert sind, oder zumindest nicht damit kollidieren.

  • Erstens: Der Großteil der Arbeit für erfolgreiche Analysen besteht in der Vorverarbeitung der Daten. Daten sind chaotisch, und Bereinigen, Mischen, Verschmelzen und viele andere Verben sind die Voraussetzung dafür, dass man mit ihnen etwas Sinnvolles anfangen kann.

  • Zweitens ist die Iteration ein grundlegender Bestandteil der Datenwissenschaft. Modellierung und Analyse erfordern in der Regel mehrere Durchläufe über dieselben Daten. BeliebteOptimierungsverfahren wie der stochastische Gradientenabstieg erfordern wiederholte Überprüfungen der Eingaben, um Konvergenz zu erreichen. Iteration ist auch für den Arbeitsablauf des Datenwissenschaftlers wichtig. Die Wahl der richtigen Merkmale, die Auswahl der richtigen Algorithmen, die Durchführung der richtigen Signifikanztests und die Suche nach den richtigen Hyperparametern erfordern allesamtExperimente.

  • Drittens: Die Aufgabe ist nicht vorbei, wenn ein gut funktionierendes Modell erstellt wurde. Das Ziel der Datenwissenschaft ist es, Daten für Nicht-Datenwissenschaftler/innen nutzbar zu machen. Der Einsatz von Datenempfehlungsmaschinen und Echtzeit-Betrugserkennungssystemen gipfelt in Datenanwendungen. In solchen Systemen werden die Modelle Teil eines Produktionsdienstes und müssen möglicherweise regelmäßig oder sogar in Echtzeit neu erstellt werden.

PySpark geht gut mit den oben genannten Herausforderungen der Datenwissenschaft um. erkennt an, dass der größte Engpass bei der Entwicklung von Datenanwendungen nicht CPU, Festplatte oder Netzwerk sind, sondern die Produktivität der Analysten. Die Zusammenführung der gesamten Pipeline, von der Vorverarbeitung bis zur Modellauswertung, in einer einzigen Programmierumgebung kann die Entwicklung beschleunigen. Durch die Kombination eines ausdrucksstarken Programmiermodells mit einer Reihe von analytischen Bibliotheken in einer REPL-Umgebung (Read-Eval-Print-Loop) vermeidet PySpark die Umwege über IDEs. Je schneller Analysten mit ihren Daten experimentieren können, desto höher ist die Wahrscheinlichkeit, dass sie etwas Nützliches damit machen können.

Eine Read-Eval-Print-Schleife (REPL) ist eine Computerumgebung, in der Benutzereingaben gelesen und ausgewertet werden und die Ergebnisse dann an den Benutzer zurückgegeben werden.

Die Kern-APIs von PySpark bieten eine solide Grundlage für die Datentransformation, unabhängig von Funktionen in Statistik, maschinellem Lernen oder Matrixalgebra. Bei der Erkundung eines Datensatzes und um ein Gefühl für ihn zu bekommen, können Datenwissenschaftler/innen die Daten im Speicher behalten, während sie Abfragen ausführen, und die transformierten Versionen der Daten einfach zwischenlagern, ohne dass sie auf der Festplatte landen. Als Framework, das die Modellierung vereinfacht, aber auch für Produktionssysteme geeignet ist, ist es ein großer Gewinn für das Ökosystem der Datenwissenschaft.

Wie geht es weiter?

Spark überbrückt die Lücke zwischen Systemen, die für explorative Analysen entwickelt wurden, und Systemen, die für operative Analysen entwickelt wurden. Es wird oft gesagt, dass ein Datenwissenschaftler jemand ist, der besser in der Technik ist als die meisten Statistiker und besser in der Statistik als die meisten Ingenieure. Zumindest ist Spark als operatives System besser als die meisten explorativen Systeme und besser für die Datenexploration geeignet als die Technologien, die üblicherweise in operativen Systemen eingesetzt werden. Wir hoffen, dass dieses Kapitel hilfreich war und du jetzt Lust hast, PySpark in die Praxis umzusetzen. Genau das werden wir ab dem nächsten Kapitel tun!

Get Erweiterte Analytik mit PySpark 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