# Einführung

Die meisten von Ihnen verwenden SQL-Fensterfunktionen, aber Sie kratzen nur an der Oberfläche – a ROW_NUMBER() hier, a SUM() OVER() Dort. Das wahre Potenzial der Fensterfunktionen zeigt sich, wenn man sie auf schwierigere Probleme anwendet. Ich werde Sie durch vier Muster führen, die Fensterfunktionen von ihrer nützlichsten Seite zeigen.

Bei den Beispielen handelt es sich allesamt um echte Interviewfragen, die Sie üben können StrataScratch.

# Laufende Gesamtsummen

Die Berechnung laufender Summen ist eine der häufigsten Geschäftsanwendungen von Fensterfunktionen. Die Finanzleute lieben es absolut! Es wird verwendet, um den kumulierten monatlichen Umsatz zu verfolgen, der dann problemlos in die Berechnung Ihres aktuellen Stands im Vergleich zum jährlichen Umsatzziel einfließt.

Was dieses Downside zu einem Fensterfunktionsproblem macht, ist, dass Sie normalerweise sowohl den Wert professional Periode als auch die kumulierte Summe in dieselbe Ausgabe einbeziehen sollten. Du kannst es nicht verwenden GROUP BY mit SUM()weil dadurch einzelne Zeilen ausgeblendet werden. Die offensichtliche Lösung ist additionally die Verwendung einer Fensterfunktion, d. h. SUM() OVER().

// Beispiel: Berechnung des Umsatzes im Zeitverlauf

Diese Amazon-Frage fordert Sie ursprünglich auf, den gleitenden 3-Monats-Durchschnitt zu berechnen. Wir ignorieren dies jedoch und berechnen den kumulierten Umsatz für jeden Monat.

Daten: Hier ist die amazon_purchases Tabellenvorschau.

Code: Die innere Abfrage wandelt Datumsangaben in um YYYY-MM formatieren mit TO_CHAR() und aggregiert die monatlichen Einnahmen und filtert die Renditen heraus WHERE purchase_amt > 0.

Die äußere Abfrage wendet die Fensterfunktion auf die von uns berechneten Monatssummen an. Ich gebe (absichtlich) keine explizite Rahmenklausel an OVER()daher ist die Fensterfunktion standardmäßig auf RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW. Das bedeutet, dass das Fenster alle Zeilen enthält, die der aktuellen Zeile, additionally dem Monat, vorangehen. Mit anderen Worten, die kumulierte Summe beträgt: alle vorherigen Monate + der aktuelle Monat. Das überrascht nicht Ist eine Lehrbuchdefinition einer kumulativen Summe.

SELECT t.month,
       t.monthly_revenue,
       SUM(t.monthly_revenue) OVER(ORDER BY t.month) AS cumulative_revenue
FROM (
    SELECT TO_CHAR(created_at::DATE, 'YYYY-MM') AS month,
        SUM(purchase_amt) AS monthly_revenue
    FROM amazon_purchases
    WHERE purchase_amt > 0
    GROUP BY TO_CHAR(created_at::date, 'YYYY-MM')
    ORDER BY TO_CHAR(created_at::date, 'YYYY-MM')
) t
ORDER BY t.month ASC;

Ausgabe:

# Lücken und Inseln (Sessionisierung)

Auch dieses Muster umfasst sequenzielle Daten, genau wie laufende Summen, verwendet jedoch andere Fensterfunktionen.

Ein Insel ist eine Reihe von Zeilen mit derselben Bedingungz. B. aufeinanderfolgende tägliche Anmeldungen. A Lücke ist der Raum zwischen Inseln.

Eine der häufigsten realen Anwendungen dieses Musters ist Sessionisierung – Gruppieren eines rohen Ereignisstroms in Sitzungen. Eine Sitzung wird normalerweise als definiert Abfolge von Ereignissen desselben Benutzers, bei der keine Lücke zwischen aufeinanderfolgenden Ereignissen eine gewisse Zeitüberschreitung überschreitet (30 Minuten ist der Webanalysestandard).

Sessionisierung wird häufig angewendet in Produkt- und Datenentwicklung. Es wird überall dort eingesetzt, wo Sie rohe Ereignisströme in sinnvolle Aktivitätseinheiten gruppieren müssen.

Die klassische Erkennung in SQL besteht aus zwei Schritten:

• LAG() oder LEAD() – um jede Zeile mit der davor oder danach zu vergleichen und zu markieren, wo ein neuer Streak beginnt.
• SUM(flag) OVER (PARTITION BY consumer ORDER BY date) – um Flags in einer Streak-ID zu sammeln, da diese innerhalb eines Streaks flach bleibt und an jeder Grenze erhöht wird.

// Beispiel: Consumer Streaks finden

Der Frage aus LinkedIn- und Meta-Interviews fordert Sie auf, bis zum 10. August 2022 die drei besten Benutzer mit der längsten Plattformbesuchssträhne zu finden. Sie sollten alle Benutzer mit den drei längsten Streaks ausgeben, wenn es mehr als einen Benutzer professional Streaklänge gibt.

Daten: Der Tisch ist user_streaks.

Code: Die Abfrage ist lang, aber sauber in CTEs gegliedert, sodass sie leicht zu verstehen ist.

1. unique_visits: Entfernt doppelte Besuchsdatensätze und begrenzt die Daten auf den 10. August 2022.
2. streak_flags: Verwendungen LAG() um das vorherige Besuchsdatum professional Benutzer abzurufen und die Zeile als zu kennzeichnen 0 (eine Streak-Fortsetzung, wenn die Lücke 1 Tag beträgt) oder 1 (ein neuer Streak-Begin für jede andere Lücke).
3. streak_ids: Wandelt Flags mithilfe einer kumulativen Summe in Streak-Gruppen-IDs um SUM().
4. streak_lengths: Zählt Tage professional Streak.
5. longest_per_user: Behält nur den längsten Streak jedes Benutzers.
6. ranked_lengths: Ordnet unterschiedliche Streifenlängen ein.
7. top_lengths: Findet die drei besten Streifenlängenwerte.

Das Finale SELECT verbindet alles: Es zeigt alle Benutzer mit den drei besten Streaks und ihrer jeweiligen Streak-Länge in Tagen.

WITH unique_visits AS (
    SELECT DISTINCT user_id, date_visited
    FROM   user_streaks
    WHERE  date_visited <= DATE '2022-08-10'),
streak_flags AS (
    SELECT *,
           CASE
               WHEN date_visited
                     - LAG(date_visited) OVER (PARTITION BY user_id ORDER BY date_visited) = 1
               THEN 0
               ELSE 1
           END AS new_streak
    FROM   unique_visits),
streak_ids AS (
    SELECT *,
           SUM(new_streak) OVER (PARTITION BY user_id ORDER BY date_visited) AS streak_id
    FROM   streak_flags),
streak_lengths AS (
    SELECT user_id,
           streak_id,
           COUNT(*) AS streak_length
    FROM   streak_ids
    GROUP  BY user_id, streak_id),
longest_per_user AS (
    SELECT user_id,
           MAX(streak_length) AS streak_length
    FROM   streak_lengths
    GROUP  BY user_id),
ranked_lengths AS (
    SELECT DISTINCT
           streak_length,
           DENSE_RANK() OVER (ORDER BY streak_length DESC) AS len_rank
    FROM   longest_per_user),
top_lengths AS (
    SELECT streak_length
    FROM   ranked_lengths
    WHERE  len_rank <= 3)
SELECT u.user_id,
       u.streak_length
FROM   longest_per_user u
JOIN   top_lengths       t USING (streak_length)
ORDER  BY u.streak_length DESC, u.user_id;

Ausgabe:

# Kohortenanalyse

A Kohorte ist eine Gruppe von Benutzern, die ein Startereignis teilenzum Beispiel ein erster Kauf, eine erste Anmeldung oder ein erstes Abonnementdatum. Das Analysieren von Kohorten ist das Grundlage des Retention-Reportingsda es die Frage beantwortet wie viele Benutzer nach der Startveranstaltung zurückgekommen sind.

Das Wichtigste bei der Kohortenanalyse ist das Finden Kohortenanker im Aktivitätsverlauf des Benutzers, sodass Sie alle nachfolgenden Aktivitäten daran messen können.

Dies lässt sich in SQL auf drei Hauptansätze für Fensterfunktionen reduzieren:

1. MIN(event_time) OVER (PARTITION BY user_id) – das häufigste Muster, wenn der Anker ein Datum ist.
2. FIRST_VALUE(attribute) OVER (PARTITION BY user_id ORDER BY event_time) – wird verwendet, wenn Sie den Ankerwert selbst benötigen, z. B. den ersten Händler oder die erste Produktkategorie.
3. ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY event_time) = 1 – Wird verwendet, wenn Sie das erste Ereignis als separate Zeile isolieren und wieder mit dem gesamten Verlauf verbinden möchten, anstatt es über alle Zeilen zu übertragen.

// Beispiel: Erstbestellungen zählen

Hier ist ein DoorDash-Frage. Dazu müssen Sie die Anzahl der Bestellungen und Erstbestellungen (aus Kundensicht) für jeden Händler berechnen. Sie sollten auch Händler ausschließen, die keine Bestellungen erhalten haben.

Daten: Die erste Tabelle wird benannt order_details.

Die zweite Tabelle ist merchant_details.

Code: Im ersten CTE findet die Kohortenlogik statt. Ich benutze das FIRST_VALUE() Fensterfunktion, um den Händler von der frühesten Bestellung jedes Kunden an jede Zeile in seiner Bestellhistorie anzuhängen. Das Ergebnis ist eine Tabelle, in der jede Bestellung mit der Angabe versehen ist, bei welchem ​​Händler der Kunde angefangen hat.

Im zweiten CTE verbinde ich die Etiketten mit a wieder mit der vollständigen Bestellhistorie LEFT JOIN um sicherzustellen, dass Händler, die Bestellungen erhalten haben, aber nie der erste Händler von irgendjemandem waren, trotzdem im Ergebnis erscheinen. Wir verwenden COUNT() Und DISTINCT Nur die Kunden zu zählen, für die dieser Händler der erste struggle – das ist Ihre Kohortengröße. Mit einem anderen COUNT()erhalten Sie die Gesamtzahl der Bestellungen. DISTINCT ist auch hier erforderlich, da die LEFT JOIN mit first_order kann doppelte Bestellzeilen erzeugen – seitdem first_order Behält eine Zeile professional Bestellung (nicht professional Kunde), eine einzelne Bestellung in order_details kann mit mehreren Zeilen in übereinstimmen first_order für denselben Kunden, wobei die Anzahl ohne diesen erhöht wird.

Im Finale SELECTwir schließen uns dem an number_of_customers CTE mit merchant_details die Händlernamen einzubringen.

WITH first_order AS  (
SELECT customer_id,
       FIRST_VALUE(merchant_id) OVER(PARTITION BY customer_id ORDER BY order_timestamp) AS first_merchant
FROM order_details),
number_of_customers AS  (
SELECT merchant_id,
       COUNT(DISTINCT f.customer_id) AS first_time_orders,
       COUNT(DISTINCT id) AS total_number_of_orders
FROM order_details d
LEFT JOIN first_order f ON d.merchant_id = f.first_merchant
GROUP BY 1)
SELECT identify,
       total_number_of_orders,
       first_time_orders
FROM number_of_customers
JOIN merchant_details ON number_of_customers.merchant_id = merchant_details.id;

Ausgabe:

# Perzentil- und Rankinganalyse

Aggregatfunktionen geben Ihnen den Durchschnitt an. Fensterbasierte Rating-Funktionen informieren Sie über die Verteilung, und in Verteilungen finden sich die interessanten Geschäftsfragen. Ist Ihr Bestellwert im 90. Perzentil ungewöhnlich hoch, was darauf hindeutet, dass einige große Käufer den Umsatz verzerren? Befinden sich die unteren 25 % der Vertriebsmitarbeiter in der Nähe des Medianwerts oder weit darunter?

NTILE(n) unterteilt Zeilen in n ungefähr gleiche Eimer. PERCENT_RANK() drückt den Rang jeder Zeile als Wert zwischen 0 und 1 aus. CUME_DIST() Gibt an, welcher Bruchteil der Zeilen einen Wert hat, der kleiner oder gleich der aktuellen Zeile ist. Und PERCENTILE_CONT() Berechnet den tatsächlichen Wert bei einem bestimmten Perzentilschwellenwert – nützlich, wenn Sie auf der Grundlage eines dynamischen Cutoffs und nicht auf der Grundlage einer Rangfolge innerhalb einer Ergebnismenge filtern möchten.

// Beispiel: Identifizieren von Betrug im höchsten Perzentilbereich

Hier ist eines von Google und Netflix. Sie möchten, dass Sie die verdächtigsten Ansprüche in jedem Bundesstaat identifizieren. Es wird davon ausgegangen, dass die obersten 5 % der Ansprüche in jedem Bundesstaat potenziell betrügerisch sind.

Daten: Die Tabelle ist benannt fraud_score.

Code: Im Code, PERCENTILE_CONT(0.95) berechnet den interpolierten Wert am 95. Perzentil der Betrugswerte in jedem Bundesstaat.

Im Folgenden SELECT In der Anweisung wird der CTE mit der Originaltabelle verknüpft, sodass jeder Anspruch mit dem Schwellenwert für seinen eigenen Bundesstaat verglichen werden kann. Ansprüche in Höhe oder über diesem Wert werden gekürzt.

