In meinem vorherigen BeitragImmediate Caching – was es ist, wie es funktioniert und wie es Ihnen viel Geld und Zeit sparen kann, wenn Sie KI-gestützte Apps mit hohem Datenverkehr ausführen. Im heutigen Beitrag führe ich Sie durch die Implementierung von Immediate Caching speziell mithilfe der OpenAI-API und bespreche einige häufige Fallstricke.

---

Eine kurze Erinnerung an Immediate Caching

Bevor wir uns die Hände schmutzig machen, werfen wir einen kurzen Blick auf das Konzept des Immediate Caching. Immediate Caching ist eine Funktionalität, die in Frontier-Modell-API-Diensten wie dem bereitgestellt wird OpenAI-API oder Claudes API, Dies ermöglicht das Zwischenspeichern und Wiederverwenden von Teilen der LLM-Eingabe, die häufig wiederholt werden. Solche wiederholten Teile können Systemaufforderungen oder Anweisungen sein, die jedes Mal beim Ausführen einer KI-App an das Modell übergeben werden, zusammen mit anderen variablen Inhalten, wie der Anfrage des Benutzers oder aus einer Wissensdatenbank abgerufenen Informationen. Um beim Immediate-Caching auf den Cache zugreifen zu können, müssen die wiederholten Teile des Prompts am Anfang des Prompts stehen, nämlich a Eingabeaufforderungspräfix. Damit das Immediate-Caching aktiviert werden kann, muss dieses Präfix außerdem einen bestimmten Wert überschreiten Schwelle (Beispiel: Für OpenAI sollte das Präfix mehr als 1.024 Token betragen, während Claude für verschiedene Modelle unterschiedliche Mindestcachelängen hat.) Sofern diese beiden Bedingungen erfüllt sind – wiederholte Token als Präfix, die den durch den API-Dienst und das API-Modell definierten Größenschwellenwert überschreiten – kann Caching aktiviert werden, um beim Ausführen von KI-Apps Skaleneffekte zu erzielen.

Im Gegensatz zum Caching in anderen Komponenten in einem RAG oder einer anderen KI-App erfolgt das Immediate-Caching auf Token-Ebene, in den internen Prozeduren des LLM. Insbesondere erfolgt die LLM-Inferenz in zwei Schritten:

• VorfüllenDas heißt, das LLM berücksichtigt die Benutzeraufforderung zum Generieren des ersten Tokens und
• DekodierungDas heißt, das LLM generiert rekursiv die Token der Ausgabe nacheinander

Kurz gesagt: Beim Immediate-Caching werden die Berechnungen gespeichert, die in der Pre-Fill-Section durchgeführt werden, sodass das Modell sie nicht erneut berechnen muss, wenn dasselbe Präfix erneut angezeigt wird. Alle Berechnungen, die in der Section der Dekodierungsiterationen stattfinden, werden nicht zwischengespeichert, auch wenn sie wiederholt werden.

Für den Relaxation des Beitrags werde ich mich ausschließlich auf die Verwendung von Immediate-Caching in der OpenAI-API konzentrieren.

---

Was ist mit der OpenAI-API?

In der API von OpenAI wurde das Immediate-Caching zunächst eingeführt 1. Oktober 2024. Ursprünglich wurde ein Rabatt von 50 % auf die zwischengespeicherten Token angeboten, heutzutage beträgt dieser Rabatt jedoch bis zu 90 %. Darüber hinaus können durch Zugriff auf den Immediate-Cache zusätzliche Latenzeinsparungen von bis zu 80 % erzielt werden.

Wenn das Zwischenspeichern von Eingabeaufforderungen aktiviert ist, versucht der API-Dienst, auf den Cache für eine übermittelte Anforderung zuzugreifen, indem er die übermittelte Eingabeaufforderung an einen entsprechenden Laptop weiterleitet, auf dem der entsprechende Cache voraussichtlich vorhanden ist. Dies wird als Cache-Routing bezeichnet. Zu diesem Zweck verwendet der API-Dienst normalerweise einen Hash der ersten 256 Token der Eingabeaufforderung.

Darüber hinaus ermöglicht ihre API auch die explizite Definition eines prompt_cache_key Parameter in der API-Anfrage an das Modell. Dabei handelt es sich um einen einzelnen Schlüssel, der definiert, auf welchen Cache wir uns beziehen. Ziel ist es, die Wahrscheinlichkeit weiter zu erhöhen, dass unsere Eingabeaufforderung an den richtigen Laptop weitergeleitet wird und den Cache erreicht.

Darüber hinaus bietet die OpenAI-API zwei unterschiedliche Arten des Cachings in Bezug auf die Dauer, die durch definiert werden prompt_cache_retention Parameter. Das sind:

• Beibehaltung des In-Reminiscence-Immediate-Cache: Dies ist im Wesentlichen der Normal-Caching-Typ, der für alle Modelle verfügbar ist, für die Immediate-Caching verfügbar ist. Beim In-Reminiscence-Cache bleiben zwischengespeicherte Daten für einen Zeitraum von 5 bis 10 Minuten zwischen Anfragen aktiv.
• Erweiterte Aufbewahrung des Immediate-Cache: Dies ist verfügbar für bestimmte Modelle. Der erweiterte Cache ermöglicht das Speichern von Daten im Cache für einen Zeitraum von maximal 24 Stunden.

