Ich wurde gebeten, bei der Arbeit etwas Neues zu machen: Geben Sie uns anhand eines Datendumps unstrukturierter Textdaten einen detaillierten PDF-Bericht mit Erkenntnissen darüber, was Kunden in diesem Quartal über unsere Produkte sagen.

Additionally habe ich eine klare Aufforderung geschrieben. Gab Claude eine detaillierte Anleitung. Habe es mit dem Datensatz gefüttert. Es gab mir eine Ausgabe. Ich habe es geliefert.

Doch als der Stakeholder und ich das Ergebnis eingehend überprüften, fielen uns einige zunehmend beunruhigende Dinge auf.

Claude hatte mit Sicherheit Unrecht.

Nicht falsch falsch, als würden Fakten aus dem Nichts halluziniert. Eher wie … übermütig falsch. Es würde einen vierteljährlichen Einblicksbericht erstellen und etwa Folgendes sagen:

„Die detrimental Stimmung in der Kleiderabteilung hat in diesem Quartal um 23 % zugenommen, was auf eine deutliche Verschiebung der Kundenzufriedenheit hindeutet, die sofortige Aufmerksamkeit des Produktteams erfordert.“

Klingt großartig. Allerdings struggle dieser Anstieg quick ausschließlich auf einen einzigen beliebten Artikel zurückzuführen, der Mitte des Quartals auf den Markt kam und einen bekannten Größenfehler aufwies. Ein Produkt. Nicht die ganze Abteilung.

Claude hatte keine Ahnung. Und meine Aufforderung besagte nicht, dass es sich darum kümmern sollte.

Ein vierteljährlicher Kundenbewertungsbericht

Ich werde Sie durch eine von mir erstellte Claude-Fähigkeit führen, die eine generiert vierteljährlicher Kundenstimmungsbericht aus unstrukturiertem Produktbewertungstext, der als PDF an Stakeholder geliefert wird.

Natürlich werde ich den tatsächlichen Datensatz, den ich bei der Arbeit analysiert habe, nicht weitergeben. Der Datensatz, den ich verwende, ist der Rezensionen zu E-Commerce-Bekleidung für Damen Datensatz von Kaggle (CC0-Lizenz). Es enthält 23.000 echte, anonymisierte Kundenbewertungen aus allen Bekleidungsabteilungen (Oberteile, Kleider, Unterteile, Jacken und mehr) mit Textual content, Sternebewertungen und Produktmetadaten. Verweise auf das Unternehmen in den Bewertungen wurden durch „Einzelhändler“ ersetzt.

Die Fähigkeit sollte:

• Lesen Sie einen gefilterten Teil der Bewertungen für das aktuelle Quartal
• Gruppieren Sie sie nach Abteilung
• Identifizieren Sie Tendencies und Bedenken
• Schreiben Sie eine professionelle PDF-Zusammenfassung für das Produktführungsteam

Hier ist die ursprüngliche Eingabeaufforderung:

Sie sind ein Datenanalyst, der einen vierteljährlichen Kundenstimmungsbericht für einen E-Commerce-Einzelhändler für Damenbekleidung erstellt. Verfassen Sie anhand der Kundenbewertungen dieses Quartals (einschließlich Bewertungstext, Sternebewertungen und Abteilung) einen professionellen Stakeholder-Bericht, der Folgendes umfasst:

– Eine allgemeine Stimmungszusammenfassung für das Quartal

– Schlüsselthemen nach Abteilung (Oberteile, Kleider, Unterteile, Jacken)

– 2-3 herausragende Erkenntnisse aus dem Rezensionstext

– Eine kurze Empfehlung für das Produktteam

Seien Sie professionell und klar.

Wenn Sie mit dieser Aufgabe fertig sind, erstellen Sie bitte einen Ability mit dem Titel „reviews-analysis“ und speichern Sie dort Ihre Anweisungen.

Wie „sicher falsch“ tatsächlich aussieht

Hier ist ein Beispiel dafür, was Claude mit der oben genannten naiven Fähigkeit in einem Quartal produziert hat, in dem die Kleiderabteilung einen Zustrom negativer Bewertungen verzeichnete:

„Die detrimental Stimmung in der Kleiderabteilung hat in diesem Quartal deutlich zugenommen, da Kunden häufig Passform- und Größenprobleme anführten. Dies deutet darauf hin, dass die Größenstandards des Einzelhändlers möglicherweise von den Kundenerwartungen abweichen – ein Development, der, wenn er nicht berücksichtigt wird, die Markentreue in dieser Schlüsselkategorie untergraben könnte.“

Die wahre Erklärung? Ein Kleid (eine einzelne SKU) wurde in Woche 7 mit einem Qualitätsproblem bei der Cost auf den Markt gebracht. Die Bewertungen waren quick ausschließlich über diesen einen Punkt. Der Relaxation der Kleiderabteilung lief intestine.

Claude hat nicht unbedingt etwas erfunden. Es gab einfach keinen Kontext dafür, warum das Muster existierte. Und ohne diesen Kontext tat es das, was LLMs tun: Es füllte die Lücke mit der plausibelsten Erzählung.

Die Lösung: 4 Zeilen, die Sie einschließen MÜSSEN

Zeile 1: Sagen Sie Claude, welcher Kontext fehlt

Sie haben KEINEN Zugriff auf Produkteinführungskalender, Bestandsaufzeichnungen, Werbekampagnen oder den Verlauf einzelner SKU-Ebenen. Führen Sie Tendencies auf Abteilungsebene NICHT auf markenweite Ursachen zurück. Melden Sie Muster, die Sie im Textual content beobachten. Erklären Sie nicht, warum sie existieren, es sei denn, die Bewertungen selbst machen dies eindeutig.

Diese einzige Anweisung eliminiert eine große Kategorie sicherer Unrichtigkeit. Ohne sie wird Claude immer nach einer strategischen Erzählung greifen, denn das ist es, was ein guter Analyst tut, und Claude versucht, ein guter Analyst zu sein.

Das Drawback ist, dass ein guter Analyst auch weiß, was er nicht weiß. Sie sagen: „Wir sehen in diesem Quartal Beschwerden über erhöhte Größen bei Kleidern. Dies kann auf eine kürzlich erfolgte Markteinführung beschränkt sein, aber wir benötigen Daten auf SKU-Ebene, um dies zu bestätigen.“ Claude wird das nicht sagen, es sei denn, du sagst es.

Zeile 2: Definieren Sie, was „signifikant“ tatsächlich bedeutet

Claude liebt das Wort bedeutsam. Es nutzt es ständig. Und es definiert es quick nie.

Kennzeichnen Sie eine Stimmungsänderung nur dann als „signifikant“, wenn sie eine Änderung des Positiv-/Negativ-Verhältnisses um mehr als 15 Prozentpunkte im Vergleich zum Vorquartal darstellt, ODER wenn ein Thema in mehr als 20 % der Bewertungen in einer bestimmten Abteilung vorkommt. Verwenden Sie für kleinere Signale Formulierungen wie „leichter Anstieg“ oder „geringfügiger Anstieg“. Verwenden Sie die Wörter „bemerkenswert“ oder „bedeutend“ nicht für alles, was unter diesen Schwellenwerten liegt. Geben Sie zusammen mit Ihrem Anspruch immer den tatsächlichen Zahlenwert für die Schicht an.

Sie können die Schwellenwerte von 15 % und 20 % so anpassen, wie es für Ihre Daten sinnvoll ist. Es geht darum, Claudes Sprache an etwas Realem zu verankern.

Ohne dies wird Claude sowohl einen Anstieg der Beschwerden um drei Bewertungen als auch einen echten Stimmungsrückgang um 30 Punkte als „signifikant“ bezeichnen. Ihre Stakeholder werden anfangen, abzuschalten. Und wenn etwas wirklich Bedeutsames passiert, werden sie es nicht bemerken.

Zeile 3: Erzwingen Sie einen Vertrauensqualifizierer für jede Erkenntnis

Fügen Sie vor jeder Erkenntnis eine Konfidenzbezeichnung in Klammern ein: (Datengestützt), (Möglich) oder (Spekulativ).

Verwenden Sie (Datengestützt) nur, wenn sich die Erkenntnisse direkt aus dem bereitgestellten Rezensionstext ergeben. Verwenden Sie (Möglich), wenn die Erkenntnis eine vernünftige Schlussfolgerung aus dem Textual content darstellt. Verwenden Sie (spekulativ), wenn Sie Annahmen über Ursachen oder Zusammenhänge treffen, die in den Bewertungen selbst nicht vorhanden sind.

Als ich diese Zeile zum ersten Mal hinzugefügt habe, hatte ich hauptsächlich (datengestützte) Tags erwartet. Was ich tatsächlich bekam, struggle eine Mischung aus allen dreien, die mir genau verriet, wie sehr Claude Lücken in meinen vorherigen Berichten gefüllt hatte, ohne dass ich es bemerkte.

Ein Beispiel dafür, wie die Ausgabe nach dem Hinzufügen dieser Zeile aussieht:

Jetzt können Ihre Stakeholder genau sehen, was solide und was eine Vermutung ist. Das ist ein viel ehrlicherer Bericht.

Zeile 4: Fordern Sie Claude auf, die Grenzen der Analyse anzugeben

Fügen Sie am Ende des Berichts einen Abschnitt mit dem Titel „Was Ihnen dieser Bericht nicht sagen kann“ ein. Pay attention Sie zwei bis drei Dinge auf, die erforderlich wären, um aussagekräftigere Schlussfolgerungen zu ziehen, z. B. Bewertungsaufschlüsselungen auf SKU-Ebene, Rücklaufquoten oder Daten zu Wiederholungskäufen.

Diese Zeile zwingt Claude dazu, die Grenzen seiner eigenen Analyse anzuerkennen. Und es gibt Ihren Stakeholdern einen klaren Fahrplan dafür, welche Fragen weiter untersucht werden müssen, was eigentlich das Wertvollste ist, was ein Analyst tun kann.

Hier ist die Ausgabe:

So verwenden Sie Claude, um die Fertigkeit zu verfeinern

Es reicht nicht aus, eine Fertigkeit einmal zu schreiben. Sie müssen es auf die gleiche Weise testen und verbessern, wie Sie es bei einem Modell tun würden.

Schritt 1: Führen Sie den Ability an bekannten Beispielen aus.

Filtern Sie den Datensatz nach einem Zeitfenster, in dem Sie bereits wissen, was passiert ist. (Ein Quartal mit einem Produktrückruf, einer saisonalen Aktion, einem Zeitraum mit ungewöhnlich hohen Rücklaufquoten usw.) Sehen Sie, was Claude sagt. Wird das Wort „erheblich“ richtig verwendet? Werden dort Fakten/Statistiken aufgeführt, wo sie sein sollten?

Schritt 2: Füttere Claude mit seiner eigenen Ausgabe und bitte ihn um eine Prüfung.

Claude ist intestine darin, seine eigene Selbstüberschätzung einzufangen, wenn man ihn ausdrücklich auffordert, danach zu suchen.

Hier ist ein vierteljährlicher Kundenstimmungsbericht, der von einem KI-Analysten erstellt wurde. Überprüfen Sie alle Erkenntnisse in diesem Bericht und kennzeichnen Sie Folgendes:

– Machen Sie kausale Behauptungen ohne direkte Beweise im Rezensionstext

– Verwenden Sie Wörter wie „bedeutend“ oder „bemerkenswert“ ohne Begründung

– Ordnen Sie einzelne Produktprobleme markenweiten Tendencies zu

– Gehen Sie davon aus, dass im Datensatz kein Kontext vorhanden ist (Startkalender,

Inventar, Kaufhistorie)

