10 Python-Einzeiler zur Berechnung der Bedeutung von Modellmerkmalen
Bild vom Herausgeber

Modelle des maschinellen Lernens verstehen ist ein wesentlicher Aspekt beim Aufbau vertrauenswürdiger KI-Systeme. Die Verständlichkeit solcher Modelle beruht auf zwei grundlegenden Eigenschaften: Erklärbarkeit Und Interpretierbarkeit. Ersteres bezieht sich darauf, wie intestine wir das „Innere“ eines Modells beschreiben können (d. h. wie es funktioniert und intern aussieht), während sich Letzteres darauf bezieht, wie leicht Menschen die erfassten Beziehungen zwischen Eingabemerkmalen und vorhergesagten Ausgaben verstehen können. Wie wir sehen können, ist der Unterschied zwischen ihnen subtil, aber es gibt eine starke Brücke, die beide verbindet: Characteristic-Wichtigkeit.

In diesem Artikel werden 10 einfache, aber effektive Python-Einzeiler vorgestellt, mit denen Sie die Wichtigkeit von Modellmerkmalen aus verschiedenen Perspektiven berechnen können. So können Sie nicht nur verstehen, wie sich Ihr Modell für maschinelles Lernen verhält, sondern auch, warum es die Vorhersage(n) getroffen hat.

1. Integrierte Funktionsbedeutung in entscheidungsbaumbasierten Modellen

Baumbasierte Modelle wie Random Forests und XGBoost Mit Ensembles können Sie mithilfe eines Attributs wie dem folgenden ganz einfach eine Liste der Gewichtungen von Merkmalsbedeutung erhalten:

Beachten Sie, dass mannequin sollte a priori ein trainiertes Modell enthalten. Das Ergebnis ist ein Array, das die Wichtigkeit von Options enthält. Wenn Sie jedoch eine selbsterklärendere Model wünschen, erweitert dieser Code den vorherigen Einzeiler, indem er die Characteristic-Namen für einen Datensatz wie Iris in einer Zeile einfügt.

2. Koeffizienten in linearen Modellen

Einfachere lineare Modelle wie die lineare Regression und die logistische Regression legen Merkmalsgewichte auch über erlernte Koeffizienten offen. Dies ist eine Möglichkeit, die erste davon direkt und sauber zu erhalten (entfernen Sie den Positionsindex, um alle Gewichte zu erhalten):

3. Sortieren von Options nach Wichtigkeit

Ähnlich wie die erweiterte Model von Nummer 1 oben kann dieser nützliche Einzeiler verwendet werden, um Options nach ihren Wichtigkeitswerten in absteigender Reihenfolge zu ordnen: ein hervorragender Einblick, welche Options am stärksten oder einflussreichsten zu Modellvorhersagen beitragen.

4. Bedeutung der modellunabhängigen Permutation

Permutationswichtigkeit ist ein zusätzlicher Ansatz zur Messung der Wichtigkeit eines Merkmals – nämlich durch Mischen seiner Werte und Analysieren, wie eine Metrik, die zur Messung der Leistung des Modells verwendet wird (z. B. Genauigkeit oder Fehler), abnimmt. Dementsprechend ist dieser modellunabhängige Einzeiler von scikit-lernen wird verwendet, um Leistungseinbußen zu messen, die durch zufälliges Mischen der Werte einer Funktion entstehen.

5. Mittlerer Genauigkeitsverlust bei Kreuzvalidierungspermutationen

Dies ist ein effizienter Einzeiler zum Testen von Permutationen im Kontext von Kreuzvalidierungsprozessen – um zu analysieren, wie sich das Mischen der einzelnen Options auf die Modellleistung auswirkt Ok Falten.

6. Visualisierungen der Permutationsbedeutung mit Eli5

Eli5 – eine Kurzform von „Erklären, als wäre ich 5 (Jahre alt)“ – ist im Kontext des maschinellen Lernens von Python eine Bibliothek für kristallklare Erklärbarkeit. Es bietet eine leicht visuell interaktive HTML-Ansicht der Characteristic-Wichtigkeiten, wodurch es besonders praktisch für Notebooks ist und sich sowohl für trainierte lineare als auch für Baummodelle eignet.

7. Globale SHAP-Funktionsbedeutung

Gestalten ist eine beliebte und leistungsstarke Bibliothek, mit der Sie tiefer in die Erklärung der Bedeutung von Modellmerkmalen einsteigen können. Es kann verwendet werden, um mittlere absolute SHAP-Werte (Characteristic-Significance-Indikatoren in SHAP) für jedes Characteristic zu berechnen – alles im Rahmen eines modellunabhängigen, theoretisch fundierten Messansatzes.

8. Zusammenfassendes Diagramm der SHAP-Werte

Im Gegensatz zu globalen SHAP-Characteristic-Bedeutungen liefert das Übersichtsdiagramm nicht nur die globale Bedeutung von Options in einem Modell, sondern auch deren Richtungen und hilft so visuell zu verstehen, wie Characteristic-Werte Vorhersagen nach oben oder unten verschieben.

Schauen wir uns ein visuelles Beispiel des erzielten Ergebnisses an:

9. Single-Prediction-Erklärungen mit SHAP

Ein besonders attraktiver Aspekt von SHAP besteht darin, dass es nicht nur dabei hilft, das Gesamtverhalten des Modells und die Bedeutung von Merkmalen zu erklären, sondern auch, wie Merkmale speziell eine einzelne Vorhersage beeinflussen. Mit anderen Worten: Wir können eine einzelne Vorhersage offenlegen oder zerlegen und erklären, wie und warum das Modell diese spezifische Ausgabe erbracht hat.

10. Modellunabhängige Funktionsbedeutung mit LIME

KALK ist eine different Bibliothek zu SHAP, die lokale Ersatzerklärungen generiert. Anstatt die eine oder andere zu verwenden, ergänzen sich diese beiden Bibliotheken intestine und tragen dazu bei, die Bedeutung von Merkmalen für einzelne Vorhersagen besser einzuschätzen. In diesem Beispiel wird dies für ein zuvor trainiertes logistisches Regressionsmodell durchgeführt.

Zusammenfassung

In diesem Artikel wurden 10 effektive Python-Einzeiler vorgestellt, die dabei helfen, Modelle für maschinelles Lernen besser zu verstehen, zu erklären und zu interpretieren, wobei der Schwerpunkt auf der Bedeutung von Funktionen liegt. Mithilfe dieser Instruments ist es keine mysteriöse Blackbox mehr, die Funktionsweise Ihres Modells von innen zu verstehen.

10 Python-Einzeiler zum Generieren von Zeitreihenfunktionen

Einführung

Zeitreihendaten Normalerweise ist ein tiefgreifendes Verständnis erforderlich, um effektive und aufschlussreiche Prognosemodelle zu erstellen. Zwei Schlüsseleigenschaften sind bei der Zeitreihenvorhersage von entscheidender Bedeutung: Darstellung und Granularität.

• Bei der Darstellung geht es darum, zeitliche Rohdaten – z. B. tägliche oder stündliche Messungen – mithilfe sinnvoller Ansätze in aussagekräftige Muster umzuwandeln
• Bei der Granularität geht es darum, zu analysieren, wie genau solche Muster Variationen im Zeitverlauf erfassen.

Als zwei Seiten derselben Medaille sind ihre Unterschiede subtil, aber eines ist sicher: Beide werden durch erreicht Function-Engineering.

In diesem Artikel werden 10 einfache Python-Einzeiler zum Generieren von Zeitreihenfunktionen basierend auf verschiedenen Merkmalen und Eigenschaften vorgestellt, die den Rohzeitreihendaten zugrunde liegen. Diese Einzeiler können einzeln oder in Kombination verwendet werden, um Ihnen bei der Erstellung informativerer Datensätze zu helfen, die viel über das zeitliche Verhalten Ihrer Daten verraten – wie sie sich entwickeln, wie sie schwanken und welche Traits sie im Laufe der Zeit aufweisen.

Beachten Sie, dass unsere Beispiele verwenden Pandas Und NumPy.