Was nun die Kosten für all diese Kosten angeht, berechnet OpenAI dasselbe professional eingegebenem (nicht zwischengespeichertem) Token, unabhängig davon, ob wir das sofortige Caching aktiviert haben oder nicht. Wenn es uns gelingt, den Cache erfolgreich aufzurufen, werden uns die zwischengespeicherten Token zu einem stark reduzierten Preis in Rechnung gestellt, mit einem Rabatt von bis zu 90 %. Darüber hinaus bleibt der Preis professional Eingabe-Token sowohl für die In-Reminiscence- als auch für die erweiterte Cache-Aufbewahrung gleich.

---

Promptes Caching in der Praxis

Sehen wir uns additionally anhand eines einfachen Python-Beispiels mithilfe des API-Dienstes von OpenAI an, wie Immediate-Caching tatsächlich funktioniert. Genauer gesagt werden wir ein realistisches Szenario erstellen, in dem a lange Systemaufforderung (Präfix) wird über mehrere Anfragen hinweg wiederverwendet. Wenn Sie hier sind, haben Sie vermutlich bereits Ihre OpenAI API-Schlüssel installiert und die erforderlichen Bibliotheken installiert haben. Das erste, was Sie tun müssen, wäre additionally, das zu importieren OpenAI Bibliothek, sowie time zum Erfassen der Latenz und zum Initialisieren einer Instanz des OpenAI-Purchasers:

from openai import OpenAI
import time

shopper = OpenAI(api_key="your_api_key_here")

Dann können wir unser Präfix definieren (die Token, die wiederholt werden und die wir zwischenspeichern möchten):

long_prefix = """
You're a extremely educated assistant specialised in machine studying.
Reply questions with detailed, structured explanations, together with examples when related.

""" * 200  

Beachten Sie, wie wir die Länge künstlich erhöhen (mit 200 multiplizieren), um sicherzustellen, dass der Caching-Schwellenwert von 1.024 Token erreicht wird. Dann richten wir noch einen Timer ein, um unsere Latenzeinsparungen zu messen, und schon können wir endlich unseren Anruf tätigen:

begin = time.time()

response1 = shopper.responses.create(
    mannequin="gpt-4.1-mini",
    enter=long_prefix + "What's overfitting in machine studying?"
)

finish = time.time()

print("First response time:", spherical(finish - begin, 2), "seconds")
print(response1.output(0).content material(0).textual content)

Was erwarten wir additionally von hier aus? Für Modelle ab gpt-4o und neuer ist das Immediate-Caching standardmäßig aktiviert, und da unsere 4.616 Eingabe-Tokens deutlich über dem Schwellenwert von 1.024 Präfix-Tokens liegen, können wir loslegen. Diese Anfrage prüft additionally zunächst, ob es sich bei der Eingabe um einen Cache-Treffer handelt (das ist nicht der Fall, da wir zum ersten Mal eine Anfrage mit diesem Präfix stellen), und da dies nicht der Fall ist, verarbeitet sie die gesamte Eingabe und speichert sie dann im Cache. Wenn wir das nächste Mal eine Eingabe senden, die bis zu einem gewissen Grad mit den anfänglichen Token der zwischengespeicherten Eingabe übereinstimmt, erhalten wir einen Cache-Treffer. Lassen Sie uns dies in der Praxis überprüfen, indem wir eine zweite Anfrage mit demselben Präfix stellen:

begin = time.time()

response2 = shopper.responses.create(
    mannequin="gpt-4.1-mini",
    enter=long_prefix + "What's regularization?"
)

finish = time.time()

print("Second response time:", spherical(finish - begin, 2), "seconds")
print(response2.output(0).content material(0).textual content)

In der Tat! Die zweite Anfrage läuft deutlich schneller (23,31 vs. 15,37 Sekunden). Dies liegt daran, dass das Modell die Berechnungen für das zwischengespeicherte Präfix bereits durchgeführt hat und nur den neuen Teil „Was ist Regularisierung?“ von Grund auf verarbeiten muss. Dadurch erzielen wir durch die Verwendung von Immediate-Caching eine deutlich geringere Latenz und geringere Kosten, da zwischengespeicherte Token rabattiert werden.

---

Eine weitere Sache, die in der OpenAI-Dokumentation erwähnt wird, über die wir bereits gesprochen haben, ist die prompt_cache_key Parameter. Insbesondere können wir laut Dokumentation explizit einen Immediate-Cache-Schlüssel definieren, wenn wir eine Anfrage stellen, und auf diese Weise die Anfragen definieren, die denselben Cache verwenden müssen. Dennoch habe ich versucht, es in mein Beispiel einzubeziehen, indem ich die Anforderungsparameter entsprechend angepasst habe, hatte aber nicht viel Glück:

response1 = shopper.responses.create(
    prompt_cache_key = 'prompt_cache_test1',
    mannequin="gpt-5.1",
    enter=long_prefix + "What's overfitting in machine studying?"
)

Es scheint eine Weile her zu sein prompt_cache_key in den API-Funktionen vorhanden ist, ist es im Python SDK noch nicht verfügbar. Mit anderen Worten: Wir können die Wiederverwendung des Caches noch nicht explizit steuern, sondern sie erfolgt eher automatisch und nach bestem Wissen und Gewissen.