Schlagen Sie für jedes markierte Ingredient eine überarbeitete Model vor, die besser abgesichert ist.

Schritt 3: Fügen Sie für jeden gefundenen Fehler eine Klausel hinzu.

Jedes Mal, wenn Claude einen Bericht mit eindeutig falschen oder übertriebenen Erkenntnissen erstellt, bitten Sie ihn, Ihren Fähigkeiten eine neue Einschränkung hinzuzufügen. Mit der Zeit werden Ihre Fähigkeiten sozusagen zu einer Aufzeichnung von allem, was Claude falsch macht.

Ein Wort der Vorsicht

Das Hinzufügen von Einschränkungen zu Ihrem Ability kann manchmal dazu führen, dass Claude eine Ausgabe erzeugt, bei der jeder einzelne Satz mit „…obwohl zusätzliche Daten erforderlich wären, um dies zu bestätigen“ endet.

Das ist auch nicht nützlich.

Das Ziel ist kalibriertes Vertrauen, bei dem die Stärke von Claudes Sprache mit der Stärke der Beweise übereinstimmt. Wenn Sie den Eindruck haben, dass Claude zu unzuverlässig wird, können Sie eine ausgleichende Einschränkung hinzufügen:

Überqualifizieren Sie nicht jede Aussage. Wenn ein Muster in vielen Bewertungen deutlich und konsistent auftritt, geben Sie es klar an und geben Sie Verweise auf die Daten hinter dem Muster an. Reservequalifikationen für wirklich ungewisse oder spekulative Ansprüche.

Abschluss

Claude ist beeindruckend darin, professionell aussehende Berichte zu erstellen, was manchmal ein Drawback sein kann.

Der Lack verbirgt die Selbstüberschätzung. Ihre Stakeholder sehen eine saubere Formatierung und eine verbindliche Sprache und gehen davon aus, dass die Erkenntnisse solide sind, auch wenn dies nicht der Fall ist.

Die vier Zeilen, die ich hier durchlaufen habe, machen Claude nicht weniger fähig. Sie machen es ehrlicher. Und im Berichtskontext ist Ehrlichkeit mehr wertvoll als beeindruckend.

Lesen Sie hier mehr darüber, für welche anderen Anwendungsfälle Claude intestine ist, einschließlich der Erstellung von Dashboards, dem Debuggen und dem Schreiben von Dokumentation:

→ 3 Claude-Fähigkeiten, die jeder Datenwissenschaftler im Jahr 2026 braucht

Danke fürs Lesen

Verbinde dich mit mir LinkedIn

Kauf mir einen Kaffee um meine Arbeit zu unterstützen!

von autonomen Fahrzeugen und KI-Sprachmodellen, doch die wichtigste physische Schnittstelle, über die wir uns mit Maschinen verbinden, ist seit fünfzig Jahren unverändert geblieben. Erstaunlicherweise verwenden wir zum Klicken und Ziehen immer noch die Computermaus, ein Gerät, das Doug Engelbart Anfang der 1960er Jahre entwickelt hat. Vor ein paar Wochen habe ich beschlossen, diese Norm durch die Programmierung in Python in Frage zu stellen.

Für Datenwissenschaftler und ML-Ingenieure ist dieses Projekt mehr als nur ein Partytrick – es ist eine Meisterklasse in angewandter Laptop Imaginative and prescient. Wir werden eine Echtzeit-Pipeline aufbauen, die einen unstrukturierten Videostream (Pixel) aufnimmt, sequentiell ein ML-Modell anwendet, um Merkmale (Handmarkierungen) zu extrahieren und sie schließlich in greifbare Befehle umwandelt (Bewegen des Cursors). Im Grunde ist dies ein „Hallo Welt“-Beispiel für die nächste Era der Mensch-Laptop-Interaktion.

Das Ziel? Steuern Sie den Mauszeiger einfach durch eine Handbewegung. Sobald Sie das Programm starten, wird in einem Fenster Ihr Webcam-Feed mit einem in Echtzeit überlagerten Handskelett angezeigt. Der Cursor auf Ihrem Laptop folgt der Bewegung Ihres Zeigefingers. Es ist quick wie Telekinese – Sie steuern ein digitales Objekt, ohne ein physisches Gerät zu berühren.

Das Konzept: Python das „Sehen“ beibringen

Um die physische Welt (meine Hand) mit der digitalen Welt (dem Mauszeiger) zu verbinden, haben wir beschlossen, das Downside in zwei Teile zu unterteilen: die Augen und das Gehirn.

• The Eyes – Webcam (OpenCV): Movies von der Kamera in Echtzeit zu erhalten, das ist der erste Schritt. Wir werden dafür OpenCV verwenden. OpenCV ist eine umfangreiche Laptop-Imaginative and prescient-Bibliothek, die es Python ermöglicht, auf Frames einer Webcam zuzugreifen und diese zu verarbeiten. Unser Code öffnet die Standardkamera mit cv2.VideoCapture(0) und liest dann die Frames nacheinander weiter.
• Das Gehirn – Hand-Landmark-Erkennung (MediaPipe): Um jeden Body zu analysieren, die Hand zu finden und die Schlüsselpunkte auf der Hand zu erkennen, haben wir uns an die MediaPipe Palms-Lösung von Google gewandt. Hierbei handelt es sich um ein vorab trainiertes Modell für maschinelles Lernen, das in der Lage ist, ein Bild einer Hand aufzunehmen und die Positionen von 21 3D-Markierungen (Gelenke und Fingerspitzen) einer Hand vorherzusagen. Um es einfach auszudrücken: MediaPipe-Hände „erkennen hier nicht nur eine Hand“, sondern zeigen Ihnen sogar genau, wo sich jede Fingerspitze und jeder Knöchel im Bild befindet. Sobald Sie diese Orientierungspunkte gefunden haben, ist die größte Herausforderung im Grunde genommen vorbei: Wählen Sie einfach den gewünschten Orientierungspunkt aus und verwenden Sie seine Koordinaten.

Im Grunde bedeutet das, dass wir jedes Kamerabild an MediaPipe übergeben, das die (x,y,z)-Koordinaten von 21 Punkten auf der Hand ausgibt. Um einen Cursor zu steuern, folgen wir der Place des Orientierungspunkts Nr. 8 (der Spitze des Zeigefingers). (Wenn wir das Klicken später implementieren würden, könnten wir den Abstand zwischen Orientierungspunkt Nr. 8 und Nr. 4 (Daumenspitze) überprüfen, um eine Einklemmung zu identifizieren.) Im Second sind wir nur an der Bewegung interessiert: Wenn wir die Place der Zeigefingerspitze finden, können wir diese ziemlich genau mit der Place des Mauszeigers in Verbindung bringen, an die er sich bewegen soll.

Die Magie von MediaPipe

MediaPipe​‍​‌‍​‍‌ Palms kümmert sich um die anspruchsvollen Teile der Handerkennung und Orientierungspunktschätzung. Die Lösung nutzt maschinelles Lernen, um 21 Handmarkierungen aus nur einem Bildrahmen vorherzusagen.

Darüber hinaus ist es vorab trainiert (tatsächlich anhand von mehr als 30.000 Handbildern), was bedeutet, dass wir unser Modell nicht trainieren müssen. Wir holen uns einfach das Hand-Monitoring-„Gehirn“ von MediaPipe in ​‍​‌‍​‍‌Python:

mp_hands = mp.options.arms
arms = mp_hands.Palms(max_num_hands=1, min_detection_confidence=0.7)

Additionally​‍​‌‍​‍‌ danach wird jedes Mal ein neuer Body gesendet arms.course of()gibt es eine Liste der erkannten Hände zusammen mit ihren 21 Orientierungspunkten zurück. Wir rendern sie auf dem Bild, damit wir visuell überprüfen können, ob es funktioniert. Das Entscheidende ist, dass wir für jede Hand erhalten können hand_landmarks.landmark(i) für i von 0 bis 20, jeweils mit normalisierten (x, y, z)-Koordinaten. Konkret ist die Spitze des Zeigefingers der Orientierungspunkt (8) und die Spitze des Daumens der Orientierungspunkt (4). Durch die Verwendung von MediaPipe sind wir bereits von der anspruchsvollen Aufgabe entlastet, die Geometrie der Handhaltung herauszufinden.

Das Setup

Dafür benötigen Sie keinen Supercomputer – ein typischer Laptop computer mit Webcam reicht aus. Installieren Sie einfach diese Python-Bibliotheken:

pip set up opencv-python mediapipe pyautogui numpy

• opencv-python: Verwaltet den Webcam-Video-Feed. Mit OpenCV können wir Frames in Echtzeit erfassen und in einem Fenster anzeigen.
• Medienpipe: Stellt das Hand-Monitoring-Modell (MediaPipe Palms) bereit. Es erkennt die Hand und gibt 21 Orientierungspunkte zurück.
• pyautogui: Eine plattformübergreifende GUI-Automatisierungsbibliothek. Wir werden es verwenden, um den eigentlichen Mauszeiger auf unserem Bildschirm zu bewegen. Zum Beispiel, pyautogui.moveTo(x, y) Bewegt den Cursor sofort an die Place (x, y).
• Numpy: Wird für numerische Operationen verwendet, hauptsächlich zum Zuordnen von Kamerakoordinaten zu Bildschirmkoordinaten. Wir verwenden numpy.interp um Werte von der Webcam-Rahmengröße auf die volle Bildschirmauflösung zu skalieren.

Jetzt ist unsere Umgebung bereit und wir können die vollständige Logik in eine einzige Datei schreiben (z. B. ai_mouse.py).

Der Kodex

Die Kernlogik ist bemerkenswert prägnant (weniger als 60 Zeilen). Hier ist das vollständige Python-Skript:

import cv2
import mediapipe as mp
import pyautogui
import numpy as np

# --- CONFIGURATION ---
SMOOTHING = 5  # Larger = smoother motion however extra lag.
plocX, plocY = 0, 0  # Earlier finger place
clocX, clocY = 0, 0  # Present finger place

# --- INITIALIZATION ---
cap = cv2.VideoCapture(0)  # Open webcam (0 = default digital camera)

mp_hands = mp.options.arms
# Observe max 1 hand to keep away from confusion, confidence threshold 0.7
arms = mp_hands.Palms(max_num_hands=1, min_detection_confidence=0.7)
mp_draw = mp.options.drawing_utils

screen_width, screen_height = pyautogui.measurement()  # Get precise display screen measurement

print("AI Mouse Lively. Press 'q' to stop.")

whereas True:
    # STEP 1: SEE - Seize a body from the webcam
    success, img = cap.learn()
    if not success:
        break

    img = cv2.flip(img, 1)  # Mirror picture so it feels pure
    frame_height, frame_width, _ = img.form
    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

    # STEP 2: THINK - Course of the body with MediaPipe
    outcomes = arms.course of(img_rgb)

    # If a hand is discovered:
    if outcomes.multi_hand_landmarks:
        for hand_landmarks in outcomes.multi_hand_landmarks:
            # Draw the skeleton on the body so we are able to see it
            mp_draw.draw_landmarks(img, hand_landmarks, mp_hands.HAND_CONNECTIONS)

            # STEP 3: ACT - Transfer the mouse primarily based on the index finger tip.
            index_finger = hand_landmarks.landmark(8)  # landmark #8 = index fingertip
            
            x = int(index_finger.x * frame_width)
            y = int(index_finger.y * frame_height)

            # Map webcam coordinates to display screen coordinates
            mouse_x = np.interp(x, (0, frame_width), (0, screen_width))
            mouse_y = np.interp(y, (0, frame_height), (0, screen_height))

            # Clean the values to cut back jitter (The "Skilled Really feel")
            clocX = plocX + (mouse_x - plocX) / SMOOTHING
            clocY = plocY + (mouse_y - plocY) / SMOOTHING

            # Transfer the precise mouse cursor
            pyautogui.moveTo(clocX, clocY)

            plocX, plocY = clocX, clocY  # Replace earlier location

    # Present the webcam feed with overlay
    cv2.imshow("AI Mouse Controller", img)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):  # Give up on 'q' key
        break