1. Verzögerungsfunktion (autoregressive Darstellung)

Die Idee hinter der Verwendung autoregressiver Darstellungs- oder Verzögerungsmerkmale ist einfacher als es klingt: Sie besteht darin, die vorherige Beobachtung als neues Prädiktormerkmal in die aktuelle Beobachtung einzufügen. Im Wesentlichen ist dies wohl die einfachste Methode, zeitliche Abhängigkeiten darzustellen, z. B. zwischen dem aktuellen Zeitpunkt und früheren Zeitpunkten.

Schauen wir uns diesen als ersten einzeiligen Beispielcode in dieser Liste von 10 genauer an.

In diesem einzeiligen Beispiel wird davon ausgegangen, dass Sie einen Rohzeitreihendatensatz in einem gespeichert haben DataFrame angerufen dfeines der vorhandenen Attribute ist benannt 'worth'. Beachten Sie, dass das Argument in der shift() Die Funktion kann angepasst werden, um den registrierten Wert abzurufen N Zeitpunkte oder Beobachtungen vor dem aktuellen:

Bei täglichen Zeitreihendaten ist die Verwendung sinnvoll, wenn Sie frühere Werte für einen bestimmten Wochentag, z. B. Montag, erfassen möchten shift(7).

2. Rollmittel (kurzfristige Glättung)

Um lokale Traits zu erfassen oder kurzfristige Schwankungen in den Daten zu glätten, ist es in der Regel praktisch, gleitende Mittelwerte über die Daten hinweg zu verwenden N frühere Beobachtungen, die zur aktuellen Beobachtung führen: Dies ist eine einfache, aber sehr nützliche Methode, um manchmal chaotische Rohzeitreihenwerte über ein bestimmtes Merkmal zu glätten.

In diesem Beispiel wird ein neues Function erstellt, das für jede Beobachtung den gleitenden Mittelwert der drei vorherigen Werte dieses Options in aktuellen Beobachtungen enthält:

Geglättete Zeitreihenfunktion mit gleitendem Mittelwert

3. Rollierende Standardabweichung (lokale Volatilität)

Ähnlich wie bei gleitenden Mittelwerten besteht auch die Möglichkeit, neue Merkmale auf der Grundlage der gleitenden Standardabweichung zu erstellen, was für die Modellierung der Volatilität aufeinanderfolgender Beobachtungen effektiv ist.

In diesem Beispiel wird eine Funktion zum Modellieren der Variabilität der neuesten Werte über ein gleitendes Fenster einer Woche unter der Annahme täglicher Beobachtungen vorgestellt.

4. Erweiterungsmittel (kumulativer Speicher)

Der expandierende Mittelwert berechnet den Mittelwert aller Datenpunkte bis (einschließlich) der aktuellen Beobachtung in der zeitlichen Abfolge. Es handelt sich additionally um einen gleitenden Mittelwert mit ständig wachsender Fenstergröße. Es ist nützlich zu analysieren, wie sich der Mittelwert der Werte in einem Zeitreihenattribut im Laufe der Zeit entwickelt, um so Aufwärts- oder Abwärtstrends langfristig zuverlässiger zu erfassen.

5. Differenzierung (Trendentfernung)

Diese Technik wird verwendet, um langfristige Traits zu entfernen und Änderungsraten hervorzuheben – was in instationären Zeitreihen wichtig ist, um sie zu stabilisieren. Es berechnet die Differenz zwischen aufeinanderfolgenden Beobachtungen (aktuelle und vorherige) eines Zielattributs:

6. Zeitbasierte Funktionen (Zeitkomponentenextraktion)

Einfach, aber in realen Anwendungen sehr nützlich, kann dieser Einzeiler verwendet werden, um relevante Informationen aus der vollständigen Datums-/Uhrzeitfunktion zu zerlegen und zu extrahieren oder Ihre Zeitreihe zu indizieren, um die es geht:

Wichtig: Seien Sie vorsichtig und prüfen Sie, ob in Ihrer Zeitreihe die Datum-Uhrzeit-Informationen in einem regulären Attribut oder als Index der Datenstruktur enthalten sind. Wenn es der Index wäre, müssen Sie möglicherweise stattdessen Folgendes verwenden:

7. Rollende Korrelation (zeitliche Beziehung)

Dieser Ansatz geht einen Schritt über das Rollieren von Statistiken über ein Zeitfenster hinaus, um zu messen, wie aktuelle Werte mit ihren verzögerten Gegenstücken korrelieren, und trägt so dazu bei, sich entwickelnde Autokorrelationen zu entdecken. Dies ist beispielsweise nützlich bei der Erkennung von Regimewechseln, additionally abrupten und anhaltenden Verhaltensänderungen in den Daten im Laufe der Zeit, die auftreten, wenn rollierende Korrelationen irgendwann schwächer werden oder sich umkehren.

8. Fourier-Merkmale (Saisonalität)

Sinusförmige Fourier-Transformationen können in Rohzeitreihenattributen verwendet werden, um zyklische oder saisonale Muster zu erfassen. Durch die Anwendung der Sinus- (oder Kosinus-)Funktion werden beispielsweise zyklische Tagesinformationen, die den Datums-/Uhrzeitmerkmalen zugrunde liegen, in kontinuierliche Merkmale umgewandelt, die zum Erlernen und Modellieren jährlicher Muster nützlich sind.

Erlauben Sie mir, in diesem Beispiel aus gutem Grund einen Zweizeiler anstelle eines Einzeilers zu verwenden: Sinus und Kosinus zusammen erfassen das Gesamtbild möglicher zyklischer Saisonalitätsmuster besser.

9. Exponentiell gewichteter Mittelwert (adaptive Glättung)

Der exponentiell gewichtete Mittelwert – oder kurz EWM – wird angewendet, um exponentiell abfallende Gewichte zu erhalten, die aktuellen Datenbeobachtungen eine höhere Bedeutung verleihen und gleichzeitig das Langzeitgedächtnis bewahren. Es handelt sich um einen adaptiveren und etwas „intelligenteren“ Ansatz, bei dem aktuelle Beobachtungen Vorrang vor der fernen Vergangenheit haben.

10. Rollende Entropie (Informationskomplexität)

Zum Schluss noch ein bisschen Mathe! Die rollierende Entropie eines bestimmten Merkmals über ein Zeitfenster berechnet, wie zufällig oder verteilt die Werte über dieses Zeitfenster sind, und offenbart so die Menge und Komplexität der darin enthaltenen Informationen. Niedrigere Werte der resultierenden rollierenden Entropie weisen auf ein Gefühl von Ordnung und Vorhersagbarkeit hin. Je höher diese Werte sind, desto größer ist das „Chaos und die Unsicherheit“.

Zusammenfassung

In diesem Artikel haben wir 10 Strategien untersucht und veranschaulicht – jeweils über eine einzige Codezeile –, um eine Vielzahl von Mustern und Informationen aus rohen Zeitreihendaten zu extrahieren, von einfacheren Traits bis hin zu anspruchsvolleren Traits wie Saisonalität und Informationskomplexität.

Bild vom Herausgeber

# Einführung

CSV-Dateien sind überall in Datenworkflows zu finden, von Datenbankexporten über API-Antworten bis hin zum Herunterladen von Tabellenkalkulationen. Während Pandas großartig funktioniert, benötigen Sie manchmal schnelle Lösungen, die Sie mit Python programmieren können, ohne Pandas installieren zu müssen.

Das integrierte CSV-Modul von Python kann in Kombination mit Listenverständnissen und Generatorausdrücken die meisten gängigen CSV-Aufgaben in einer einzigen Codezeile erledigen. Diese Einzeiler eignen sich perfekt für die schnelle Datenexploration, ETL-Debugging oder wenn Sie in eingeschränkten Umgebungen arbeiten, in denen externe Bibliotheken nicht verfügbar sind.

Lassen Sie uns einen Beispiel-Geschäftsdatensatz mit 50 Datensätzen verwenden: knowledge.csv und legen Sie los!

Hyperlink zum Code auf GitHub