---

Was kann additionally schief gehen?

Das Aktivieren des Immediate-Cachings und das tatsächliche Aufrufen des Caches scheint nach dem, was wir bisher gesagt haben, ziemlich einfach zu sein. Was kann additionally schief gehen und dazu führen, dass uns der Cache fehlt? Leider viele Dinge. So einfach es auch ist, erfordert Immediate-Caching viele verschiedene Annahmen. Das Fehlen auch nur einer dieser Voraussetzungen führt zu einem Cache-Fehler. Aber schauen wir genauer hin!

Ein offensichtlicher Fehler besteht darin, dass das Präfix unter dem Schwellenwert für die Aktivierung des Immediate-Caching liegt, nämlich weniger als 1.024 Token. Dies ist jedoch sehr leicht lösbar – wir können die Anzahl der Präfix-Token jederzeit künstlich erhöhen, indem wir einfach mit einem geeigneten Wert multiplizieren, wie im obigen Beispiel gezeigt.

Eine andere Sache wäre, das Präfix stillschweigend zu brechen. Insbesondere müssen wir, selbst wenn wir für alle Anforderungen persistente Anweisungen und Systemaufforderungen angemessener Größe verwenden, äußerst vorsichtig sein, die Präfixe nicht zu zerstören, indem wir zu Beginn der Modelleingabe vor dem Präfix Variableninhalte hinzufügen. Dies ist eine garantierte Möglichkeit, den Cache zu brechen, unabhängig davon, wie lang und wiederholt das folgende Präfix ist. Übliche Verdächtige, die in diese Falle tappen, sind dynamische Daten, beispielsweise das Anhängen der Benutzer-ID oder von Zeitstempeln am Anfang der Eingabeaufforderung. Daher besteht eine bewährte Vorgehensweise bei der gesamten KI-App-Entwicklung darin, dass dynamische Inhalte immer am Ende der Eingabeaufforderung angehängt werden sollten – niemals am Anfang.

Letztendlich ist hervorzuheben, dass es beim Immediate-Caching nur um die Pre-Fill-Section geht – die Dekodierung wird nie zwischengespeichert. Das bedeutet, dass selbst wenn wir dem Modell auferlegen, Antworten nach einer bestimmten Vorlage zu generieren, die mit bestimmten festen Token beginnt, diese Token nicht zwischengespeichert werden und uns ihre Verarbeitung wie gewohnt in Rechnung gestellt wird.

Umgekehrt ist es für bestimmte Anwendungsfälle nicht wirklich sinnvoll, Immediate Caching zu verwenden. In solchen Fällen handelt es sich um hochdynamische Eingabeaufforderungen wie Chatbots mit wenigen Wiederholungen, einmalige Anfragen oder personalisierte Systeme in Echtzeit.

. . .

In meinen Gedanken

Schnelles Caching kann die Leistung von KI-Anwendungen sowohl hinsichtlich der Kosten als auch der Zeit erheblich verbessern. Insbesondere bei der Skalierung von KI-Apps ist Immediate-Caching äußerst praktisch, um Kosten und Latenz auf einem akzeptablen Niveau zu halten.

Für die OpenAI-API ist das Immediate-Caching standardmäßig aktiviert und die Kosten für Eingaben und nicht zwischengespeicherte Token sind dieselben, unabhängig davon, ob wir das Immediate-Caching aktivieren oder nicht. Man kann additionally nur gewinnen, wenn man das Immediate-Caching aktiviert und versucht, es bei jeder Anfrage zu treffen, auch wenn man keinen Erfolg hat.

Claude bietet über seine API auch umfangreiche Funktionen zum Immediate-Caching, die wir in einem zukünftigen Beitrag ausführlich untersuchen werden.

Danke fürs Lesen!

. . .

Hat Ihnen dieser Beitrag gefallen? Lasst uns Freunde sein! Begleiten Sie mich auf:

Unterstapel Medium LinkedIn Kauf mir einen Kaffee!

Alle Bilder vom Autor, sofern nicht anders angegeben.

Faszinierende Aspekte von Zeitreihen sind die intrinsische Komplexität einer scheinbar einfachen Artwork von Daten.

Letztendlich haben Sie in Zeitreihen eine x-Achse, die normalerweise die Zeit

Allerdings verbirgt sich die Komplexität in der Entwicklung der interessierenden Menge (y-Achse) über die Zeit (x-Achse). Stellt diese Entwicklung eine dar? Development? Hat es welche? Datenpunkte die deutlich vom erwarteten Sign abweichen? Ist es stabil oder unvorhersehbar? Ist der Durchschnittswert der Menge größer als wir erwarten würden? Diese können alle irgendwie definiert werden als Anomalien.

Dieser Artikel ist eine Sammlung verschiedener Techniken zur Anomalieerkennung. Das Ziel besteht darin, dass wir anhand eines Datensatzes mit mehreren Zeitreihen erkennen können welche Zeitreihe ist anomal und Warum.

Dies sind die 4 Zeitreihenanomalien, die wir erkennen werden:

1. Wir werden jeden Development in unserer Zeitreihe erkennen (Trendanomalie)
2. Wir werden bewerten, wie volatil die Zeitreihe ist (Volatilitätsanomalie).
3. Wir werden die Punktanomalien innerhalb der Zeitreihe erkennen (Einzelpunktanomalie).
4. Wir werden die Anomalien innerhalb unserer Signalbank erkennen, um zu verstehen, welches Sign sich anders verhält als unser Signalsatz (Anomalie auf Datensatzebene).

Wir werden jede Anomalieerkennungsmethode aus dieser Sammlung theoretisch beschreiben und die Python-Implementierung zeigen. Der gesamte Code, den ich für diesen Weblog-Beitrag verwendet habe, ist im enthalten PieroPaialungaAI/timeseriesanomaly GitHub-Ordner

0. Der Datensatz

Um den Anomalie-Kollektor zu erstellen, benötigen wir einen Datensatz, in dem wir genau wissen, nach welcher Anomalie wir suchen, damit wir wissen, ob unser Anomalie-Detektor funktioniert oder nicht. Um das zu erreichen, habe ich eine erstellt knowledge.py Skript. Das Skript enthält ein DataGenerator-Objekt, das:

1. Liest die Konfiguration unseres Datensatzes aus einer config.json*-Datei.
2. Erstellt ein Datensatz von Anomalien
3. Gibt Ihnen die Möglichkeit, es einfach zu machen speichern die Daten und Handlung ihnen.

Dies ist der Codeausschnitt:

Wir können additionally sehen, dass wir Folgendes haben:

1. Eine geteilte Zeitachsevon 0 bis 100
2. Mehrere Zeitreihen die eine Zeitreihe bilden Datensatz
3. Jede Zeitreihe präsentiert einen oder mehrere Anomalien.

Die Anomalien sind erwartungsgemäß:

1. Das Trendverhaltenwobei die Zeitreihen ein lineares oder polynomielles Verhalten aufweisen
2. Die Volatilitätwobei die Zeitreihe volatiler und sich ändernder als regular ist
3. Der Ebenenwechselwobei die Zeitreihe einen höheren Durchschnitt als regular aufweist
4. Eine Punktanomaliewobei die Zeitreihe einen anomalen Punkt hat.

Unser Ziel wird es nun sein, eine zu haben Werkzeugkasten Dadurch kann jede einzelne dieser Anomalien für den gesamten Datensatz identifiziert werden.

*Mit der Datei config.json können Sie alle Parameter unseres Datensatzes ändern, z. B. die Anzahl der Zeitreihen, die Zeitreihenachse und die Artwork der Anomalien. So sieht es aus:

1. Identifizierung von Trendanomalien

1.1 Theorie

Wenn wir „eine Trendanomalie“ sagen, suchen wir nach einer Strukturelles Verhalten: Die Reihe bewegt sich im Laufe der Zeit nach oben oder unten oder sie biegt sich gleichmäßig ab. Dies ist bei realen Daten wichtig, da Drift häufig eine Verschlechterung des Sensors, eine Änderung des Benutzerverhaltens, Probleme mit dem Modell/der Datenpipeline oder ein anderes zugrunde liegendes Phänomen bedeutet, das in Ihrem Datensatz untersucht werden muss.

Wir betrachten zwei Arten von Traits:

• Lineare Regression: Wir passen die Zeitreihe mit einem linearen Development an
• Polynomielle Regression: Wir passen die Zeitreihe mit einem Polynom niedrigen Grades an.

In der Praxis messen wir den Fehler des linearen Regressionsmodells. Wenn es zu groß ist, passen wir die Polynomregression an. Wir betrachten einen Development als „signifikant“, wenn der p-Wert unter einem festgelegten Schwellenwert liegt (üblicherweise p < 0,05).

1.2 Code

Das AnomalyDetector-Objekt in anomaly_detector.py führt den oben beschriebenen Code mit den folgenden Funktionen aus:

• Der Detektorwodurch die Daten geladen werden, die wir in DataGenerator generiert haben.
• discover_trend_anomaly Und alle_Trends erkennen Erkennen Sie den (letzten) Development für eine einzelne Zeitreihe bzw. für den gesamten Datensatz
• get_series_with_trend Gibt die Indizes zurück, die einen signifikanten Development aufweisen.

Wir können verwenden plot_trend_anomalies um die Zeitreihe anzuzeigen und zu sehen, wie es uns geht:

Intestine! So können wir die „trendigen“ Zeitreihen in unserem Datensatz fehlerfrei abrufen. Lass uns weitermachen!

2. Identifizierung von Volatilitätsanomalien

2.1 Theorie

Da wir nun einen globalen Development haben, können wir uns darauf konzentrieren Volatilität. Was ich mit Volatilität meine, ist im Klartext: Wie überall ist unsere Zeitreihe? Genauer gesagt, Wie verhält sich die Varianz der Zeitreihe im Vergleich zum Durchschnitt unseres Datensatzes?

So testen wir diese Anomalie:

1. Wir werden es tun Entfernen Sie den Development aus dem Zeitreihendatensatz.
2. Wir werden das finden Statistik der Varianz.
3. Wir werden das finden Ausreißer dieser Statistiken

Ziemlich einfach, oder? Lassen Sie uns mit dem Code eintauchen!

2.2 Code