# Cleanup
cap.launch()
cv2.destroyAllWindows()

Dieses​‍​‌‍​‍‌ Programm wiederholt kontinuierlich den gleichen dreistufigen Prozess in jedem Body: SEHEN, DENKEN, HANDELN. Zunächst wird ein Bild von der Webcam aufgenommen. Anschließend wird MediaPipe angewendet, um die Hand zu identifizieren und die Orientierungspunkte zu zeichnen. Schließlich greift der Code auf die Place der Zeigefingerspitze (Markierung Nr. 8) zu und wendet sie zum Bewegen des ​‍​‌‍​‍‌Cursors an.

Da​‍​‌‍​‍‌ der Webcam-Rahmen und Ihr Show unterschiedliche Koordinatensysteme haben, transformieren wir zunächst die Fingerspitzenposition mithilfe von auf die gesamte Bildschirmauflösung numpy.interp und anschließend aufrufen pyautogui.moveTo(x, y) um den Cursor zu verschieben. Um die Stabilität der Bewegung zu verbessern, führen wir zusätzlich eine kleine Glättung ein (unter Berücksichtigung des Durchschnitts der Positionen über die Zeit), um den Jitter zu verringern.

Das Ergebnis

Führen Sie​‍​‌‍​‍‌ das Skript durch python ai_mouse.py. Das Fenster „AI Mouse Controller“ öffnet sich und zeigt Ihre Kameraaktivität an. Halten Sie Ihre Hand vor die Kamera und Sie sehen ein darüber eingezeichnetes farbiges Skelett (Handgelenke und Verbindungen). Bewegen Sie dann Ihren Zeigefinger, und der Mauszeiger bewegt sich sanft über Ihren Bildschirm und folgt Ihrer Fingerbewegung in Echtzeit.

Zunächst​‍​‌‍​‍‌ kommt es seltsam vor – in gewisser Weise ganz wie Telekinese. Doch innerhalb von Sekunden wird es vertraut. Aufgrund der Interpolations- und Glättungseffekte, die Teil des Programms sind, bewegt sich der Cursor genau so, wie Sie es von Ihrem Finger erwarten würden. Wenn das System Ihre Hand vorübergehend nicht erkennen kann, kann es sein, dass der Cursor nonetheless bleibt, bis er wieder erkannt wird, aber im Großen und Ganzen ist es beeindruckend, wie intestine es funktioniert. (Wenn Sie gehen möchten, drücken Sie einfach die q-Style im OpenCV-Fenster.)

Fazit: Die Zukunft der Schnittstellen

Für dieses Projekt wurden nur etwa 60 Zeilen Python geschrieben, aber es konnte etwas recht Tiefgründiges demonstrieren.

Erste. Wir beschränkten uns auf Lochkarten, dann auf Tastaturen und schließlich auf Mäuse. Jetzt winken Sie einfach mit der Hand und Python versteht das als Befehl. Da sich die Branche auf räumliches Computing konzentriert, ist die gestenbasierte Steuerung keine Science-Fiction-Zukunft mehr – sie wird zur Realität, wie wir mit Maschinen interagieren werden.

Dieser Prototyp scheint natürlich (noch) nicht bereit zu sein, Ihre Maus für Wettkampfspiele zu ersetzen. Aber es hat uns einen Einblick gegeben, wie KI die Lücke dazwischen schließt Absicht Und Aktion verschwinden.

Ihre nächste Herausforderung: Der „Pinch“-Klick

Der logische nächste Schritt besteht darin, dies von einer Demo in ein Instrument umzuwandeln. Durch die Erkennung einer Pinch-Geste kann eine „Klick“-Funktion implementiert werden:

• Messen Sie den euklidischen Abstand zwischen Orientierungspunkt Nr. 8 (Indexspitze) und Orientierungspunkt Nr. 4 (Daumenspitze).
• Wenn der Abstand kleiner als ein bestimmter Schwellenwert (z. B. 30 Pixel) ist, wird ausgelöst pyautogui.click on().

Probieren Sie es einfach aus. Machen Sie etwas, das wie Magie wirkt.

Lassen Sie uns verbinden

Wenn Sie es schaffen, das zu bauen, würde ich mich freuen, es zu sehen. Nehmen Sie gerne Kontakt mit mir auf LinkedIn und schick mir eine DM mit deinen Ergebnissen. Ich schreibe regelmäßig über Themen wie Python, KI und kreatives ​‍​‌‍​‍‌Coding.

Referenzen

• MediaPipe-Hände (Google): Modell und Dokumentation zur Erkennung von Handmarkierungen
• OpenCV-Python-Dokumentation: Instruments zur Webcam-Erfassung, Bildverarbeitung und Visualisierung
• PyAutoGUI-Dokumentation: Programmatische Cursorsteuerungs- und Automatisierungs-APIs (moveTo, click onusw.)
• NumPy-Dokumentation: numpy.interp() zum Zuordnen von Webcam-Koordinaten zu Bildschirmkoordinaten
• Doug Engelbart und die Computermaus (Historischer Kontext): Der Ursprung der Maus als moderne Schnittstellenbasis

Bild vom Autor

# Einführung

Es gibt heute zahlreiche Instruments zur Verarbeitung von Datensätzen. Sie alle behaupten – und das tun sie natürlich auch –, dass sie die beste und richtige Wahl für Sie sind. Aber sind sie es? Es gibt zwei Hauptanforderungen, die diese Instruments erfüllen sollten: Sie sollten alltägliche Datenanalysevorgänge einfach und schnell durchführen, selbst unter dem Druck großer Datenmengen.

Um das beste Werkzeug zu ermitteln DuckDB, SQLiteUnd Pandaswir haben sie unter diesen Bedingungen getestet.

Zunächst gaben wir ihnen nur alltägliche Analyseaufgaben: Summieren von Werten, Gruppieren nach Kategorien, Filtern mit Bedingungen und Aggregationen mehrerer Felder. Dies spiegelte wider, wie Analysten tatsächlich mit realen Datensätzen arbeiten, im Vergleich zu Szenarien, die darauf ausgelegt sind, die besten Eigenschaften eines Instruments darzustellen.

Zweitens haben wir diese Operationen an einem Kaggle-Datensatz mit über 1 Million Zeilen durchgeführt. Es ist ein realistischer Wendepunkt – klein genug, um auf einem einzelnen Laptop ausgeführt zu werden, aber groß genug, dass Speicherdruck und Abfragegeschwindigkeit deutliche Unterschiede zwischen den Instruments erkennen lassen.

Mal sehen, wie diese Exams verlaufen sind.

# Der von uns verwendete Datensatz

// Datensatzübersicht

Wir haben den Bankdatensatz von verwendet Kaggle. Dieser Datensatz enthält über 1 Million Zeilen, bestehend aus fünf Spalten:

Dieser Datensatz wird mit Python generiert. Auch wenn es möglicherweise nicht ganz den realen Daten ähnelt, reichen Größe und Struktur aus, um die Leistungsunterschiede zwischen den Instruments zu testen und zu vergleichen.

// Mit Pandas einen Blick in die Daten werfen

Wir haben verwendet Pandas um den Datensatz in ein Jupyter-Notizbuch zu laden und seine allgemeine Struktur, Abmessungen und Nullwerte zu untersuchen. Hier ist der Code.

import pandas as pd
df = pd.read_excel('bankdataset.xlsx')

print("Dataset form:", df.form)

df.head()

Hier ist die Ausgabe.

Wenn Sie einen schnellen Überblick über gängige Vorgänge beim Durchsuchen von Datensätzen benötigen, schauen Sie sich dieses praktische Handbuch an Pandas-Spickzettel.

Sehen wir uns vor dem Benchmarking an, wie die Umgebung eingerichtet wird.

# Einrichten einer fairen Testumgebung

Alle drei Instruments – DuckDB, SQLite und Pandas – wurden in derselben Jupyter Pocket book-Umgebung eingerichtet und ausgeführt, um sicherzustellen, dass der Check truthful battle. Dadurch wurde sichergestellt, dass die Bedingungen zur Laufzeit und die Speichernutzung durchgehend konstant blieben.

Zuerst haben wir die notwendigen Pakete installiert und geladen.

Hier sind die Instruments, die wir brauchten:

• Pandas: für Normal DataFrame Operationen
• duckdb: für die SQL-Ausführung auf a DataFrame
• sqlite3: zum Verwalten einer eingebetteten SQL-Datenbank
• Zeit: zum Erfassen der Ausführungszeit
• Memory_profiler: um die Speicherzuordnung zu messen

# Set up if any of them should not in your surroundings
!pip set up duckdb --quiet

import pandas as pd
import duckdb
import sqlite3
import time
from memory_profiler import memory_usage

Bereiten wir nun die Daten in einem Format vor, das von allen drei Instruments gemeinsam genutzt werden kann.

// Daten in Pandas laden

Wir verwenden Pandas, um den Datensatz einmal zu laden, und geben ihn dann für DuckDB und SQLite frei oder registrieren ihn.

df = pd.read_excel('bankdataset.xlsx')

df.head()

Hier ist die zu validierende Ausgabe.

// Registrieren von Daten bei DuckDB

Mit DuckDB können Sie direkt auf Pandas zugreifen DataFrameS. Sie müssen nichts umrechnen – einfach registrieren und abfragen. Hier ist der Code.

# Register DataFrame as a DuckDB desk
duckdb.register("bank_data", df)

# Question through DuckDB
duckdb.question("SELECT * FROM bank_data LIMIT 5").to_df()

Hier ist die Ausgabe.

// Vorbereiten von Daten für SQLite

Da SQLite Excel-Dateien nicht direkt liest, haben wir zunächst die Pandas hinzugefügt DataFrame an eine In-Reminiscence-Datenbank. Anschließend verwendeten wir eine einfache Abfrage, um das Datenformat zu untersuchen.

conn_sqlite = sqlite3.join(":reminiscence:")

df.to_sql("bank_data", conn_sqlite, index=False, if_exists="change")

pd.read_sql_query("SELECT * FROM bank_data LIMIT 5", conn_sqlite)

Hier ist die Ausgabe.

# Wie wir die Instruments bewertet haben

Wir haben dieselben vier Abfragen für DuckDB, SQLite und Pandas verwendet, um ihre Leistung zu vergleichen. Jede Abfrage wurde für eine allgemeine Analyseaufgabe entwickelt, die widerspiegelt, wie die Datenanalyse in der realen Welt angewendet wird.

// Sicherstellung einer konsistenten Einrichtung

Der In-Reminiscence-Datensatz wurde von allen drei Instruments verwendet.

• Pandas befragte die DataFrame direkt
• DuckDB führte SQL-Abfragen direkt gegen die aus DataFrame
• SQLite hat eine Kopie davon gespeichert DataFrame in einer In-Reminiscence-Datenbank und führte darauf SQL-Abfragen aus

Diese Methode stellte sicher, dass alle drei Instruments dieselben Daten verwendeten und mit denselben Systemeinstellungen arbeiteten.

// Messung der Ausführungszeit

Um die Abfragedauer zu verfolgen, verwendet Python time Das Modul verpackte jede Abfrage in einen einfachen Begin-/Finish-Timer. Es wurde nur die Ausführungszeit der Abfrage aufgezeichnet; Datenlade- und Vorbereitungsschritte wurden ausgeschlossen.

// Verfolgen der Speichernutzung