# 1. Suchen Sie nach der Spaltensumme

Berechnen Sie die Summe einer beliebigen numerischen Spalte über alle Zeilen.

print(f"Whole: ${sum(float(r(3)) for r in __import__('csv').reader(open(path)) if r(0) != 'transaction_id'):,.2f}")

Hier, path ist die Variable, die den Pfad zur Beispiel-CSV-Datei enthält. In diesem Beispiel in Google Colab ist dies der Fall path = "/content material/knowledge.csv".

Ausgabe:

Hier, __import__('csv') importiert das integrierte CSV-Modul inline. Der Generatorausdruck überspringt die Kopfzeile, konvertiert Spaltenwerte in Gleitkommazahlen, summiert sie und formatiert sie mit Währungsnotation. Passen Sie den Spaltenindex (3) und die Kopfzeilenprüfung nach Bedarf an.

# 2. Nach Most gruppieren

Finden Sie heraus, welche Gruppe in Ihrem Datensatz den höchsten Gesamtwert aufweist.

print(max({r(5): sum(float(row(3)) for row in __import__('csv').reader(open(path)) if row(5) == r(5) and row(0) != 'transaction_id') for r in __import__('csv').reader(open(path)) if r(0) != 'transaction_id'}.objects(), key=lambda x: x(1)))

Ausgabe:

('Mike Rodriguez', 502252.0)

Das Wörterbuchverständnis gruppiert nach Spalte 5 und summiert die Werte von Spalte 3 für jede Gruppe. Ein Durchgang sammelt Gruppenschlüssel und ein zweiter führt die Aggregation durch. max() mit einem Lambda findet die höchste Summe. Passen Sie die Spaltenindizes für verschiedene Gruppierungsvorgänge an.

# 3. Filtern und zeigen Sie eine Teilmenge von Zeilen an

Zeigen Sie mit formatierter Ausgabe nur Zeilen an, die einer bestimmten Bedingung entsprechen.

print("n".be part of(f"{r(1)}: ${float(r(3)):,.2f}" for r in __import__('csv').reader(open(path)) if r(7) == 'Enterprise' and r(0) != 'transaction_id'))

Ausgabe:

Acme Corp: $45,000.00
Gamma Options: $78,900.00
Zeta Methods: $156,000.00
Iota Industries: $67,500.25
Kappa LLC: $91,200.75
Nu Applied sciences: $76,800.25
Omicron LLC: $128,900.00
Sigma Corp: $89,700.75
Phi Corp: $176,500.25
Omega Applied sciences: $134,600.50
Alpha Options: $71,200.25
Matrix Methods: $105,600.25

Der Generatorausdruck filtert Zeilen, bei denen Spalte 7 gleich ist Enterpriseformatiert dann die Spalten 1 und 3. Mit "n".be part of(...) vermeidet das Drucken einer Liste von None Werte.

# 4. Gruppieren nach Summenverteilung

Erhalten Sie Gesamtsummen für jeden eindeutigen Wert in einer Gruppierungsspalte.

print({g: f"${sum(float(row(3)) for row in __import__('csv').reader(open(path)) if row(6) == g and row(0) != 'transaction_id'):,.2f}" for g in set(row(6) for row in __import__('csv').reader(open(path)) if row(0) != 'transaction_id')})

Ausgabe:

{'Asia Pacific': '$326,551.75', 'Europe': '$502,252.00', 'North America': '$985,556.00'}

Das Wörterbuchverständnis extrahiert zunächst mithilfe eines Mengenverständnisses eindeutige Werte aus Spalte 6 und berechnet dann die Summe von Spalte 3 für jede Gruppe. Dies ist aufgrund der Generatorausdrücke speichereffizient. Ändern Sie die Spaltenindizes, um sie nach verschiedenen Feldern zu gruppieren.

# 5. Schwellenwertfilter mit Sortierung

Suchen und ordnen Sie alle Datensätze über einem bestimmten numerischen Schwellenwert.

print(((n, f"${v:,.2f}") for n, v in sorted(((r(1), float(r(3))) for r in record(__import__('csv').reader(open(path)))(1:) if float(r(3)) > 100000), key=lambda x: x(1), reverse=True)))

Ausgabe:

(('Phi Corp', '$176,500.25'), ('Zeta Methods', '$156,000.00'), ('Omega Applied sciences', '$134,600.50'), ('Omicron LLC', '$128,900.00'), ('Matrix Methods', '$105,600.25'))

Dadurch werden Zeilen gefiltert, in denen Spalte 3 überschritten wird 100000erstellt Tupel aus Namen und numerischen Werten, sortiert nach dem numerischen Wert und formatiert die Werte dann als Währung für die Anzeige. Passen Sie den Schwellenwert und die Spalten nach Bedarf an.

# 6. Zählen Sie eindeutige Werte

Ermitteln Sie schnell, wie viele unterschiedliche Werte in einer Spalte vorhanden sind.

print(len(set(r(2) for r in __import__('csv').reader(open(path)) if r(0) != 'transaction_id')))

Ausgabe:

Hier extrahiert das Mengenverständnis eindeutige Werte aus Spalte 2; len() zählt sie. Dies ist nützlich, um die Datenvielfalt zu überprüfen oder unterschiedliche Kategorien zu finden.

# 7. Bedingte Aggregation

Berechnen Sie Durchschnittswerte oder andere Statistiken für bestimmte Teilmengen Ihrer Daten.

print(f"Common: ${sum(float(r(3)) for r in __import__('csv').reader(open(path)) if r(6) == 'North America' and r(0) != 'transaction_id') / sum(1 for r in __import__('csv').reader(open(path)) if r(6) == 'North America' and r(0) != 'transaction_id'):,.2f}")

Ausgabe:

Dieser Einzeiler berechnet den Durchschnitt von Spalte 3 für Zeilen, die der Bedingung in Spalte 6 entsprechen. Er verwendet eine Summe dividiert durch eine Anzahl (über einen Generatorausdruck). Es liest die Datei zweimal, hält aber die Speichernutzung niedrig.

# 8. Mehrspaltiger Filter

Wenden Sie mehrere Filterbedingungen gleichzeitig auf verschiedene Spalten an.

print("n".be part of(f"{r(1)} | {r(2)} | ${float(r(3)):,.2f}" for r in __import__('csv').reader(open(path)) if r(2) == 'Software program' and float(r(3)) > 50000 and r(0) != 'transaction_id'))

Ausgabe:

Zeta Methods | Software program | $156,000.00
Iota Industries | Software program | $67,500.25
Omicron LLC | Software program | $128,900.00
Sigma Corp | Software program | $89,700.75
Phi Corp | Software program | $176,500.25
Omega Applied sciences | Software program | $134,600.50
Nexus Corp | Software program | $92,300.75
Apex Industries | Software program | $57,800.00

Es kombiniert mehrere Filterbedingungen mit and Operatoren, prüft Zeichenfolgengleichheit und numerische Vergleiche und formatiert die Ausgabe mit Pipe-Trennzeichen für eine saubere Anzeige.

# 9. Berechnen Sie die Spaltenstatistik

Generieren Sie auf einmal Min-, Max- und Durchschnittsstatistiken für numerische Spalten.

vals = (float(r(3)) for r in __import__('csv').reader(open(path)) if r(0) != 'transaction_id'); print(f"Min: ${min(vals):,.2f} | Max: ${max(vals):,.2f} | Avg: ${sum(vals)/len(vals):,.2f}"); print(vals)

Ausgabe:

Min: $8,750.25 | Max: $176,500.25 | Avg: $62,564.13
(45000.0, 12500.5, 78900.0, 23400.75, 8750.25, 156000.0, 34500.5, 19800.0, 67500.25, 91200.75, 28750.0, 43200.5, 76800.25, 15600.75, 128900.0, 52300.5, 31200.25, 89700.75, 64800.0, 22450.5, 176500.25, 38900.75, 27300.0, 134600.5, 71200.25, 92300.75, 18900.5, 105600.25, 57800.0)

