Berechnen Sie die Intervalle effizient, die nach ID in DataFrame unter Verwendung von Polaren gruppiert sind

In diesem Artikel wird im Detail erläutert, wie das Zeitintervall zwischen aufeinanderfolgenden Ereignissen innerhalb jeder unabhängigen Kennung (ID) in Pandas oder Polars DataFrame effizient berechnet wird, indem die Fensterfunktion pl.expr.over () der Polars -Bibliothek verwendet wird. Durch die Vermeidung herkömmlicher MAP oder anwenden Operationen zeigen wir, wie die polar native Expression-API in Kombination mit Funktionen wie Diff () und dt.total_seconds () verwendet wird, um die Datenverarbeitung mit hohen Leistungen zu erreichen und schließlich neue Zeitintervallspalten zu generieren.

Bei der Datenanalyse und -verarbeitung stoßen wir häufig Szenarien, in denen das Zeitintervall zwischen Ereignissen in Zeitreihendaten berechnet werden muss. Insbesondere bei der Verarbeitung von Benutzerverhaltensprotokollen, Sitzungsdaten- oder Sensor -Lesungen ist die Gruppierung nach bestimmten Entitäten (z. B. Benutzer -ID, Geräte -ID) und die Berechnung des Zeitunterschieds ihrer internen aufeinanderfolgenden Ereignisse eine gemeinsame Analyse. Als Hochleistungsdatenfreame-Bibliothek bietet Polars leistungsstarke Expressionssysteme und Fensterfunktionsfunktionen, die solche Aufgaben mit extrem hoher Effizienz erledigen können.

1. Problemhintergrund und Polarvorteile

Angenommen, wir haben einen Datenrahmen, der ID und Zeitstempelspalten enthält, wobei der Zeitstempel die Endzeit einer bestimmten Sitzung oder eines bestimmten Ereignisses darstellt. Unser Ziel ist es, das Zeitintervall zwischen seinen aufeinanderfolgenden Sitzungen für jede eindeutige ID zu berechnen und das Ergebnis in einer neuen Spaltenzeit zu speichern.

Herkömmliche Pandas -Operationen können tendenziell GroupBy () in Kombination mit Apply () oder Transform () verwenden, aber bei großen Datensätzen können diese Methoden ineffizient sein. Polars ist so konzipiert, dass sie den Multi-Core-CPUs und die Parallelisierung mit Expressionssystemen und faulen Rechenleistung voll auskommen, die es bei der Verarbeitung großer Daten gut abschneiden. Für die Anforderungen des Computers nach Gruppen bietet Polars optimiertere Fensterfunktionen (Fensterfunktionen).

2. Kernkonzept: Fensterfunktion pl.expr.over ()

Polars 'pl.expr.over () ist der Schlüssel zur Implementierung von Gruppierungsberechnungen. Sie können Daten gruppieren und Ausdrücke in jeder Gruppe anwenden, ohne die Operation von Group_By () explizit durchzuführen. Dies ähnelt dem Konzept der Überklausel in SQL und ermöglicht es, Operationen wie Aggregation, Ranking oder Differenzberechnung auf bestimmte Partitionen der Daten zu reagieren.

Wenn in Verbindung mit der Diff () -Funktion verwendet wird, stellt Over ("ID") sicher, dass sich die Diff () -Operation nur innerhalb der ID -Gruppe befindet, zu der sie gehört, und berechnet die kontinuierliche Zeitdifferenz innerhalb jeder ID korrekt.

3.. Detaillierte Lösung Erläuterung

Wir werden demonstrieren, wie die Sitzungsintervalle für jede ID mit einem minimal reproduzierbaren Beispiel effizient berechnet werden.

3.1 Beispieldaten vorbereiten

Zunächst erstellen wir einen Beispieldatenframe mit ID und Zeitstempel und konvertieren ihn in einen Polars -Datenrahmen, um sicherzustellen, dass die Spalte Zeitstempel die DateTime -Art von Polaren ist.

 Polare als PL importieren
Pandas als PD importieren