WITH state_percentiles AS (
    SELECT state,
           PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY fraud_score) AS p95
    FROM fraud_score
    GROUP BY state)
SELECT f.policy_num,
       f.state,
       f.claim_cost,
       f.fraud_score
FROM fraud_score f
JOIN state_percentiles sp
ON f.state = sp.state
WHERE f.fraud_score >= sp.p95;

Ausgabe:

# Abschluss

Diese vier Muster haben eine gemeinsame Philosophie: Erledigen Sie die Arbeit in der Datenbank möglichst in einem einzigen Durchgang und nutzen Sie dabei die volle Ausdruckskraft der SQL-Fensterspezifikation.

Was Fensterfunktionen wirklich leistungsstark macht, ist nicht eine einzelne Funktion für sich. Es ist die Zusammensetzbarkeit: Sie können CTEs verketten und mehrere Fensterfunktionen gleichzeitig anwenden SELECTund erstellen Sie eine komplexe analytische Logik, die sich quick wie eine Beschreibung des Geschäftsproblems selbst liest.

Nate Rosidi ist Datenwissenschaftler und in der Produktstrategie tätig. Er ist außerdem außerordentlicher Professor für Analytik und Gründer von StrataScratch, einer Plattform, die Datenwissenschaftlern hilft, sich mit echten Interviewfragen von Prime-Unternehmen auf ihre Interviews vorzubereiten. Nate schreibt über die neuesten Tendencies auf dem Karrieremarkt, gibt Ratschläge zu Vorstellungsgesprächen, stellt Knowledge-Science-Projekte vor und behandelt alles rund um SQL.

beginnt oft mit Werkzeugen wie Pandas. Sie sind intuitiv, leistungsstark und perfekt für kleine bis mittelgroße Datensätze. Sobald Ihre Daten jedoch über das hinausgehen, was bequem in den Speicher passt, tauchen Leistungsprobleme auf. Hier ist PySpark kommt rein.

Beachten Sie, dass ich in diesem Artikel die Begriffe Spark und PySpark häufig synonym verwende. Für unsere Zwecke spielt es keine Rolle, aber Sie sollten bedenken, dass sie unterschiedlich sind. Spark ist das übergreifende Framework für verteiltes Computing (geschrieben in Scala) und PySpark ist eine dedizierte Python-API für Spark.

Was ist PySpark?

PySpark ist die Python-API für Apache Spark, ein verteiltes Pc-Framework zur effizienten Verarbeitung großer Datenmengen. Anstatt alle Berechnungen auf einer einzigen Maschine auszuführen, verteilt Spark die Arbeit auf mehrere Maschinen (einen Cluster), sodass Sie Daten in großem Maßstab verarbeiten und gleichzeitig Code schreiben können, der Python-Benutzern dennoch vertraut vorkommt.

Einer der Hauptvorteile von PySpark besteht darin, dass es einen Großteil der Komplexität verteilter Systeme abstrahiert. Sie müssen Threads, Speicher oder Netzwerkkommunikation nicht manuell verwalten. Spark kümmert sich für Sie um diese Anliegen, während Sie sich auf die Beschreibung konzentrieren Was Sie möchten eher mit den Daten umgehen als Wie es sollte ausgeführt werden.

Wenn Sie noch kein Spark-Neuling sind, sollten Sie vor der Verwendung von Spark drei wichtige Kernideen kennen lernen. Diese sind:

1. Cluster

Wenn Leute hören, dass Spark auf einem „Cluster“ läuft, kann das einschüchternd klingen. In der Praxis sind für den Einstieg keine tiefgreifenden Kenntnisse über verteilte Systeme erforderlich. Ein Cluster ist einfach eine Gruppe miteinander vernetzter Server, die zusammenarbeiten können. In einer Spark-Anwendung, die auf einem Cluster ausgeführt wird, fungiert eine Maschine als TreiberKoordinierung der Arbeit, während die anderen als fungieren TestamentsvollstreckerDurchführung von Berechnungen für Datenblöcke. Wenn die Executor-Knoten ihre Arbeit beendet haben, senden sie ein Sign an den Treiberknoten zurück, und der Treiber kann dann mit dem endgültigen Ergebnissatz alles tun, was erforderlich ist.

                          ┌───────────────────┐
                          │       Driver      │
                          │(your PySpark app) │
                          └─────────┬─────────┘
                                    │ 
                                    | The Driver farms out work
                                    | to a number of executors
               ┌────────────────────┼───────────────────────────┐
               │                    │                           │
       ┌───────▼────────┐   ┌───────▼────────┐          ┌───────▼────────┐
       │   Executor 1   │   │   Executor 2   │          │   Executor N   │
       │  processes half│   │  processes half│  ......  │  processes half│
       │   of the info  │   |   of the info  │          │   of the info  │
       └────────────────┘   └────────────────┘          └────────────────┘

Denken Sie daran, dass Sie Spark nicht auf einem physischen Rechencluster ausführen müssen. Wenn Sie PySpark lokal ausführen, wird Spark simuliert ein Cluster auf Ihrem Laptop computer oder PC mit mehreren Kernen. Eine der Stärken von PySpark besteht darin, dass derselbe Code später mit nur sehr geringfügigen Änderungen in einem echten Cluster bereitgestellt werden kann, sei es in der Cloud oder vor Ort.

Diese Trennung von Koordination und Ausführung ermöglicht Spark die Skalierung. Wenn Datensätze wachsen, können mehr Executoren hinzugefügt werden, um Daten parallel zu verarbeiten, wodurch die Laufzeit verkürzt wird, ohne dass Änderungen an Ihrem Code erforderlich sind.

2. Der Spark-Datenrahmen

Das Herzstück von PySpark ist das DataFrame-APIDies ist die Hauptmethode, mit der Sie in Spark mit Daten arbeiten. Ein DataFrame ist einfach eine Datentabelle, die aus Zeilen und Spalten besteht – sehr ähnlich einer Tabelle in einer Datenbank oder einem DataFrame in Pandas. Wenn Sie bereits SQL oder Pandas verwendet haben, werden Ihnen die Grundideen bekannt vorkommen.

Mit Spark DataFrames können Sie allgemeine Datenaufgaben wie das Filtern von Zeilen, das Auswählen von Spalten, das Gruppieren von Daten, das Zusammenführen von Tabellen und das Berechnen von Zusammenfassungen wie Zählungen oder Durchschnittswerten ausführen. Diese Vorgänge sind leicht zu lesen und zu schreiben, sodass Sie sich auf sie konzentrieren können Was Sie möchten eher mit den Daten als mit den technischen Particulars ihrer Funktionsweise arbeiten.

Das Besondere an Spark ist, was hinter den Kulissen passiert. Spark ermittelt automatisch die effizienteste Methode zur Ausführung Ihrer DataFrame-Vorgänge und führt diese dann parallel auf mehreren Computern in einem Cluster aus. Sie müssen dies nicht selbst verwalten – Spark kümmert sich um Dinge wie die Aufteilung der Daten, die Koordinierung der Arbeit und die Wiederherstellung nach Fehlern, wenn etwas schief geht.

Aus diesem Grund können Spark DataFrames damit umgehen sehr große Datensätzeauch solche, die zu groß sind, um in den Speicher eines einzelnen Computer systems zu passen. Gleichzeitig bieten sie eine einfache und vertraute Benutzeroberfläche, was PySpark zu einem leistungsstarken und dennoch zugänglichen Device für die Arbeit mit Huge Knowledge macht.

3. Faule vs. eifrige Bewertung

Eine weitere wissenswerte Stärke von PySpark ist der Ansatz zwischen fauler und eifriger Ausführung.

Die meisten Python-Datenbibliotheken wie Pandas verwenden eifrige Ausführung. Das bedeutet, dass, wenn Sie eine Operation ausführen, diese sofort ausgeführt wird, gefolgt von der nächsten Operation und so weiter.

PySpark geht damit anders um, indem es eine Technik namens Lazy Execution verwendet. Wenn Sie Datentransformationen schreiben, z. B. das Auswählen von Spalten oder das Filtern von Zeilen, führt Spark diese nicht sofort aus. Stattdessen erstellt es einen optimierten Ausführungsplan und führt die Berechnung nur aus, wenn eine Aktion (z. B. das Anzeigen von Ergebnissen oder das Schreiben von Daten auf die Festplatte) ausgelöst wird. Dadurch kann Spark den Workflow vor der Ausführung optimieren und Ihren Code ohne zusätzlichen Aufwand Ihrerseits effizienter machen.

Keen execution (e.g. pandas)
information  ──filter──► end result (computed instantly)

In pandas, every operation runs as quickly as it's referred to as. That is 
intuitive however may be inefficient for big datasets.

PySpark makes use of lazy execution.

Lazy execution (PySpark)
information ──filter──►
        │
        └─groupby──►   (plan builds right here)
             │
             └─agg──►  (nonetheless no execution)
                     │
                 motion ──► executes right here

Um diesen Punkt deutlich zu machen, stellen Sie sich das folgende Szenario vor. Nehmen wir an, wir haben einen Datenrahmen mit 10 Millionen Datensätzen, den wir …

a) Fügen Sie eine neue leere Spalte namens X hinzu

b) Filtern Sie die Daten auf eine Weise, die dazu führt, dass wir 50 % der Datensätze entfernen

c) Führen Sie eine Aggregation der verbleibenden Datensätze durch, sodass die neue Spalte X den MAX-Wert eines anderen Werts in dieser Zeile enthält

d) Drucken Sie die Zeile mit dem höchsten Wert von X aus

Auf einem System wie Pandas, das eine eifrige Ausführung durchführt, wird jeder Schritt genau so ausgeführt, wie wir es oben beschrieben haben. Für 10 Millionen Datensätze würde es so aussehen:

1. Spalte hinzufügen: Das System erstellt eine neue Model des Datensatzes mit 10 Millionen Zeilen im Speicher und fügt Spalte X hinzu.
2. Filter: Das System filtert alle 10 Millionen Zeilen, was zu 5 Millionen Löschungen führt, und schreibt a neu 5-Millionen-Zeilen-Datensatz im Speicher.
3. Aggregation: Es berechnet den MAX-Wert für jede Zeile und aktualisiert die Spalte.
4. Drucken: Es findet die oberste Zeile und zeigt sie Ihnen an.

Das Downside ist, dass wir eine Menge „schwere Arbeit“ geleistet haben (eine Spalte zu 10 Millionen Zeilen hinzugefügt), nur um im nächsten Schritt sofort die Hälfte dieser Arbeit wegzuwerfen.

Spark hingegen führt aufgrund seines Lazy-Execution-Modells keine Arbeit aus, wenn Sie die Schritte (a), (b) oder (c) definieren. Stattdessen wird ein erstellt Logischer Plan (auch DAG genannt – Directed Uneven Graph), um die Arbeit zu erledigen.

Wenn Sie schließlich Schritt (d) auslösen – Die Aktion – Der Optimierer von Spark betrachtet den gesamten Plan und stellt fest, dass er viel intelligenter funktionieren kann:

• Prädikat-Pushdown: Spark sieht den Filter (50 % der Datensätze entfernen). Anstatt Spalte X zu 10 Millionen Zeilen hinzuzufügen, ist es Verschiebt die Filterung ganz an den Anfang.
• Optimierung: Es fügt nur Spalte X hinzu und aggregiert die übrig 5 Millionen Zeilen.
• Ergebnis: Es vermeidet die Verarbeitung von 5 Millionen Datensätzen und spart 50 % Speicher- und CPU-Zeit.

Einrichten der Entwicklungsumgebung

Okay, das ist genug der Theorie. Schauen wir uns an, wie Sie PySpark auf Ihrem System installieren und einige Beispielcode-Snippets ausführen können. Als Einführungstext für Anfänger würde die tatsächliche Erstellung eines realen Clusters mit mehreren Knoten den Rahmen dieses Artikels sprengen. Aber wie ich bereits erwähnt habe, kann Spark einen synthetischen Cluster auf Ihrem PC oder Laptop computer erstellen, wenn es sich um einen Multicore-PC oder Laptop computer handelt, was der Fall sein wird, wenn Ihr System weniger als etwa 10 Jahre alt ist.

Als Erstes richten wir für diese Arbeit eine separate Entwicklungsumgebung ein, um sicherzustellen, dass unsere Projekte isoliert sind und sich nicht gegenseitig beeinträchtigen. Für diesen Teil verwende ich WSL2 Ubuntu für Home windows und Conda, Sie können aber auch die Umgebung und Methode verwenden, die Sie gewohnt sind.

Installieren Sie PySpark usw.

# 1. Create a brand new setting with Python 3.11 (very secure for Spark)
conda create -n spark_env python=3.11 -y

# 2. Activate it
conda activate spark_env

# 3. Set up PySpark and PyArrow (wanted for Parquet recordsdata)
pip set up pyspark pyarrow jupyter

Um zu überprüfen, ob PySpark korrekt installiert wurde, geben Sie den Befehl pyspark in ein Terminalfenster ein.

$ pyspark