Dadurch wird eine Liste numerischer Werte aus Spalte 3 erstellt und dann Min., Max. und Durchschnitt in einer Zeile berechnet. Das Semikolon trennt Anweisungen. Es ist speicherintensiver als Streaming, aber für diese Statistiken schneller als das Lesen mehrerer Dateien.

# 10. Gefilterte Daten exportieren

Erstellen Sie eine neue CSV-Datei, die nur Zeilen enthält, die Ihren Kriterien entsprechen.

__import__('csv').author(open('filtered.csv','w',newline="")).writerows((r for r in record(__import__('csv').reader(open(path)))(1:) if float(r(3)) > 75000))

Dadurch wird die CSV-Datei gelesen, Zeilen basierend auf einer Bedingung gefiltert und in eine neue Datei geschrieben. Der newline="" Der Parameter verhindert zusätzliche Zeilenumbrüche. Beachten Sie, dass in diesem Beispiel der Header übersprungen wird (er verwendet (1:)), additionally schließen Sie es explizit ein, wenn Sie einen Header in der Ausgabe benötigen.

Zusammenfassung

Ich hoffe, dass Sie diese Einzeiler für die CSV-Verarbeitung hilfreich finden.

Solche Einzeiler sind praktisch für:

• Schnelle Datenexploration und -validierung
• Einfache Datentransformationen
• Prototyping vor dem Schreiben vollständiger Skripte

Aber Sie sollten sie meiden aus:

• Produktionsdatenverarbeitung
• Dateien, die eine komplexe Fehlerbehandlung erfordern
• Mehrstufige Transformationen

Diese Techniken funktionieren mit dem integrierten CSV-Modul von Python, wenn Sie schnelle Lösungen ohne Einrichtungsaufwand benötigen. Viel Spaß beim Analysieren!

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.

Bild von Editor | Chatgpt

# Einführung

Daten Engineering umfasst die Verarbeitung großer Datensätze, das Erstellen von ETL -Pipelines und die Aufrechterhaltung der Datenqualität. Dateningenieure arbeiten mit Streaming -Daten, überwachen die Systemleistung, verarbeiten Schemaänderungen und gewährleisten die Datenkonsistenz über verteilte Systeme.

Python-Einzeiler können dazu beitragen, diese Aufgaben zu vereinfachen, indem komplexe Operationen in einzelnen, lesbaren Aussagen kondensiert werden. Dieser Artikel konzentriert sich auf praktische Einzeiler, die allgemeine Daten technische Probleme lösen.

Die hier vorgestellten Einzeiler behandeln reale Aufgaben wie Verarbeitung von Ereignisdaten mit unterschiedlichen Strukturen, die Analyse von Systemprotokollen auf Leistungsprobleme, die Bearbeitung von API-Antworten mit unterschiedlichen Schemas und die Implementierung von Datenqualitätsprüfungen. Fangen wir an.

Hyperlink zum Code auf GitHub

# Beispieldaten

Lassen Sie uns einige Beispieldaten aufspannen, um unsere Einzeiler auszuführen:

import pandas as pd
import numpy as np
import json
from datetime import datetime, timedelta

# Create streaming occasion information
np.random.seed(42)
occasions = ()
for i in vary(1000):
    properties = {
        'device_type': np.random.selection(('cell', 'desktop', 'pill')),
        'page_path': np.random.selection(('/residence', '/merchandise', '/checkout')),
        'session_length': np.random.randint(60, 3600)
    }
    if np.random.random() > 0.7:
        properties('purchase_value') = spherical(np.random.uniform(20, 300), 2)

    occasion = {
        'event_id': f'evt_{i}',
        'timestamp': (datetime.now() - timedelta(hours=np.random.randint(0, 72))).isoformat(),
        'user_id': f'user_{np.random.randint(100, 999)}',
        'event_type': np.random.selection(('view', 'click on', 'buy')),
        'metadata': json.dumps(properties)
    }
    occasions.append(occasion)

# Create database efficiency logs
db_logs = pd.DataFrame({
    'timestamp': pd.date_range('2024-01-01', durations=5000, freq='1min'),
    'operation': np.random.selection(('SELECT', 'INSERT', 'UPDATE'), 5000, p=(0.7, 0.2, 0.1)),
    'duration_ms': np.random.lognormal(imply=4, sigma=1, measurement=5000),
    'table_name': np.random.selection(('customers', 'orders', 'merchandise'), 5000),
    'rows_processed': np.random.poisson(lam=25, measurement=5000),
    'connection_id': np.random.randint(1, 20, 5000)
})

# Create API log information
api_logs = ()
for i in vary(800):
    log_entry = {
        'timestamp': datetime.now() - timedelta(minutes=np.random.randint(0, 1440)),
        'endpoint': np.random.selection(('/api/customers', '/api/orders', '/api/metrics')),
        'status_code': np.random.selection((200, 400, 500), p=(0.8, 0.15, 0.05)),
        'response_time': np.random.exponential(150)
    }
    if log_entry('status_code') == 200:
        log_entry('payload_size') = np.random.randint(100, 5000)
    api_logs.append(log_entry)

# 1. Extrahieren von JSON -Feldern in DataFrame -Spalten

Konvertieren Sie die JSON -Metadatenfelder aus Ereignisprotokollen zur Analyse in separate Datenfream -Spalten.

events_df = pd.DataFrame(({**occasion, **json.hundreds(occasion('metadata'))} for occasion in occasions)).drop('metadata', axis=1)

Dieser One-Liner verwendet das Listenverständnis mit dem Auspacken von Wörterbuch, um die Basisfelder jedes Ereignisses mit seinen analysierten JSON-Metadaten zusammenzuführen. Der drop() Entfernt das Unique metadata Spalte Da der Inhalt jetzt in separaten Spalten befindet.

Ausgabe:

Dies erstellt einen Datenrahmen mit 1000 Zeilen und 8 Spalten, in denen JSON -Felder mögen device_type Und purchase_value Werden Sie einzelne Spalten, die direkt ausfragt und aggregiert werden können.

# 2. Identifizieren der Leistungsausreißer nach Betriebstyp

Finden Sie Datenbankvorgänge, die im Vergleich zu ähnlichen Vorgängen ungewöhnlich lange dauern.

outliers = db_logs.groupby('operation').apply(lambda x: x(x('duration_ms') > x('duration_ms').quantile(0.95))).reset_index(drop=True)

Diese Gruppendatenbankprotokolle nach Betriebstyp und filtert dann jede Gruppe für Datensätze, die die 95. Perzentildauer überschreiten.

Verkürzte Ausgabe:

Dies kehrt ungefähr 250 Ausreißerbetriebe zurück (5% von 5000 insgesamt), wobei jeder Vorgang signifikant langsamer als 95% der ähnlichen Vorgänge erzielte.

# 3. Berechnen der durchschnittlichen Reaktionszeiten für API -Endpunkte

Überwachen Sie die Leistungstrends im Laufe der Zeit für verschiedene API -Endpunkte mithilfe von Schiebern.

api_response_trends = pd.DataFrame(api_logs).set_index('timestamp').sort_index().groupby('endpoint')('response_time').rolling('1H').imply().reset_index()

Dadurch werden die API -Protokolle in einen Datenrahmen umgewandelt, der setzt timestamp als Index für zeitbasierte Operationen und sortiert chronologisch, um eine monotonische Reihenfolge sicherzustellen. Es gruppiert dann zu endpoint und wendet ein rollendes 1-stündiges Fenster auf die Antwortzeiten an.

Innerhalb jedes Gleitfensters die imply() Funktion berechnet die durchschnittliche Antwortzeit. Das rollende Fenster bewegt sich über die Zeit und bietet eher Leistungstrendanalysen als isolierte Messungen.

Verkürzte Ausgabe:

Wir erhalten die Reaktionszeittrends, die zeigen, wie sich die Leistung jedes API -Endpunkts im Laufe der Zeit mit Werten in Millisekunden ändert. Höhere Werte zeigen eine langsamere Leistung an.

# 4. Erkennen von Schemaänderungen in Ereignisdaten