Ähnlich wie bei den Traits haben wir Folgendes getan:

• discover_volatility_anomalydas prüft, ob eine bestimmte Zeitreihe eine Volatilitätsanomalie aufweist oder nicht.
• alle_Volatilitäten erkennenUnd get_series_with_high_volatilitydie die gesamten Zeitreihendatensätze auf Volatilitätsanomalien überprüfen und jeweils die anomalen Indizes zurückgeben.

So zeigen wir die Ergebnisse an:

3. Einzelpunktanomalie

3.1 Theorie

Okay, jetzt ignorieren wir alle anderen Zeitreihen des Datensatzes und konzentrieren uns auf jede Zeitreihe nach der anderen. Für unsere Zeitreihe von Interesse möchten wir sehen, ob dies der Fall ist eins Punkt, der eindeutig anomal ist. Es gibt viele Möglichkeiten, dies zu tun; Wir können Transformers, 1D CNN, LSTM, Encoder-Decoder usw. nutzen. Der Einfachheit halber verwenden wir einen sehr einfachen Algorithmus:

1. Wir werden eine adoptieren Rollfenster Ansatz, bei dem sich ein Fenster mit fester Größe von hyperlinks nach rechts bewegt
2. Für jeden Punkt berechnen wir die bedeuten Und Standardabweichung des umgebenden Fensters (mit Ausnahme des Punktes selbst)
3. Mithilfe von berechnen wir, wie viele Standardabweichungen der Punkt von seiner lokalen Nachbarschaft entfernt ist Z-Rating

Wir definieren einen Punkt als anomal wenn es einen festen Z-Rating-Wert überschreitet. Wir werden Z-Rating = 3 verwenden, was das Dreifache der Standardabweichungen bedeutet.

3.2 Code

Ähnlich wie wir es für Traits und Volatilität getan haben, haben wir Folgendes:

• discover_point_anomalydas mithilfe der Rolling-Window-Z-Rating-Methode prüft, ob eine bestimmte Zeitreihe Einzelpunktanomalien aufweist.
• discover_all_point_anomalies Und get_series_with_point_anomaliesdie den gesamten Zeitreihendatensatz auf Punktanomalien überprüfen und jeweils die Indizes von Reihen zurückgeben, die mindestens einen anomalen Punkt enthalten.

Und so funktioniert es:

4. Anomalie auf Datensatzebene

4.1 Theorie

Dieser Teil ist bewusst einfach gehalten. Hier sind wir nicht Auf der Suche nach seltsamen Zeitpunkten, nach denen wir suchen seltsame Signale in der Financial institution. Was wir beantworten wollen, ist:

Gibt es Zeitreihen, deren Gesamtgröße deutlich größer (oder kleiner) ist als das, was wir angesichts des Rests des Datensatzes erwarten?

Dazu komprimieren wir jede Zeitreihe zu einer einzigen „Basiszahl“ (einem typischen Niveau) und vergleichen diese Basislinien dann in der gesamten Financial institution. Der Vergleich erfolgt im Hinblick auf mittlere Und Z-Rating.

4.2 Code

So führen wir die Anomalie auf Datensatzebene durch:

1. discover_dataset_level_anomalies()findet die Anomalie auf Datensatzebene im gesamten Datensatz.
2. get_dataset_level_anomalies()findet die Indizes, die eine Anomalie auf Datensatzebene darstellen.
3. plot_dataset_level_anomalies()zeigt eine Stichprobe von Zeitreihen an, die Anomalien aufweisen.

Dies ist der Code dazu:

5. Alle zusammen!

Okay, es ist Zeit, alles zusammenzustellen. Wir werden verwenden detector.detect_all_anomalies() und wir werden Anomalien für den gesamten Datensatz basierend auf bewerten Development, Volatilität, Single-Level Und Datensatzebene Anomalien. Das Skript hierfür ist sehr einfach:

Der df gibt Ihnen die Anomalie für jede Zeitreihe. So sieht es aus:

Wenn wir die folgende Funktion verwenden, können wir das in Aktion sehen:

Ziemlich beeindruckend, oder? Wir haben es geschafft.

6. Schlussfolgerungen

Vielen Dank, dass Sie Zeit mit uns verbringen, das bedeutet uns sehr viel. Das haben wir gemeinsam gemacht:

• Erstellte ein kleines Toolkit zur Anomalieerkennung für a Financial institution von Zeitreihen.
• Erkannt Trendanomalien Verwenden der linearen Regression und der polynomialen Regression, wenn die lineare Anpassung nicht ausreicht.
• Erkannt Volatilitätsanomalien indem zuerst der Development entfernt und dann die Varianz im gesamten Datensatz verglichen wird.
• Erkannt Einzelpunktanomalien mit einem rollierenden Fenster-Z-Rating (einfach, schnell und überraschend effektiv).
• Erkannt Anomalien auf Datensatzebene durch Komprimieren jeder Reihe zu einer Basislinie (Median) und Markieren von Signalen, die auf einer anderen Größenskala leben.
• Alles zusammenfügen in einer einzelnen Pipeline, die eine saubere Übersichtstabelle zurückgibt, die wir prüfen oder darstellen können.

In vielen realen Projekten kommt man mit einer Toolbox wie der hier erstellten sehr weit, denn:

• Es gibt dir erklärbar Signale (Development, Volatilität, Basislinienverschiebung, lokale Ausreißer).
• Es gibt dir eine starke Grundlinie bevor Sie auf schwerere Modelle umsteigen.
• Es lässt sich intestine skalieren, wenn Sie es haben viele SignaleHier wird die Erkennung von Anomalien normalerweise schmerzhaft.

Bedenken Sie, dass die Basislinie absichtlich einfach ist und sehr einfache Statistiken verwendet. Die Modularität des Codes ermöglicht es Ihnen jedoch, die Komplexität einfach zu erhöhen, indem Sie einfach die Funktionalität hinzufügen anomaly_detector_utils.py Und anomaly_detector.py.

7. Bevor Sie losfahren!

Nochmals vielen Dank für Ihre Zeit. Es bedeutet viel

Mein Identify ist Piero Paialunga und ich bin dieser Typ hier:

Ich komme ursprünglich aus Italien und habe einen Doktortitel. aus dem Universität von Cincinnatiund arbeite als Datenwissenschaftler bei The Commerce Desk in New York Metropolis. Ich schreibe darüber KI, maschinelles Lernen und die sich entwickelnde Rolle von Datenwissenschaftlern sowohl hier auf TDS als auch auf LinkedIn. Wenn Ihnen der Artikel gefallen hat und Sie mehr über maschinelles Lernen erfahren und meine Studien verfolgen möchten, können Sie:

A. Folge mir weiter Linkedinwo ich alle meine Geschichten veröffentliche
B. Folge mir weiter GitHubwo Sie meinen gesamten Code sehen können
C. Bei Fragen können Sie mir eine E-Mail senden an piero.paialunga@hotmail

Wenn Sie mit Python für Daten arbeiten, haben Sie wahrscheinlich schon einmal die frustrierende Erfahrung gemacht, mehrere Minuten auf den Abschluss einer Pandas-Operation warten zu müssen.

Zunächst scheint alles in Ordnung zu sein, aber wenn Ihr Datensatz wächst und Ihre Arbeitsabläufe komplexer werden, hat Ihr Laptop computer plötzlich das Gefühl, als würde er sich auf den Begin vorbereiten.

Vor ein paar Monaten habe ich an einem Projekt gearbeitet, bei dem E-Commerce-Transaktionen mit über 3 Millionen Datenzeilen analysiert wurden.

Es struggle eine ziemlich interessante Erfahrung, aber die meiste Zeit sah ich zu, wie sich einfache Gruppenoperationen, die normalerweise in Sekunden liefen, plötzlich in Minuten ausdehnten.

An diesem Punkt wurde mir klar, dass Pandas großartig ist, aber es reicht nicht immer aus.

Dieser Artikel untersucht moderne Alternativen zu Pandas, einschließlich Polars und DuckDB, und untersucht, wie sie die Handhabung großer Datensätze vereinfachen und verbessern können.

Lassen Sie mich aus Gründen der Klarheit einige Dinge im Voraus sagen, bevor wir beginnen.

Dieser Artikel ist kein tiefer Einblick in die Rust-Speicherverwaltung und auch keine Behauptung, Pandas sei veraltet.

Vielmehr handelt es sich um einen praktischen, praktischen Leitfaden. Sie werden reale Beispiele, persönliche Erfahrungen und umsetzbare Einblicke in Arbeitsabläufe sehen, die Ihnen Zeit und Verstand sparen können.

---

Warum Pandas sich langsam fühlen können

Ich erinnere mich, dass ich damals, als ich am E-Commerce-Projekt beteiligt struggle, mit CSV-Dateien gearbeitet habe, die mehr als zwei Gigabyte groß waren, und dass jeder Filter oder jede Aggregation in Pandas oft mehrere Minuten in Anspruch nahm.

Während dieser Zeit starrte ich auf den Bildschirm und wünschte, ich könnte einfach einen Kaffee trinken oder ein paar Episoden einer Present genießen, während der Code ausgeführt wurde.

Die Hauptprobleme, auf die ich gestoßen bin, waren Geschwindigkeit, Speicher und Komplexität des Arbeitsablaufs.

Wir alle wissen, wie große CSV-Dateien enorm viel RAM verbrauchen, manchmal mehr, als mein Laptop computer problemlos bewältigen kann. Darüber hinaus machte die Verkettung mehrerer Transformationen die Wartung des Codes schwieriger und die Ausführung langsamer.

Polars und DuckDB gehen diese Herausforderungen auf unterschiedliche Weise an.

Polars, erstellt in Rust, nutzt Multithread-Ausführung, um große Datensätze effizient zu verarbeiten.

DuckDB hingegen ist für Analysen konzipiert und führt SQL-Abfragen aus, ohne dass Sie alles in den Speicher laden müssen.

Im Grunde hat jeder von ihnen seine eigene Superkraft. Polars ist der Flitzer und DuckDB ist so etwas wie der Speichermagier.

Und das Beste daran? Beide lassen sich nahtlos in Python integrieren, sodass Sie Ihre Arbeitsabläufe verbessern können, ohne sie komplett neu schreiben zu müssen.

Einrichten Ihrer Umgebung