# Erstellen Sie einen Beispielpandas -Datenframe
Data = {
    'Id': ['a', 'a', 'a', 'b', 'b', 'b'],
    'TIMESTAMP': ['2023-01-01 10:00:00', '2023-01-01 10:30:00', '2023-01-01 11:00:00', '2023-01-01 12:00:00', '2023-01-01 12:30:00' ',' 2023-01-01-01 13:00:00 ''
}

df_pandas = pd.dataframe (Daten)

# Konvertieren Sie in Polars DataFrame und stellen Sie sicher
   pl.col ("timestamp"). str. to_datetime ()
)

print ("Original Polars DataFrame:")
drucken (Sitzungen_Features)

Ausgangsbeispiel:

 Original Polars DataFrame:
Form: (6, 2)
"
│ ID ┆ TIMESTAMP │
│ --- ┆ --- ┆
│ str ┆ DateTime [μs] │
╞════════════════════════════════════════════════════════════════════╡
│ A ┆ 2023-01-01 10:00:00 │
│ A ┆ 2023-01-01 10:30:00 │
│ A ┆ 2023-01-01 11:00:00 │
│ B ┆ 2023-01-01 12:00:00 │
│ B ┆ 2023-01-01 12:30:00 │
│ B ┆ 2023-01-01 13:00:00 │
"

3.2 Zeitintervalle unter Verwendung von pl.expr.over () berechnen

Jetzt werden wir in Verbindung mit pl.expr.over () eine neue Intervallspalte erstellen.

 # Berechnen Sie das Sitzungszeitintervall in jeder ID result_df = sissions_features.with_columns (
  PL.COL ("TIMESTAMP")
    .diff () # Berechnen Sie die Zeitdifferenz zwischen der Stromlinie und der vorherigen Zeile (das Ergebnis ist der Dauertyp)
    .dt.total_seconds () # Die Dauer in Gesamtsekunden konvertieren (i64 Typ)
    .Fill_null (0) # Die erste Sitzung jeder ID hat nicht die vorherige Sitzung, das Diff -Ergebnis ist null und die Polsterung ist hier 0
    .over ("ID") # Schlüssel: Dieser Ausdruck wird in jeder eindeutigen "ID" -Gruppe ausgeführt.

print ("\ ndataframe Nach Berechnung des Zeitintervalls:")
print (result_df)

Code Parsen:

1. PL.Col ("Timestamp"): Wählen Sie die Spalte Zeitstempel aus.
2. .diff (): Berechnet die Differenz zwischen dem aktuellen Linienzeitstempel und dem Zeitstempel der vorherigen Linien. Für den ersten Datensatz jeder ID wird das Ergebnis von Diff () null sein, da es keine vorherige Zeile gibt.
3. .dt.total_seconds (): Das Ergebnis von Diff () ist ein Dauertyp. .dt.total_seconds () konvertiert diese Dauer in eine Gesamtzahl von Sekunden und gibt einen Ganzzahltyp (i64) zurück.
4. .Fill_null (0): Da das Ergebnis des ersten Datensatzes jeder ID -Gruppe null ist, verwenden wir fill_null (0), um diese Nullwerte auf 0 zu füllen, was dem erwarteten Ergebnis entspricht.
5. .over ("id"): Dies ist der Kernschritt. Es sagt Polars, dass der vorherige Diff (). Dt.Total_seconds (). FILL_NULL (0) Ausdruck sollte unabhängig innerhalb des "Fensters" ausgeführt werden, das durch jeden einzigartigen ID -Wert definiert ist. Dies bedeutet, dass Diff () für alle Zeilen mit id = 'a' nur die Reihenfolge in Gruppe A berücksichtigt. Für Zeilen mit ID = 'B' berücksichtigt nur die Reihenfolge in Gruppe B.
6. .alias ("time_between_sesions"): Nennen Sie die neu generierten Spalten TIME_BETWEEN_ESSIONS.

Erwartete Ausgabe:

 Berechnen Sie den Datenrahmen nach dem Zeitintervall:
Form: (6, 3)
"
│ ID ┆ TIMESTAMP ┆ TIME_BETWEEN_ESSIONS │
│ --- ┆ --- ┆ --- ┆
│ str ┆ DateTime [μs] ┆ i64 │
╞═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
│ A ┆ 2023-01-01 10:00:00 ┆ 0 │
│ A ┆ 2023-01-01 10:30:00 ┆ 1800 │
│ A ┆ 2023-01-01 11:00:00 ┆ 1800 │
│ B ┆ 2023-01-01 12:00:00 ┆ 0 │
│ B ┆ 2023-01-01 12:30:00 ┆ 1800 │
│ B ┆ 2023-01-01 13:00:00 ┆ 1800 │
"