Identifizieren Sie, wann neue Felder in Ereignismetadaten erscheinen, die in früheren Ereignissen nicht vorhanden waren.

schema_evolution = pd.DataFrame(({ok: kind(v).__name__ for ok, v in json.hundreds(occasion('metadata')).gadgets()} for occasion in occasions)).fillna('lacking').nunique()

Dies analysiert die JSON -Metadaten aus jedem Ereignis und erstellt einen Wörterbuch -Mapping -Feldnamen für ihre Python -Typamen kind(v).__name__.

Der resultierende DataFrame verfügt über eine Zeile professional Ereignis und eine Spalte professional eindeutiges Feld für alle Ereignisse. Der fillna('lacking') erledigt Ereignisse, die keine bestimmten Felder haben, und nunique() zählt wie viele verschiedene Werte (einschließlich lacking) erscheinen in jeder Spalte.

Ausgabe:

device_type       1
page_path         1
session_length    1
purchase_value    2
dtype: int64

# 5. Aggregation von mehrstufigen Datenbankverbindungsleistung

Erstellen Sie zusammenfassende Statistiken, die nach Betriebstyp und Verbindung für die Ressourcenüberwachung gruppiert sind.

connection_perf = db_logs.groupby(('operation', 'connection_id')).agg({'duration_ms': ('imply', 'rely'), 'rows_processed': ('sum', 'imply')}).spherical(2)

Diese Gruppendatenbankprotokolle nach Betriebstyp und Verbindungs ​​-ID gleichzeitig, wodurch eine hierarchische Analyse der Umgang mit verschiedenen Verbindungen erstellt wird.

Der agg() Die Funktion wendet mehrere Aggregationsfunktionen an: imply Und rely Damit die Dauer sowohl durchschnittliche Leistung als auch Abfragefrequenz zeigen kann, während sum Und imply für rows_processed Durchschnittsmuster zeigen. Der spherical(2) sorgt für eine lesbare Dezimalpräzision.

Ausgabe:

Dadurch wird ein multi-indexed-Datenrahmen erstellt, das zeigt, wie jede Verbindung unterschiedliche Vorgänge ausführt.

# 6. Erstellen stündlicher Ereignistypverteilungsmuster

Berechnen Sie die Verteilungsmuster des Ereignisarts über verschiedene Stunden hinweg, um die Benutzerverhaltenszyklen zu verstehen.

hourly_patterns = pd.DataFrame(occasions).assign(hour=lambda x: pd.to_datetime(x('timestamp')).dt.hour).groupby(('hour', 'event_type')).measurement().unstack(fill_value=0).div(pd.DataFrame(occasions).assign(hour=lambda x: pd.to_datetime(x('timestamp')).dt.hour).groupby('hour').measurement(), axis=0).spherical(3)

Dies extrahiert Stunde aus Zeitstempeln mit assign() und ein Lambda, dann erstellt dann eine Kreuzung von Stunden und Ereignisarten mithilfe von Tätigkeiten groupby Und unstack.

Der div() Der Betrieb normalisiert sich durch Gesamtereignisse professional Stunde, um eine proportionale Verteilung und nicht um Rohzahlen zu zeigen.

Verkürzte Ausgabe:

Gibt eine Matrix zurück, die den Anteil jedes Ereignisarts zeigt (viewAnwesend click onAnwesend buy) für jede Stunde des Tages, wobei Benutzerverhaltensmuster und Spitzenaktivitätsperioden für unterschiedliche Aktionen aufgedeckt werden.

# 7. Berechnung der API -Fehlerrate Zusammenfassung nach Statuscode

Überwachen Sie die API -Gesundheit, indem Sie Fehlerverteilungsmuster über alle Endpunkte analysieren.

error_breakdown = pd.DataFrame(api_logs).groupby(('endpoint', 'status_code')).measurement().unstack(fill_value=0).div(pd.DataFrame(api_logs).groupby('endpoint').measurement(), axis=0).spherical(3)

Diese gruppiert API -Protokolle von beiden endpoint Und status_codeverwendet dann measurement() Ereignisse zählen und unstack() Statuscodes in Spalten zu drehen. Der div() Der Betrieb normalisiert sich durch Gesamtanforderungen professional Endpunkt, um Anteile anstelle von Rohzahlen anzuzeigen, wodurch die Endpunkte die höchsten Fehlerraten und welche Arten von Fehlern sie erzeugen.

Ausgabe:

status_code     200    400    500
endpoint                         
/api/metrics  0.789  0.151  0.060
/api/orders   0.827  0.140  0.033
/api/customers    0.772  0.167  0.061

Erstellt eine Matrix, die den Anteil jedes Statuscode (200, 400, 500) für jeden Endpunkt zeigt, sodass problematische Endpunkte erkennen und ob sie bei Clientfehlern (4xx) oder Serverfehler (5xx) fehlschlagen.

# 8. Implementierung der Erkennung von Schiebfensteranomalie

Erkennen Sie ungewöhnliche Muster, indem Sie die aktuelle Leistung mit der jüngsten historischen Leistung vergleichen.

anomaly_flags = db_logs.sort_values('timestamp').assign(rolling_mean=lambda x: x('duration_ms').rolling(window=100, min_periods=10).imply()).assign(is_anomaly=lambda x: x('duration_ms') > 2 * x('rolling_mean'))

Diese Sorten loget sich chronologisch an, berechnet einen rollenden Mittelwert der letzten 100 Operationen mithilfe rolling()Anschließend markiert Operationen, bei denen die aktuelle Dauer doppelt so hoch ist wie der Rolling -Durchschnitt. Der min_periods=10 Stellt sicher, dass die Berechnungen erst beginnen, nachdem ausreichende Daten verfügbar sind.

Verkürzte Ausgabe:

Fügt jedem Datenbankvorgang Anomalie -Flags hinzu und identifiziert Operationen, die im Vergleich zur jüngsten Leistung ungewöhnlich langsam sind, anstatt statische Schwellenwerte zu verwenden.

# 9. Optimieren speichereffizienter Datentypen

Optimieren Sie automatisch die Verwendungsverbrauch von DataFrame -Speicher, indem Sie numerische Typen auf die kleinstmöglichen Darstellungen heruntergefahren werden.

optimized_df = db_logs.assign(**{c: (pd.to_numeric(db_logs(c), downcast="integer") if pd.api.varieties.is_integer_dtype(db_logs(c)) else pd.to_numeric(db_logs(c), downcast="float")) for c in db_logs.select_dtypes(embody=('int', 'float')).columns})

Dies wählt nur numerische Spalten aus und ersetzt sie im Unique db_logs mit heruntergekommenen Versionen verwenden pd.to_numeric(). Für Ganzzahlspalten versucht es int8Anwesend int16Und int32 Vor dem Aufenthalt bei int64. Für Float -Spalten versucht es float32 vor float64.

Dies reduziert den Speicherverbrauch für große Datensätze.

# 10. Berechnung stündlicher Ereignisverarbeitungsmetriken

Überwachen Sie Streaming Pipeline Well being, indem Sie das Ereignisvolumen und die Benutzer -Engagement -Muster verfolgen.

pipeline_metrics = pd.DataFrame(occasions).assign(hour=lambda x: pd.to_datetime(x('timestamp')).dt.hour).groupby('hour').agg({'event_id': 'rely', 'user_id': 'nunique', 'event_type': lambda x: (x == 'buy').imply()}).rename(columns={'event_id': 'total_events', 'user_id': 'unique_users', 'event_type': 'purchase_rate'}).spherical(3)

Dies extrahiert die Stunde aus Zeitstempeln und Gruppen Ereignisse zu Stunde und berechnet dann drei wichtige Metriken: Gesamtveranstaltung der Ereignisanzeige mithilfe rely()einzigartige Benutzer verwenden nunique()und Kaufumrechnungsrate unter Verwendung einer Lambda, die den Anteil der Kaufveranstaltungen berechnet. Der rename() Die Methode bietet beschreibende Spaltennamen für die endgültige Ausgabe.

Ausgabe:

Dies zeigt stündliche Kennzahlen, die den gesamten Tag des Ereignisvolumens, des Nutzungsbetriebs und der Conversion -Raten im Laufe des Tages angeben.

# Einpacken

Diese Einzeiler sind nützlich für Daten technische Aufgaben. Sie kombinieren PANDAS-Operationen, statistische Analysen und Datentransformationstechniken, um reale Szenarien effizient zu bewältigen.

Jedes Muster kann anhand spezifischer Anforderungen angepasst und erweitert werden und gleichzeitig die Kernlogik beibehalten, die sie für die Produktionsanwendung wirksam macht.

Completely happy 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, 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 | Chatgpt

# Einführung

Wenn es um maschinelles Lernen geht, ist die Effizienz der Schlüssel. Das Schreiben von sauberem, lesbarem und prägnantem Code beschleunigt nicht nur die Entwicklung, sondern erleichtert auch die Pipelines für maschinelles Lernen zu verstehen, zu teilen, zu warten und zu debuggen. Python mit seiner natürlichen und ausdrucksstarken Syntax passt hervorragend zum Erstellen leistungsstarker Einzeiler, die gemeinsame Aufgaben in einer einzigen Codelinie erledigen können.

Dieses Tutorial konzentriert sich auf zehn praktische Einzeiler, die die Kraft von Bibliotheken wie nutzen Scikit-Be taught Und Pandas Um Ihre Workflows für maschinelles Lernen zu optimieren. Wir werden alles von Datenvorbereitung und Modelltraining bis hin zur Bewertung und Merkmalsanalyse abdecken.

Fangen wir an.

# Einrichten der Umgebung

Bevor wir unseren Code erstellen können, importieren wir die erforderlichen Bibliotheken, die wir in den Beispielen verwenden werden.

import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score

Lassen Sie uns damit nach dem anderen codieren.

# 1. Laden eines Datensatzes

Beginnen wir mit einer der Grundlagen. Erste Schritte mit einem Projekt bedeutet häufig das Laden von Daten. Scikit-Be taught verfügt über mehrere Spielzeugdatensätze, die perfekt zum Testen von Modellen und Workflows geeignet sind. Sie können sowohl die Funktionen als auch die Zielvariable in einer einzigen, sauberen Linie laden.

X, y = load_iris(return_X_y=True)

Dieser One-Liner verwendet die load_iris Funktion und Mengen return_X_y=True Um die Function -Matrix direkt zurückzugeben X und der Zielvektor yvermeiden Sie die Notwendigkeit, ein wörterbuchartiges Objekt zu analysieren.

# 2. Aufteilen von Daten in Trainings- und Testsätze

Ein weiterer grundlegender Schritt in jedem Projekt für maschinelles Lernen ist die Aufteilung Ihrer Daten in mehrere Sätze für unterschiedliche Verwendungen. Der train_test_split Funktion ist eine Hauptstütze; Es kann in einer Zeile ausgeführt werden, um vier separate Datenrahmen für Ihre Trainings- und Testsätze zu erstellen.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

Hier verwenden wir test_size=0.3 30% der Daten zum Testen zuweisen und verwenden stratify=y Um den Anteil der Klassen im Zug und die Testsätze zu gewährleisten, spiegelt der ursprüngliche Datensatz wider.

# 3. Erstellen und Coaching eines Modells

Warum zwei Zeilen verwenden, um ein Modell zu instanziieren und es dann zu trainieren? Sie können die ketten match Methode direkt zum Konstruktor des Modells für eine kompakte und lesbare Codezeile wie folgt:

mannequin = LogisticRegression(max_iter=1000, random_state=42).match(X_train, y_train)

Diese einzelne Zeile erstellt a LogisticRegression Modellieren Sie und trainiert es sofort in Ihren Trainingsdaten und gibt das angepasste Modellobjekt zurück.

# 4. Durchführen von Okay-fach Kreuzvalidierung

Die Kreuzvalidierung liefert eine robustere Schätzung der Leistung Ihres Modells als ein einzelner Zugtest. Scikit-larns cross_val_score erleichtert es einfach, diese Bewertung in einem Schritt durchzuführen.

scores = cross_val_score(LogisticRegression(max_iter=1000, random_state=42), X, y, cv=5)