Bevor wir mit dem Codieren beginnen, stellen Sie sicher, dass Ihre Umgebung bereit ist. Aus Konsistenzgründen habe ich Pandas 2.2.0, Polars 0.20.0 und DuckDB 1.9.0 verwendet.

Das Anheften von Versionen kann Ihnen Kopfschmerzen ersparen, wenn Sie Tutorials folgen oder Code teilen.

pip set up pandas==2.2.0 polars==0.20.0 duckdb==1.9.0

Importieren Sie in Python die Bibliotheken:

import pandas as pd
import polars as pl
import duckdb
import warnings
warnings.filterwarnings("ignore")

Ich verwende beispielsweise einen E-Commerce-Verkaufsdatensatz mit Spalten wie Bestell-ID, Produkt-ID, Area, Land, Umsatz und Datum. Ähnliche Datensätze können Sie hier herunterladen Kaggle oder synthetische Daten generieren.

Daten werden geladen

Das effiziente Laden von Daten gibt den Ton für den Relaxation Ihres Arbeitsablaufs vor. Ich erinnere mich an ein Projekt, bei dem die CSV-Datei quick 5 Millionen Zeilen hatte.

Pandas hat es geschafft, aber die Ladezeiten waren lang und das wiederholte Nachladen während des Assessments struggle schmerzhaft.

Es struggle einer dieser Momente, in denen Sie sich wünschten, Ihr Laptop computer hätte eine „Schnellvorlauf“-Style.

Der Wechsel zu Polars und DuckDB hat alles völlig verbessert, und plötzlich konnte ich quick sofort auf die Daten zugreifen und sie bearbeiten, was die Check- und Iterationsprozesse ehrlich gesagt viel angenehmer machte.

Mit Pandas:

df_pd = pd.read_csv("gross sales.csv")
print(df_pd.head(3))

Mit Polaren:

df_pl = pl.read_csv("gross sales.csv")
print(df_pl.head(3))

Mit DuckDB:

con = duckdb.join()
df_duck = con.execute("SELECT * FROM 'gross sales.csv'").df()
print(df_duck.head(3))

DuckDB kann CSVs direkt abfragen, ohne die gesamten Datensätze in den Speicher laden zu müssen, was die Arbeit mit großen Dateien erheblich erleichtert.

Daten filtern

Das Drawback hierbei ist, dass die Filterung in Pandas langsam sein kann, wenn Millionen von Zeilen verarbeitet werden. Ich musste einmal europäische Transaktionen in einem riesigen Verkaufsdatensatz analysieren. Pandas brauchten Minuten, was meine Analyse verlangsamte.

Mit Pandas:

filtered_pd = df_pd(df_pd.area == "Europe")

Polars ist schneller und kann mehrere Filter effizient verarbeiten:

filtered_pl = df_pl.filter(pl.col("area") == "Europe")

DuckDB verwendet SQL-Syntax:

filtered_duck = con.execute("""
    SELECT *
    FROM 'gross sales.csv'
    WHERE area = 'Europe'
""").df()

Jetzt können Sie große Datensätze in Sekunden statt in Minuten filtern, sodass Sie mehr Zeit haben, sich auf die Erkenntnisse zu konzentrieren, die wirklich wichtig sind.

Große Datensätze schnell aggregieren

Durch die Aggregation fühlen sich Pandas oft langsam. Stellen Sie sich vor, für einen Marketingbericht den Gesamtumsatz professional Land zu berechnen.

Bei Pandas:

agg_pd = df_pd.groupby("nation")("income").sum().reset_index()

In Polaren:

agg_pl = df_pl.groupby("nation").agg(pl.col("income").sum())

In DuckDB:

agg_duck = con.execute("""
    SELECT nation, SUM(income) AS total_revenue
    FROM 'gross sales.csv'
    GROUP BY nation
""").df()

Ich erinnere mich, dass ich diese Aggregation für einen Datensatz mit 10 Millionen Zeilen ausgeführt habe. Bei Pandas dauerte es quick eine halbe Stunde. Polars hat den gleichen Vorgang in weniger als einer Minute abgeschlossen.

Das Gefühl der Erleichterung struggle quick so, als würde man einen Marathon beenden und feststellen, dass die Beine noch funktionieren.

Zusammenführen von Datensätzen im großen Maßstab

Das Zusammenfügen von Datensätzen gehört zu den Dingen, die einfach klingen, bis man tatsächlich knietief in den Daten steckt.

In realen Projekten befinden sich Ihre Daten normalerweise in mehreren Quellen, sodass Sie sie mithilfe gemeinsamer Spalten wie Kunden-IDs kombinieren müssen.

Das habe ich auf die harte Tour gelernt, als ich an einem Projekt arbeitete, bei dem es darum ging, Millionen von Kundenbestellungen mit einem ebenso großen demografischen Datensatz zu kombinieren.

Jede Datei struggle für sich genommen groß genug, aber das Zusammenführen fühlte sich an, als würde man versuchen, zwei Puzzleteile zusammenzufügen, während Ihr Laptop computer um Gnade bettelte.

Pandas brauchten so lange, dass ich anfing, das Zusammenfügen auf die gleiche Weise zu messen, wie die Leute messen, wie lange es dauert, bis ihr Popcorn aus der Mikrowelle fertig ist.

Spoiler: Das Popcorn hat jedes Mal gewonnen.