4. Gründe, um eine Karte zu vermeiden oder zu bewerben

In Polars wird dringend empfohlen, aus folgenden Gründen die Verwendung von MAP_Groups (), Apply () oder anderen nativen Schleifenfunktionen in Python zu vermeiden:

• Leistungs Engpass : MAP- oder Anwenden von Funktionen arbeiten normalerweise auf der Ebene der Python -Interpreter und können die zugrunde liegenden Rostoptimierungs- und Parallelisierungsfunktionen von Polaren nicht vollständig nutzen. Für große Datensätze führt dies zu einer signifikanten Leistungsverschlechterung.
• Lazy Evaluation : Viele Operationen von Polaren unterstützen die Faulheit, was bedeutet, dass ein Ausführungsplan erstellt wird, der die Berechnungen nur dann ausführt, wenn die Ergebnisse erforderlich sind. Und MAP oder Apply löst die Berechnungen sofort aus, wodurch der Vorteil der faulen Bewertung verstößt.
• Gedächtniseffizienz : Die Expression API von Polaren wird optimiert, um Aufgaben normalerweise mit geringem Speicherverbrauch zu erledigen. Karte oder Anwendung kann unnötige Konvertierungen zwischen Python -Objekten durchführen und den Speicheraufwand erhöhen.
• Lesbarkeit und Wartung : Obwohl Karten flexibel erscheinen mögen, wenn native Ausdrücke dieselbe Funktion erfüllen können, ist die Verwendung nativer Ausdrücke im Code normalerweise prägnanter, klarer und vom Polars -Optimierer einfacher zu verstehen und beschleunigt zu werden.

5. Vorsichtsmaßnahmen und Best Practices

• Datensortierung : Die Funktion diff () berechnet die Differenz zwischen der aktuellen Zeile und ihrer "vorherigen Zeile". Um sicherzustellen, dass die Berechnungslogik von Time_Between_Sessions korrekt ist, müssen die Daten in der Spalte Zeitstempel in jeder ID -Gruppe in aufsteigender Reihenfolge sortiert werden . Wenn Ihre Rohdaten nicht sortiert sind, addieren Sie beispielsweise den Vorgang.

   result_df = sissions_features.sort ("id", "timestamp"). With_Columns (
    pl.col ("timestamp"). diff (). dt.total_seconds (). fill_null (0) .over ("id"). alias ("time_between_sesions")
  )

  In unserem Beispiel wurden die Daten nach ID und Zeitstempel sortiert, sodass die Sortierung weggelassen werden kann.

• Datentyp : Stellen Sie sicher, dass die Spalte Zeitstempel die DateTime -Art von Polaren ist. Wenn es sich um eine Zeichenfolge handelt, müssen Sie Str. to_datetime () zur Konvertierung verwenden.
• Ergebnistyp : dt.total_seconds () gibt i64 (64-Bit-Ganzzahl) zurück, was für die meisten Zeitintervallberechnungen ausreicht. Wenn eine schwimmende Punktpräzision erforderlich ist (z. B. Millisekunden), können Sie dt.total_milliseconds () oder dt.total_microseconds () verwenden.

Zusammenfassen

Durch dieses Tutorial haben wir gelernt, wie man die Fensterfunktion von Polars pl.expr.over () verwendet, kombiniert mit Ausdrücken wie Diff () und dt.total_seconds (), um die Zeitintervalle geteilt durch Gruppen in Dataframe effizient und anmutig zu berechnen. Dieser Ansatz nutzt die Hochleistungsmerkmale der Polars voll aus, vermeidet die Leistungs Engpässe, die herkömmliche Karten oder anwenden können, und ist eine empfohlene Praxis für den Umgang mit groß angelegten Zeitreihengruppendaten. Durch die Beherrschung der Verwendung der Over () -Funktion werden Ihre Fähigkeit, komplexe Datenkonversionsaufgaben in Polaren zu erledigen, erheblich verbessern.

Das obige ist der detaillierte Inhalt vonBerechnen Sie die Intervalle effizient, die nach ID in DataFrame unter Verwendung von Polaren gruppiert sind. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!