Zusammen mit der Verarbeitungszeit zeigt die Speichernutzung an, wie intestine jede Engine bei großen Datenmengen funktioniert.

Bei Bedarf kann die Speichernutzung unmittelbar vor und nach jeder Abfrage abgetastet werden, um den inkrementellen RAM-Verbrauch abzuschätzen.

// Die Benchmark-Abfragen

Wir haben jede Engine anhand derselben vier alltäglichen Analyseaufgaben getestet:

1. Gesamttransaktionswert: Summieren einer numerischen Spalte
2. Nach Domäne gruppieren: Aggregieren der Transaktionszahlen professional Kategorie
3. Nach Standort filtern: Zeilen werden vor der Aggregation nach einer Bedingung gefiltert
4. Gruppieren nach Domäne und Standort: Mehrfeldaggregation mit Durchschnittswerten

# Benchmark-Ergebnisse

// Abfrage 1: Gesamttransaktionswert

Hier messen wir, wie Pandas, DuckDB und SQLite bei der Summierung abschneiden Worth Spalte im gesamten Datensatz.

// Pandas-Leistung

Wir berechnen den Gesamttransaktionswert anhand von .sum() auf der Worth Spalte. Hier ist der Code.

pandas_results = ()

def pandas_q1():
    return df('Worth').sum()

mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q1()
finish = time.time()
mem_after = memory_usage(-1)(0)

pandas_results.append({
    "engine": "Pandas",
    "question": "Complete transaction worth",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})
pandas_results

Hier ist die Ausgabe.

// DuckDB-Leistung

Wir berechnen den Gesamttransaktionswert mithilfe einer Vollspaltenaggregation. Hier ist der Code.

duckdb_results = ()

def duckdb_q1():
    return duckdb.question("SELECT SUM(worth) FROM bank_data").to_df()

mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q1()
finish = time.time()
mem_after = memory_usage(-1)(0)

duckdb_results.append({
    "engine": "DuckDB",
    "question": "Complete transaction worth",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})
duckdb_results

Hier ist die Ausgabe.

// SQLite-Leistung

Wir berechnen den gesamten Transaktionswert durch Summieren worth Spalte. Hier ist der Code.

sqlite_results = ()

def sqlite_q1():
    return pd.read_sql_query("SELECT SUM(worth) FROM bank_data", conn_sqlite)

mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q1()
finish = time.time()
mem_after = memory_usage(-1)(0)

sqlite_results.append({
    "engine": "SQLite",
    "question": "Complete transaction worth",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})
sqlite_results

Hier ist die Ausgabe.

// Gesamtleistungsanalyse

Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.

import matplotlib.pyplot as plt


all_q1 = pd.DataFrame(pandas_results + duckdb_results + sqlite_results)

fig, axes = plt.subplots(1, 2, figsize=(10,4))

all_q1.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False, title="Execution Time (s)")
all_q1.plot(x="engine", y="reminiscence", form="barh", colour="salmon", ax=axes(1), legend=False, title="Reminiscence Utilization (MB)")

plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

Pandas ist bei weitem das schnellste und speichereffizienteste hier und wird bei minimaler RAM-Nutzung quick sofort ausgeführt. DuckDB ist etwas langsamer und benötigt mehr Speicher, bleibt aber effizient, während SQLite sowohl am langsamsten als auch am höchsten im Hinblick auf den Speicherverbrauch ist.

// Abfrage 2: Nach Domäne gruppieren

Hier messen wir die Leistung von Pandas, DuckDB und SQLite beim Gruppieren von Transaktionen Area und summieren ihre Zählungen.

// Pandas-Leistung

Wir berechnen die Gesamttransaktionszahl professional Area anhand von .groupby() auf der Area Spalte.

def pandas_q2():
    return df.groupby('Area')('Transaction_count').sum()

mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q2()
finish = time.time()
mem_after = memory_usage(-1)(0)