Polars und DuckDB haben mir einen Ausweg verschafft.

Mit Pandas:

merged_pd = df_pd.merge(pop_df_pd, on="nation", how="left")

Polaren:

merged_pl = df_pl.be a part of(pop_df_pl, on="nation", how="left")

DuckDB:

merged_duck = con.execute("""
    SELECT *
    FROM 'gross sales.csv' s
    LEFT JOIN 'pop.csv' p
    USING (nation)
""").df()

Tritt bei Arbeiten mit großen Datensätzen, die Ihren Arbeitsablauf früher eingefroren haben, laufen jetzt reibungslos und effizient.

Faule Auswertung in Polaren

Eine Sache, die mir zu Beginn meiner Reise in die Datenwissenschaft nicht bewusst struggle, struggle, wie viel Zeit verschwendet wird, wenn ich Transformationen Zeile für Zeile durchführe.

Polars geht das anders an.

Es nutzt eine Technik namens Lazy Analysis, die im Wesentlichen wartet, bis Sie die Definition Ihrer Transformationen abgeschlossen haben, bevor Sie irgendwelche Operationen ausführt.

Es untersucht die gesamte Pipeline, ermittelt den effizientesten Pfad und führt alles gleichzeitig aus.

Es ist, als hätte man einen Freund, der sich Ihre gesamte Bestellung anhört, bevor er in die Küche geht, statt jemanden, der jede Anweisung einzeln entgegennimmt und ständig hin und her geht.

Das TDS-Artikel erklärt ausführlich die verzögerte Bewertung.

So sieht der Ablauf aus:

Pandas:

df = df(df("quantity") > 100)
df = df.groupby("phase").agg({"quantity": "imply"})
df = df.sort_values("quantity")

Polars Lazy-Modus:

import polars as pl

df_lazy = (
    pl.scan_csv("gross sales.csv")
      .filter(pl.col("quantity") > 100)
      .groupby("phase")
      .agg(pl.col("quantity").imply())
      .kind("quantity")
)

outcome = df_lazy.accumulate()

Als ich den Lazy-Modus zum ersten Mal verwendete, fühlte es sich seltsam an, keine sofortigen Ergebnisse zu sehen. Aber einmal bin ich das Finale gelaufen .accumulate()der Geschwindigkeitsunterschied struggle offensichtlich.

Eine verzögerte Auswertung löst zwar nicht jedes Leistungsproblem auf magische Weise, bringt aber ein Maß an Effizienz mit sich, für das Pandas nicht konzipiert wurde.

---

Fazit und Erkenntnisse

Die Arbeit mit großen Datenmengen muss sich nicht wie ein Ringen mit Ihren Instruments anfühlen.

Die Verwendung von Polars und DuckDB hat mir gezeigt, dass das Drawback nicht immer bei den Daten lag. Manchmal struggle es das Werkzeug, mit dem ich damit umging.

Wenn Sie aus diesem Tutorial etwas mitnehmen, dann dieses: Sie müssen Pandas nicht aufgeben, können aber nach etwas Besserem greifen, wenn Ihre Datensätze an ihre Grenzen stoßen.

Polars bietet Ihnen Geschwindigkeit und eine intelligentere Ausführung, und mit DuckDB können Sie große Dateien abfragen, als wären sie winzig. Zusammen sorgen sie dafür, dass sich die Arbeit mit großen Datenmengen einfacher und weniger ermüdend anfühlt.

Wenn Sie tiefer in die in diesem Tutorial untersuchten Ideen eintauchen möchten, lesen Sie die offizielle Dokumentation von Polaren Und DuckDB sind gute Ausgangspunkte.

Die Hauptkomponentenanalyse (PCA) ist eine der beliebtesten Methoden zur Dimensionsreduzierung, die Statistikern und Praktikern des maschinellen Lernens zur Verfügung steht. Bevor wir uns näher damit befassen, was dies bedeutet, wollen wir über einige Szenarien sprechen, in denen wir solche Methoden in unserem täglichen Leben verwenden, wahrscheinlich ohne es zu wissen.

1. Suchmaschinen: Wenn wir Google oder andere Web sites verwenden, um die Antwort auf eine Frage zu finden, werden unsere Suchanfragen nicht Wort für Wort abgeglichen, sondern es werden Methoden verwendet, um die Komplexität unserer Suche zunächst in kleinere Teile zu reduzieren und dann danach zu suchen. Die Reduzierung der Komplexität führt zu schnelleren Ergebnissen und wird durch Dimensionsreduzierung erreicht.
2. Bildkomprimierung: Erinnern Sie sich an das eine Mal, als Sie versuchten, ein Bild auf eine Web site hochzuladen, nur um dann festzustellen, dass das Bild die maximale Dateigröße überschritten hat? Nachdem wir uns mit der daraus resultierenden Frustration auseinandergesetzt hatten, suchten wir uns dann Hilfe bei Instruments wie Photoshop, um die Größe des Bildes zu reduzieren. Was Photoshop oder ähnliche Instruments im Hintergrund leisten, nennt man Dimensionsreduzierung.
3. Musik: Musik-Streaming-Dienste verwenden verschiedene Methoden, um die Größe der gestreamten Musik zu reduzieren und uns so Zeit zu sparen und …