Python 3.11.14 | packaged by conda-forge | (most important, Oct 22 2025, 22:46:25) (GCC 14.3.0) on linux
Kind "assist", "copyright", "credit" or "license" for extra data.
WARNING: Utilizing incubator modules: jdk.incubator.vector
WARNING: bundle solar.safety.motion not in java.base
Utilizing Spark's default log4j profile: org/apache/spark/log4j2-defaults.properties
26/01/15 16:15:21 WARN Utils: Your hostname, tpr-desktop, resolves to a loopback tackle: 127.0.1.1; utilizing 10.255.255.254 as a substitute (on interface lo)
26/01/15 16:15:21 WARN Utils: Set SPARK_LOCAL_IP if you'll want to bind to a different tackle
Utilizing Spark's default log4j profile: org/apache/spark/log4j2-defaults.properties
Setting default log degree to "WARN".
To regulate logging degree use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
26/01/15 16:15:22 WARN NativeCodeLoader: Unable to load native-hadoop library in your platform... utilizing builtin-java lessons the place relevant
WARNING: A terminally deprecated technique in solar.misc.Unsafe has been referred to as
WARNING: solar.misc.Unsafe::arrayBaseOffset has been referred to as by org.apache.spark.unsafe.Platform (file:/house/tom/miniconda3/envs/pandas_to_pyspark/lib/python3.11/site-packages/pyspark/jars/spark-unsafe_2.13-4.1.1.jar)
WARNING: Please take into account reporting this to the maintainers of sophistication org.apache.spark.unsafe.Platform
WARNING: solar.misc.Unsafe::arrayBaseOffset can be eliminated in a future launch
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _ / _ / _ `/ __/  '_/
   /__ / .__/_,_/_/ /_/_   model 4.1.1
      /_/
Utilizing Python model 3.11.14 (most important, Oct 22 2025 22:46:25)
Spark context Internet UI obtainable at http://10.255.255.254:4040
Spark context obtainable as 'sc' (grasp = native(*), app id = local-1768493723158).
SparkSession obtainable as 'spark'.
>>>

Wenn Sie das Spark-Willkommensbanner nicht sehen, ist ein Fehler aufgetreten und Sie sollten Ihre Set up noch einmal überprüfen.

Beispiel 1 – Erstellen eines lokalen Clusters

Das ist eigentlich ziemlich einfach. Geben Sie einfach Folgendes in Ihr Notizbuch ein.

from pyspark.sql import SparkSession

# Initialize the Spark Session
spark = SparkSession.builder 
    .grasp("native(*)") 
    .appName("MyLocalCluster") 
    .config("spark.driver.reminiscence", "2g") 
    .getOrCreate()

# Confirm the cluster is operating
print(f"Spark is operating model: {spark.model}")
print(f"Grasp URL: {spark.sparkContext.grasp}")



#
# The output
#
Spark is operating model: 4.1.1
Grasp URL: native(*)

Der SparkSession Konzept ist wichtig. In den frühen Tagen von Spark mussten Benutzer mehrere „Einstiegspunkte“ jonglieren (wie SparkContext für Kernfunktionen, SQLContext für Datenrahmen und HiveContext für Datenbanken). Für Anfänger battle es verwirrend.

Die SparkSession wurde in Spark 2.0 als „One-Cease-Store“ für alles eingeführt. Es ist der zentrale Einstiegspunkt für die Interaktion mit der Spark-Funktionalität.

Beispiel 2 – Erstellen eines Datenrahmens

Das Erstellen von Datenrahmen und das Bearbeiten der darin enthaltenen Daten in PySpark ist das, was Sie die meiste Zeit tun. Und es ist ziemlich einfach zu machen. Hier definieren wir, dass unser Datenrahmen drei Datensätze und drei benannte Spalten enthält.

# 1. Outline your information as a listing of tuples
information = (
    ("Alice", 34, "New York"),
    ("Bob", 45, "London"),
    ("Catherine", 29, "Paris")
)

# 2. Outline your column names
columns = ("Title", "Age", "Metropolis")

# 3. Create the DataFrame
df = spark.createDataFrame(information, columns)

# 4. Present the end result
df.present()



#
# The output
#
+---------+---+--------+
|     Title|Age|    Metropolis|
+---------+---+--------+
|    Alice| 34|New York|
|      Bob| 45|  London|
|Catherine| 29|   Paris|
+---------+---+--------+

Wahrscheinlicher ist, dass alle von Ihnen verwendeten Datenrahmen zunächst durch das Einlesen von Daten aus einer Datei oder Datenbank erstellt werden. Erstellen Sie auf Ihrem System eine CSV-Datei mit dem Namen sales_data.csv und folgendem Inhalt.

transaction_id,customer_name,net_amount,tax_amount, is_member
101,Alice,250.50,25.05,true
102,Bob,120.00,6.00, false
103,Charlie,450.75,25.07,true
104,David,89.99,5.73,false

Das Erstellen eines Datenrahmens aus einer Datei wie dieser ist einfach.

# Load the CSV file
df = spark.learn.format("csv") 
    .possibility("header", "true") 
    .possibility("inferSchema", "true") 
    .load("sales_data.csv")

# Present the info
print("Dataframe Contents:")
df.present()

# Present the info sorts (Schema)
print("Knowledge Schema:")
df.printSchema()



#
# The output
#
Dataframe Contents:
+--------------+-------------+----------+----------+----------+
|transaction_id|customer_name|net_amount|tax_amount| is_member|
+--------------+-------------+----------+----------+----------+
|           101|        Alice|     250.5|     25.05|      true|
|           102|          Bob|     120.0|       6.0|     false|
|           103|      Charlie|    450.75|     25.07|      true|
|           104|        David|     89.99|      5.73|     false|
+--------------+-------------+----------+----------+----------+

Knowledge Schema:
root
 |-- transaction_id: integer (nullable = true)
 |-- customer_name: string (nullable = true)
 |-- net_amount: double (nullable = true)
 |-- tax_amount: double (nullable = true)
 |--  is_member: string (nullable = true)

Beispiel 3 – Datenverarbeitung

Sobald Sie Ihre Eingabedaten in einem Datenrahmen haben, möchten Sie sie natürlich als Nächstes verarbeiten oder auf irgendeine Weise manipulieren. Das ist auch einfach. Nehmen wir an, wir möchten unter Bezugnahme auf die soeben geladenen Umsatzdaten den Bruttobetrag (Netto + Steuern) und den Steuersatz als Prozentsatz des Bruttobetrags für jeden Datensatz berechnen und diese zu unserem anfänglichen Datenrahmen hinzufügen.

from pyspark.sql import capabilities as F

# 1. Add 'gross_amount' by including internet and tax
# 2. Add 'tax_percentage' by dividing tax by the brand new gross quantity
df_extended = df.withColumn("gross_amount", F.col("net_amount") + F.col("tax_amount")) 
                .withColumn("tax_percentage", 
                            (F.col("tax_amount") / (F.col("net_amount") + F.col("tax_amount"))) * 100)

# 3. Optionally available: Spherical the proportion to 2 decimal locations for readability
df_extended = df_extended.withColumn("tax_percentage", F.spherical(F.col("tax_percentage"), 2))

# Present the brand new columns together with the previous ones
df_extended.present()



#
# The output
#
+--------------+-------------+----------+----------+----------+------------+--------------+
|transaction_id|customer_name|net_amount|tax_amount| is_member|gross_amount|tax_percentage|
+--------------+-------------+----------+----------+----------+------------+--------------+
|           101|        Alice|     250.5|     25.05|      true|      275.55|          9.09|
|           102|          Bob|     120.0|       6.0|     false|       126.0|          4.76|
|           103|      Charlie|    450.75|     25.07|      true|      475.82|          5.27|
|           104|        David|     89.99|      5.73|     false|       95.72|          5.99|
+--------------+-------------+----------+----------+----------+------------+--------------+

Zusammenfassung

Damit ist unser kurzer Ausflug in die Welt des verteilten Rechnens mit PySpark abgeschlossen. Ich habe erklärt, was PySpark ist und warum Sie die Verwendung in Betracht ziehen sollten, wenn die von Ihnen verarbeiteten Daten Ihre Speichergrenzen überschreiten. Kurz gesagt: Die Fähigkeit von PySpark, auf große Multi-Node-Cluster zu skalieren, sein Lazy-Execution-Modell und die Datenrahmen-Datenstruktur machen es zu einem idealen Kraftpaket für die Datenverarbeitung.

PySpark wird häufig in Pipelines für Datentechnik, Analyse und maschinelles Lernen eingesetzt. Es lässt sich intestine in Cloud-Plattformen integrieren, unterstützt eine Vielzahl von Datenquellen (wie CSV, Parquet und Datenbanken) und lässt sich von einem Laptop computer bis hin zu großen Produktionsclustern skalieren.

Wenn Sie mit Python vertraut sind und mit großen Datenmengen arbeiten möchten, ohne auf die vertraute Syntax zu verzichten, ist PySpark ein hervorragender nächster Schritt. Es schließt die Lücke zwischen einfacher Datenanalyse und umfangreicher Datenverarbeitung und ist damit ein wertvolles Werkzeug für jeden, der in die Welt der Huge Knowledge einsteigt.

Hoffentlich können Sie meine einfachen Codierungsbeispiele und Erklärungen verwenden, um den nächsten Schritt zur Verwendung von PySpark in der realen Welt, auf einem echten Cluster, zu machen und eine ordnungsgemäße Huge-Knowledge-Verarbeitung durchzuführen.

Ich habe das Konzept des föderierten Lernens (FL) durch a Comedian von Google im Jahr 2019. Es struggle ein brillanter Artikel und hat hervorragend erklärt, wie Produkte verbessert werden können, ohne Benutzerdaten in die Cloud zu senden. In letzter Zeit wollte ich die technische Seite dieses Bereichs genauer verstehen. Trainingsdaten sind zu einem so wichtigen Intestine geworden, da sie für die Erstellung guter Modelle unerlässlich sind. Viele davon bleiben jedoch ungenutzt, weil sie fragmentiert, unstrukturiert oder in Silos eingeschlossen sind.

Als ich anfing, dieses Gebiet zu erkunden, fand ich das Blumenrahmenum die unkomplizierteste und anfängerfreundlichste Artwork zu sein, in FL durchzustarten. Es ist Open Supply, die Dokumentation ist klar und die Group ist sehr aktiv und hilfsbereit. Dies ist einer der Gründe für mein erneutes Interesse an diesem Bereich.

Dieser Artikel ist der erste Teil einer Reihe, in der ich mich eingehender mit föderiertem Lernen befasse. Dabei gehe ich darauf ein, was es ist, wie es implementiert wird, welche offenen Probleme es mit sich bringt und warum es in datenschutzrelevanten Umgebungen wichtig ist. In den nächsten Teilen werde ich tiefer auf die praktische Umsetzung mit dem eingehen Blume diskutieren Sie den Datenschutz beim föderierten Lernen und untersuchen Sie, wie sich diese Ideen auf fortgeschrittenere Anwendungsfälle übertragen lassen.

Wenn zentralisiertes maschinelles Lernen nicht superb ist

Wir wissen, dass KI-Modelle auf großen Datenmengen basieren, doch viele der nützlichsten Daten sind sensibel, verteilt und schwer zugänglich. Denken Sie an Daten in Krankenhäusern, Telefonen, Autos, Sensoren und anderen Edge-Systemen. Datenschutzbedenken, lokale Regeln, begrenzter Speicher und Netzwerkbeschränkungen machen die Übertragung dieser Daten an einen zentralen Ort sehr schwierig oder sogar unmöglich. Dadurch bleiben große Mengen wertvoller Daten ungenutzt. Im Gesundheitswesen ist dieses Downside besonders sichtbar. Krankenhäuser erzeugen jedes Jahr Dutzende Petabytes an Daten, Studien gehen jedoch davon aus, dass es bis zu 10 Petabytes an Daten sind 97 % dieser Daten bleiben ungenutzt.

Traditionelles maschinelles Lernen geht davon aus, dass alle Trainingsdaten an einem Ort gesammelt werden können, normalerweise auf einem zentralen Server oder Rechenzentrum. Dies funktioniert, wenn Daten frei verschoben werden können, funktioniert jedoch nicht, wenn die Daten privat oder geschützt sind. In der Praxis hängt ein zentralisiertes Coaching auch von stabiler Konnektivität, ausreichender Bandbreite und geringer Latenz ab, was in verteilten oder Edge-Umgebungen nur schwer zu gewährleisten ist.

In solchen Fällen gibt es zwei häufige Möglichkeiten. Eine Möglichkeit besteht darin, die Daten überhaupt nicht zu nutzen, was bedeutet, dass wertvolle Informationen in Silos eingeschlossen bleiben.

Die andere Möglichkeit besteht darin, jede lokale Entität ein Modell anhand ihrer eigenen Daten trainieren zu lassen und nur das weiterzugeben, was das Modell lernt, während die Rohdaten niemals ihren ursprünglichen Speicherort verlassen. Diese zweite Possibility bildet die Grundlage des föderierten Lernens, das es Modellen ermöglicht, aus verteilten Daten zu lernen, ohne diese zu verschieben. Ein bekanntes Beispiel ist Google Gboard auf Androidwo Funktionen wie die Vorhersage des nächsten Wortes und Intelligentes Verfassen laufen auf Hunderten Millionen Geräten.

Föderiertes Lernen: Das Modell auf die Daten übertragen

Föderiertes Lernen kann als eine kollaborative Einrichtung für maschinelles Lernen betrachtet werden, bei der das Coaching stattfindet, ohne dass Daten an einem zentralen Ort gesammelt werden. Bevor wir uns ansehen, wie es unter der Haube funktioniert, sehen wir uns einige Beispiele aus der Praxis an, die zeigen, warum dieser Ansatz in Umgebungen mit hohem Risiko wichtig ist, die sich über Bereiche vom Gesundheitswesen bis hin zu sicherheitsrelevanten Umgebungen erstrecken.

Gesundheitspflege

Im Gesundheitswesen wird föderiertes Lernen frühzeitig ermöglicht COVID-Screening durch Kuriale KIein System, das in mehreren NHS-Krankenhäusern unter Verwendung routinemäßiger Vitalparameter und Bluttests trainiert wird. Da Patientendaten nicht zwischen Krankenhäusern ausgetauscht werden konnten, wurde die Schulung lokal an jedem Standort durchgeführt und es wurden nur Modellaktualisierungen ausgetauscht. Das resultierende globale Modell ließ sich besser verallgemeinern als Modelle, die in einzelnen Krankenhäusern trainiert wurden, insbesondere wenn es an unbekannten Standorten evaluiert wurde.

Medizinische Bildgebung

Föderiertes Lernen wird auch in der medizinischen Bildgebung untersucht. Forscher am UCL und am Moorfields Eye Hospital nutzen es dazu Feinabstimmung großer Imaginative and prescient Basis-Modelle bei Scans empfindlicher Augen das lässt sich nicht zentralisieren.

Verteidigung

Über das Gesundheitswesen hinaus wird föderiertes Lernen auch in anderen Bereichen eingesetzt sicherheitsrelevante Bereiche wie Verteidigung und Luftfahrt. Dabei werden Modelle auf verteilte physiologische und betriebliche Daten trainiert, die lokal bleiben müssen.

Verschiedene Arten des Federated Studying

Auf einer übergeordneten Ebene kann Federated Studying basierend auf einigen gängigen Typen gruppiert werden wer die Kunden sind Und wie die Daten aufgeteilt werden.

• Geräteübergreifendes vs. siloübergreifendes föderiertes Lernen

Geräteübergreifendes föderiertes Lernen Die Nutzung vieler Purchasers, die bis zu Millionen umfassen können, wie persönliche Geräte oder Telefone, umfasst jeweils eine kleine Menge lokaler Daten und eine unzuverlässige Konnektivität. Zu einem bestimmten Zeitpunkt nimmt jedoch nur ein kleiner Bruchteil der Geräte an einer bestimmten Runde teil. Google Gboard ist ein typisches Beispiel für dieses Setup.

Siloübergreifend föderiertes Lernen, auf der anderen Seite, Beteiligt ist eine viel kleinere Anzahl von Kunden, in der Regel Organisationen wie Krankenhäuser oder Banken. Jeder Consumer verfügt über einen großen Datensatz und verfügt über stabile Rechenleistung und Konnektivität. Die meisten realen Anwendungsfälle in Unternehmen und im Gesundheitswesen sehen aus wie siloübergreifendes, föderiertes Lernen.

• Horizontales vs. vertikales föderiertes Lernen

Horizontales föderiertes Lernen beschreibt, wie Daten auf mehrere Purchasers aufgeteilt werden. In diesem Fall teilen sich alle Purchasers den gleichen Characteristic-Area, aber jeder enthält unterschiedliche Samples. Beispielsweise können mehrere Krankenhäuser dieselben medizinischen Variablen erfassen, jedoch für unterschiedliche Patienten. Dies ist die häufigste Type des föderierten Lernens.

Vertikales föderiertes Lernen wird verwendet, wenn Purchasers denselben Entitätssatz teilen, aber über unterschiedliche Funktionen verfügen. Beispielsweise verfügen möglicherweise ein Krankenhaus und ein Versicherungsanbieter über Daten zu denselben Personen, jedoch mit unterschiedlichen Attributen. Das Coaching erfordert in diesem Fall eine sichere Koordination, da sich die Characteristic-Räume unterscheiden, und dieser Aufbau ist weniger verbreitet als horizontales föderiertes Lernen.

Diese Kategorien schließen sich gegenseitig nicht aus. Ein reales System wird oft mit beiden Achsen beschrieben, zum Beispiel a Siloübergreifendes, horizontales föderiertes Lernen aufstellen.

Wie Federated Studying funktioniert

Federated Studying folgt einem einfachen, wiederholten Prozess, der von einem zentralen Server koordiniert und von mehreren Purchasers ausgeführt wird, die Daten lokal speichern, wie im Diagramm unten dargestellt.

Das Coaching im föderierten Lernen erfolgt durch Wiederholung Verbundlernrunden. In jeder Runde wählt der Server eine kleine zufällige Teilmenge von Purchasers aus, sendet ihnen die aktuellen Modellgewichte und wartet auf Aktualisierungen. Jeder Consumer trainiert das Modell lokal mit stochastischer Gradientenabstiegnormalerweise für mehrere lokale Epochen in eigenen Stapeln, und gibt nur die aktualisierten Gewichte zurück. Auf hoher Ebene folgt es den folgenden fünf Schritten:

1. Initialisierung

Auf dem Server wird ein globales Modell erstellt, das als Koordinator fungiert. Das Modell kann zufällig initialisiert werden oder in einem vorab trainierten Zustand beginnen.

2. Modellverteilung

In jeder Runde wählt der Server eine Reihe von Purchasers aus (basierend auf Zufallsstichproben oder einer vordefinierten Strategie), die am Coaching teilnehmen, und sendet ihnen die aktuellen globalen Modellgewichte. Bei diesen Purchasers kann es sich um Telefone, IoT-Geräte oder einzelne Krankenhäuser handeln.

3. Lokale Ausbildung

Jeder ausgewählte Consumer trainiert das Modell dann lokal mit seinen eigenen Daten. Die Daten verlassen nie den Kunden und alle Berechnungen erfolgen auf dem Gerät oder innerhalb einer Organisation wie einem Krankenhaus oder einer Financial institution.

4. Modellaktualisierungskommunikation

Nach dem lokalen Coaching senden Purchasers nur die aktualisierten Modellparameter (z. B. Gewichtungen oder Gradienten) an den Server zurück, während Rohdaten jederzeit geteilt werden.

5. Aggregation

Der Server aggregiert die Consumer-Updates, um ein neues globales Modell zu erstellen. Während Föderierte Mittelwertbildung (Fed Avg) ist ein gängiger Ansatz für die Aggregation, Es werden auch andere Strategien verwendet. Das aktualisierte Modell wird dann an die Purchasers zurückgesendet und der Vorgang wiederholt sich bis zur Konvergenz.

Federated Studying ist ein iterativer Prozess und jeder Durchgang durch diese Schleife wird als Runde bezeichnet. Das Coaching eines föderierten Modells erfordert normalerweise viele Runden, manchmal Hunderte, abhängig von Faktoren wie Modellgröße, Datenverteilung und dem zu lösenden Downside.

Mathematische Instinct hinter Federated Averaging

Der oben beschriebene Workflow kann auch formeller geschrieben werden. Die Abbildung unten zeigt das Unique Föderierte Mittelwertbildung (Fed Avg) Algorithmus von Googles bahnbrechendes Papier. Dieser Algorithmus wurde später zum Hauptbezugspunkt und zeigte, dass föderiertes Lernen in der Praxis funktionieren kann. Diese Formulierung wurde heute tatsächlich zum Bezugspunkt für die meisten föderierten Lernsysteme.

Der ursprüngliche Federated Averaging-Algorithmus, der die Server-Consumer-Trainingsschleife und die gewichtete Aggregation lokaler Modelle zeigt.
Das Herzstück von Federated Averaging ist der Aggregationsschritt, bei dem der Server das globale Modell aktualisiert, indem er einen gewichteten Durchschnitt der lokal trainierten Clientmodelle ermittelt. Dies kann wie folgt geschrieben werden:

Diese Gleichung macht deutlich, wie jeder Kunde zum globalen Modell beiträgt. Kunden mit mehr lokalen Daten haben einen größeren Einfluss, während Kunden mit weniger Stichproben proportional weniger beitragen. In der Praxis ist diese einfache Idee der Grund, warum Fed Avg zur Standardbasis für föderiertes Lernen wurde.

Eine einfache NumPy-Implementierung

Schauen wir uns ein Minimalbeispiel an, bei dem fünf Kunden ausgewählt wurden. Der Einfachheit halber gehen wir davon aus, dass jeder Kunde das lokale Coaching bereits abgeschlossen hat und seine aktualisierten Modellgewichte zusammen mit der Anzahl der verwendeten Proben zurückgegeben hat. Anhand dieser Werte berechnet der Server eine gewichtete Summe, die das neue globale Modell für die nächste Runde erzeugt. Dies spiegelt direkt die Fed-Durchschnittsgleichung wider, ohne dass Schulungen oder kundenseitige Particulars eingeführt werden müssen.

import numpy as np

# Consumer fashions after native coaching (w_{t+1}^ok)
client_weights = (
    np.array((1.0, 0.8, 0.5)),     # consumer 1
    np.array((1.2, 0.9, 0.6)),     # consumer 2
    np.array((0.9, 0.7, 0.4)),     # consumer 3
    np.array((1.1, 0.85, 0.55)),   # consumer 4
    np.array((1.3, 1.0, 0.65))     # consumer 5
)

# Variety of samples at every consumer (n_k)
client_sizes = (50, 150, 100, 300, 4000)

# m_t = whole variety of samples throughout chosen shoppers S_t
m_t = sum(client_sizes) # 50+150+100+300+400

# Initialize international mannequin w_{t+1}
w_t_plus_1 = np.zeros_like(client_weights(0))

# FedAvg aggregation:

# w_{t+1} = sum_{ok in S_t} (n_k / m_t) * w_{t+1}^ok
# (50/1000) * w_1 + (150/1000) * w_2 + ...

for w_k, n_k in zip(client_weights, client_sizes):
    w_t_plus_1 += (n_k / m_t) * w_k

print("Aggregated international mannequin w_{t+1}:", w_t_plus_1)
-------------------------------------------------------------
Aggregated international mannequin w_{t+1}: (1.27173913 0.97826087 0.63478261)

Wie die Aggregation berechnet wird

Um die Dinge ins rechte Licht zu rücken: Wir können den Aggregationsschritt auf nur zwei Kunden erweitern und sehen, wie die Zahlen übereinstimmen.

Herausforderungen in föderierten Lernumgebungen

Föderiertes Lernen bringt seine eigenen Herausforderungen mit sich. Eines der Hauptprobleme bei der Implementierung besteht darin, dass die Daten zwischen den Purchasers häufig nicht-IID (nicht unabhängig und identisch verteilt) sind. Dies bedeutet, dass verschiedene Purchasers möglicherweise sehr unterschiedliche Datenverteilungen sehen, was wiederum das Coaching verlangsamen und das globale Modell instabiler machen kann. Beispielsweise können Krankenhäuser in einer Föderation unterschiedliche Bevölkerungsgruppen versorgen, die unterschiedlichen Mustern folgen können.

Föderierte Systeme können alles umfassen, von einigen wenigen Organisationen bis hin zu Millionen von Geräten, und die Verwaltung von Beteiligung, Abbrüchen und Aggregation wird mit zunehmender Systemgröße schwieriger.

Während föderiertes Lernen die Rohdaten lokal hält, löst es keine vollständige Lösung Privatsphäre von allein. Bei Modellaktualisierungen können immer noch personal Informationen verloren gehen, wenn sie nicht geschützt sind. Daher sind häufig zusätzliche Datenschutzmethoden erforderlich. Endlich, Kommunikation kann eine Quelle von Engpässen sein. Da Netzwerke langsam oder unzuverlässig sein können und das Senden häufiger Updates kostspielig sein kann.

Fazit und wie es weitergeht

In diesem Artikel haben wir verstanden, wie föderiertes Lernen auf hohem Niveau funktioniert, und sind auch eine einfache Numpy-Implementierung durchgegangen. Anstatt jedoch die Kernlogik von Hand zu schreiben, gibt es Frameworks wie Flower, die eine einfache und versatile Möglichkeit zum Aufbau föderierter Lernsysteme bieten. Im nächsten Teil nutzen wir Flower, um die schwere Arbeit für uns zu erledigen, damit wir uns auf das Modell und die Daten konzentrieren können und nicht auf die Mechanismen des föderierten Lernens. Wir werden auch einen Blick darauf werfen föderierte LLMswo Modellgröße, Kommunikationskosten und Datenschutzbeschränkungen noch wichtiger werden.

Hinweis: Alle Bilder wurden, sofern nicht anders angegeben, vom Autor erstellt.

Kundenorientierte Plattformen sind für moderne Unternehmen unerlässlich. Von E-Commerce-Web sites bis hin zu Datenportaleverarbeiten diese Plattformen vertrauliche Informationen, einschließlich personenbezogener Daten, Zahlungsdetails und Kontoanmeldeinformationen. Der Schutz dieser Daten ist von entscheidender Bedeutung, da Verstöße das Vertrauen schädigen, zu behördlichen Strafen und finanziellen Verlusten führen können. Eine klare Herangehensweise an Cybersicherheit stellt sicher, dass sowohl das Unternehmen als auch seine Kunden sicher bleiben.

Implementieren Sie eine starke Authentifizierung

Die Authentifizierung ist die erste Verteidigungslinie. Die Multi-Faktor-Authentifizierung fügt eine wichtige Schutzebene hinzu, indem sie über ein Passwort hinaus eine zusätzliche Verifizierung erfordert. Biometrie, Authentifizierungs-Apps und Einmalcodes verringern das Risiko eines unbefugten Zugriffs erheblich. Kennwortrichtlinien, die Komplexität und regelmäßige Änderungen erzwingen, tragen ebenfalls zum Schutz von Konten bei. Unternehmen sollten Benutzer in der Erstellung sicherer Passwörter schulen und gängige Phishing-Taktiken erkennen, mit denen schwache Authentifizierungsmaßnahmen umgangen werden können.

Verschlüsseln Sie ruhende und übertragene Daten

Durch die Verschlüsselung wird sichergestellt, dass smart Daten für Unbefugte unlesbar bleiben. Auf Servern oder Datenbanken gespeicherte Daten sowie über Netzwerke übertragene Informationen sollten starke Verschlüsselungsprotokolle verwenden. Transport Layer Safety (TLS) schützt Daten während der Übertragung, während Superior Encryption Commonplace (AES) für ruhende Daten allgemein empfohlen wird. Regelmäßige Prüfungen der Verschlüsselungspraktiken und Schlüsselverwaltungsrichtlinien verhindern potenzielle Schwachstellen und stellen die Einhaltung von Industriestandards sicher.

Überwachen und prüfen Sie den Zugriff

Eine kontinuierliche Überwachung des Plattformzugriffs ist von entscheidender Bedeutung. Durch die Protokollierung von Benutzeraktivitäten und die Überprüfung von Zugriffsmustern können Anomalien erkannt werden, die auf böswilliges Verhalten hinweisen können. Verdächtige Anmeldeversuche, unregelmäßige Transaktionsmuster und plötzliche Änderungen im Benutzerverhalten sollten Warnungen zur sofortigen Untersuchung auslösen. Durch die Durchführung regelmäßiger Audits wird sichergestellt, dass nur autorisiertes Private Zugriff auf kritische Systeme und Kundendaten hat.

Aktualisieren und patchen Sie die Software program regelmäßig

Schwachstellen in Software program können Chancen für Cyberangriffe schaffen. Regelmäßige Updates und Patch-Administration verhindern die Ausnutzung bekannter Schwachstellen. Dazu gehört die Aktualisierung der zugrunde liegenden Plattform, der Webanwendungen und aller Integrationen, einschließlich der Dienste von Drittanbietern. Kommerzielle Banking-Software programBeispielsweise müssen sie mit den neuesten Patches gepflegt werden, um Finanztransaktionen und smart Kundendaten vor neuen Bedrohungen zu schützen.

Informieren Sie Mitarbeiter und Benutzer

Menschliches Versagen bleibt eine der Hauptursachen für Datenschutzverletzungen. Mitarbeiter und Kunden sollten fortlaufend Anleitung zu sicheren On-line-Praktiken erhalten. Die Schulung sollte das Erkennen von Phishing-Versuchen, das Vermeiden verdächtiger Downloads und das Melden potenzieller Sicherheitsvorfälle umfassen. Eine klare Kommunikation fördert eine Sicherheitskultur, in der sich Benutzer zu proaktivem Handeln befähigt fühlen.

Entwickeln Sie einen Reaktionsplan für Vorfälle

Selbst bei starken Abwehrmaßnahmen kann es zu Verstößen kommen. Ein Vorfallreaktionsplan gewährleistet eine schnelle Eindämmung, Untersuchung und Wiederherstellung. Durch die Definition von Rollen, Kommunikationsprotokollen und Eskalationsverfahren werden Ausfallzeiten minimiert und Schäden begrenzt. Das regelmäßige Testen des Plans verbessert die Bereitschaft und trägt dazu bei, das Vertrauen der Kunden im Falle eines Vorfalls aufrechtzuerhalten.

Kundenorientierte Plattformen müssen Zugänglichkeit und Sicherheit in Einklang bringen. Durch die Implementierung starker Authentifizierung, Verschlüsselung, Überwachung, Software program-Updates, Benutzerschulung und Verfahren zur Reaktion auf Vorfälle wird eine sichere Umgebung für smart Daten geschaffen. Unternehmen, die proaktive Maßnahmen ergreifen, reduzieren Risiken, stärken das Vertrauen der Kunden und wahren gleichzeitig die Compliance in einem zunehmend digitalen Markt. Um mehr zu erfahren, schauen Sie sich die Infografik unten an.

Bild von Editor | Chatgpt

Das Visualisierung von Daten kann sich anfühlen, um zu versuchen, ein Meisterwerk mit einem stumpfen Bleistift zu skizzieren. Sie wissen, was Sie erstellen möchten, aber das Werkzeug in Ihrer Hand ist einfach nicht kooperiert. Wenn Sie jemals ein Durcheinander von Code gestarrt haben und Ihr Matplotlib -Diagramm weniger wie eine unordentliche Ausgabe aussehen lassen, sind Sie nicht allein.

Ich erinnere mich an mein erstes Mal mit Matplotlib. Ich musste Temperaturdaten für ein Projekt zeichnen, und nach stundenlangem Googeln „Wie man X-Achse-Etiketten dreht“ hatte ich ein Diagramm, das so aussah, als ob es einen Twister überlebte. Klingt vertraut? Deshalb habe ich diesen Leitfaden zusammengestellt – um Ihnen zu helfen, die Frustration zu überspringen und saubere, professionelle Handlungen zu erstellen, die tatsächlich Sinn machen.

Warum Matplotlib? (Und warum es sich manchmal klobig anfühlt)

Matplotlib ist der Großvater von Python -Ploting -Bibliotheken. Es ist mächtig, flexibel und … sagen wir, schrullig. Anfänger stellen oft Fragen wie:

• „Warum erfordert etwas so Einfaches wie ein Balkendiagramm 10 Codezeilen?“
• „Wie kann ich meine Handlungen davon abhalten, aus 1995 auszusehen?“
• „Gibt es eine Möglichkeit, dies weniger schmerzhaft zu machen?“

Die kurze Antwort auf diese? Ja.

Matplotlib verfügt über eine Lernkurve, aber sobald Sie seine Logik erfasst, werden Sie endlose Anpassungen freischalten. Stellen Sie sich vor, Sie lernen, dass Sie zuerst eine Schaltschicht fahren lassen: Sie werden jedoch bald ohne nachzudenken.

Erste Schritte: Ihre erste Handlung in 5 Minuten

Bevor wir in fortgeschrittene Methods eintauchen, nageln wir die Grundlagen. Installieren Matplotlib mit pip set up matplotlibVersuchen Sie es dann.

Erstes, was zu tun ist: Importieren Sie Matplotlib auf herkömmliche Weise.

import matplotlib.pyplot as plt

Erstellen wir einige Beispieldaten:

years = (2010, 2015, 2020)
gross sales = (100, 250, 400)

Lassen Sie uns nun eine Figur und eine Achse erstellen:

Zeit, um die Daten zu zeichnen:

ax.plot(years, gross sales, marker="o", linestyle="--", colour="inexperienced")

Fügen Sie nun Etiketten und einen Titel hinzu:

ax.set_xlabel('Yr')
ax.set_ylabel('Gross sales (in 1000's)')
ax.set_title('Firm Development: 2010-2020')

Schließlich müssen wir das Diagramm anzeigen:

Was passiert hier?

• plt.subplots() erstellt eine Figur (die Leinwand) und eine Achse (der Plotbereich)
• ax.plot() Zeichnet ein Zeilendiagramm. Die Marker-, Linestyle- und Farbargumente jazzieren es auf
• Etiketten und Titel werden mit hinzugefügt mit hinzugefügt set_xlabel()Anwesend set_ylabel()Und set_title()

Professional -Tipp: Beschriften Sie Ihre Achsen immer! Eine unbeschreibene Handlung bringt Verwirrung und erscheint unprofessionell.

Die Anatomie eines Matplotlib -Diagramms

Um Matplotlib zu beherrschen, müssen Sie seine Sprache sprechen. Hier ist eine Aufschlüsselung der Schlüsselkomponenten:

• Abbildung: Das gesamte Fenster oder die gesamte Seite. Es ist das große Bild.
• Achsen: Wo das Diagramm passiert. Eine Figur kann mehrere Achsen haben (denken Sie an Nebenhandlungen).
• Achse: Die X- und Y -Herrscher, die die Datengrenzen definieren.
• Künstler: Alles, was Sie sehen, von Textual content über Linien bis hin zu Markierungen.

Verwirrt über Figuren gegen Achsen? Stellen Sie sich die Figur als Bilderrahmen und die Achsen als Foto im Inneren vor.

Nächste Schritte

OK, es ist Zeit, deinen PLOST zu machen … weniger hässlich. Matplotlibs Standardstil schreit „Akademisches Papier von 2003“. Lassen Sie uns es modernisieren. Hier sind einige Strategien.

1. Verwenden Sie Stylesheets

Stylesheets sind vorkonfigurierte Paletten, um Ihre Arbeit zusammenhängende Färbung zu verleihen:

Weitere Optionen, die Sie für die Stylesheet -Farbkonfigurationen verwenden können seabornAnwesend fivethirtyeightAnwesend dark_background.

2. Anpassen Sie Farben und Schriftarten

Geben Sie sich nicht mit den Standardfarben oder Schriftarten zufrieden und fügen Sie eine gewisse Personalisierung hinzu. Es braucht nicht viel, um dies zu tun:

ax.plot(years, gross sales, colour="#2ecc71", linewidth=2.5)
ax.set_xlabel('Yr', fontsize=12, fontfamily='Arial')

3. Fügen Sie Gitter hinzu (aber sparsam)

Sie möchten nicht, dass Netze überwältigend werden, aber wenn Sie sie garantiert haben, können Sie Ihre Arbeit ein gewisses Aptitude und Nutzen bringen:

ax.grid(True, linestyle="--", alpha=0.6) 

4.. Anmerkende wichtige Punkte

Gibt es einen Datenpunkt, der eine zusätzliche Erklärung benötigt? Annotieren Sie gegebenenfalls:

ax.annotate('Document Gross sales in 2020!', xy=(2020, 400), xytext=(2018, 350),
    arrowprops=dict(facecolor="black", shrink=0.05))

Aufwertung: Fortgeschrittene Techniken

1. Nebenhandlungen: Multitasking für Handlungen

Wenn Sie mehrere Diagramme nebeneinander anzeigen müssen, erstellen Sie Sublots, um 2 Zeilen und 1 Spalte zu erstellen.

fig, axes = plt.subplots(nrows=2, ncols=1, figsize=(8, 6)) axes(0).plot(years, gross sales, colour="blue")  
axes(1).scatter(years, gross sales, colour="pink")  
plt.tight_layout()

Die letzte Zeile verhindert überlappend.

2. Wärme- und Konturdiagramme

Visualisieren Sie 3D -Daten in 2D:

import numpy as np

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

contour = ax.contourf(X, Y, Z, cmap='viridis')

Wenn Sie eine Farbskala hinzufügen möchten:

3. Interaktive Diagramme

Zeit, um Ihre Diagramme anklicken zu lassen mplcursors:

import mplcursors

line, = ax.plot(years, gross sales)
mplcursors.cursor(line).join("add", lambda sel: sel.annotation.set_text(f"Gross sales: ${sel.goal(1)}ok"))

Einpacken

Bevor Sie hier rauskommen, werfen wir einen kurzen Blick auf die gängigen Matplotlib -Kopfschmerzen und deren Korrekturen:

• „Meine Etiketten sind abgeschnitten!“ – Verwenden plt.tight_layout() oder die Polsterung mit Abb.
• „Warum ist meine Handlung leer?!“ – vergessen plt.present() Jupyter verwenden? Hinzufügen %matplotlib an der Spitze inline
• „Die Schriftarten sehen pixelig aus“ – Vektorformate (PDF, SVG) mit speichern plt.savefig('plot.pdf', dpi=300)

Wenn Sie bereit sind, selbst zu experimentieren, sollten Sie jetzt einige Herausforderungen machen, die Sie jetzt abschließen können. Wenn Sie stecken bleiben, teilen Sie Ihren Code in den Kommentaren und lassen Sie uns gemeinsam beheben.

• Passen Sie ein Histogramm an die Markenfarben Ihres Unternehmens an
• Erstellen Sie ein Diagramm aus einem kürzlich veröffentlichten Nachrichtenartikel so intestine Sie können
• Animieren Sie ein Diagramm, das Datenänderungen im Laufe der Zeit zeigt (Hinweis: Versuchen Sie FuncAnimation)

Zuletzt entwickelt sich Matplotlib, ebenso wie Ihr Wissen. Setzen Sie ein Lesezeichen für diese Ressourcen, um sie beim Fortschritt zu überprüfen:

Abschluss

Matplotlib ist nicht nur eine Bibliothek – es ist ein Toolkit für das Geschichtenerzählen. Unabhängig davon, ob Sie Klimadaten visualisieren oder Verkaufstrends darstellen, ist das Ziel Klarheit. Denken Sie daran, selbst Experten Google „Wie man manchmal eine zweite Y-Achse hinzufügt“. Der Schlüssel ist, einfach zu beginnen, oft zu iterieren und die Dokumentation nicht fürchten.

Shittu Olumide ist ein Software program-Ingenieur und technischer Autor, der sich leidenschaftlich für die Nutzung hochmoderner Technologien für überzeugende Erzählungen befindet, mit einem scharfen Auge für Particulars und einem Händchen zur Vereinfachung komplexer Konzepte. Sie können auch Shittu finden Twitter.

Bild von Autor | Leinwand

Haben Sie jemals ein Python -Skript ausgeführt und wünscht sich sofort, Sie hätten die Eingabetaste nicht gedrückt?

Das Debuggen in der Datenwissenschaft ist nicht nur eine Handlung. Es ist eine Überlebensfähigkeit – insbesondere im Umgang mit unordentlichen Datensätzen oder der Entwicklung von Vorhersagemodellen, auf die sich tatsächliche Menschen verlassen.

In diesem Artikel werden wir die Grundlagen des Debuggens untersuchen, insbesondere in Ihren Datenwissenschafts-Workflows, indem wir einen realen Datensatz aus einem Doordash-Zustellungsjob und vor allem wie ein Profi debuggen.

Doordash -Lieferdauer Vorhersage: Womit haben wir es zu tun?

In diesen Daten ProjektDoordash bat seine Datenwissenschaftskandidaten, die Lieferdauer vorherzusagen. Schauen wir uns zuerst die Datensatzinformationen an. Hier ist der Code:

Hier ist die Ausgabe:

Es scheint, dass sie die Lieferdauer nicht zur Verfügung gestellt haben, additionally sollten Sie sie hier berechnen. Es ist einfach, aber keine Sorgen, wenn Sie Anfänger sind. Mal sehen, wie es berechnet werden kann.

import pandas as pd
from datetime import datetime

# Assuming historical_data is your DataFrame
historical_data("created_at") = pd.to_datetime(historical_data('created_at'))
historical_data("actual_delivery_time") = pd.to_datetime(historical_data('actual_delivery_time'))
historical_data("actual_total_delivery_duration") = (historical_data("actual_delivery_time") - historical_data("created_at")).dt.total_seconds()
historical_data.head()

Hier ist der Kopf des Ausgangs; Sie können das sehen actual_total_delivery_duration.

Intestine, jetzt können wir anfangen! Aber davor ist hier die Datendefinitionssprache für diesen Datensatz.

Spalten in historical_data.csv

Zeitfunktionen:

• Market_ID: Eine Stadt/Area, in der Doordash tätig ist, z. B. Los Angeles, angegeben in den Daten als ID.
• erstellt_at: Zeitstempel in UTC, als der Verbraucher doordash eingereicht wurde. (Hinweis: Dieser Zeitstempel befindet sich in UTC, aber falls Sie es benötigen, conflict die tatsächliche Zeitzone der Area US/Pacific).
• TRIX_DELIVERY_TIME: Zeitstempel in UTC, wenn die Bestellung an den Verbraucher geliefert wurde.

Speicherfunktionen:

• store_id: Eine ID, die das Restaurant repräsentiert, für die die Bestellung eingereicht wurde.
• store_primary_category: Küche Kategorie des Eating places, z. B. Italienisch, Asiaten.
• Order_Protocol: Ein Geschäft kann über viele Modi Bestellungen von Doordash erhalten. Dieses Feld repräsentiert eine ID, die das Protokoll bezeichnet.

Bestellfunktionen:

• Total_items: Gesamtzahl der Elemente in der Reihenfolge.
• Subtotal: Gesamtwert der eingereichten Bestellung (in Cent).
• num_distinct_items: Anzahl der in der Reihenfolge enthaltenen unterschiedlichen Elemente.
• min_item_price: Preis des Artikels mit den geringsten Kosten in der Bestellung (in Cent).
• MAX_ITEM_PRICE: Preis des Artikels mit den höchsten Kosten in der Bestellung (in Cent).

Marktmerkmale:

Als Marktplatz haben wir Informationen über den Zustand des Marktes, wenn die Bestellung aufgegeben wird, die zur Schätzung der Lieferzeit verwendet werden können. Die folgenden Merkmale sind Werte zum Zeitpunkt von created_at (Einreichungszeit bestellen):

• Total_onShift_Dashers: Anzahl der verfügbaren Dashers, die zum Zeitpunkt der Auftragserstellung innerhalb von 10 Meilen vom Laden entfernt sind.
• Total_busy_dashers: Teilmenge des obigen total_onshift_dashers die derzeit an einer Bestellung arbeiten.
• Total_outhting_orders: Anzahl der Bestellungen innerhalb von 10 Meilen nach dieser Bestellung, die derzeit bearbeitet werden.

Vorhersagen aus anderen Modellen:

Wir haben Vorhersagen aus anderen Modellen für verschiedene Phasen des Lieferprozesses, den wir verwenden können:

• geschätzt_order_place_duration: Geschätzte Zeit für das Restaurant, um die Bestellung von Doordash (in Sekunden) zu erhalten.
• ESTAUATATED_STORE_TO_CONSUMER_DRIVING_DIERUNG: Geschätzte Reisezeit zwischen Retailer und Verbraucher (in Sekunden).

Großartig, additionally lass uns anfangen!

Gemeinsame Python -Fehler in Datenwissenschaftsprojekten

In diesem Abschnitt werden wir gemeinsame Debugging -Fehler in einem der entdecken DatenwissenschaftsprojekteBeginnen Sie mit dem Lesen des Datensatzes und dem wichtigsten Teil: Modellierung.

Lesen des Datensatzes: FileNotFoundErrorDTYPE -Warnung und Korrekturen

Fall 1: Datei nicht gefunden – Klassiker

In der Information Science begrüßt Ihr erster Fehler Sie oft bei read_csv. Und nicht mit einem Hallo. Lassen Sie uns diesen genauen Second zusammen debuggen, Linie für Linie. Hier ist der Code:

import pandas as pd

strive:
    df = pd.read_csv('Strata Questions/historical_data.csv')
    df.head(3)
besides FileNotFoundError as e:
    import os
    print("File not discovered. Here is the place Python is wanting:")
    print("Working listing:", os.getcwd())
    print("Accessible recordsdata:", os.listdir())
    increase e

Hier ist die Ausgabe.

Sie erhöhen nicht nur einen Fehler – Sie befragen ihn. Dies zeigt, wo der Code denkt, dass er ist und was er um ihn herum sieht. Wenn Ihre Datei nicht in der Liste steht, wissen Sie jetzt. Keine Vermutung. Nur Fakten.

Ersetzen Sie den Pfad durch den vollen und voilà!

Fall 2: DTYPE -Fehlinterpretation – Pythons leise falscher Vermutung

Sie laden den Datensatz, aber etwas ist aus. Der Fehler versteckt sich in Ihren Typen.

# Assuming df is your loaded DataFrame
strive:
    print("Column Varieties:n", df.dtypes)
besides Exception as e:
    print("Error studying dtypes:", e)

Hier ist die Ausgabe.

Fall 3: Datum an Parsen – Der stille Saboteur

Wir haben festgestellt, dass wir zuerst die Lieferdauer berechnen sollten, und wir haben sie mit dieser Methode gemacht.

strive:
    # This code was proven earlier to calculate the supply period
    df("created_at") = pd.to_datetime(df('created_at'))
    df("actual_delivery_time") = pd.to_datetime(df('actual_delivery_time'))
    df("actual_total_delivery_duration") = (df("actual_delivery_time") - df("created_at")).dt.total_seconds()
    print("Efficiently calculated supply period and checked dtypes.")
    print("Related dtypes:n", df(('created_at', 'actual_delivery_time', 'actual_total_delivery_duration')).dtypes)
besides Exception as e:
    print("Error throughout date processing:", e)

Hier ist die Ausgabe.

Intestine und professionell! Jetzt vermeiden wir diese roten Fehler, die unsere Stimmung erhöhen – ich weiß, dass es Ihre Motivation dämpfen kann.

Umgang mit fehlenden Daten: KeyErrorsAnwesend NaNsund logische Fallstricke

Einige Fehler stürzen Ihren Code nicht ab. Sie geben Ihnen nur die falschen Ergebnisse, bis Sie sich fragen, warum Ihr Modell Müll ist.

In diesem Abschnitt geht es zu fehlenden Daten – nicht nur, wie man sie reinigt, sondern wie man sie ordnungsgemäß debuggiert.

Fall 1: KeyError – Sie dachten, diese Spalte existierte

Hier ist unser Code.

strive:
    print(df('store_rating'))
besides KeyError as e:
    print("Column not discovered:", e)
    print("Listed below are the accessible columns:n", df.columns.tolist())

Hier ist die Ausgabe.

Der Code brach wegen der Logik nicht; Es brach wegen einer Annahme. Genau das ist der Debugging -Debugging. Pay attention Sie Ihre Spalten immer auf, bevor Sie sie blind zugreifen.

Fall 2: Nan Depend – Fehlende Werte, die Sie nicht erwartet haben

Sie nehmen an, alles ist sauber. Aber reale Daten vereinen immer Lücken. Lassen Sie uns nach ihnen suchen.

strive:
    null_counts = df.isnull().sum()
    print("Nulls per column:n", null_counts(null_counts > 0))
besides Exception as e:
    print("Failed to examine nulls:", e)

Hier ist die Ausgabe.

Dies enthüllt die stillen Unruhestifter. Vielleicht store_primary_category fehlt in Tausenden von Reihen. Vielleicht fehlgeschlagen Zeitstempel die Konvertierung und sind jetzt jetzt NaT.

Sie hätten es nicht gewusst, wenn Sie nicht überprüft hätten. Debugging – Bestätigung jeder Annahme.

Fall 3: Logische Fallstricke – Fehlende Daten, die tatsächlich nicht fehlen

Nehmen wir an, Sie versuchen, Bestellungen zu filtern, bei denen der Subtotal von mehr als 1.000.000 liegt und Hunderte von Reihen erwartet. Aber das gibt dir Null:

strive:
    filtered = df(df('subtotal') > 1000000)
    print("Rows with subtotal > 1,000,000:", filtered.form(0))
besides Exception as e:
    print("Filtering error:", e)

Das ist kein Codefehler – es ist ein logischer Fehler. Sie haben hochwertige Bestellungen erwartet, aber vielleicht gibt es keine über dieser Schwelle. Debuggen Sie es mit einem Reichweitescheck:

print("Subtotal vary:", df('subtotal').min(), "to", df('subtotal').max())

Hier ist die Ausgabe.

Fall 4: isna() ≠ Null bedeutet nicht, dass es sauber ist

Selbst wenn isna().sum() Zeigt Null an, es gibt möglicherweise schmutzige Daten wie Whitespace oder ‚None‘ als Zeichenfolge. Führen Sie eine aggressivere Überprüfung durch:

strive:
    fake_nulls = df(df('store_primary_category').isin(('', ' ', 'None', None)))
    print("Rows with faux lacking classes:", fake_nulls.form(0))
besides Exception as e:
    print("Pretend lacking worth test failed:", e)

Dies fängt versteckten Müll, das isnull() Fehler.

Function Engineering -Störungen: TypeErrorsDatum an Parsen und mehr

Function Engineering scheint zunächst Spaß zu haben, bis Ihre neue Spalte jedes Modell bricht oder a wirft TypeError Mittelpipeline. Hier erfahren Sie, wie Sie diese Section debuggen, wie jemand, der zuvor verbrannt wurde.

Fall 1: Sie denken, Sie können sich teilen, aber Sie können nicht

Lassen Sie uns eine neue Funktion erstellen. Wenn ein Fehler auftritt, ist unser try-except Block wird es fangen.

strive:
    df('value_per_item') = df('subtotal') / df('total_items')
    print("value_per_item created efficiently")
besides Exception as e:
    print("Error occurred:", e)

Hier ist die Ausgabe.

Keine Fehler? Intestine. Aber schauen wir uns genauer an.

print(df(('subtotal', 'total_items', 'value_per_item')).pattern(3))

Hier ist die Ausgabe.

Fall 2: Datum der Parsen schief gegangen

Jetzt ändern Sie Ihre dtype Ist wichtig, aber was ist, wenn Sie der Meinung sind, dass alles richtig gemacht wurde, aber Probleme bestehen bleiben?

# That is the usual method, however it may fail silently on blended sorts
df("created_at") = pd.to_datetime(df("created_at"))
df("actual_delivery_time") = pd.to_datetime(df("actual_delivery_time"))

Sie denken vielleicht, dass es in Ordnung ist, aber wenn Ihre Spalte gemischte Typen hat, kann sie stillschweigend scheitern oder Ihre Pipeline brechen. Deshalb ist es anstatt direkt Transformationen vorzunehmen, eine robuste Funktion zu verwenden.

from datetime import datetime

def parse_date_debug(df, col):
    strive:
        parsed = pd.to_datetime(df(col))
        print(f"(SUCCESS) '{col}' parsed efficiently.")
        return parsed
    besides Exception as e:
        print(f"(ERROR) Did not parse '{col}':", e)
        # Discover non-date-like values to debug
        non_datetimes = df(pd.to_datetime(df(col), errors="coerce").isna())(col).distinctive()
        print("Pattern values inflicting difficulty:", non_datetimes(:5))
        increase

df("created_at") = parse_date_debug(df, "created_at")
df("actual_delivery_time") = parse_date_debug(df, "actual_delivery_time")

Hier ist die Ausgabe.

Dies hilft Ihnen, fehlerhafte Zeilen zu verfolgen, wenn die Parsen von DateTime abfällt.

Fall 3: Naive Division, die irreführen könnte

Dies macht keinen Fehler in unseren Datenrahmen, da die Spalten bereits numerisch sind. Aber hier ist das Drawback: Einige Datensätze schleichen sich an Objekttypen, auch wenn sie wie Zahlen aussehen. Das führt zu:

• Irreführende Verhältnisse
• Falsches Modellverhalten
• Keine Warnungen

df("busy_dashers_ratio") = df("total_busy_dashers") / df("total_onshift_dashers")

Validieren wir vor dem Computertypen, auch wenn der Vorgang keinen Fehler macht.

import numpy as np

def create_ratio_debug(df, num_col, denom_col, new_col):
    num_type = df(num_col).dtype
    denom_type = df(denom_col).dtype

    if not np.issubdtype(num_type, np.quantity) or not np.issubdtype(denom_type, np.quantity):
        print(f"(TYPE WARNING) '{num_col}' or '{denom_col}' is just not numeric.")
        print(f"{num_col}: {num_type}, {denom_col}: {denom_type}")
        df(new_col) = np.nan
        return df
    
    if (df(denom_col) == 0).any():
        print(f"(DIVISION WARNING) '{denom_col}' incorporates zeros.")
    
    df(new_col) = df(num_col) / df(denom_col)
    return df

df = create_ratio_debug(df, "total_busy_dashers", "total_onshift_dashers", "busy_dashers_ratio")

Hier ist die Ausgabe.

Dies gibt eine Sichtbarkeit in potenziellen Problemen von Division zu Null und verhindert stille Fehler.

Modellierungsfehler: Formen Sie Mismatch und Bewertungsverwirrung

Fall 1: NAN -Werte in Funktionen bewirken das Modell zum Absturz

Nehmen wir an, wir wollen ein lineares Regressionsmodell erstellen. LinearRegression() unterstützt NAN -Werte nicht nativ. Wenn eine Zeile in X einen fehlenden Wert hat, weigert sich das Modell zu trainieren.

Hier ist der Code, der absichtlich eine Formfehlanpassung erstellt, um einen Fehler auszulösen:

from sklearn.linear_model import LinearRegression

X_train = df(("estimated_order_place_duration", "estimated_store_to_consumer_driving_duration")).iloc(:-10)
y_train = df("actual_total_delivery_duration").iloc(:-5) 
mannequin = LinearRegression()
mannequin.match(X_train, y_train)

Hier ist die Ausgabe.

Lassen Sie uns dieses Drawback debuggen. Erstens suchen wir nach Nans.

print(X_train.isna().sum())

Hier ist die Ausgabe.

Intestine, lass uns auch die andere Variable überprüfen.

print(y_train.isna().sum())

Hier ist die Ausgabe.

Die Mismatch- und NAN -Werte müssen gelöst werden. Hier ist der Code, um ihn zu beheben.

from sklearn.linear_model import LinearRegression

# Re-align X and y to have the identical size
X = df(("estimated_order_place_duration", "estimated_store_to_consumer_driving_duration"))
y = df("actual_total_delivery_duration")

# Step 1: Drop rows with NaN in options (X)
valid_X = X.dropna()

# Step 2: Align y to match the remaining indices of X
y_aligned = y.loc(valid_X.index)

# Step 3: Discover indices the place y is just not NaN
valid_idx = y_aligned.dropna().index

# Step 4: Create closing clear datasets
X_clean = valid_X.loc(valid_idx)
y_clean = y_aligned.loc(valid_idx)

mannequin = LinearRegression()
mannequin.match(X_clean, y_clean)
print("✅ Mannequin educated efficiently!")

Und voilà! Hier ist die Ausgabe.

Fall 2: Objektspalten (Daten) stürmen das Modell ab

Angenommen, Sie versuchen, ein Modell mit einem Zeitstempel wie zu trainieren actual_delivery_time.

Aber – oh nein – es ist immer noch ein Objekt oder ein DateTime -Typ, und Sie mischen es versehentlich mit numerischen Spalten. Lineare Regression magazine das nicht ein bisschen.

from sklearn.linear_model import LinearRegression

X = df(("actual_delivery_time", "estimated_order_place_duration"))
y = df("actual_total_delivery_duration")

mannequin = LinearRegression()
mannequin.match(X, y)

Hier ist der Fehlercode:

Sie kombinieren zwei inkompatible Datentypen in der X -Matrix:

• Eine Spalte (actual_delivery_time) Ist datetime64.
• Der andere (estimated_order_place_duration) Ist int64.

Scikit-Be taught erwartet, dass alle Funktionen gleich numerisch sind. Es kann nicht gemischte Typen wie DateTime und int verarbeiten. Lassen Sie es uns lösen, indem Sie die DateTime -Spalte in eine numerische Darstellung konvertieren (UNIX -Zeitstempel).

# Guarantee datetime columns are parsed accurately, coercing errors to NaT
df("actual_delivery_time") = pd.to_datetime(df("actual_delivery_time"), errors="coerce")
df("created_at") = pd.to_datetime(df("created_at"), errors="coerce")

# Recalculate period in case of recent NaNs
df("actual_total_delivery_duration") = (df("actual_delivery_time") - df("created_at")).dt.total_seconds()

# Convert datetime to a numeric function (Unix timestamp in seconds)
df("delivery_time_timestamp") = df("actual_delivery_time").astype("int64") // 10**9

Intestine. Nachdem die DTypes numerisch sind, wenden wir das ML -Modell an.

from sklearn.linear_model import LinearRegression

# Use the brand new numeric timestamp function
X = df(("delivery_time_timestamp", "estimated_order_place_duration"))
y = df("actual_total_delivery_duration")

# Drop any remaining NaNs from our function set and goal
X_clean = X.dropna()
y_clean = y.loc(X_clean.index).dropna()
X_clean = X_clean.loc(y_clean.index)

mannequin = LinearRegression()
mannequin.match(X_clean, y_clean)
print("✅ Mannequin educated efficiently!")

Hier ist die Ausgabe.

Toller Job!

Letzte Gedanken: Debuggen intelligenter, nicht härter

Modellabstürze stammen nicht immer aus komplexen Fehlern – manchmal ist es nur eine streunende Nan oder eine nicht konvertierte Date -Spalte, die sich in Ihre Datenpipeline schlich.

Anstatt mit kryptischen Stapelspuren oder Werfen zu ringen try-except Blöcke wie Darts im Dunkeln, graben früh in Ihren Datenrahmen ein. Blick auf .information()überprüfen .isna().sum()und scheuen Sie sich nicht vor .dtypes. Diese einfachen Schritte enthüllen versteckte Landminen, bevor Sie überhaupt getroffen haben match().

Ich habe Ihnen gezeigt, dass selbst ein übersehener Objekttyp oder ein hinterhältiger fehlender Wert ein Modell sabotieren kann. Mit einem schärferen Auge, einer saubereren Vorbereitung und einer absichtlichen Function -Extraktion wechseln Sie jedoch von Debugging reaktiv zum Aufbau clever.

Nate Rosidi ist Datenwissenschaftler und in Produktstrategie. Er ist außerdem eine zusätzliche Professorin für Lehranalysen und Gründer von Stratascratch, einer Plattform, die Datenwissenschaftlern hilft, sich auf ihre Interviews mit echten Interviewfragen von Prime -Unternehmen vorzubereiten. Nate schreibt über die neuesten Traits auf dem Karrieremarkt, gibt Interviewberatung, teilt Datenwissenschaftsprojekte und deckt alles SQL ab.

Vollständige Erklärung zur linearen Regression und wie sie lernt

So wie Herr Miyagi dem jungen Daniel LaRusso Karate durch sich wiederholende einfache Aufgaben beibrachte, die ihn schließlich in das Karate Child verwandelten, legt die Beherrschung grundlegender Algorithmen wie der linearen Regression den Grundstein für das Verständnis der komplexesten KI-Architekturen wie Deep Neural Networks und LLMs.

Durch diesen tiefen Einblick in die einfache, aber leistungsstarke lineare Regression lernen Sie viele der grundlegenden Teile kennen, die die fortschrittlichsten Modelle ausmachen, die heute von Milliardenunternehmen entwickelt werden.

Die lineare Regression ist eine einfache mathematische Methode, mit der die Beziehung zwischen zwei Variablen verstanden und Vorhersagen getroffen werden können. Bei einigen Datenpunkten, wie dem folgenden, versucht die lineare Regression, die zu zeichnen Linie der besten Passform durch diese Punkte. Es ist das „Wachs an, Wachs weg“ der Datenwissenschaft.

Sobald diese Linie gezogen ist, verfügen wir über ein Modell, mit dem wir neue Werte vorhersagen können. Im obigen Beispiel könnten wir bei einer gegebenen neuen Hausgröße versuchen, den Preis mit dem linearen Regressionsmodell vorherzusagen.

Die lineare Regressionsformel

Y ist die abhängige Variable, additionally das, was Sie berechnen möchten – der Hauspreis im vorherigen Beispiel. Sein Wert hängt von anderen Variablen ab, daher der Title.

X sind die unabhängigen Variablen. Dies sind die Faktoren, die den Wert von beeinflussen Y. Bei der Modellierung sind die unabhängigen Variablen die Eingaben für das Modell, und das, was das Modell ausspuckt, ist die Vorhersage oder Ŷ.

β sind Parameter. Den Namen Parameter geben wir den Werten, die das Modell anpasst (oder lernt), um die Beziehung zwischen den unabhängigen Variablen zu erfassen X und die abhängige Variable Y. Während das Modell trainiert wird, bleibt die Eingabe des Modells dieselbe, die Parameter werden jedoch angepasst, um die gewünschte Ausgabe besser vorherzusagen.

Parameterlernen

Wir benötigen einige Dinge, um die Parameter anpassen und genaue Vorhersagen erzielen zu können.

1. Trainingsdaten – diese Daten bestehen aus Eingabe- und Ausgabepaaren. Die Eingaben werden in das Modell eingespeist und während des Trainings werden die Parameter angepasst, um zu versuchen, den Zielwert auszugeben.
2. Die Kostenfunktion – auch Verlustfunktion genannt – ist eine mathematische Funktion, die misst, wie intestine die Vorhersage eines Modells mit dem Zielwert übereinstimmt.
3. Trainingsalgorithmus – ist eine Methode, mit der die Parameter des Modells angepasst werden, um den durch die Kostenfunktion gemessenen Fehler zu minimieren.

Sehen wir uns eine Kostenfunktion und einen Trainingsalgorithmus an, die in der linearen Regression verwendet werden können.

MSE ist eine häufig verwendete Kostenfunktion bei Regressionsproblemen, bei denen das Ziel darin besteht, einen kontinuierlichen Wert vorherzusagen. Dies unterscheidet sich von Klassifizierungsaufgaben, beispielsweise der Vorhersage des nächsten Tokens in einem Vokabular, wie in großen Sprachmodellen. MSE konzentriert sich auf numerische Unterschiede und wird bei einer Vielzahl von Regressions- und neuronalen Netzwerkproblemen verwendet. So berechnen Sie es:

1. Berechnen Sie die Differenz zwischen dem vorhergesagten Wert, Ŷund der Zielwert, Y.
2. Quadrieren Sie diesen Unterschied – stellen Sie sicher, dass alle Fehler positiv sind, und bestrafen Sie große Fehler stärker.
3. Summieren Sie die quadrierten Differenzen für alle Datenproben
4. Teilen Sie die Summe durch die Anzahl der Proben, Num den durchschnittlichen quadratischen Fehler zu erhalten

Sie werden feststellen, dass der MSE kleiner wird, je näher unsere Vorhersage dem Zielwert kommt, und dass er umso größer wird, je weiter er davon entfernt ist. Beide Wege verlaufen quadratisch, da die Differenz quadriert wird.

Das Konzept des Gradientenabstiegs besteht darin, dass wir uns in kleinen Schritten durch den „Kostenraum“ bewegen können, mit dem Ziel, das globale Minimal zu erreichen – den niedrigsten Wert im Raum. Die Kostenfunktion bewertet, wie intestine die aktuellen Modellparameter das Ziel vorhersagen, indem sie uns den Verlustwert liefert. Eine zufällige Änderung der Parameter garantiert keine Verbesserungen. Wenn wir jedoch den Gradienten der Verlustfunktion in Bezug auf jeden Parameter untersuchen, d. h. die Richtung des Verlusts nach einer Aktualisierung des Parameters, können wir die Parameter so anpassen, dass sie sich in Richtung eines geringeren Verlusts bewegen, was darauf hindeutet, dass sich unsere Vorhersagen annähern die Zielwerte.

Die Stufen beim Gefälleabstieg müssen sorgfältig dimensioniert werden, um Fortschritt und Präzision in Einklang zu bringen. Bei zu großen Schritten besteht die Gefahr, dass wir über das globale Minimal hinausschießen und es ganz verfehlen. Sind die Schritte hingegen zu klein, werden die Aktualisierungen ineffizient und zeitaufwändig, wodurch die Wahrscheinlichkeit steigt, dass man in einem lokalen Minimal stecken bleibt, anstatt das gewünschte globale Minimal zu erreichen.

Gradientenabstiegsformel

Im Kontext der linearen Regression könnte θ sein β0 oder β1. Der Gradient ist die partielle Ableitung der Kostenfunktion nach θ, oder einfacher ausgedrückt, er ist ein Maß dafür, wie stark sich die Kostenfunktion ändert, wenn der Parameter θ leicht angepasst wird.

Ein großer Gradient zeigt an, dass der Parameter einen signifikanten Einfluss auf die Kostenfunktion hat, während ein kleiner Gradient auf einen geringen Effekt hindeutet. Das Vorzeichen des Gradienten gibt die Richtung der Änderung der Kostenfunktion an. Ein negativer Gradient bedeutet, dass die Kostenfunktion mit zunehmendem Parameter abnimmt, während ein positiver Gradient bedeutet, dass sie zunimmt.

Was passiert additionally mit dem Parameter, wenn ein großer negativer Gradient vorliegt? Nun, das adverse Vorzeichen vor der Lernrate wird mit dem negativen Vorzeichen des Gradienten aufgehoben, was zu einer Addition des Parameters führt. Und da der Farbverlauf groß ist, werden wir eine große Zahl hinzufügen. Daher wird der Parameter erheblich angepasst, um seinen größeren Einfluss auf die Reduzierung der Kostenfunktion widerzuspiegeln.

Werfen wir einen Blick auf die Preise der Schwämme, mit denen Karate Child Mr. Miyagis Auto gewaschen hat. Wenn wir ihren Preis (abhängige Variable) basierend auf ihrer Höhe und Breite (unabhängige Variablen) vorhersagen wollten, könnten wir ihn mithilfe einer linearen Regression modellieren.

Wir können mit diesen drei Trainingsdatenbeispielen beginnen.

Lassen Sie uns nun den mittleren quadratischen Fehler (MSE) als Kostenfunktion verwenden Jund lineare Regression als unser Modell.

Die lineare Regressionsformel verwendet X1 und X2 für die Breite bzw. Höhe. Beachten Sie, dass es keine unabhängigen Variablen mehr gibt, da unsere Trainingsdaten keine weiteren enthalten. In diesem Beispiel gehen wir davon aus, dass Breite und Höhe des Schwamms ausreichen, um seinen Preis vorherzusagen.

Der erste Schritt besteht nun darin, die Parameter zu initialisieren, in diesem Fall auf 0. Anschließend können wir die unabhängigen Variablen in das Modell einspeisen, um unsere Vorhersagen zu erhalten. Ŷund prüfen Sie, wie weit diese von unserem Ziel entfernt sind Y.

Wie Sie sich vorstellen können, sind die Parameter im Second nicht sehr hilfreich. Aber wir sind jetzt bereit, den Gradient Descent-Algorithmus zu verwenden, um die Parameter in nützlichere zu aktualisieren. Zuerst müssen wir die partiellen Ableitungen jedes Parameters berechnen, was einige Berechnungen erfordert, aber glücklicherweise müssen wir dies im gesamten Prozess nur einmal tun.

Mit den partiellen Ableitungen können wir die Werte unserer Fehler einsetzen, um den Gradienten jedes Parameters zu berechnen.

Beachten Sie, dass die MSE nicht berechnet werden musste, da sie nicht direkt bei der Parameteraktualisierung verwendet wird, sondern nur ihre Ableitung. Es ist auch sofort ersichtlich, dass alle Steigungen negativ sind, was bedeutet, dass alle erhöht werden können, um die Kostenfunktion zu verringern. Der nächste Schritt besteht darin, die Parameter mit einer Lernrate zu aktualisieren, bei der es sich um einen Hyperparameter handelt, additionally um eine Konfigurationseinstellung in einem maschinellen Lernmodell, die vor Beginn des Trainingsprozesses angegeben wird. Im Gegensatz zu Modellparametern, die während des Trainings erlernt werden, werden Hyperparameter manuell eingestellt und steuern Aspekte des Lernprozesses. Hier verwenden wir willkürlich 0,01.

Dies struggle der letzte Schritt unserer ersten Iteration im Prozess des Gradientenabstiegs. Wir können diese neuen Parameterwerte verwenden, um neue Vorhersagen zu treffen und den MSE unseres Modells neu zu berechnen.

Die neuen Parameter nähern sich den tatsächlichen Schwammpreisen an und haben zu einem viel niedrigeren MSE geführt, aber es gibt noch viel zu trainieren. Wenn wir den Gradientenabstiegsalgorithmus 50 Mal durchlaufen, dieses Mal mit Python statt von Hand – da Herr Miyagi nie etwas über Codierung gesagt hat – erreichen wir die folgenden Werte.

Schließlich kamen wir zu einem ziemlich guten Modell. Die wahren Werte, die ich zum Generieren dieser Zahlen verwendet habe, waren (1, 2, 3) und nach nur 50 Iterationen kamen die Parameter des Modells beeindruckend nahe. Durch die Erweiterung des Trainings auf 200 Schritte, was einen weiteren Hyperparameter darstellt, konnte das lineare Regressionsmodell bei gleicher Lernrate nahezu perfekt an die wahren Parameter konvergieren, was die Leistungsfähigkeit des Gradientenabstiegs demonstrierte.

Viele der grundlegenden Konzepte, die die komplizierte Kampfkunst der künstlichen Intelligenz ausmachen, wie Kostenfunktionen und Gradientenabstieg, können vollständig verstanden werden, wenn man einfach das einfache „Wachs an, Wachs weg“-Werkzeug der linearen Regression studiert.

Künstliche Intelligenz ist ein weites und komplexes Gebiet, das auf vielen Ideen und Methoden aufbaut. Obwohl es noch viel mehr zu entdecken gibt, ist die Beherrschung dieser Grundlagen ein wichtiger erster Schritt. Hoffentlich hat Sie dieser Artikel diesem Ziel näher gebracht, ein „Wachs auf, Wachs ab“ nach dem anderen.

Lassen Sie uns gemeinsam unsere Breite der Wissenschaft ausbauen.

Ich prüfe zunehmend Lebensläufe und führe Telefongespräche und Vorstellungsgespräche, um unseren nächsten Wissenschaftler einzustellen, und habe deshalb mehr denn je über die detaillierten Erwartungen nachgedacht, die ich an unsere Daten- und angewandten Wissenschaftler habe. Aus diesem Grund habe ich kürzlich einen Beitrag über die Mathematik geschrieben, nach der ich in unseren Interviews mit Datenwissenschaftlern suche, der von den Lesern sehr intestine angenommen wurde (Hyperlink unten), und deshalb habe ich beschlossen, diese Diskussion fortzusetzen, indem ich viel tiefer in die Maschine eintauche Das Lernwissen, das wir von unseren Datenwissenschaftlern in diesem Beitrag erwarten.

Mir ist bewusst, dass es mehr als genug Tutorials zu Vorstellungsgesprächen im Bereich Information Science gibt, aber ich habe mich trotzdem entschieden, diesen Beitrag zu schreiben, weil ich Kandidaten nicht auf eine umfassende Quelle verweisen konnte, um sich auf ihre Vorstellungsgespräche oder alltäglichen ML-Aufgaben als Daten vorzubereiten Wissenschaftler. Wenn Sie sich auf ein Vorstellungsgespräch mit einem Datenwissenschaftler vorbereiten oder einfach nur vorhaben, Ihre Erinnerungen an die damit verbundenen Themen aufzufrischen, wird Ihnen dieser Beitrag meiner Meinung nach hilfreich sein.

Zumindest empfehle ich Ihnen dringend, durchzublättern, einen Blick auf die Tabellen zu werfen, auf deren Erstellung ich persönlich sehr stolz bin, und wenn Sie sie hilfreich finden, markieren Sie den Beitrag für Ihre zukünftige Referenz und Lektüre.

Bild vom Autor | Canva

Wenn Sie Dateningenieur werden möchten, kann dies überfordernd sein, da die Werkzeuge und Fähigkeiten, die Sie erlernen müssen, ziemlich einschüchternd wirken können. Wenn Sie nach Stellen als Dateningenieur suchen, werden Sie feststellen, dass die Stellenbeschreibungen sehr viel verlangen, sodass die Leute wegschauen.

Sie sollten jedoch nicht alle Anforderungen erfüllen, solange Sie die Grundlagen beherrschen. Das Erlernen der Grundlagen des Knowledge Engineering kann Ihnen dabei helfen, Ihre Karriere als Knowledge Engineer zu steuern.

In diesem Weblog gehe ich auf fünf kostenlose On-line-Kurse ein, die Ihnen die Grundlagen des Knowledge Engineering näherbringen.

Knowledge Engineering für alle

Verknüpfung: Knowledge Engineering für alle

Wie der Titel schon sagt, ist dieser von DataCamp angebotene Kurs für alle, die sich für Knowledge Engineering interessieren, egal ob Sie Anfänger sind oder schon auf halbem Weg – dieser Kurs ist für alle, die sich für Knowledge Engineering interessieren. Dieser Kurs ist eine No-Code-Einführung in Knowledge Engineering, in der Sie alles über Knowledge Engineers erfahren.

Sie erfahren, wie Dateningenieure die Grundlagen legen und wie Datenwissenschaftler ihre Aufgaben damit erledigen können. Es ist wichtig, den Unterschied zwischen einem Dateningenieur und einem Datenwissenschaftler zu verstehen. Von der Datenspeicherung bis zu Datenverarbeitungstechniken lernen Sie, wie Sie Datenpipelines entwickeln und wie Sie Parallel- und Cloud-Computing in Ihren Datentechnikprojekten einsetzen.

Knowledge Engineering Kurs für Anfänger

Verknüpfung: Knowledge Engineering Kurs für Anfänger

Vielleicht sind Sie nicht der Typ, der einem schriftlichen Kursplan folgt, und Sie brauchen das Gefühl, in einer Unterrichtsumgebung zu sein. Dieser 3-stündige Knowledge-Engineering-Kurs für Anfänger wird von freeCodeCamp angeboten.

In diesem Kurs für Anfänger lernen Sie die Grundlagen des Knowledge Engineering. Sie lernen Datenbanken, Docker und analytisches Engineering kennen, erkunden fortgeschrittene Themen wie den Aufbau von Datenpipelines mit Airflow und beschäftigen sich mit Batchverarbeitung mit Spark und Streaming-Daten mit Kafka. Der Kurs gipfelt in einem umfassenden Projekt, bei dem Sie Ihre Fähigkeiten beim Erstellen einer vollständigen Finish-to-Finish-Pipeline auf die Probe stellen.

ASUx: Datentechnik

Verknüpfung: ASUx: Datentechnik

In 5 Wochen, 1-9 Stunden professional Woche, erhalten Sie einführende Einblicke in das Knowledge Engineering der Arizona State College. In diesem Kurs erhalten Sie interaktive Movies, die Ihnen helfen, sowohl die analytischen Konzepte als auch die Software program zu verstehen.

Der Schwerpunkt liegt auf der Arbeit mit Datenbanken im Knowledge Engineering und der Interaktion mit ihnen über SQL. Durch das Erlernen der Datenbankstruktur und der Verknüpfung von Daten aus mehreren Tabellen können Sie sich ein solides Grundwissen im Knowledge Engineering aneignen, mit dem Sie später Berichte mit SQL erstellen und Skripte für die Datenverarbeitung schreiben können.

Python und Pandas für Knowledge Engineering

Verknüpfung: Python und Pandas für Knowledge Engineering

Die Beherrschung von Python und Pandas ist für Ihre Karriere als Dateningenieur unerlässlich. Eine sehr beliebte Programmiersprache bzw. Bibliothek – wenn Sie diese Fähigkeiten beherrschen, wird Ihre Karriere als Dateningenieur von Erfolg gekrönt sein.

In knapp 4 Wochen lernen Sie, wie Sie Entwicklungsumgebungen einrichten, Daten bearbeiten und reale Probleme effizient lösen. Sie lernen außerdem die grundlegende Python-Syntax und Datenstrukturen, Pandas DataFrames zur Datenbearbeitung und Alternativen zu Pandas für Huge Knowledge.

IBM Knowledge Engineering Skilled-Zertifikat

Verknüpfung: IBM Knowledge Engineering Skilled-Zertifikat

Nehmen wir an, Sie sind der Typ Mensch, der einen Kurs von Anfang bis Ende durchzieht, vom Anfänger bis zum Experten. Dieser Kurs könnte für Sie geeignet sein. Dieser von IBM angebotene Knowledge-Engineering-Kurs ist ein professionelles Zertifikat, das aus 16 Kursabschnitten besteht und in 6 Monaten abgeschlossen werden kann, wenn Sie 10 Stunden professional Woche investieren.

In diesem Kurs erlernen Sie die aktuellsten praktischen Fähigkeiten und Kenntnisse, die Dateningenieure in ihrer täglichen Arbeit einsetzen. Anschließend beschäftigen Sie sich mit der Erstellung, Gestaltung und Verwaltung relationaler Datenbanken und der Anwendung von Konzepten der Datenbankverwaltung (DBA) auf RDBMSs wie MySQL, PostgreSQL und IBM Db2. Mit der Zeit entwickeln Sie praktische Kenntnisse in NoSQL und Huge Knowledge mithilfe von MongoDB, Cassandra, Cloudant, Hadoop, Apache Spark, Spark SQL, Spark ML und Spark Streaming.

Am Ende des Kurses können Sie ETL und Datenpipelines mit Bash, Airflow und Kafka implementieren, Knowledge Warehouses entwerfen, füllen und bereitstellen sowie BI-Berichte und interaktive Dashboards erstellen.

Einpacken

In diesem Weblog möchte ich Sie durch die Grundlagen des Knowledge Engineering führen, von kleinen Kursen bis hin zur vollständigen Zertifizierung. Jeder lernt auf einem anderen Niveau und wir alle lernen auch auf unterschiedliche Weise. Die Wahl eines für Sie geeigneten Kurses ist wichtig, um die Grundlagen des Knowledge Engineering zu erlernen.

Nisha Arya ist Datenwissenschaftlerin, freiberufliche technische Redakteurin und Redakteurin und Neighborhood-Managerin für KDnuggets. Sie ist besonders daran interessiert, Karriereberatung oder Tutorials für die Datenwissenschaft sowie theoriebasiertes Wissen rund um die Datenwissenschaft bereitzustellen. Nisha deckt ein breites Themenspektrum ab und möchte die verschiedenen Möglichkeiten erkunden, wie künstliche Intelligenz die Langlebigkeit des menschlichen Lebens verbessern kann. Als eifrige Lernerin möchte Nisha ihr technisches Wissen und ihre Schreibfähigkeiten erweitern und gleichzeitig anderen helfen, Anleitung zu geben.