pandas_results.append({
    "engine": "Pandas",
    "question": "Group by area",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in pandas_results if p("question") == "Group by area")

Hier ist die Ausgabe.

// DuckDB-Leistung

Wir berechnen die Gesamtzahl der Transaktionen professional Area mithilfe einer SQL-Anweisung GROUP BY auf der area Spalte.

def duckdb_q2():
    return duckdb.question("""
        SELECT area, SUM(transaction_count) 
        FROM bank_data 
        GROUP BY area
    """).to_df()

mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q2()
finish = time.time()
mem_after = memory_usage(-1)(0)

duckdb_results.append({
    "engine": "DuckDB",
    "question": "Group by area",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in duckdb_results if p("question") == "Group by area")

Hier ist die Ausgabe.

// SQLite-Leistung

Wir berechnen die Gesamtzahl der Transaktionen professional Area mithilfe von SQL GROUP BY auf der In-Reminiscence-Tabelle.

def sqlite_q2():
    return pd.read_sql_query("""
        SELECT area, SUM(transaction_count) AS total_txn
        FROM bank_data
        GROUP BY area
    """, conn_sqlite)

mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q2()
finish = time.time()
mem_after = memory_usage(-1)(0)

sqlite_results.append({
    "engine": "SQLite",
    "question": "Group by area",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in sqlite_results if p("question") == "Group by area")

Hier ist die Ausgabe.

// Gesamtleistungsanalyse

Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

groupby_results = (r for r in (pandas_results + duckdb_results + sqlite_results) 
                   if "Group by" in r("question"))

df_groupby = pd.DataFrame(groupby_results)

fig, axes = plt.subplots(1, 2, figsize=(10,4))

df_groupby.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False, title="Execution Time (s)")
df_groupby.plot(x="engine", y="reminiscence", form="barh", colour="salmon", ax=axes(1), legend=False, title="Reminiscence Utilization (MB)")

plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

DuckDB ist am schnellsten, Pandas benötigt etwas mehr Zeit für weniger Speicher, während SQLite sowohl am langsamsten als auch am speicherintensivsten ist.

// Abfrage 3: Nach Standort filtern (Goa)

Hier messen wir die Leistung von Pandas, DuckDB und SQLite beim Filtern des Datensatzes Location = 'Goa' und Summieren der Transaktionswerte.

// Pandas-Leistung

Wir filtern Zeilen nach Location == 'Goa' und summieren ihre Werte. Hier ist der Code.

def pandas_q3():
    return df(df('Location') == 'Goa')('Worth').sum()

mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q3()
finish = time.time()
mem_after = memory_usage(-1)(0)

pandas_results.append({
    "engine": "Pandas",
    "question": "Filter by location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in pandas_results if p("question") == "Filter by location")

Hier ist die Ausgabe.

// DuckDB-Leistung

Wir filtern Transaktionen nach Location = 'Goa' und berechnen Sie ihren Gesamtwert. Hier ist der Code.

def duckdb_q3():
    return duckdb.question("""
        SELECT SUM(worth) 
        FROM bank_data 
        WHERE location = 'Goa'
    """).to_df()

mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q3()
finish = time.time()
mem_after = memory_usage(-1)(0)

duckdb_results.append({
    "engine": "DuckDB",
    "question": "Filter by location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in duckdb_results if p("question") == "Filter by location")

Hier ist die Ausgabe.

// SQLite-Leistung

Wir filtern Transaktionen nach Location = 'Goa' und summieren ihre Werte. Hier ist der Code.

def sqlite_q3():
    return pd.read_sql_query("""
        SELECT SUM(worth) AS total_value
        FROM bank_data
        WHERE location = 'Goa'
    """, conn_sqlite)

mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q3()
finish = time.time()
mem_after = memory_usage(-1)(0)

sqlite_results.append({
    "engine": "SQLite",
    "question": "Filter by location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in sqlite_results if p("question") == "Filter by location")

Hier ist die Ausgabe.

// Gesamtleistungsanalyse

Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

filter_results = (r for r in (pandas_results + duckdb_results + sqlite_results)
                  if r("question") == "Filter by location")

df_filter = pd.DataFrame(filter_results)

fig, axes = plt.subplots(1, 2, figsize=(10, 4))

df_filter.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False, title="Execution Time (s)")
df_filter.plot(x="engine", y="reminiscence", form="barh", colour="salmon", ax=axes(1), legend=False, title="Reminiscence Utilization (MB)")

plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

DuckDB ist die schnellste und effizienteste; Pandas ist bei höherer Speichernutzung langsamer; und SQLite ist am langsamsten, benötigt aber weniger Speicher.

// Abfrage 4: Gruppieren nach Domäne und Standort

// Pandas-Leistung

Wir berechnen den durchschnittlichen Transaktionswert gruppiert nach beiden Area Und Location. Hier ist der Code.

def pandas_q4():
    return df.groupby(('Area', 'Location'))('Worth').imply()

mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q4()
finish = time.time()
mem_after = memory_usage(-1)(0)

pandas_results.append({
    "engine": "Pandas",
    "question": "Group by area & location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in pandas_results if p("question") == "Group by area & location")

Hier ist die Ausgabe.

// DuckDB-Leistung

Wir berechnen den durchschnittlichen Transaktionswert gruppiert nach beiden area Und location. Hier ist der Code.

def duckdb_q4():
    return duckdb.question("""
        SELECT area, location, AVG(worth) AS avg_value
        FROM bank_data
        GROUP BY area, location
    """).to_df()

mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q4()
finish = time.time()
mem_after = memory_usage(-1)(0)

duckdb_results.append({
    "engine": "DuckDB",
    "question": "Group by area & location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in duckdb_results if p("question") == "Group by area & location")

Hier ist die Ausgabe.

// SQLite-Leistung

Wir berechnen den durchschnittlichen Transaktionswert gruppiert nach beiden area Und location. Hier ist der Code.

def sqlite_q4():
    return pd.read_sql_query("""
        SELECT area, location, AVG(worth) AS avg_value
        FROM bank_data
        GROUP BY area, location
    """, conn_sqlite)

mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q4()
finish = time.time()
mem_after = memory_usage(-1)(0)

sqlite_results.append({
    "engine": "SQLite",
    "question": "Group by area & location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in sqlite_results if p("question") == "Group by area & location")

Hier ist die Ausgabe.

// Gesamtleistungsanalyse

Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

gdl_results = (r for r in (pandas_results + duckdb_results + sqlite_results)
               if r("question") == "Group by area & location")

df_gdl = pd.DataFrame(gdl_results)

fig, axes = plt.subplots(1, 2, figsize=(10, 4))

df_gdl.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False,
            title="Execution Time (s)")
df_gdl.plot(x="engine", y="reminiscence", form="barh", ax=axes(1), legend=False,
            title="Reminiscence Utilization (MB)", colour="salmon")

plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

DuckDB verarbeitet Mehrfeld-Gruppierungen am schnellsten bei mäßiger Speichernutzung, Pandas ist bei sehr hoher Speichernutzung langsamer und SQLite ist bei erheblichem Speicherverbrauch am langsamsten.

# Endgültiger Vergleich aller Abfragen

Wir haben diese drei Engines hinsichtlich Speicher und Geschwindigkeit miteinander verglichen. Schauen wir uns noch einmal die Ausführungszeit an. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

all_results = pd.DataFrame(pandas_results + duckdb_results + sqlite_results)

measure_order = (
    "Complete transaction worth",
    "Group by area",
    "Filter by location",
    "Group by area & location",
)
engine_colors = {"Pandas": "#1f77b4", "DuckDB": "#ff7f0e", "SQLite": "#2ca02c"}

fig, axes = plt.subplots(2, 2, figsize=(12, 8))
axes = axes.ravel()

for i, q in enumerate(measure_order):
    d = all_results(all_results("question") == q)
    axes(i).barh(d("engine"), d("time"), 
                 colour=(engine_colors(e) for e in d("engine")))
    for y, v in enumerate(d("time")):
        axes(i).textual content(v, y, f" {v:.3f}", va="heart")
    axes(i).set_title(q, fontsize=10)
    axes(i).set_xlabel("Seconds")

fig.suptitle("Per-Measure Comparability — Execution Time", fontsize=14)
plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

Dieses Diagramm zeigt, dass DuckDB bei quick allen Abfragen durchweg die niedrigsten Ausführungszeiten aufweist, mit Ausnahme des Gesamttransaktionswerts, bei dem Pandas die Nase vorn hat. SQLite ist auf der ganzen Linie mit Abstand das langsamste. Lassen Sie uns als nächstes den Speicher überprüfen. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

all_results = pd.DataFrame(pandas_results + duckdb_results + sqlite_results)

measure_order = (
    "Complete transaction worth",
    "Group by area",
    "Filter by location",
    "Group by area & location",
)
engine_colors = {"Pandas": "#1f77b4", "DuckDB": "#ff7f0e", "SQLite": "#2ca02c"}

fig, axes = plt.subplots(2, 2, figsize=(12, 8))
axes = axes.ravel()

for i, q in enumerate(measure_order):
    d = all_results(all_results("question") == q)
    axes(i).barh(d("engine"), d("reminiscence"), 
                 colour=(engine_colors(e) for e in d("engine")))
    for y, v in enumerate(d("reminiscence")):
        axes(i).textual content(v, y, f" {v:.1f}", va="heart")
    axes(i).set_title(q, fontsize=10)
    axes(i).set_xlabel("MB")

fig.suptitle("Per-Measure Comparability — Reminiscence Utilization", fontsize=14)
plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

Dieses Diagramm zeigt, dass SQLite bei der Speichernutzung zwischen der besten und der schlechtesten Leistung schwankt, Pandas mit zwei besten und zwei schlechtesten Fällen extrem ist, während DuckDB bei allen Abfragen konstant im Mittelfeld bleibt. Infolgedessen erweist sich DuckDB insgesamt als die ausgewogenste Wahl und liefert eine konstant schnelle Leistung bei moderater Speichernutzung. Pandas zeigt Excessive – manchmal die schnellsten, manchmal die schwersten –, während SQLite mit der Geschwindigkeit zu kämpfen hat und beim Speicher oft auf der ineffizienten Seite landet.

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 High-Unternehmen auf ihre Interviews vorzubereiten. Nate schreibt über die neuesten Traits auf dem Karrieremarkt, gibt Ratschläge zu Vorstellungsgesprächen, stellt Knowledge-Science-Projekte vor und behandelt alles rund um SQL.

Bild von Autor | Ideogramm

Sie kennen dieses Gefühl, wenn Sie Daten in verschiedenen Formaten und Quellen verstreut haben, und Sie müssen alles verstehen? Genau das lösen wir heute. Lassen Sie uns eine ETL -Pipeline erstellen, die unordentliche Daten aufnimmt und sie in etwas tatsächlich Nützliches verwandelt.

In diesem Artikel werde ich Sie durch das Erstellen einer Pipeline führen, die E-Commerce-Transaktionen verarbeitet. Nichts Besonderes, nur praktischer Code, der den Job erledigt.

Wir holen Daten aus einer CSV-Datei (wie Sie von einer E-Commerce-Plattform herunterladen würden), reinigen Sie sie und speichern sie für die Analyse in einer geeigneten Datenbank.

Hyperlink zum Code auf GitHub

Was ist ein Extrakt, eine Transformation, eine Lastpipeline (ETL)?

Jede ETL -Pipeline folgt dem gleichen Muster. Sie schnappen sich Daten von irgendwo (Extrahieren), reinigen Sie sie und machen sie besser (Transformation), dann geben Sie sie an einen nützlichen Ort (Laden).

ETL Pipeline | Bild von Autor | Diagrams.internet (Draw.io)

Der Prozess beginnt mit dem Extrakt Section, in der Daten aus verschiedenen Quellsystemen wie Datenbanken, APIs, Dateien oder Streaming -Plattformen abgerufen werden. Während dieser Section identifiziert und zieht die Pipeline relevante Daten und führt gleichzeitig Verbindungen zu unterschiedlichen Systemen auf, die möglicherweise mit verschiedenen Zeitplänen und Formaten arbeiten.

Als nächstes die verwandeln Die Section repräsentiert die Kernverarbeitungsstufe, in der extrahierte Daten einer Reinigung, Validierung und Umstrukturierung unterzogen werden. Dieser Schritt befasst sich mit Datenqualitätsproblemen, wendet Geschäftsregeln an, führt Berechnungen durch und wandelt Daten in das erforderliche Format und die erforderliche Struktur um. Gemeinsame Transformationen umfassen Datentypkonvertierungen, Feldzuordnung, Aggregationen und die Entfernung von Duplikaten oder ungültige Datensätze.

Schließlich die laden Section überträgt die jetzt transformierten Daten in das Zielsystem. Dieser Schritt kann durch Volllast auftreten, wobei ganze Datensätze ersetzt oder inkrementelle Lasten ersetzt werden, wobei nur neue oder geänderte Daten hinzugefügt werden. Die Ladestrategie hängt von Faktoren wie Datenvolumen, Systemleistungsanforderungen und geschäftlichen Anforderungen ab.

Schritt 1: Auszug

In dem Schritt „Extrakt“ werden wir Daten in die Hände bekommen. In der realen Welt laden Sie diesen CSV möglicherweise von der Berichts-Dashboard Ihrer E-Commerce-Plattform aus, ziehen Sie es von einem FTP-Server oder erhalten Sie über API. Hier lesen wir in einer verfügbaren CSV -Datei.

def extract_data_from_csv(csv_file_path):
    strive:
        print(f"Extracting knowledge from {csv_file_path}...")
        df = pd.read_csv(csv_file_path)
        print(f"Efficiently extracted {len(df)} information")
        return df
    besides FileNotFoundError:
        print(f"Error: {csv_file_path} not discovered. Creating pattern knowledge...")
        csv_file = create_sample_csv_data()
        return pd.read_csv(csv_file)

Jetzt, da wir die Rohdaten aus seiner Quelle haben (raw_transactions.csv), wir müssen es in etwas Nutzbares verwandeln.

Schritt 2: Transformation

Hier machen wir die Daten tatsächlich nützlich.

def transform_data(df):
    print("Reworking knowledge...")
    
    df_clean = df.copy()
    
    # Take away information with lacking emails
    initial_count = len(df_clean)
    df_clean = df_clean.dropna(subset=('customer_email'))
    removed_count = initial_count - len(df_clean)
    print(f"Eliminated {removed_count} information with lacking emails")
    
    # Calculate derived fields
    df_clean('total_amount') = df_clean('value') * df_clean('amount')
    
    # Extract date elements
    df_clean('transaction_date') = pd.to_datetime(df_clean('transaction_date'))
    df_clean('yr') = df_clean('transaction_date').dt.yr
    df_clean('month') = df_clean('transaction_date').dt.month
    df_clean('day_of_week') = df_clean('transaction_date').dt.day_name()
    
    # Create buyer segments
    df_clean('customer_segment') = pd.lower(df_clean('total_amount'), 
                                        bins=(0, 50, 200, float('inf')), 
                                        labels=('Low', 'Medium', 'Excessive'))
    
    return df_clean

Erstens lassen wir Zeilen mit fehlenden E -Mails fallen, da unvollständige Kundendaten für die meisten Analysen nicht hilfreich sind.

Dann berechnen wir total_amount Durch Multiplizieren von Preis und Menge. Dies scheint offensichtlich zu sein, aber Sie wären überrascht, wie oft abgeleitete Felder wie diese in Rohdaten fehlen.

Die Date -Extraktion ist sehr praktisch. Anstatt nur einen Zeitstempel zu haben, haben wir jetzt ein separates Jahr, Monat und Tag der Woche. Dies erleichtert die Analyse von Mustern wie „Verkaufen wir an Wochenenden mehr?“

Die Kundensegmentierung verwendet pd.lower() kann besonders nützlich sein. Es wird automatisch Kunden in Ausgabenkategorien ein. Anstatt nur Transaktionsmengen zu haben, haben wir sinnvolle Geschäftssegmente.

Schritt 3: Laden

In einem echten Projekt laden Sie möglicherweise in eine Datenbank, senden an eine API oder drängen auf Cloud -Speicher.

Hier laden wir unsere sauberen Daten in eine ordnungsgemäße SQLite -Datenbank.

def load_data_to_sqlite(df, db_name="ecommerce_data.db", table_name="transactions"):
    print(f"Loading knowledge to SQLite database '{db_name}'...")
    
    conn = sqlite3.join(db_name)
    
    strive:
        df.to_sql(table_name, conn, if_exists="exchange", index=False)
        
        cursor = conn.cursor()
        cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
        record_count = cursor.fetchone()(0)
        
        print(f"Efficiently loaded {record_count} information to '{table_name}' desk")
        
        return f"Information efficiently loaded to {db_name}"
        
    lastly:
        conn.shut()

Jetzt können Analysten SQL-Abfragen ausführen, BI-Instruments verbinden und diese Daten tatsächlich zur Entscheidungsfindung verwenden.

SQLite funktioniert intestine dafür, da es leicht ist, kein Einrichten erfordert und eine einzige Datei erstellt, die Sie problemlos teilen oder sichern können. Der if_exists="exchange" Parameter bedeutet, dass Sie diese Pipeline mehrmals ausführen können, ohne sich um doppelte Daten zu kümmern.

Wir haben Überprüfungsschritte hinzugefügt, damit Sie wissen, dass die Final erfolgreich struggle. Es gibt nichts Schlimmeres, als zu glauben, dass Ihre Daten sicher gespeichert sind, um später einen leeren Tisch zu finden.

Ausführen der ETL -Pipeline

Dies orchestriert den gesamten Extrakt, transformieren und laden Workflow.

def run_etl_pipeline():
    print("Beginning ETL Pipeline...")
    
    # Extract
    raw_data = extract_data_from_csv('raw_transactions.csv')
    
    # Rework  
    transformed_data = transform_data(raw_data)
    
    # Load
    load_result = load_data_to_sqlite(transformed_data)
    
    print("ETL Pipeline accomplished efficiently!")
    
    return transformed_data

Beachten Sie, wie dies alles zusammenhält. Extrahieren, transformieren, laden, fertig. Sie können dies ausführen und sofort Ihre verarbeiteten Daten sehen.

Sie können den vollständigen Code finden auf Github.

Einpacken

Diese Pipeline übernimmt Roh -Transaktionsdaten und verwandelt sie in etwas, mit dem ein Analyst oder Datenwissenschaftler tatsächlich zusammenarbeiten kann. Sie haben saubere Aufzeichnungen, berechnete Felder und aussagekräftige Segmente.

Jede Funktion macht eine Sache intestine, und Sie können jeden Teil leicht ändern oder erweitern, ohne den Relaxation zu brechen.

Versuchen Sie nun, selbst zu laufen. Versuchen Sie auch, es für einen anderen Anwendungsfall zu ändern. Blissful Coding!

Bala Priya c ist ein Entwickler und technischer Schriftsteller aus Indien. Sie arbeitet gern an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessensgebiete und Fachgebiete umfassen DevOps, Information Science und natürliche Sprachverarbeitung. Sie liest gerne, schreibt, codieren und Kaffee! Derzeit arbeitet sie daran, ihr Wissen mit der Entwicklergemeinschaft zu lernen und zu teilen, indem sie Tutorials, Anleitungen, Meinungsstücke und vieles mehr autorisiert. Bala erstellt auch ansprechende Ressourcenübersichten und Codierungs -Tutorials.

Bild von Autor | Ideogramm

Daten sind chaotisch. Wenn Sie additionally Informationen von APIs, analysieren, reale Datensätze analysieren und dergleichen, werden Sie zwangsläufig auf Duplikate, fehlende Werte und ungültige Einträge stoßen. Anstatt denselben Reinigungscode wiederholt zu schreiben, spart eine intestine gestaltete Pipeline Zeit und sorgt für die Konsistenz in Ihren Datenwissenschaftsprojekten.

In diesem Artikel werden wir eine wiederverwendbare Datenreinigung und Validierungspipeline für Daten erstellen, die häufig auf die Datenqualitätsprobleme geht und gleichzeitig ein detailliertes Suggestions darüber gibt, was festgelegt wurde. Am Ende haben Sie ein Software, das Datensätze reinigen und in nur wenigen Codezeilen gegen Geschäftsregeln validieren kann.

Hyperlink zum Code auf GitHub

Warum Datenreinigungspipelines?

Denken Sie an Datenpipelines wie Montage -Linien in der Herstellung. Jeder Schritt führt eine bestimmte Funktion aus, und die Ausgabe aus einem Schritt wird zum Eingang für den nächsten. Dieser Ansatz macht Ihren Code in verschiedenen Projekten aufrechterhalten, überprüfbarer und wiederverwendbarer.

Eine einfache Datenreinigungspipeline
Bild von Autor | Diagrams.internet (Draw.io)

Unsere Pipeline übernimmt drei Kernverantwortung:

• Reinigung: Entfernen Sie Duplikate und verarbeiten Sie fehlende Werte (Verwenden Sie dies als Ausgangspunkt. Sie können nach Bedarf so viele Reinigungsschritte hinzufügen.)
• Validierung: Stellen Sie sicher, dass Daten die Geschäftsregeln und -beschränkungen entsprechen
• Berichterstattung: Verfolgen Sie, welche Änderungen während der Verarbeitung vorgenommen wurden

Einrichtung der Entwicklungsumgebung

Bitte stellen Sie sicher, dass Sie eine aktuelle Model von Python verwenden. Wenn Sie lokal verwenden, erstellen Sie eine virtuelle Umgebung und installieren Sie die erforderlichen Pakete:

Sie können auch Google Colab oder ähnliche Pocket book -Umgebungen verwenden, wenn Sie es vorziehen.

Definieren des Validierungsschemas

Bevor wir Daten validieren können, müssen wir definieren, wie „gültig“ aussieht. Wir werden Pydantic verwenden, eine Python -Bibliothek, die Typ -Hinweise verwendet, um Datentypen zu validieren.

class DataValidator(BaseModel):
    title: str
    age: Elective(int) = None
    e-mail: Elective(str) = None
    wage: Elective(float) = None
    
    @field_validator('age')
    @classmethod
    def validate_age(cls, v):
        if v is just not None and (v < 0 or v > 100):
            increase ValueError('Age have to be between 0 and 100')
        return v
    
    @field_validator('e-mail')
    @classmethod
    def validate_email(cls, v):
        if v and '@' not in v:
            increase ValueError('Invalid e-mail format')
        return v

Dieses Schema modelliert die erwarteten Daten mithilfe der Syntax von Pydantic. Um die zu verwenden @field_validator Dekorateur, du brauchst das @classmethod Dekorateur. Die Validierungslogik stellt sicher, dass das Alter innerhalb angemessener Grenzen fällt, und E -Mails enthalten das Image „@“.

Aufbau der Pipeline -Klasse

Unsere Hauptpipeline -Klasse umfasst alle Reinigungs- und Validierungslogik:

class DataPipeline:
    def __init__(self):
        self.cleaning_stats = {'duplicates_removed': 0, 'nulls_handled': 0, 'validation_errors': 0}

Der Konstruktor initialisiert ein Statistikwörterbuch, um Änderungen zu verfolgen, die während der Verarbeitung vorgenommen wurden. Dies trägt dazu bei, die Datenqualität genauer zu betrachten und die Reinigungsschritte im Laufe der Zeit zu verfolgen.

Schreiben der Datenreinigungslogik

Lassen Sie uns a hinzufügen clean_data Methode zur Behandlung gemeinsamer Datenqualitätsprobleme wie fehlenden Werten und doppelten Datensätzen:

def clean_data(self, df: pd.DataFrame) -> pd.DataFrame:
    initial_rows = len(df)
    
    # Take away duplicates
    df = df.drop_duplicates()
    self.cleaning_stats('duplicates_removed') = initial_rows - len(df)
    
    # Deal with lacking values
    numeric_columns = df.select_dtypes(embrace=(np.quantity)).columns
    df(numeric_columns) = df(numeric_columns).fillna(df(numeric_columns).median())
    
    string_columns = df.select_dtypes(embrace=('object')).columns
    df(string_columns) = df(string_columns).fillna('Unknown')

Dieser Ansatz ist clever bei der Behandlung verschiedener Datentypen. Numerische fehlende Werte werden mit dem Median gefüllt (robuster als Mittel gegen Ausreißer), während Textspalten einen Platzhalterwert erhalten. Die doppelte Entfernung erfolgt zunächst, um zu vermeiden, dass unsere medianen Berechnungen verzerrt werden.

Hinzufügen von Validierung mit Fehlerverfolgung

Der Validierungsschritt verarbeitet jede Zeile einzeln und sammelt sowohl gültige als auch detaillierte Fehlerinformationen:

def validate_data(self, df: pd.DataFrame) -> pd.DataFrame:
    valid_rows = ()
    errors = ()
    
    for idx, row in df.iterrows():
        strive:
            validated_row = DataValidator(**row.to_dict())
            valid_rows.append(validated_row.model_dump())
        besides ValidationError as e:
            errors.append({'row': idx, 'errors': str(e)})
    
    self.cleaning_stats('validation_errors') = len(errors)
    return pd.DataFrame(valid_rows), errors

Dieser Zeilen-für-Reihen-Ansatz stellt sicher, dass ein schlechter Rekord die gesamte Pipeline nicht zum Absturz bringt. Gültige Zeilen werden durch den Prozess fortgesetzt, während Fehler zur Überprüfung erfasst werden. Dies ist wichtig in Produktionsumgebungen, in denen Sie verarbeiten müssen, was Sie während der Markierung von Problemen können.

Orchestrieren die Pipeline

Der course of Methode verbindet alles zusammen:

def course of(self, df: pd.DataFrame) -> Dict(str, Any):
    cleaned_df = self.clean_data(df.copy())
    validated_df, validation_errors = self.validate_data(cleaned_df)
    
    return {
        'cleaned_data': validated_df,
        'validation_errors': validation_errors,
        'stats': self.cleaning_stats
    }

Der Rückgabewert ist ein umfassender Bericht, der die gereinigten Daten, alle Validierungsfehler und Verarbeitungsstatistiken enthält.

Alles zusammenstellen

So verwenden Sie die Pipeline in der Praxis:

# Create pattern messy information
sample_data = pd.DataFrame({
    'title': ('Tara Jamison', 'Jane Smith', 'Lucy Lee', None, 'Clara Clark','Jane Smith'),
    'age': (25, -5, 25, 35, 150,-5),
    'e-mail': ('taraj@e-mail.com', 'invalid-email', 'lucy@e-mail.com', 'jane@e-mail.com', 'clara@e-mail.com','invalid-email'),
    'wage': (50000, 60000, 50000, None, 75000,60000)
})

pipeline = DataPipeline()
outcome = pipeline.course of(sample_data)

Die Pipeline entfernt automatisch den doppelten Datensatz, verarbeitet den fehlenden Namen, indem er ihn mit „Unbekannter“ füllt, das fehlende Gehalt mit dem Medianwert füllt und Validierungsfehler für das damaging Alter und ungültige E -Mails fällt.

Sie können finden Das vollständige Skript auf GitHub.

Erweiterung der Pipeline

Diese Pipeline dient als Grundlage, auf die Sie aufbauen können. Betrachten Sie diese Verbesserungen für Ihre spezifischen Bedürfnisse:

Benutzerdefinierte Reinigungsregeln: Fügen Sie Methoden für die domänenspezifische Reinigung wie die Standardisierung von Telefonnummern oder Adressen hinzu.

Konfigurierbare Validierung: Machen Sie das pydantische Schema konfigurierbar, sodass dieselbe Pipeline unterschiedliche Datentypen verarbeiten kann.

Erweiterte Fehlerbehandlung: Implementieren Sie die Wiederholungslogik für vorübergehende Fehler oder automatische Korrektur für häufige Fehler.

Leistungsoptimierung: Für große Datensätze sollten Sie vektorisierte Operationen oder parallele Verarbeitung verwenden.

Einpacken

Bei Datenpipelines geht es nicht nur darum, einzelne Datensätze zu reinigen. Es geht darum, zuverlässige, wartbare Systeme aufzubauen.

Dieser Pipeline -Ansatz sorgt für die Konsistenz in Ihren Projekten und erleichtert die Anpassung der Geschäftsregeln, wenn sich die Anforderungen ändern. Beginnen Sie mit dieser grundlegenden Pipeline und passen Sie sie dann für Ihre spezifischen Anforderungen an.

Der Schlüssel ist ein zuverlässiges, wiederverwendbares System, das die alltäglichen Aufgaben erledigt, sodass Sie sich darauf konzentrieren können, Erkenntnisse aus sauberen Daten zu extrahieren. Glückliche Datenreinigung!

Bala Priya c ist ein Entwickler und technischer Schriftsteller aus Indien. Sie arbeitet gern an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessensgebiete und Fachgebiete umfassen DevOps, Knowledge Science und natürliche Sprachverarbeitung. Sie liest gerne, schreibt, codieren und Kaffee! Derzeit arbeitet sie daran, ihr Wissen mit der Entwicklergemeinschaft zu lernen und zu teilen, indem sie Tutorials, Anleitungen, Meinungsstücke und vieles mehr autorisiert. Bala erstellt auch ansprechende Ressourcenübersichten und Codierungs -Tutorials.

Bild von Autor | Leinwand

Das Navigieren und Verständnis großer Codebasen kann eine Herausforderung sein, insbesondere für neue Entwickler, die sich einem Projekt anschließen oder ältere Repositorys erneut besuchen. Traditionelle Methoden zum Verständnis von Codestrukturen beinhalten das Lesen zahlreicher Dateien und Dokumentationen, die zeitaufwändig und fehleranfällig sein können. Gitdiagram bietet eine Lösung, indem Github -Repositories in interaktive Diagramme umgewandelt werden und eine visuelle Darstellung der Codebasis -Architektur bereitgestellt werden. Dieses Device hilft beim Verständnis komplexer Systeme und zur Verbesserung der Zusammenarbeit zwischen Entwicklungsteams. In diesem Artikel werde ich Sie durch den Schritt-für-Schritt-Prozess der lokalen Verwendung von Gitdiagram führen. Additionally, ohne weiteres Warten, fangen wir an.

Schritt-für-Schritt-Anleitung zur Verwendung von Gitdiagram lokal

Schritt 1: Klonen Sie das Gitdiagram -Repository

git clone https://github.com/ahmedkhaleel2004/gitdiagram.git
cd gitdiagram

Schritt 2: Abhängigkeiten installieren

Dies holt und installiert Abhängigkeiten in node_modules.

Stellen Sie vor dem Ausführen von PNPM -Set up sicher, dass Sie über Node.js und PNPM international installiert sind.

• So laden Sie es von node.js ein, laden Sie es von herunter nodejs.org
• Führen Sie den folgenden Befehl aus, um PNPM zu installieren:

Schritt 3: Umgebungsvariablen einrichten

Bearbeiten die .Env -Datei Um Ihren OpenAI / Anthropic / OpenRouter -API -Schlüssel und non-compulsory Ihr GitHub Private Entry Token einzuschließen.

Schritt 4: Backend -Dienste starten

docker-compose up --build -d

Der Fastapi -Server ist bei verfügbar LOCALHOST: 8000. Sie sehen die folgende Nachricht auf der Serverseite.

{"message":"Howdy from GitDiagram API!"}

Schritt 5: Initialisieren Sie die Datenbank

Führen Sie die folgenden Befehle aus, um die Datenbank einzurichten:

chmod +x start-database.sh
./start-database.sh
pnpm db:push

Wenn Sie aufgefordert werden, ein zufälliges Passwort zu generieren, geben Sie Ja ein. Die Postgres -Datenbank beginnt in einem Container bei Localhost: 5432.
Notiz: Als ich versuchte, diesen Befehl auszuführen, bekam ich diesen Fehler:

sh: drizzle-kit: command not discovered
 ELIFECYCLE  Command failed.
 WARN   Native bundle.json exists, however node_modules lacking, did you imply to put in?

Es stellte sich heraus, dass ich Nrizzle-Equipment nicht installiert hatte. Wenn Sie dies additionally sehen, rennen Sie einfach:

Danach funktionierte PNPM DB: Push intestine und gab mir diese Ausgabe:

No config path offered, utilizing default 'drizzle.config.ts'
Studying config file '/Customers/kanwal/Desktop/gitdiagram/drizzle.config.ts'
Utilizing 'postgres' driver for database querying
(✓) Pulling schema from database...
(✓) Adjustments utilized

Schritt 6: Führen Sie den Frontend aus

Sie können jetzt auf die Web site zugreifen unter LOCALHOST: 3000 und bearbeiten Sie die in Backend/App/Router/generate.py definierten Ratenlimits im Erzeugungsfunktionsdekorator. Versuchen wir, das Github -Repo der Fastapi -Bibliothek zu visualisieren.

Frontend -Schnittstelle:

Ausgabe:

Schließe Gedanken

Dies ist eine großartige Idee und ein wirklich nützliches Repository. Ich persönlich hatte das Bedürfnis nach so etwas in meinen eigenen Projekten, daher schätze ich die Anstrengung und Imaginative and prescient dahinter.

Das heißt, ein unvoreingenommener Meinung zu bieten – es gibt definitiv Raum für Verbesserungen.

Ein wiederkehrendes Downside, auf das ich stieß, conflict:

Syntax error in textual content mermaid model 11.4.

Nach Angaben des Projektbesitzers Ahmedkhaleel2004Dieser Fehler bedeutet normalerweise, dass die LLM ungültige mermaid.js syntax erzeugt hat.

Ich habe versucht, dieses Downside auf zahlreiche Arten anzugehen, aber letztendlich finde ich, dass es keine zuverlässige Lösung gibt – es ist meistens eine Einschränkung der LLM. Wenn es eine Möglichkeit gäbe, mermaid.js -Code zu validieren, würde das helfen, aber ab sofort bin ich mir nicht sicher, wie.

Er stellte auch fest, dass die aktuelle Eingabeaufforderung (in `prompts.py`, insbesondere die dritte, die Meerjungfrau -Code generiert) bereits versucht, die korrekte Syntax durchzusetzen – aber es ist nicht narrensicher, und es treten immer noch neue Syntaxprobleme auf.

Eine Lösung, die ich on-line gefunden habe, die funktioniert hat
Während ich die Github -Probleme durchgab, stieß ich auf eine von einem andere Benutzer geteilte Problemumgehung, die tatsächlich für mich funktioniert hat:

Fügen Sie dies dem Anpassungsdiagramm hinzu: Ignorieren Sie das Syntax -Downside aus der Meerjungfrauversion 11.4.1 und regenerieren Sie den Relaxation des Diagramms.

Die Verwendung dieser Zeile half dabei, den Fehler zu umgehen. Obwohl einige Komponenten noch fehlen, erzeugte es zumindest ein Teildiagramm-genug, um ein hohes Verständnis der Codebasis zu vermitteln.

Kanwal Mehreen Kanwal ist ein Ingenieur für maschinelles Lernen und technischer Schriftsteller mit einer tiefgreifenden Leidenschaft für die Datenwissenschaft und die Schnittstelle von KI mit Medizin. Sie hat das eBook „Produktivität mit Chatgpt maximieren“. Als Google -Era -Gelehrte 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie wird auch als Teradata -Vielfalt in Tech Scholar, MITACS Globalink Analysis Scholar und Harvard Wecode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter der Veränderung, nachdem er Femcodes gegründet hat, um Frauen in STEM -Bereichen zu stärken.

ist magisch – bis Sie feststellen, welches Modell für Ihren Datensatz verwendet werden soll. Sollten Sie mit einem zufälligen Wald oder einer logistischen Regression gehen? Was ist, wenn ein naives Bayes -Modell beides übertrifft? Für die meisten von uns beantwortet dies Stunden manueller Exams, Modellbildung und Verwirrung.

Aber was wäre, wenn Sie den gesamten Modellauswahlprozess automatisieren könnten?
In diesem Artikel werde ich Sie durch ein einfaches, aber mächtiges führen Python Automatisierung, die automatisch die besten maschinellen Lernmodelle für Ihren Datensatz auswählt. Sie brauchen keine tiefen ML -Kenntnisse oder Tuning -Fähigkeiten. Schließen Sie einfach Ihre Daten ein und lassen Sie Python den Relaxation machen.

Warum automatisieren Sie die ML -Modellauswahl?

Es gibt mehrere Gründe, lasst uns einige von ihnen sehen. Denken Sie darüber nach:

• Die meisten Datensätze können auf verschiedene Weise modelliert werden.
• Es ist zeitaufwändig, jedes Modell manuell zu versuchen.
• Das frühzeitige Auswahl des falschen Modells kann Ihr Projekt entgleisen.

Mit der Automatisierung können Sie:

• Vergleichen Sie Dutzende von Modellen sofort.
• Erhalten Sie Leistungsmetriken, ohne sich wiederholten Code zu schreiben.
• Identifizieren Sie High-Performing-Algorithmen basierend auf Genauigkeit, F1-Rating oder RMSE.

Es ist nicht nur bequem, es ist eine intelligente ML -Hygiene.

Bibliotheken werden wir verwenden

Wir werden 2 unterschätzte Python -ML -Automatisierungsbibliotheken untersuchen. Diese sind LazyPredict Und Pykarett. Sie können beide mit dem unten angegebenen PIP -Befehl installieren.

pip set up lazypredict
pip set up pycaret

Importieren der erforderlichen Bibliotheken

Nachdem wir die erforderlichen Bibliotheken installiert haben, importieren wir sie. Wir werden auch einige andere Bibliotheken importieren, die uns helfen, die Daten zu laden und sie für die Modellierung vorzubereiten. Wir können sie mit dem unten angegebenen Code importieren.

import pandas as pd
from sklearn.model_selection import train_test_split
from lazypredict.Supervised import LazyClassifier
from pycaret.classification import *

Dataset laden

Wir werden den frei verfügbaren Diabetes -Datensatz verwenden, und Sie können diese Daten daraus überprüfen Hyperlink. Wir werden den folgenden Befehl verwenden, um die Daten herunterzuladen, sie in einem Datenrahmen zu speichern und die X (Funktionen) und Y (Ergebnis) zu definieren.

# Load dataset
url = "https://uncooked.githubusercontent.com/jbrownlee/Datasets/grasp/pima-indians-diabetes.knowledge.csv"
df = pd.read_csv(url, header=None)

X = df.iloc(:, :-1)
y = df.iloc(:, -1)

Verwenden von LazyPredict

Nachdem der Datensatz und die erforderlichen Bibliotheken importiert werden, teilen wir die Daten in ein Coaching und einen Testdatensatz auf. Danach werden wir es endlich an LazyPredict weitergeben, um zu verstehen, was das beste Modell für unsere Daten ist.

# Cut up knowledge
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# LazyClassifier
clf = LazyClassifier(verbose=0, ignore_warnings=True)
fashions, predictions = clf.match(X_train, X_test, y_train, y_test)

# High 5 fashions
print(fashions.head(5))

In der Ausgabe können wir deutlich erkennen, dass LazyPredict versucht hat, die Daten in über 20 ml -Modellen anzupassen, und die Leistung in Bezug auf Genauigkeit, ROC, AUC usw. wird gezeigt, dass sie das beste Modell für die Daten auswählt. Dies macht die Entscheidung weniger zeitaufwändig und genauer. In ähnlicher Weise können wir eine Handlung der Genauigkeit dieser Modelle erstellen, um es zu einer visuelleren Entscheidung zu machen. Sie können auch die benötigte Zeit überprüfen, was vernachlässigbar ist, was es viel mehr Zeit spart.

import matplotlib.pyplot as plt

# Assuming `fashions` is the LazyPredict DataFrame
top_models = fashions.sort_values("Accuracy", ascending=False).head(10)

plt.determine(figsize=(10, 6))
top_models("Accuracy").plot(form="barh", colour="skyblue")
plt.xlabel("Accuracy")
plt.title("High 10 Fashions by Accuracy (LazyPredict)")
plt.gca().invert_yaxis()
plt.tight_layout()

Verwenden von Pycaret

Überprüfen wir nun, wie Pycaret funktioniert. Wir werden denselben Datensatz verwenden, um die Modelle zu erstellen und die Leistung zu vergleichen. Wir werden den gesamten Datensatz verwenden, da Pycarett selbst einen Testtrain-Cut up durchführt.

Der folgende Code wird:

• Führen Sie mehr als 15 Modelle aus
• Bewerten Sie sie mit Kreuzvalidierung
• Geben Sie den besten auf der Leistung zurück

Alles in zwei Codezeilen.

clf = setup(knowledge=df, goal=df.columns(-1))
best_model = compare_models()

Wie wir hier sehen können, liefert PyCaret viel mehr Informationen über die Leistung des Modells. Es kann ein paar Sekunden dauern als LazyPredict, aber es liefert auch mehr Informationen, damit wir eine fundierte Entscheidung darüber treffen können, welches Modell wir fortsetzen möchten.

Actual-Life-Anwendungsfälle

Einige reale Anwendungsfälle, in denen diese Bibliotheken von Vorteil sein können, sind:

• Schnelles Prototyping bei Hackathons
• Interne Dashboards, die das beste Modell für Analysten vorschlagen
• ML unterrichten, ohne in Syntax zu ertrinken
• Ideen vor dem Testen vor der vollständigen Bereitstellung

Abschluss

Die Verwendung von Automl -Bibliotheken wie die, die wir besprochen haben, heißt das nicht, dass Sie die Mathematik hinter Modellen lernen sollten. Aber in einer schnelllebigen Welt ist es ein großer Produktivitätsschub.

Was ich an LazyPredict und Pycaret liebe, ist, dass sie Ihnen eine kurze Rückkopplungsschleife geben, sodass Sie sich auf Characteristic -Engineering, Domänenkenntnisse und Interpretationen konzentrieren können.

Wenn Sie ein neues ML -Projekt starten, probieren Sie diesen Workflow aus. Sie sparen Zeit, treffen bessere Entscheidungen und beeindrucken Ihr Workforce. Lassen Sie Python das schwere Heben durchführen, während Sie intelligenteren Lösungen bauen.

In diesem Tutorial behandeln wir, wie Sie einen Datenrahmen in R anhängen – einer der häufigsten Modifikationen, die für einen Datenrahmen durchgeführt werden.

Ein Datenrahmen ist eine der wesentlichen Datenstrukturen in der R -Programmiersprache. Es ist bekannt, dass es sehr flexibel ist, da es viele Datentypen enthalten kann und leicht zu ändern ist. Eine der typischsten Modifikationen, die an einem Datenrahmen in R durchgeführt wurden, ist das Hinzufügen neuer Beobachtungen (Zeilen).

In diesem Tutorial diskutieren wir die verschiedenen Möglichkeiten, einen oder mehrere Zeilen an einen Datenrahmen in R anzuhängen. Wenn Sie neu für das Erstellen von DataFrame in R haben, möchten Sie möglicherweise lesen So erstellen Sie einen Datenrahmen in R. Bevor Sie diesen Beitrag fortsetzen.

Lassen Sie uns vor dem Begin einen einfachen Datenrahmen als Experiment erstellen:

super_sleepers_initial <- knowledge.body(animal=c('koala', 'hedgehog'), 
                                     nation=c('Australia', 'Italy'),
                                     avg_sleep_hours=c(21, 18), 
                                     stringsAsFactors=FALSE)
print(super_sleepers_initial)

Notiz: Beim Erstellen des oben genannten Datenframe stringsAsFactors=FALSE. Standardmäßig ist dieser Parameter TRUEIn den meisten Fällen (es sei denn, wir haben keine Zeichenspalte des Datentyps), ist es stark empfohlen auf einstellen FALSE Unterdrückung der Standardkonvertierung des Zeichens in den Datentyp und daher vermeiden Sie unerwünschte Nebenwirkungen. Als Experiment können Sie diesen Parameter aus dem obigen Code -Stück entfernen, diese und die nachfolgenden Codezellen ausführen und die Ergebnisse beobachten.

Anhängen einer einzelnen Zeile an einen Datenrahmen in R.

Verwendung rbind()

Um eine Zeile an einen Datenrahmen in R anzuhängen, können wir die verwenden rbind() integrierte Funktion, die für „Reihenbindungen“ steht. Die grundlegende Syntax ist die folgende:

dataframe <- rbind(dataframe, new_row)

Beachten Sie, dass in der obigen Syntax durch new_row Wir werden höchstwahrscheinlich a verstehen Liste eher als a VektorEs sei denn, alle Spalten unseres Datenrahmens haben denselben Datentyp (was nicht häufig der Fall ist).

Lassen Sie uns einen neuen Datenrahmen rekonstruieren super_sleepers von der anfänglichen super_sleepers_initial und fügen Sie eine weitere Zeile hinzu:

# Reconstructing the super_sleepers dataframe
super_sleepers <- super_sleepers_initial

super_sleepers <- rbind(super_sleepers, listing('sloth', 'Peru', 17))
print(super_sleepers)

Die neue Zeile wurde am Ende des Datenrahmens angehängt.

Es ist wichtig zu berücksichtigen, dass hier und in allen nachfolgenden Beispielen die neue Zeile (oder Zeilen) die Struktur des Datenrahmens widerspiegeln muss, an den sie angehängt ist, was bedeutet, dass die Länge der Liste gleich der Anzahl der Spalten in den Datenrahmen und der Nachfolge der Datentypen der Elemente in der Liste der Datentypen der Datentypen der Datentypen der Datentypen der Datentypen der Datentypen entspricht. Im anderen Fall wirft das Programm einen Fehler auf.

Verwendung nrow()

Eine andere Möglichkeit, eine einzelne Zeile an einen R -Datenrahmen anzuhängen, besteht darin, die Verwendung des nrow() Funktion. Die Syntax ist wie folgt:

dataframe(nrow(dataframe) + 1,) <- new_row

Diese Syntax bedeutet wörtlich, dass wir die Anzahl der Zeilen im Datenrahmen berechnen (nrow(dataframe)), 1 zu dieser Nummer hinzufügen (nrow(dataframe) + 1) und dann eine neue Zeile anhängen new_row in diesem Index des Datenrahmens (dataframe(nrow(dataframe) + 1,)) – dh als neue letzte Reihe.

Wie zuvor unsere new_row Muss höchstwahrscheinlich ein sein Liste eher als a VektorEs sei denn, alle Spalten des Datenrahmens haben denselben Datentyp, was nicht üblich ist.

Fügen wir unserem Tisch noch einen „Tremendous-Sleeper“ hinzu:

super_sleepers(nrow(super_sleepers) + 1,) <- listing('panda', 'China', 10)
print(super_sleepers)

Wieder wurde die neue Zeile am Ende des Datenrahmens angehängt.

Verwendung add_row() von tidyverse

Was ist, wenn wir stattdessen eine neue Zeile zum Ende des Datenrahmens, sondern in einem bestimmten Index hinzufügen möchten? Zum Beispiel haben wir herausgefunden, dass Tigers täglich 16 Stunden schlafen (dh mehr als Pandas in unserer Bewertung, daher müssen wir diese Beobachtung als zweite in die Endzeile des Datenrahmens einfügen). In diesem Fall ist die Verwendung der Foundation R nicht genug, aber wir können die verwenden add_row() Funktion der tidyverse R -Paket (wir müssen es möglicherweise installieren, wenn es noch nicht installiert wird, indem wir ausgeführt werden set up.packages("tidyverse")):

library(tidyverse)
super_sleepers <- super_sleepers 
                                             nation='India', 
                                             avg_sleep_hours=16, 
                                             .earlier than=4)
print(super_sleepers)

Hier sollten wir Folgendes beachten:

• Wir haben dieselben Namen der Spalten in derselben Reihenfolge wie im vorhandenen Datenrahmen übergeben und ihnen die entsprechenden neuen Werte zugewiesen.
• Nach dieser Sequenz haben wir das hinzugefügt .earlier than Optionaler Parameter und angegeben den erforderlichen Index. Wenn wir das nicht tun würden, wird die Zeile standardmäßig zum Ende des Datenrahmens hinzugefügt. Alternativ könnten wir die verwenden .after Optionaler Parameter und zuweisen den Index der Zeile ihm nach welche die neue Beobachtung einfügen.
• Wir haben den Zuordnungsoperator verwendet <- Um die auf den aktuellen Datenrahmen angewendeten Änderungen zu speichern.

Anhängen mehrerer Zeilen an einen Datenrahmen in R.

Verwendung rbind()

Oft müssen wir nicht eine, sondern mehrere Zeilen an einen R -Datenframe anhängen. Die einfachste Methode hier besteht wieder darin, die zu verwenden rbind() Funktion. Genauer gesagt müssen wir in diesem Fall zwei Datenrahmen praktisch kombinieren: die anfängliche und die eine, die die Zeilen enthält, die angehängt werden sollen.

dataframe_1 <- rbind(dataframe_1, dataframe_2)

Um zu sehen, wie es funktioniert, rekonstruieren wir einen neuen Datenrahmen super_sleepers von der anfänglichen super_sleepers_initialDrucken Sie es aus, um sich zu erinnern, wie es aussieht, und fügen Sie zwei neue Zeilen an das Ende hinzu:

# Reconstructing the super_sleepers dataframe
super_sleepers <- super_sleepers_initial
print(super_sleepers)
cat('nn')  # printing an empty line

# Creating a brand new dataframe with the mandatory rows
super_sleepers_2 <- knowledge.body(animal=c('squirrel', 'panda'), 
                               nation=c('Canada', 'China'),
                               avg_sleep_hours=c(15, 10), 
                               stringsAsFactors=FALSE)

# Appending the rows of the brand new dataframe to the top of the present one
super_sleepers <- rbind(super_sleepers, super_sleepers_2)
print(super_sleepers)

Zur Erinnerung müssen die neuen Zeilen die Struktur des Datenrahmens widerspiegeln, an den sie angehängt werden, was bedeutet, dass die Anzahl der Spalten in beiden Datenfrüchten, die Spaltennamen, deren Nachfolge und Datentypen gleich sein müssen.

Verwendung nrow()

Alternativ können wir die verwenden nrow() Funktionen, um mehrere Zeilen an einen Datenrahmen in R anzuhängen. Hier ist dieser Ansatz jedoch hier nicht empfohlen Weil die Syntax sehr ungeschickt und schwer zu lesen ist. In diesem Fall müssen wir den Begin und den Endindex berechnen. Dafür müssen wir viel mehr Manipulation mit dem machen nrow() Funktion. Technisch gesehen lautet die Syntax wie folgt:

dataframe_1((nrow(dataframe_1) + 1):(nrow(dataframe_1) + nrow(dataframe_2)),) <- dataframe_2

Lassen Sie uns unsere rekonstruieren super_sleepers aus super_sleepers_initial und hängen Sie ihnen die Zeilen des bereits vorhandenen Datenrahmens an super_sleepers_2:

# Reconstructing the super_sleepers dataframe
super_sleepers <- super_sleepers_initial

super_sleepers((nrow(super_sleepers) + 1):(nrow(super_sleepers) + nrow(super_sleepers_2)),) <- super_sleepers_2
print(super_sleepers)

Wir haben den gleichen Datenrahmen wie im vorherigen Beispiel erhalten und beobachtet, dass der vorherige Ansatz viel eleganter ist.

Verwendung add_row() von tidyverse

Schließlich können wir wieder die verwenden add_row() Funktion der tidyverse Paket. Dieser Ansatz ist flexibler, da wir die neuen Zeilen am Ende des aktuellen Datenrahmens entweder anhängen oder vor/nach einer bestimmten Zeile einfügen können, die durch seinen Index angegeben ist.

Lassen Sie uns die Beobachtungen für Faultier und Tiger zwischen Igel und Eichhörnchen im aktuellen Datenrahmen einfügen super_sleepers:

library(tidyverse)
super_sleepers <- super_sleepers 
                                             nation=c('Peru', 'India'),
                                             avg_sleep_hours=c(17, 16), 
                                             .earlier than=3)
print(super_sleepers)

Beachten Sie, dass wir, um das obige Ergebnis zu erhalten, verwenden können .after=2 anstatt .earlier than=3.

Abschluss

In diesem Tutorial haben wir gelernt, wie man eine einzelne Zeile (oder mehrere Zeilen) an einen Datenrahmen in r angehängt hat – oder wie sie (oder sie) in einen bestimmten Index des Datenrahmens eingefügt werden. Insbesondere haben wir 3 Ansätze berücksichtigt: Verwenden der Verwendung der rbind() oder nrow() Funktionen der Foundation R oder der add_row() Funktion der tidyverse R -Paket. Wir haben den besten Anwendungsfällen für jede Methode und die Nuancen, die in verschiedenen Situationen berücksichtigt werden müssen, besondere Aufmerksamkeit geschenkt.

Wenn Sie mehr über die Arbeit mit DataFrames in R erfahren möchten, schauen Sie sich an So fügen Sie einem Datenrahmen in R eine Spalte hinzu (mit 18 Code -Beispielen)

Analysieren Sie riesige Datensätze direkt im Speicher – schneller als je zuvor

In diesem Projekt werden wir verarbeiten riesige Datensätze indem sie direkt in den Speicher geladen werden, was eine schnellere Analyse als mit herkömmlichen Methoden ermöglicht.

Durch Hebelwirkung In-Reminiscence-VerarbeitungWir können große Datenmengen effizient verarbeiten und schnell und effektiv aussagekräftige Erkenntnisse gewinnen.

Während die Geodatenanalyse ein zentraler Schwerpunkt ist, sind die Hauptziele des Projekts:

• Beherrschen groß angelegte Datenmanipulation
• Bewerben SQL-basierte Analysetechniken
• Erkundung leistungsstarker Instruments für In-Reminiscence-Verarbeitung

Das Projekt integriert diese Konzepte anhand von Geodaten als Beispiel aus der Praxis.

Am Ende werden Sie verstehen, wie man große Datenmengen im Speicher verarbeitet, und sich so wertvolle Fähigkeiten für zukünftige Projekte aneignen.