Dieser One-Liner initialisiert ein neues logistisches Regressionsmodell, spaltet die Daten in 5-fach, Züge und bewertet das Modell fünfmal (bewertet das Modell (bewertet das Modellcv=5) und gibt eine Liste der Ergebnisse aus jeder Falte zurück.

# 5. Vorhersagen machen und Genauigkeit berechnen

Nach dem Coaching Ihres Modells möchten Sie seine Leistung im Testsatz bewerten. Sie können dies tun und die Genauigkeitsbewertung mit einem einzigen Methodenaufruf erhalten.

accuracy = mannequin.rating(X_test, y_test)

Der .rating() Die Methode kombiniert die Vorhersage- und Genauigkeitsberechnungschritte bequem und gibt die Genauigkeit des Modells auf die bereitgestellten Testdaten zurück.

# 6. Numerische Merkmale skalieren

Die Function -Skalierung ist ein häufiger Vorverarbeitungsschritt, insbesondere für Algorithmen, die für die Skala der Eingangsmerkmale empfindlich sind – einschließlich SVMs und logistischer Regression. Sie können den Scaler passen und Ihre Daten gleichzeitig mit dieser einzelnen Python -Linie transformieren:

X_scaled = StandardScaler().fit_transform(X)

Der fit_transform Die Methode ist eine bequeme Abkürzung, die die Skalierungsparameter aus den Daten lernt und die Transformation auf einmal anwendet.

# 7. Anwenden von One-Scorching-Codierung auf kategoriale Daten anwenden

One-HOT-Codierung ist eine Standardtechnik zum Umgang mit kategorialen Merkmalen. Während Scikit-Be taught eine mächtige hat OneHotEncoder Methode leistungsstark, die get_dummies Die Funktion von Pandas ermöglicht einen echten Einzelliner für diese Aufgabe.

df_encoded = pd.get_dummies(pd.DataFrame(X, columns=('f1', 'f2', 'f3', 'f4')), columns=('f1'))

Diese Zeile konvertiert eine bestimmte Spalte (f1) In einem PANDAS -Datenframe in neue Spalten mit Binärwerten (Binärwerte () (f1, f2, f3, f4), perfekt für maschinelles Lernmodelle.

# 8. Definieren einer Scikit-Be taught-Pipeline

Scikit-Be taught-Pipelines machen das Ketten mehrere Verarbeitungsschritte und einen endgültigen Schätzer unkompliziert. Sie verhindern Datenleckage und vereinfachen Ihren Workflow. Das Definieren einer Pipeline ist wie folgt ein sauberer Einzeiler:

pipeline = Pipeline((('scaler', StandardScaler()), ('svc', SVC())))

Dadurch wird eine Pipeline erstellt, die die Daten zuerst mithilfe der Daten skaliert StandardScaler und füttert dann das Ergebnis in einen Unterstützungs -Vektorklassifizierer.

# 9. Hyperparameter mit GridSearchCV Tuning

Das Finden der besten Hyperparameter für Ihr Modell kann mühsam sein. GridSearchCV kann dazu beitragen, diesen Prozess zu automatisieren. Durch Verketten .match()Sie können die Suche initialisieren, definieren und alles in einer Zeile ausführen.

grid_search = GridSearchCV(SVC(), {'C': (0.1, 1, 10), 'kernel': ('linear', 'rbf')}, cv=3).match(X_train, y_train)

Dadurch wird eine Gittersuche nach einer festgelegt SVC Modell, testet verschiedene Werte auf C Und kernelführt 3-fache Kreuzvalidierung durch (cv=3) und passt sie in die Trainingsdaten, um die beste Kombination zu finden.

# 10. Extrahieren von Merkmalsimporien extrahieren

Für baumbasierte Modelle wie zufällige Wälder ist das Verständnis, welche Merkmale am einflussreichsten sind, für den Aufbau eines nützlichen und effizienten Modells von entscheidender Bedeutung. Ein Listenverständnis ist ein klassischer pythonischer Einzeiler zum Extrahieren und Sortieren von Funktionsfunktionen. Beachten Sie, dass dieser Auszug das Modell zuerst erstellt und dann einen One-Liner verwendet, um die Funktionen von Funktionsfunktionen zu bestimmen.

# First, prepare a mannequin
feature_names = ('sepal_length', 'sepal_width', 'petal_length', 'petal_width')
rf_model = RandomForestClassifier(random_state=42).match(X_train, y_train)

# The one-liner
importances = sorted(zip(feature_names, rf_model.feature_importances_), key=lambda x: x(1), reverse=True)

Dieser Einzeiler kombiniert den Namen der einzelnen Funktionen mit seiner Wichtigkeitsbewertung und sortiert dann die Liste in absteigender Reihenfolge, um zuerst die wichtigsten Funktionen anzuzeigen.

# Einpacken

Diese zehn Einzeiler zeigen, wie Pythons prägnante Syntax Ihnen helfen kann, effizienteren und lesbaren Code für maschinelles Lernen zu schreiben. Integrieren Sie diese Verknüpfungen in Ihren täglichen Workflow, um die Kesselplatte zu reduzieren, Fehler zu minimieren und mehr Zeit zu konzentrieren, um sich auf das zu konzentrieren, was wirklich wichtig ist: Erstellen effektiver Modelle und extrahiere wertvolle Erkenntnisse aus Ihren Daten.

Matthew Mayo (@Mattmayo13) hat einen Grasp -Abschluss in Informatik und ein Diplom in Knowledge Mining. Als Geschäftsführer von Kdnuggets & Statologieund beitragen Redakteur bei Meisterschaft für maschinelles LernenMatthew zielt darauf ab, komplexe Datenwissenschaftskonzepte zugänglich zu machen. Zu seinen beruflichen Interessen zählen natürliche Sprachverarbeitung, Sprachmodelle, Algorithmen für maschinelles Lernen und die Erforschung der aufstrebenden KI. Er ist von der Mission getrieben, das Wissen in der Datenwissenschaftsgemeinschaft zu demokratisieren. Matthew kodiert seit seinem 6 -jährigen Lebensjahr.

Bild von Autor | Ideogramm

# Einführung

Die meisten Anwendungen stützen sich stark auf JSON für Datenaustausch, Konfigurationsmanagement und API -Kommunikation.

Das integrierte JSON-Modul von Python in Kombination mit Hear-Verständnissen und Wörterbuchoperationen ermöglicht es, komplexe JSON-Manipulationen mit überraschend prägnantem Code durchzuführen. Diese Einzeiler helfen Ihnen dabei, aussagekräftige Informationen aus JSON-Daten effizient zu analysieren, zu transformieren und zu extrahieren.

# Erstellen von Beispieldaten

Lassen Sie uns realistische JSON-Datensätze erstellen, die gemeinsame Szenarien darstellen, denen Sie in realen Anwendungen begegnen werden:

import json
from collections import defaultdict, Counter

# Pattern product catalog
merchandise = (
    {"id": 1, "title": "Laptop computer", "value": 999.99, "class": "Electronics", "inventory": 25, "ranking": 4.5},
    {"id": 2, "title": "Espresso Maker", "value": 79.99, "class": "Home equipment", "inventory": 15, "ranking": 4.2},
    {"id": 3, "title": "Smartphone", "value": 699.99, "class": "Electronics", "inventory": 50, "ranking": 4.7},
    {"id": 4, "title": "Desk Chair", "value": 159.99, "class": "Furnishings", "inventory": 8, "ranking": 4.1},
    {"id": 5, "title": "Headphones", "value": 199.99, "class": "Electronics", "inventory": 30, "ranking": 4.6}
)

# Pattern worker information
workers = (
    {"title": "Alice Johnson", "division": "Engineering", "wage": 95000, "initiatives": ("API", "Database")},
    {"title": "Bob Smith", "division": "Advertising", "wage": 65000, "initiatives": ("Marketing campaign", "Analytics")},
    {"title": "Carol Davis", "division": "Engineering", "wage": 105000, "initiatives": ("Frontend", "Testing")},
    {"title": "David Wilson", "division": "Gross sales", "wage": 75000, "initiatives": ("Outreach", "CRM")}
)

# Pattern nested API response
api_response = {
    "standing": "success",
    "information": {
        "orders": (
            {"id": "ORD001", "buyer": {"title": "John Doe", "electronic mail": "john@instance.com"}, "objects": ({"product": "Laptop computer", "amount": 1})},
            {"id": "ORD002", "buyer": {"title": "Jane Smith", "electronic mail": "jane@instance.com"}, "objects": ({"product": "Mouse", "amount": 2})}
        ),
        "total_orders": 2
    }
}

In den folgenden Beispielen habe ich die Druckaussagen weggelassen und mich nur auf die Einzeiler selbst konzentriert.

# 1. Extrahieren Sie alle Werte für einen bestimmten Schlüssel

Bei der Arbeit mit JSON -Arrays müssen Sie häufig alle Werte für ein bestimmtes Feld über mehrere Objekte hinweg extrahieren. Dieser Ein-Liner-Spucks spreizt spezifische Werte aus verschachtelten Strukturen effizient, was es perfekt zum Erstellen von Zusammenfassungslisten oder zur Vorbereitung von Daten zur weiteren Analyse macht.

product_names = (merchandise('title') for merchandise in merchandise)

Diese Liste durch Verständnis durch jedes Wörterbuch in der Produktliste und extrahiert das Feld „Title“. Die Sq. -Bracket -Notation greift direkt auf den Schlüssel zu und erstellt eine neue Liste, die nur die gewünschten Werte enthält, während die ursprüngliche Reihenfolge beibehalten wird.

('Laptop computer', 'Espresso Maker', 'Smartphone', 'Desk Chair', 'Headphones')

# 2. Filterung von JSON -Objekten nach Bedingung

Die Datenfilterung ist bei der Arbeit mit großen JSON -Datensätzen unerlässlich. Dieser One-Liner kombiniert das Listenverständnis mit einer bedingten Logik, um nur Objekte zu extrahieren, die bestimmte Kriterien erfüllen und die Erstellung der Schnelldaten-Untergruppe ohne komplexe Schleifen ermöglichen.

expensive_products = (merchandise for merchandise in merchandise if merchandise('value') > 200)

Der bedingte Ausdruck bewertet das Preisfeld jedes Produkts und umfasst nur diejenigen Objekte, bei denen die Bedingung wahr ist.

({'id': 1,
  'title': 'Laptop computer',
  'value': 999.99,
  'class': 'Electronics',
  'inventory': 25,
  'ranking': 4.5},
 {'id': 3,
  'title': 'Smartphone',
  'value': 699.99,
  'class': 'Electronics',
  'inventory': 50,
  'ranking': 4.7})

# 3. Gruppieren Sie JSON -Objekte nach Feldwert

Die Kategorisierung von Daten nach bestimmten Attributen ist eine häufige Anforderung bei der Datenverarbeitung. Dieser One-Liner erstellt ein Wörterbuch, bei dem Schlüssel eindeutige Feldwerte und -werte darstellen, die Hear von Objekten enthalten, die dieses Attribut teilen und eine effiziente Datenorganisation und -analyse ermöglichen.

products_by_category = {ok: (merchandise for merchandise in merchandise if merchandise('class') == ok) for ok in set(merchandise('class') for merchandise in merchandise)}

Das Wörterbuchverständnis erstellt zunächst eine Reihe eindeutiger Kategorienwerte und filtert dann für jede Kategorie die Produktliste so, dass sie nur übereinstimmende Elemente enthält.

{'Furnishings': ({'id': 4,
   'title': 'Desk Chair',
   'value': 159.99,
   'class': 'Furnishings',
   'inventory': 8,
   'ranking': 4.1}),
 'Home equipment': ({'id': 2,
   'title': 'Espresso Maker',
   'value': 79.99,
   'class': 'Home equipment',
   'inventory': 15,
   'ranking': 4.2}),
 'Electronics': ({'id': 1,
   'title': 'Laptop computer',
   'value': 999.99,
   'class': 'Electronics',
   'inventory': 25,
   'ranking': 4.5},
  {'id': 3,
   'title': 'Smartphone',
   'value': 699.99,
   'class': 'Electronics',
   'inventory': 50,
   'ranking': 4.7},
  {'id': 5,
   'title': 'Headphones',
   'value': 199.99,
   'class': 'Electronics',
   'inventory': 30,
   'ranking': 4.6})}

# 4. Berechnung der Aggregatstatistiken von JSON

Die schnelle statistische Analyse von JSON -Daten hilft bei der Identifizierung von Tendencies und Mustern. Dieser One-Liner berechnet gleichzeitig mehrere Aggregatfunktionen und liefert umfassende Einblicke in die numerischen Eigenschaften Ihres Datensatzes, ohne separate Berechnungsschleifen zu schreiben.

price_stats = {'min': min(merchandise('value') for merchandise in merchandise), 'max': max(merchandise('value') for merchandise in merchandise), 'avg': sum(merchandise('value') for merchandise in merchandise) / len(merchandise)}

Das Wörterbuchverständnis wendet unterschiedliche Aggregatfunktionen auf dieselben extrahierten Werte an, wobei Generatorausdrücke für die Speichereffizienz verwendet werden.

{'min': 79.99, 'max': 999.99, 'avg': 427.98999999999995}

# 5. JSON -Struktur transformieren

Die Umstrukturierung von JSON -Daten zu unterschiedlichen Schemas oder API -Anforderungen ist häufig erforderlich. Dieser Einzeiler erstellt neue Objekte mit modifizierten Feldnamen, berechneten Werten oder filtrierten Attributen, wodurch eine nahtlose Datenumwandlung zwischen verschiedenen Systemformaten ermöglicht wird.

simplified_products = ({'title': merchandise('title'), 'value': merchandise('value'), 'out there': merchandise('inventory') > 0} for merchandise in merchandise)

Das Listenverständnis erstellt neue Wörterbücher mit transformierten Feldnamen und berechneten booleschen Werten. Dieser Ansatz ermöglicht die Umbenennung von Feldzügen, Typ -Konvertierung und berechnete Attribute in einem einzigen Ausdruck, während sauberer, lesbarer Code beibehalten wird.

({'title': 'Laptop computer', 'value': 999.99, 'out there': True},
 {'title': 'Espresso Maker', 'value': 79.99, 'out there': True},
 {'title': 'Smartphone', 'value': 699.99, 'out there': True},
 {'title': 'Desk Chair', 'value': 159.99, 'out there': True},
 {'title': 'Headphones', 'value': 199.99, 'out there': True})

# 6. sicheres Extrahieren verschachtelter Werte sicher extrahieren

Verschachtete JSON -Daten müssen sorgfältig alle fehlenden Schlüssel behandeln, um Fehler zu vermeiden. Dieser One-Liner verwendet die GET-Methode mit Standardwerten, um verschachtelte Informationen sicher zu extrahieren, um einen robusten Code zu gewährleisten, der auch unvollständige oder missgebildete Daten behandelt.

customer_emails = (order.get('buyer', {}).get('electronic mail', 'N/A') for order in api_response('information')('orders'))

Die geketteten .get() Methoden liefern Standardwerte auf jeder Ebene, die verhindern KeyErrorAusnahmen beim Zugriff auf verschachtelte Strukturen. Dieser Ansatz ist für die Arbeit mit externen APIs oder von Benutzer erstellten Daten von wesentlicher Bedeutung, bei denen die Präsenz der Feldwäsche nicht garantiert wird.

('john@instance.com', 'jane@instance.com')

# 7. Zählen der Ereignisse der Feldwerte

Um Datenverteilungsmuster zu verstehen, müssen Sie zählen, wie häufig bestimmte Werte in Ihrem Datensatz angezeigt werden. Dieser Einzeiler erstellt eine Frequenzkarte der Feldwerte, die sofortige Einblicke in die Datenzusammensetzung bietet und hilfreiche Mustern oder Ausreißer identifiziert.

category_counts = Counter(merchandise('class') for merchandise in merchandise)

Der Counter Die Klasse ist automatisch das Auftreten jedes einzigartigen Wertes aus dem Generatorausdruck. Dieser Ansatz ist effizienter als manuelle Zählschleifen.

Counter({'Electronics': 3, 'Home equipment': 1, 'Furnishings': 1})

# 8. Zusammenführen mehrerer JSON -Objekte

Die Kombination von Daten aus mehreren JSON -Quellen ist häufig bei der Arbeit mit Microservices oder Federated Programs. Dieser One-Liner verschmilzt Objekte, indem sie Schlüsseln abgleichen und konsolidierte Datensätze erstellen, die Informationen aus verschiedenen Quellen enthalten.

enhanced_products = ({**product, 'total_value': product('value') * product('inventory')} for product in merchandise)

Das Wörterbuchpackung packt die vorhandenen Felder aus und fügt gleichzeitig neue berechnete Werte hinzu.

({'id': 1,
  'title': 'Laptop computer',
  'value': 999.99,
  'class': 'Electronics',
  'inventory': 25,
  'ranking': 4.5,
  'total_value': 24999.75},
 {'id': 2,
  'title': 'Espresso Maker',
  'value': 79.99,
  'class': 'Home equipment',
  'inventory': 15,
  'ranking': 4.2,
  'total_value': 1199.85},
...
 {'id': 5,
  'title': 'Headphones',
  'value': 199.99,
  'class': 'Electronics',
  'inventory': 30,
  'ranking': 4.6,
  'total_value': 5999.700000000001})

# 9. Objekte mit maximalen/minimalen Werten finden

Das Identifizieren von Datensätzen mit extremen Werten ist für die Datenanalyse und die Qualitätskontrolle von wesentlicher Bedeutung. Dieser Einzeiler findet Objekte, die die höchsten oder niedrigsten Werte für bestimmte Felder enthalten und die schnelle Identifizierung von Ausreißern, High-Künstlern oder Kanten in Ihrem Datensatz ermöglichen.

highest_rated = max(merchandise, key=lambda x: x('ranking'))

Der max Funktion mit a key Der Parameter gibt das Objekt mit dem maximalen Wert für den angegebenen Schlüssel zurück. Dieser Ansatz ist lesbarer als manuelle Iteration und funktioniert mit einem vergleichbaren Feldtyp, einschließlich Zeichenfolgen und Daten.

{'id': 3,
 'title': 'Smartphone',
 'value': 699.99,
 'class': 'Electronics',
 'inventory': 50,
 'ranking': 4.7}

# 10. Abflachende verschachtelte JSON -Arrays

Komplexe JSON -Strukturen enthalten häufig verschachtelte Arrays, die für die Analyse oder Verarbeitung abgeflacht werden müssen. Dieser Einzeiler extrahiert und kombiniert Elemente aus verschachtelten Hear und erzeugt eine einzige flache Struktur, mit der in nachfolgenden Operationen einfacher zu arbeiten sind.

projects_list = (venture for worker in workers for venture in worker('initiatives'))

Das verschachtelte Listenverständnis iteriert zunächst die Mitarbeiter, dann über die Projektliste der einzelnen Mitarbeiter und erstellt eine abgeflachte Reihe aller Projektnamen. Diese Doppel-Loop-Struktur behandelt effizient verschärfete Arrays mit variabler Länge.

('API',
 'Database',
 'Marketing campaign',
 'Analytics',
 'Frontend',
 'Testing',
 'Outreach',
 'CRM')

# Abschluss

Diese Python-Einzeiler zeigen, wie nützlich Python für die Manipulation von JSON-Daten ist.

Der Schlüssel ist, die integrierten Funktionen, Verständnisse und die Flexibilität von Wörterbuchoperationen von Python zu verstehen.

Mit diesen können Sie wahrscheinlich die API -Antworten verarbeiten, Daten zwischen verschiedenen Formaten transformieren und nützliche Informationen aus komplexen JSON -Strukturen extrahieren.

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.