# Einführung

Die zeilenweise Iteration ist einer der häufigsten Leistungsengpässe in Pandas Code. Bei kleinen Datensätzen bleibt es unbemerkt, aber für Verarbeitung großer Datenmengendas wird wirkungsvoll.

Pandas ist darauf gebaut NumPydas mit kompiliertem C-Code Operationen für ganze Arrays auf einmal ausführt. Das Durchlaufen von Zeilen in Python umgeht dies vollständig und erzwingt jede Operation zurück in den Python-Interpreter – eine Zeile nach der anderen.

Dieser Artikel behandelt 7 Alternativen zu Schleifen in Pandas, von denen jede für eine andere Artwork der Transformation geeignet ist. Am Ende haben Sie eine klare Vorstellung davon, zu welchem ​​Werkzeug Sie je nach Artwork des Issues greifen müssen.

Sie können das Colab-Notizbuch auf GitHub herunterladen.

# Einrichten des Beispieldatensatzes

In diesem Artikel verwenden wir einen realistischen E-Commerce-Auftragsdatensatz:

import pandas as pd
import numpy as np

np.random.seed(42)
n = 100_000

classes = ('Electronics', 'Clothes', 'Dwelling & Kitchen', 'Sports activities', 'Books')
areas = ('North', 'South', 'East', 'West')

df = pd.DataFrame({
    'order_id': vary(1, n + 1),
    'customer_age': np.random.randint(18, 70, n),
    'product_category': np.random.alternative(classes, n),
    'area': np.random.alternative(areas, n),
    'worth': np.spherical(np.random.uniform(5.0, 500.0, n), 2),
    'amount': np.random.randint(1, 10, n),
    'days_to_ship': np.random.randint(1, 14, n),
})
show(df.head())

Ausgabe:

Wir haben jetzt einen Datensatz mit 100.000 Zeilen, mit dem wir arbeiten können.

# 1. Verwendung vektorisierter Operationen für die Arithmetik

Für jede Arithmetik oder jeden Vergleich in einer Spalte: vektorisierte Operationen sollte Ihr erster Instinkt sein.

Was wir tun wollen: Berechnen Sie den Gesamtumsatz professional Bestellung.

df('income') = df('worth') * df('amount')
show(df(('worth', 'amount', 'income')).head())

Ausgabe:

# 2. Anwenden einer Funktion für bedingte Logik

Wenn Ihre Transformation eine Logik beinhaltet, die nicht als einfache Arithmetik ausgedrückt werden kann, .apply() ermöglicht es Ihnen, eine Funktion über eine Spalte oder Zeile zu übergeben.

Was wir tun wollen: Weisen Sie ein Versandprioritätsetikett basierend auf den Versandtagen zu.

def shipping_label(days):
    if days <= 2:
        return 'Categorical'
    elif days <= 5:
        return 'Customary'
    else:
        return 'Financial system'

df('shipping_tier') = df('days_to_ship').apply(shipping_label)
show(df(('days_to_ship', 'shipping_tier')).head())

Ausgabe:

Benutzen .apply() ist sauber, lesbar und viel einfacher zu debuggen als eine Schleife. Verwenden Sie es, wenn Ihre Logik bedingt ist und np.the place() oder np.choose() fühlt sich zu verschachtelt an.

# 3. Verwendung np.the place() für binäre Bedingungen

Wenn Sie eine binäre Bedingung haben – ein Ergebnis, wenn wahr, ein anderes, wenn falsch – np.the place() ist die saubere und schnelle Wahl.

Was wir tun wollen: Markieren Sie Bestellungen, bei denen der Kunde Anspruch auf einen Senior-Rabatt hat.

df('senior_discount') = np.the place(df('customer_age') >= 60, True, False)
show(df(('customer_age', 'senior_discount')).head())

Ausgabe:

np.the place() ist vollständig vektorisiert und deutlich schneller als .apply() für einfache wahre oder falsche Bedingungen. Betrachten Sie es als einen vektorisierten ternären Operator.

# 4. Auswahl über mehrere Bedingungen hinweg mit np.choose()

Wenn Sie mehr als zwei Bedingungen haben, np.choose() ermöglicht es Ihnen, eine Liste von Bedingungen und entsprechenden Werten zu definieren, ohne dass verschachtelte if/elif-Ketten erforderlich sind.

Was wir tun wollen: Weisen Sie einen regionalen Steuersatz zu.

circumstances = (
    df('area') == 'North',
    df('area') == 'South',
    df('area') == 'East',
    df('area') == 'West',
)
tax_rates = (0.08, 0.06, 0.07, 0.09)

df('tax_rate') = np.choose(circumstances, tax_rates, default=0.07)
df('tax_amount') = df('worth') * df('tax_rate')
show(df(('area', 'worth', 'tax_rate', 'tax_amount')).head())

Ausgabe:

np.choose() wertet alle Bedingungen der Reihe nach aus und wählt die erste Übereinstimmung aus. Der default Der Parameter behandelt alles, was nicht übereinstimmt, was als Sicherheitsnetz nützlich ist.

# 5. Zuordnen von Werten mit einer Wörterbuchsuche

Wenn Sie Werte in einer Spalte übersetzen müssen – etwa Kategorienamen numerischen Codes zuordnen oder Schlüssel durch Beschriftungen ersetzen müssen – .map() mit einem Wörterbuch ist sauber und schnell.

Was wir tun wollen: Produktkategorien internen Abteilungscodes zuordnen.

category_codes = {
    'Electronics': 'ELEC',
    'Clothes': 'CLTH',
    'Dwelling & Kitchen': 'HOME',
    'Sports activities': 'SPRT',
    'Books': 'BOOK',
}

df('dept_code') = df('product_category').map(category_codes)
show(df(('product_category', 'dept_code')).head())

Ausgabe:

.map() funktioniert wie eine Nachschlagetabelle. Es ist eines der am wenigsten genutzten Werkzeuge bei Pandas – wir greifen oft danach .apply(lambda x: dict(x)) Wann .map(dict) macht das Gleiche schneller.

# 6. Manipulieren von Strings mit dem .str Zugriffsberechtigter

String-Manipulation Hier verwenden die Leute am häufigsten standardmäßig Schleifen oder .apply(). Der .str Zugriffsberechtigter ermöglicht es Ihnen, Zeichenfolgenoperationen über eine gesamte Spalte auszuführen, ohne dass beides erforderlich ist.

Was wir tun wollen: Extrahieren Sie das erste Wort aus dem product_category Spalte und wandeln Sie sie in Kleinbuchstaben um.

df('category_slug') = df('product_category').str.cut up().str(0).str.decrease()
show(df(('product_category', 'category_slug')).head())

Ausgabe:

Sie können verketten .str Methoden genau wie normale Python-String-Methoden. Es unterstützt auch .str.comprises(), .str.substitute(), .str.extract() für Regex und mehr.

# 7. Gruppen aggregieren mit .groupby()

Ein gängiges Schleifenmuster ist die Iteration über Teilmengen von Daten, um Statistiken auf Gruppenebene zu berechnen. .groupby() erledigt dies nativ.

Was wir tun wollen: Berechnen Sie den Gesamtumsatz und die durchschnittliche Lieferzeit professional Produktkategorie.

abstract = (
    df.groupby('product_category')
    .agg(
        total_revenue=('income', 'sum'),
        avg_ship_days=('days_to_ship', 'imply'),
        order_count=('order_id', 'depend')
    )
    .spherical(2)
    .reset_index()
)
abstract

Ausgabe:

# Das richtige Werkzeug auswählen

Die meisten Transformationen, für die Sie eine Schleife schreiben würden, passen problemlos in eines dieser Muster:

Sobald Sie anfangen, in Spalten statt in Zeilen zu denken, werden Sie feststellen, dass sich die Pandas-API weniger wie eine Problemumgehung anfühlt, sondern eher wie die tatsächlich beabsichtigte Arbeitsweise.

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.

bei einer Funktion, bei der ich 100 unordentliche Compliance-PDFs in strukturierte JSON-Regeln umwandeln musste.

Der Brute-Pressure-Ansatz lag auf der Hand: Geben Sie dem Agenten den Quelltext, erklären Sie die Aufgabe, liefern Sie Beispiele und bitten Sie ihn, die Regeln zu generieren. Da es sich um die am niedrigsten hängende Frucht handelte, probierte ich sie zuerst.

Auf den ersten Blick sah die Ausgabe intestine aus. Der Ausgabe-JSON conflict gültig und entsprach meinen Erwartungen.

Aber als ich die Ergebnisse manuell abtastete, um die Richtigkeit zu überprüfen, traten Risse auf. Einige Regeln waren zu weit gefasst, andere wurden übersehen. Einige Regeln konnten die Nuancen des Originaltextes nicht bewahren. Ich habe versucht, einen anderen Agenten zu verwenden, um die Fehler abzufangen und zu beheben, aber bei einem so großen Korpus conflict es unmöglich, die Ausgabe zuverlässig zu überprüfen.

Das conflict der frustrierende Teil. Die Fehler waren nicht offensichtlich. Diese Implementierung conflict viel zu fragil, um sie skalieren zu können.

Obwohl ich die genauen Implementierungsdetails nicht mitteilen kann, kann ich Ihnen die architektonischen Lektionen mitteilen, die ich gelernt habe, und wie ich sie schließlich implementiert habe. Hoffentlich sind diese Erkenntnisse hilfreich, wenn Sie KI-Systeme aufbauen, die skalierbar, zuverlässig bleiben und mit unübersichtlichen Daten umgehen müssen. Und wenn Sie bessere Möglichkeiten haben, Dinge zu erledigen, Nehmen Sie Kontakt zum Chat auf!

Okay, lasst uns loslegen.

Das Downside

Die 100 PDFs, mit denen ich gearbeitet habe, waren bereits analysiert und in Blöcke aufgeteilt, bevor sie mich erreichten. Aber der Rohinhalt conflict immer noch chaotisch. Es gab Aufzählungspunkte, Tabellen, OCR-Artefakte, übersetzte Abschnitte, halbstrukturierte Überschriften, Fußzeilen, Kopfzeilen, inkonsistente Formatierungen und dokumentspezifische Besonderheiten.

Ich habe mich für den Einsatz eines Agenten entschieden, weil die Entscheidung, worauf es ankommt, semantisches Urteilsvermögen erfordert. Die Dokumente folgten keinem einheitlichen Muster, sodass die Relevanz nicht allein durch einfache Regeln bestimmt werden konnte.

Man musste den umgebenden Kontext verstehen. All dies conflict nicht schwierig, wenn man es mit einem kleinen Datenblock durchführte. Die Herausforderung bestand darin, dies im großen Maßstab zuverlässig durchzuführen.

Diese Regeln wurden dann von einem anderen nachgelagerten System verarbeitet und deterministisch ausgewertet.

Was letztendlich funktionierte

Nach ein paar Experimenten wurde mir klar, dass die größte Verbesserung nicht durch eine bessere Eingabeaufforderung, ein neues Device, einen MCP-Server oder eine ausgefeiltere Agentenumgebung zustande kam.

Es kam daher, dass sich die Type des Issues veränderte.

Anstatt zu versuchen, den Agenten schlauer zu machen, habe ich den Job des Agenten kleiner gemacht.

Die erste Änderung bestand darin, die Quelldaten im Voraus vorzubereiten. Anstatt den Agenten zu bitten, eine Datenbank abzufragen, Datensätze abzurufen, zu entscheiden, ob sie die richtigen Eingaben hatte, und dann die Extraktion durchzuführen, habe ich ihr einen kontrollierteren Ausgangspunkt gegeben.

In meinem Fall bedeutete das, die relevanten Rohdaten vorübergehend lokal zu speichern.

Dies ist möglicherweise nicht immer praktikabel. Das zugrunde liegende Prinzip besteht jedoch darin, die Abrufunsicherheit zu verringern, mit der der Agent umgehen muss. Wenn die Aufgabe des Agenten darin besteht, über Inhalte nachzudenken, sollten Sie ihn nicht auch dafür verantwortlich machen, herauszufinden, ob er den richtigen Inhalt gefunden hat.

Eine andere Möglichkeit wäre, die Abfrage im Voraus vorzubereiten.

Ich habe außerdem ein Skript verwendet, um unnötige Metadaten und Felder zu entfernen, bevor ich den Rohinhalt an den Agenten übergeben habe. Weniger irrelevanter Kontext bedeutete weniger Ablenkungen, weniger Chancen für den Agenten, sich an die falschen Particulars zu erinnern, und eine insgesamt sauberere Argumentationsaufgabe.

Die wichtigste Änderung betraf jedoch die Arbeitseinheit.
Anstatt alles auf einmal zu verarbeiten, habe ich die Dinge iterativ gemacht und ein Dokument nach dem anderen verarbeitet.

Dadurch wurde jeder Job kleiner, einfacher zu prüfen, einfacher zu wiederholen und einfacher zu prüfen. Ich habe fünf Subagenten eingerichtet, um Dokumente parallel zu verarbeiten, wobei jeder Agent seinen Fortschritt in einer Datei protokolliert.

Wenn ein Dokument fehlschlug, konnte ich nur dieses Dokument erneut versuchen. Wenn bei einer Ausgabe Formatierungsprobleme auftraten, konnte ich diesen speziellen Fall beheben, ohne den gesamten Stapel erneut ausführen zu müssen. Wenn die Pipeline auf halbem Weg anhielt, bedeutete der zwischengespeicherte Fortschritt, dass sie am letzten erfolgreichen Prüfpunkt fortgesetzt werden konnte.

Hier wurde auch die Trennung der Verantwortlichkeiten deutlicher.

Der Agent kümmerte sich um die semantische Arbeit: den Inhalt verstehen, die relevanten Teile identifizieren und die JSON-Ausgabe schreiben.

Der umgebende Code kümmerte sich um die mechanischen Teile: Parallelisierung von Jobs, Durchsetzung des Schemas, Generierung von IDs, Schreiben von Dateien, Zwischenspeichern des Fortschritts, Validieren von Referenzen und Überprüfen, ob die Ausgabe auf die Originalquelle zurückgeführt werden konnte.

Ich hatte auch einen Orchestrator, der den Fortschritt des Drehbuchs überwachte.

Die Ausgabe überprüfbar machen

Eine nützliche Entwurfsentscheidung conflict das Hinzufügen von Referenz-IDs zu jeder generierten Regel. Dies bedeutete, dass jedes Ausgabeelement auf eine bestimmte Quelle verwies.

Dies erleichterte die Prüfung der Ausgabe. Anstatt zu fragen: „Sieht diese generierte Regel richtig aus?“, könnte ich präzisere Fragen stellen, wie zum Beispiel: Existiert der referenzierte Quellblock? Ist der zitierte Quelltext tatsächlich in diesem Abschnitt vorhanden?

Ich könnte auch einen anderen Agenten damit beauftragen, selektiv größere und komplexere Dokumente zu prüfen, um sicherzustellen, dass wichtige Nuancen erhalten bleiben.

Darüber hinaus habe ich eine vereinfachte Model von evals erstellt. Ich habe einen kleinen Stapel Rohdokumente durch den Workflow laufen lassen und die Ergebnisse manuell auf Abdeckung und Genauigkeit überprüft. Ein vollständiger Golden-Datensatz conflict für den Umfang dieser Aufgabe nicht praktikabel, aber ich brauchte dennoch eine Möglichkeit, mir selbst zu beweisen, dass der Workflow funktionierte.

Mein Ziel conflict es nicht, einen perfekten Benchmark zu erstellen, sondern das System so überprüfbar zu machen, dass ich die Ausgaben überprüfen, Fehler erkennen und zu einem höheren Genauigkeitsbalken iterieren konnte.

Wenn Sie Ideen haben, wie ich das besser hätte machen können, lassen Sie es mich wissen!

Mein größter Imbiss

Das funktionierende Muster bestand darin, das LLM nicht mehr als Gesamtsystem zu betrachten.

Das System wurde zuverlässiger, nicht weil der Agent perfekt wurde, sondern weil der Workflow die Nachverfolgung, Validierung und Wiederherstellung seiner Ausgaben erleichterte.

Zufälligerweise baute ich dies kurz vor der Teilnahme an der ersten AI Engineer-Konferenz in Singapur, die vom 15. bis 17. Mai 2026 stattfand.

Am letzten Tag teilte JJ Geewax, Direktor für angewandte KI bei Google DeepMind, einen Rahmen, der das auf den Punkt brachte, was ich auf die harte Tour gelernt hatte: Wir müssen aufhören, LLMs wie riesige Problemlöser einzusetzen.

Das hat bei mir Anklang gefunden, weil es so leicht ist, in diese Falle zu tappen. Es ist einfach, dem Modell einfach die Daten, das Schema, die Geschäftsregeln, Randfälle und die Verantwortung zu übertragen, sich selbst zu überprüfen. Dann sind Sie frustriert, wenn das Ergebnis inkonsistent ist.

Für zuverlässige Produktionssysteme ist jedoch in der Regel ein Hybrid das bessere Muster. Lassen Sie den Agenten die Teile verwalten, die eine semantische Beurteilung erfordern, und überlassen Sie den Code die Teile, die Struktur, Validierung und Kontrolle erfordern.

Ich werde weitere Überlegungen von AI Engineer Singapore und den Workshops, an denen ich teilgenommen habe, teilen. Der YouTube-Ausschnitt von JJs Rede hier.

Das ist alles von mir. Ich hoffe, das hat geholfen und wir sehen uns im nächsten Artikel

Fragen zur Interpretierbarkeit in der KI beginnen mit der falschen Frage. Forscher, Praktiker und sogar Regulierungsbehörden fragen oft, ob ein Modell ist interpretierbar. Dieser Rahmen geht jedoch davon aus, dass Interpretierbarkeit eine Eigenschaft ist, die ein Modell entweder besitzt oder nicht besitzt. Das ist es nicht.

Ein Modell ist abstrakt nicht interpretierbar oder nicht interpretierbar. Hier geht es nicht um inhärent transparente Modelle wie lineare Regression oder Entscheidungsbäume, deren Argumentation direkt überprüft werden kann. Stattdessen geht es um komplexe Modelle, deren Entscheidungsprozesse nicht sofort zugänglich sind.

Interpretierbarkeit ist daher kein Kontrollkästchen, keine Visualisierung oder ein bestimmter Algorithmus. Man versteht darunter besser eine Reihe von Methoden, die es Menschen ermöglichen, Modelle zu analysieren, um bestimmte Fragen zu beantworten. Wenn Sie die Frage ändern, ändert sich auch der Nutzen der Erklärung. Die eigentliche Frage ist additionally nicht, ob ein Modell interpretierbar ist, sondern wofür wir eine Erklärung brauchen.

Sobald wir die Interpretierbarkeit auf diese Weise sehen, entsteht eine klarere Struktur. In der Praxis erfüllen Erklärungen durchweg drei verschiedene wissenschaftliche Funktionen: Fehler diagnostizieren, Gelerntes validieren und Wissen extrahieren. Diese Rollen sind konzeptionell unterschiedlich, auch wenn sie auf ähnlichen Techniken beruhen. Das Verständnis dieser Unterscheidung hilft zu klären, wann Interpretierbarkeit erforderlich ist und welche Artwork von Erklärung wir tatsächlich benötigen.

Interpretierbarkeit als Diagnose

Die erste Rolle der Interpretierbarkeit tritt während der Modellentwicklung ein, wenn Modelle noch experimentelle Objekte sind. In diesem Stadium sind sie instabil, unvollkommen und oft in einer Weise falsch, die aggregierte Metriken nicht aufdecken können. Die Genauigkeit sagt uns, ob ein Modell erfolgreich ist, aber nicht, warum es scheitert. Zwei Modelle können die gleiche Leistung erzielen, obwohl sie auf völlig unterschiedlichen Entscheidungsregeln basieren. Man lernt vielleicht die echte Struktur; Ein anderer nutzt möglicherweise zufällige Zusammenhänge aus.

Interpretierbarkeitsmethoden ermöglichen es uns, einen Blick in den Entscheidungsprozess eines Modells zu werfen und diese versteckten Fehlermodi zu identifizieren. In diesem Sinne spielen sie eine ähnliche Rolle wie Debugging-Instruments in der Softwareentwicklung. Ohne sie bleibt die Verbesserung eines Modells weitgehend eine Spekulation. Mit ihnen können wir überprüfbare Hypothesen darüber formulieren, was das Modell tatsächlich tut.

Eine einfache Illustration ergibt sich aus der handschriftlichen Ziffernklassifizierung. Der MNIST-Datensatz ist bewusst einfach gehalten, was ihn very best für die Überprüfung macht, ob die Argumentation eines Modells mit unseren Erwartungen übereinstimmt.

Wenn wir visualisieren, welche Pixel eine Vorhersage beeinflusst haben, können wir sofort erkennen, ob sich das Netzwerk auf die Ziffernstriche oder auf irrelevante Hintergrundbereiche konzentriert. Der Unterschied sagt uns, ob das Modell ein sinnvolles Sign oder eine Abkürzung gelernt hat. In dieser diagnostischen Rolle sind Erklärungen nicht für Endbenutzer oder Stakeholder gedacht. Sie sind Instrumente für Entwickler, die versuchen, das Modellverhalten zu verstehen.

Interpretierbarkeit als Validierung

Sobald ein Modell eine gute Leistung erbringt, ändert sich die Frage. Es geht uns nicht mehr in erster Linie darum, warum es scheitert. Vielmehr wollen wir wissen, ob es aus den richtigen Gründen gelingt.

Diese Unterscheidung ist subtil, aber entscheidend. Ein System kann eine hohe Genauigkeit erreichen und dennoch wissenschaftlich irreführend sein, wenn es auf falschen Korrelationen beruht. Beispielsweise könnte ein auf die Erkennung von Tieren trainierter Klassifikator scheinbar perfekt funktionieren, obwohl er sich in Wirklichkeit auf Hintergrundhinweise und nicht auf die Tiere selbst verlässt. Aus prädiktiver Sicht scheint ein solches Modell erfolgreich zu sein. Aus wissenschaftlicher Sicht hat es das falsche Konzept gelernt.

Durch die Interpretierbarkeit können wir interne Darstellungen überprüfen und überprüfen, ob sie mit den Domänenerwartungen übereinstimmen. In tiefen neuronalen Netzen kodieren Zwischenschichten erlernte Merkmale, und die Analyse dieser Darstellungen kann Aufschluss darüber geben, ob das System eine sinnvolle Struktur entdeckt oder lediglich oberflächliche Muster gespeichert hat.

Dies wird besonders bei großen natürlichen Bilddatensätzen wie ImageNet related, bei denen Szenen erhebliche Unterschiede im Blickwinkel, im Hintergrund und im Erscheinungsbild des Objekts aufweisen.

Da ImageNet-Bilder überladene Szenen, unterschiedliche Kontexte und eine hohe Variabilität innerhalb der Klasse enthalten, müssen erfolgreiche Modelle hierarchische Darstellungen lernen, anstatt sich auf oberflächliche visuelle Hinweise zu verlassen. Wenn wir interne Filter oder Aktivierungskarten visualisieren, können wir überprüfen, ob frühe Schichten Kanten erkennen, mittlere Schichten Texturen erfassen und tiefere Schichten auf Formen reagieren. Das Vorhandensein dieser Struktur deutet darauf hin, dass das Netzwerk etwas Bedeutsames über die Daten gelernt hat. Sein Fehlen deutet darauf hin, dass Leistungsmetriken möglicherweise konzeptionelles Versagen verbergen.

In dieser zweiten Rolle besteht die Interpretierbarkeit nicht darin, ein defektes Modell zu debuggen, sondern ein erfolgreiches Modell zu validieren.

Interpretierbarkeit als Wissen

Die dritte Rolle entsteht, wenn Modelle in Bereichen angewendet werden, in denen Vorhersage allein nicht ausreicht. In diesen Kontexten werden maschinelle Lernsysteme nicht nur zur Produktion von Ergebnissen, sondern auch zur Generierung von Erkenntnissen eingesetzt. Hier wird Interpretierbarkeit zu einem Werkzeug zur Entdeckung.

Moderne Modelle können statistische Regelmäßigkeiten in Datensätzen erkennen, die weitaus größer sind, als ein Mensch manuell analysieren könnte. Wenn wir ihre Argumentation untersuchen, können sie Muster erkennen lassen, die auf neue Hypothesen oder bisher unbemerkte Zusammenhänge schließen lassen. Bei wissenschaftlichen Anwendungen ist diese Fähigkeit oft wertvoller als die Vorhersagegenauigkeit selbst.

Ein klares Beispiel ist die medizinische Bildgebung. Stellen Sie sich ein neuronales Netzwerk vor, das darauf trainiert ist, Lungenkrebs anhand von CT-Scans zu erkennen.

Wenn ein solches Modell eine Malignität vorhersagt, müssen Ärzte verstehen, welche Regionen diese Entscheidung beeinflusst haben. Wenn hervorgehobene Regionen einer Tumorgrenze entsprechen, stimmt die Erklärung mit der medizinischen Argumentation überein. Wenn dies nicht der Fall ist, kann der Vorhersage ungeachtet ihrer Genauigkeit nicht vertraut werden. Aber es gibt noch eine dritte Möglichkeit: Erklärungen könnten subtile Strukturen offenbaren, die Kliniker bisher nicht für diagnostisch related gehalten hatten. In solchen Fällen rechtfertigt die Interpretierbarkeit nicht nur eine Vorhersage, sie trägt auch zum Wissen bei.

Dabei sind Erklärungen nicht nur Hilfsmittel zum Verständnis von Modellen. Sie sind Werkzeuge zur Erweiterung des menschlichen Verständnisses.

Ein Konzept, drei Funktionen

Diese Beispiele verdeutlichen, dass Interpretierbarkeit kein einzelnes Ziel, sondern ein multifunktionaler Rahmen ist. Dieselbe Technik kann je nach gestellter Frage dabei helfen, ein Modell zu debuggen, seine Argumentation zu validieren oder Erkenntnisse zu gewinnen. Verwirrung über die Interpretierbarkeit entsteht oft, weil in den Diskussionen nicht zwischen diesen Zielen unterschieden wird.

Die sinnvollere Frage ist nicht, ob ein Modell interpretierbar ist, sondern ob es für die Aufgabe, die uns am Herzen liegt, ausreichend interpretierbar ist. Diese Anforderung hängt immer vom Kontext ab: Entwicklung, Forschung oder Bereitstellung.

Aus dieser Sicht lässt sich Interpretierbarkeit am besten nicht als Einschränkung des maschinellen Lernens verstehen, sondern als Schnittstelle zwischen Menschen und Modellen. Es ermöglicht uns zu diagnostizieren, zu validieren und zu lernen. Ohne sie bleiben Vorhersagen undurchsichtige Ergebnisse. Damit werden sie zu Objekten wissenschaftlicher Analyse.

Anstatt additionally zu fragen, ob ein Modell interpretierbar ist, sollten wir eine genauere Frage stellen:

Was genau wollen wir mit der Erklärung erklären?

Sobald diese Frage geklärt ist, ist die Interpretierbarkeit keine vage Anforderung mehr, sondern ein wissenschaftliches Instrument.

Ich hoffe es hat dir gefallen! Gern geschehen Kontaktieren Sie mich wenn Sie Fragen haben, Suggestions geben möchten oder einfach Lust haben, Ihre eigenen Projekte vorzustellen.

Auf der CES 2026 in Las Vegas am 5. Januar 2026 präsentierte JBL angekündigt die JBL Sense Professional und JBL Sense Lite Open-Ear-Ohrhörer, die die JBL OpenSound-Luftleitungstechnologie verwenden, um hochwertige Audioqualität zu liefern und gleichzeitig die Gehörgänge offen zu halten, um Umgebungsgeräusche wahrzunehmen.

JBL positioniert diese Ohrhörer als neu konzipierte Open-Ear-Kopfhörerreihe. Die JBL OpenSound-Luftleitungstechnologie bietet eine neue Artwork des Hörens, indem sie Schall durch Luftleitung überträgt, ohne die Gehörgänge zu blockieren. Benutzer können Inhalte wie Musik oder Anrufe genießen und gleichzeitig ihre Umgebung wie Verkehr oder Gespräche im Auge behalten.

Carsten Olesen, Präsident Shopper Audio bei HARMAN, erklärte: „Der JBL Sense Professional und der JBL Sense Lite stellen einen großen Sprung im Open-Ear-Audio dar.“ Er fügte hinzu: „Wir haben unser umfassendes Audio-Know-how genutzt, um durch Luftleitung einen vollen, bassreichen Klang zu liefern, etwas, das bei Open-Ear-Designs bisher unbekannt battle. In Kombination mit ganztägigem Komfort, intelligenten Funktionen und einem langlebigen, raffinierten Design setzt es einen neuen Commonplace in dieser Kategorie.“

Der JBL Sense Professional richtet sich an Benutzer, die leistungsstarkes Audio suchen. Es verfügt über eine fortschrittliche Luftleitungstechnologie gepaart mit einem adaptiven Bass-Enhance-Algorithmus zur Verbesserung der Klangqualität. Die Ohrhörer verfügen über 16,2-mm-Treiber, die Hello-Res Audio für eine klare Wiedergabe unterstützen. Vier Mikrofone arbeiten mit der Voice Pickup Sensor-Technologie von JBL zusammen, um die Stimme des Benutzers in lauten Umgebungen, beispielsweise in einem belebten Café oder in öffentlichen Verkehrsmitteln, präzise zu erfassen.

Das Design des JBL Sense Professional legt Wert auf Ergonomie für längeres Tragen und Bewegung. Ein verstellbarer Ohrbügel sichert die Ohrhörer während des ganztägigen Gebrauchs. Die Farboptionen bestehen aus Schwarz und Grau. Die Ohrhörer werden im März 2026 auf JBL.com für 199,95 $ erhältlich sein.

• JBL Open Sound-Technologie und räumlicher Klang: Kern-Audioübertragungssystem für Hören mit offenem Ohr.
• Hello-Res Audio Wi-fi mit adaptivem Bass Enhance: Ermöglicht hochauflösende Wiedergabe mit verbesserter Bassoptimierung.
• 4 Mikrofone für klare, klare Anrufe 2.0 mit KI-trainiertem Algorithmus: Verbessert die Anrufqualität durch mehrere Mikrofone und Verarbeitung künstlicher Intelligenz.
• JBL Sprachaufnahme-Sensortechnologie: Erkennt und isoliert die Stimme des Benutzers in lauten Umgebungen.
• Verstellbarer Ohrbügel für ganztägigen Komfort: Bietet sicheren und bequemen Sitz für längeres Tragen.
• Bluetooth 6.0: Unterstützt erweiterte drahtlose Konnektivität.
• Twin Join + Quick Pair von Google aktiviert: Ermöglicht die unabhängige Verbindung beider Ohrhörer und die schnelle Kopplung mit Geräten.
• Bis zu 38 Stunden Spielzeit (Ohrhörer: 8 Stunden; Hülle: 30 Stunden) mit Schnellladung (10 Minuten = 4 Stunden): Bietet eine längere Akkulaufzeit mit Schnellladefunktion.
• Kabelloses Laden: Kompatibel mit kabellosen Ladepads.
• Personi-Fi 3.0: Personalisiert Soundprofile entsprechend den Benutzerpräferenzen.
• Contact-Steuerung mit Anpassung über die JBL-App: Ermöglicht gestenbasierte Bedienung und Einstellungsanpassungen über die Begleitanwendung.

Der JBL Sense Lite konzentriert sich auf leichten Komfort für den täglichen Gebrauch. Es verfügt über ein ausgewogenes Design, das zu verschiedenen Ohrformen passt, ergänzt durch eine weiche Silikonoberfläche, die sich für geschäftliche Anrufe oder gelegentliche Hörsitzungen eignet. Die Beamforming-Technologie in Kombination mit dem Adaptive Bass Enhance-Algorithmus erzeugt einen Klang mit minimaler Leckage und sorgt so für Klarheit und Privatsphäre für den Zuhörer.

Duale Beamforming-Mikrofone tragen zur Anrufleistung bei. Die JBL Headphones-App ermöglicht eine individuelle Anpassung der Contact-Steuerung. Die Akkulaufzeit beträgt insgesamt bis zu 32 Stunden. Das Design umfasst die Schutzart IP54 für Wasser- und Staubbeständigkeit. Die Farboptionen sind Schwarz, Weiß und Lila. Der JBL Sense Lite wird im März 2026 auf JBL.com für 149,95 $ erhältlich sein.

• JBL Open Sound-Technologie: Bietet Audioübertragung mit offenem Ohr.
• 4 Mikrofone für klare, klare Anrufe: Sorgt für eine zuverlässige Sprachübertragung bei Gesprächen.
• IP54 wasser- und staubgeschützt: Schützt vor Spritzern und Partikeln.
• Verstellbarer Ohrbügel im leichten Silikondesign mit Reminiscence-Draht: Passt sich der Ohrform an und sorgt für eine sichere und bequeme Platzierung.
• Bluetooth 5.4: Bietet stabile WLAN-Leistung.
• Twin Join + Quick Pair von Google aktiviert: Unterstützt die unabhängige Verwendung von Ohrhörern und die schnelle Gerätekopplung.
• Bis zu 32 Stunden Spielzeit (Ohrhörer: 8 Stunden; Hülle: 24 Stunden) mit Schnellladung (10 Minuten = 3 Stunden): Bietet ganztägige Nutzung mit Schnelllademöglichkeit.
• Contact-Steuerung mit Anpassung über die JBL-App: Bietet intuitive, per Software program anpassbare Bedienelemente.

JBL ist seit über 75 Jahren tätig und gestaltet Erlebnisse an der Schnittstelle von Musik, Way of life, Gaming und Sport. Die Marke steigert das Hören mit überragender Audioqualität und Designs, die Individualität und Selbstdarstellung unterstützen. Professionelle Qualifikationen und Innovation zeichnen JBL aus, das von Ingenieuren und Designern auf der ganzen Welt vorangetrieben wird. Die JBL Professional Sound-Technologie fördert die Kultur durch Veranstaltungen und Partnerschaften in den Bereichen Musik, Sport und E-Sport.

Hervorgehobener Bildnachweis

Ich habe neulich an einem Drehbuch gearbeitet und es hat mich wahnsinnig gemacht. Es hat zwar funktioniert, aber es conflict nur … langsam. Wirklich langsam. Ich hatte das Gefühl, dass es viel schneller gehen könnte, wenn ich es herausfinden könnte Wo die Verzögerung conflict.

Mein erster Gedanke conflict, mit den Optimierungen zu beginnen. Ich konnte das Laden der Daten optimieren. Oder die for-Schleife umschreiben? Aber ich habe mich zurückgehalten. Ich bin schon einmal in diese Falle getappt und habe Stunden damit verbracht, einen Codeabschnitt zu „optimieren“, nur um dann festzustellen, dass er kaum einen Unterschied zur Gesamtlaufzeit macht. Donald Knuth hatte Recht, als er sagte: „Vorzeitige Optimierung ist die Wurzel allen Übels.“

Ich habe mich für einen methodischeren Ansatz entschieden. Anstatt zu raten, wollte ich es sicher herausfinden. Ich musste ein Profil des Codes erstellen, um konkrete Daten darüber zu erhalten, welche Funktionen genau die meisten Taktzyklen verbrauchten.

In diesem Artikel werde ich Sie durch den genauen Prozess führen, den ich verwendet habe. Wir nehmen ein bewusst langsames Python-Skript und verwenden zwei fantastische Instruments, um seine Engpässe mit chirurgischer Präzision zu lokalisieren.

Das erste dieser Instruments heißt cProfileein leistungsstarker, in Python integrierter Profiler. Der andere heißt Schlangenvisz, A geniales Werkzeug Das wandelt die Ausgabe des Profilers in eine interaktive visuelle Karte um.

Einrichten einer Entwicklungsumgebung

Bevor wir mit dem Codieren beginnen, richten wir unsere Entwicklungsumgebung ein. Die beste Vorgehensweise besteht darin, eine separate Python-Umgebung zu erstellen, in der Sie die erforderliche Software program installieren und experimentieren können, in dem Wissen, dass alles, was Sie tun, keine Auswirkungen auf den Relaxation Ihres Techniques hat. Ich werde dafür Conda verwenden, aber Sie können jede Methode verwenden, mit der Sie vertraut sind.

#create our check setting
conda create -n profiling_lab python=3.11 -y

# Now activate it
conda activate profiling_lab

Nachdem wir nun unsere Umgebung eingerichtet haben, müssen wir Snakeviz für unsere Visualisierungen und Numpy für das Beispielskript installieren. cProfile ist bereits in Python enthalten, daher gibt es dort nichts weiter zu tun. Da wir unsere Skripte mit einem Jupyter-Pocket book ausführen, werden wir dieses auch installieren.

# Set up our visualization instrument and numpy
pip set up snakeviz numpy jupyter

Geben Sie nun ein jupyter pocket book in Ihre Eingabeaufforderung ein. In Ihrem Browser sollte ein Jupiter-Notizbuch geöffnet sein. Wenn dies nicht automatisch geschieht, wird Ihnen danach wahrscheinlich ein Bildschirm voller Informationen angezeigt jupyter pocket book Befehl. Ganz unten finden Sie eine URL, die Sie kopieren und in Ihren Browser einfügen sollten, um das Jupyter Pocket book zu starten.

Ihre URL wird sich von meiner unterscheiden, aber sie sollte in etwa so aussehen:-

http://127.0.0.1:8888/tree?token=3b9f7bd07b6966b41b68e2350721b2d0b6f388d248cc69da

Nachdem unsere Instruments bereit sind, ist es an der Zeit, einen Blick auf den Code zu werfen, den wir reparieren werden.

Unser „Drawback“-Skript

Um unsere Profiling-Instruments ordnungsgemäß zu testen, benötigen wir ein Skript, das eindeutige Leistungsprobleme aufweist. Ich habe ein einfaches Programm geschrieben, das Verarbeitungsprobleme mit Speicher, Iteration und CPU-Zyklen simuliert, was es zu einem perfekten Kandidaten für unsere Untersuchung macht.

# run_all_systems.py
import time
import math

# ===================================================================
CPU_ITERATIONS = 34552942
STRING_ITERATIONS = 46658100
LOOP_ITERATIONS = 171796964
# ===================================================================

# --- Activity 1: A Calibrated CPU-Certain Bottleneck ---
def cpu_heavy_task(iterations):
    print("  -> Operating CPU-bound job...")
    end result = 0
    for i in vary(iterations):
        end result += math.sin(i) * math.cos(i) + math.sqrt(i)
    return end result

# --- Activity 2: A Calibrated Reminiscence/String Bottleneck ---
def memory_heavy_string_task(iterations):
    print("  -> Operating Reminiscence/String-bound job...")
    report = ""
    chunk = "report_item_abcdefg_123456789_"
    for i in vary(iterations):
        report += f"|{chunk}{i}"
    return report

# --- Activity 3: A Calibrated "Thousand Cuts" Iteration Bottleneck ---
def simulate_tiny_op(n):
    move

def iteration_heavy_task(iterations):
    print("  -> Operating Iteration-bound job...")
    for i in vary(iterations):
        simulate_tiny_op(i)
    return "OK"

# --- Fundamental Orchestrator ---
def run_all_systems():
    print("--- Beginning FINAL SLOW Balanced Showcase ---")
    
    cpu_result = cpu_heavy_task(iterations=CPU_ITERATIONS)
    string_result = memory_heavy_string_task(iterations=STRING_ITERATIONS)
    iteration_result = iteration_heavy_task(iterations=LOOP_ITERATIONS)

    print("--- FINAL SLOW Balanced Showcase Completed ---")

Schritt 1: Sammeln der Daten mit cProfile

Unser erstes Software, cProfile, ist ein in Python integrierter deterministischer Profiler. Wir können es über den Code ausführen, um unser Skript auszuführen und detaillierte Statistiken zu jedem Funktionsaufruf aufzuzeichnen.

import cProfile, pstats, io

pr = cProfile.Profile()
pr.allow()

# Run the perform you wish to profile
run_all_systems()

pr.disable()

# Dump stats to a string and print the highest 10 by cumulative time
s = io.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats("cumtime")
ps.print_stats(10)
print(s.getvalue())

Hier ist die Ausgabe.

--- Beginning FINAL SLOW Balanced Showcase ---
  -> Operating CPU-bound job...
  -> Operating Reminiscence/String-bound job...
  -> Operating Iteration-bound job...
--- FINAL SLOW Balanced Showcase Completed ---
         275455984 perform calls in 30.497 seconds

   Ordered by: cumulative time
   Listing diminished from 47 to 10 resulting from restriction <10>

   ncalls  tottime  percall  cumtime  percall filename:lineno(perform)
        2    0.000    0.000   30.520   15.260 /house/tom/.native/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3541(run_code)
        2    0.000    0.000   30.520   15.260 {built-in technique builtins.exec}
        1    0.000    0.000   30.497   30.497 /tmp/ipykernel_173802/1743829582.py:41(run_all_systems)
        1    9.652    9.652   14.394   14.394 /tmp/ipykernel_173802/1743829582.py:34(iteration_heavy_task)
        1    7.232    7.232   12.211   12.211 /tmp/ipykernel_173802/1743829582.py:14(cpu_heavy_task)
171796964    4.742    0.000    4.742    0.000 /tmp/ipykernel_173802/1743829582.py:31(simulate_tiny_op)
        1    3.891    3.891    3.892    3.892 /tmp/ipykernel_173802/1743829582.py:22(memory_heavy_string_task)
 34552942    1.888    0.000    1.888    0.000 {built-in technique math.sin}
 34552942    1.820    0.000    1.820    0.000 {built-in technique math.cos}
 34552942    1.271    0.000    1.271    0.000 {built-in technique math.sqrt}

Wir haben eine Reihe von Zahlen, die schwer zu interpretieren sein können. Hier kommt Snakeviz ins Spiel.

Schritt 2: Visualisierung des Engpasses mit Snakeviz

Hier geschieht die Magie. Snakeviz nimmt die Ausgabe unserer Profilierungsdatei und wandelt sie in ein interaktives, browserbasiertes Diagramm um, um das Auffinden von Engpässen zu erleichtern.

Nutzen wir additionally dieses Software, um zu visualisieren, was wir haben. Da ich ein Jupyter-Pocket book verwende, müssen wir es zuerst laden.

%load_ext snakeviz

Und wir führen es so aus.

%%snakeviz
predominant()

Die Ausgabe besteht aus zwei Teilen. Zuerst ist eine Visualisierung wie diese.

Was Sie sehen, ist ein „Eiszapfen“-Diagramm von oben nach unten. Von oben nach unten stellt es die Anrufhierarchie dar.

Ganz oben: Python führt unser Skript aus ().

Als nächstes: die __main__-Ausführung des Skripts (:1()). Dann die Funktion run_all_systems. Darin werden zwei Schlüsselfunktionen aufgerufen: iteration_heavy_task und cpu_heavy_task.

Der speicherintensive Verarbeitungsteil ist im Diagramm nicht gekennzeichnet. Das liegt daran, dass der Zeitanteil, der mit dieser Aufgabe verbunden ist, viel kleiner ist als der Zeitanteil, der auf die anderen beiden intensiven Funktionen entfällt. Als Ergebnis sehen wir rechts vom cpu_heavy_task-Block einen viel kleineren, unbeschrifteten Block.

Beachten Sie, dass es für die Analyse auch einen Snakeviz-Diagrammstil namens a gibt Sunburst-Diagramm. Es ähnelt ein wenig einem Kreisdiagramm, enthält jedoch eine Reihe immer größerer konzentrischer Kreise und Bögen. Die Idee dahinter ist, dass die Zeit, die Funktionen zum Ausführen benötigen, durch die Winkelausdehnung der Bogengröße des Kreises dargestellt wird. Die Wurzelfunktion ist ein Kreis in der Mitte von nämlich. Die Root-Funktion wird ausgeführt, indem sie die darunter liegenden Unterfunktionen usw. aufruft. Wir werden uns in diesem Artikel nicht mit diesem Anzeigetyp befassen.

Eine solche visuelle Bestätigung kann so viel wirkungsvoller sein, als auf eine Zahlentabelle zu starren. Ich musste nicht mehr raten, wo ich suchen sollte; Die Daten starrten mich direkt ins Gesicht.

Auf die Visualisierung folgt schnell ein Textblock, der die Zeitabläufe für verschiedene Teile Ihres Codes detailliert beschreibt, ähnlich wie die Ausgabe des cprofile-Instruments. Ich zeige hier nur die ersten etwa ein Dutzend Zeilen, da es insgesamt über 30 waren.

ncalls tottime percall cumtime percall filename:lineno(perform)
----------------------------------------------------------------
1 9.581 9.581 14.3 14.3 1062495604.py:34(iteration_heavy_task)
1 7.868 7.868 12.92 12.92 1062495604.py:14(cpu_heavy_task)
171796964 4.717 2.745e-08 4.717 2.745e-08 1062495604.py:31(simulate_tiny_op)
1 3.848 3.848 3.848 3.848 1062495604.py:22(memory_heavy_string_task)
34552942 1.91 5.527e-08 1.91 5.527e-08 ~:0(<built-in technique math.sin>)
34552942 1.836 5.313e-08 1.836 5.313e-08 ~:0(<built-in technique math.cos>)
34552942 1.305 3.778e-08 1.305 3.778e-08 ~:0(<built-in technique math.sqrt>)
1 0.02127 0.02127 31.09 31.09 <string>:1(<module>)
4 0.0001764 4.409e-05 0.0001764 4.409e-05 socket.py:626(ship)
10 0.000123 1.23e-05 0.0004568 4.568e-05 iostream.py:655(write)
4 4.594e-05 1.148e-05 0.0002735 6.838e-05 iostream.py:259(schedule)
...
...
...

Schritt 3: Die Lösung

Instruments wie Cprofiler und Snakeviz verraten es Ihnen natürlich nicht Wie um Ihre Leistungsprobleme zu beheben, aber da ich nun genau wusste, wo die Probleme lagen, konnte ich gezielte Korrekturen vornehmen.

# final_showcase_fixed_v2.py
import time
import math
import numpy as np

# ===================================================================
CPU_ITERATIONS = 34552942
STRING_ITERATIONS = 46658100
LOOP_ITERATIONS = 171796964
# ===================================================================

# --- Repair 1: Vectorization for the CPU-Certain Activity ---
def cpu_heavy_task_fixed(iterations):
    """
    Fastened by utilizing NumPy to carry out the advanced math on a whole array
    without delay, in extremely optimized C code as an alternative of a Python loop.
    """
    print("  -> Operating CPU-bound job...")
    # Create an array of numbers from 0 to iterations-1
    i = np.arange(iterations, dtype=np.float64)
    # The identical calculation, however vectorized, is orders of magnitude quicker
    result_array = np.sin(i) * np.cos(i) + np.sqrt(i)
    return np.sum(result_array)

# --- Repair 2: Environment friendly String Becoming a member of ---
def memory_heavy_string_task_fixed(iterations):
    """
    Fastened by utilizing an inventory comprehension and a single, environment friendly ''.be a part of() name.
    This avoids creating hundreds of thousands of intermediate string objects.
    """
    print("  -> Operating Reminiscence/String-bound job...")
    chunk = "report_item_abcdefg_123456789_"
    # A listing comprehension is quick and memory-efficient
    elements = (f"|{chunk}{i}" for i in vary(iterations))
    return "".be a part of(elements)

# --- Repair 3: Eliminating the "Thousand Cuts" Loop ---
def iteration_heavy_task_fixed(iterations):
    """
    Fastened by recognizing the duty is usually a no-op or a bulk operation.
    In a real-world state of affairs, you'd discover a strategy to keep away from the loop solely.
    Right here, we show the repair by merely eradicating the pointless loop.
    The aim is to indicate the price of the loop itself was the issue.
    """
    print("  -> Operating Iteration-bound job...")
    # The repair is to discover a bulk operation or eradicate the necessity for the loop.
    # Because the unique perform did nothing, the repair is to do nothing, however quicker.
    return "OK"

# --- Fundamental Orchestrator ---
def run_all_systems():
    """
    The primary orchestrator now calls the FAST variations of the duties.
    """
    print("--- Beginning FINAL FAST Balanced Showcase ---")
    
    cpu_result = cpu_heavy_task_fixed(iterations=CPU_ITERATIONS)
    string_result = memory_heavy_string_task_fixed(iterations=STRING_ITERATIONS)
    iteration_result = iteration_heavy_task_fixed(iterations=LOOP_ITERATIONS)

    print("--- FINAL FAST Balanced Showcase Completed ---")

Jetzt können wir den cprofiler für unseren aktualisierten Code erneut ausführen.

import cProfile, pstats, io

pr = cProfile.Profile()
pr.allow()

# Run the perform you wish to profile
run_all_systems()

pr.disable()

# Dump stats to a string and print the highest 10 by cumulative time
s = io.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats("cumtime")
ps.print_stats(10)
print(s.getvalue())

#
# begin of output
#

--- Beginning FINAL FAST Balanced Showcase ---
  -> Operating CPU-bound job...
  -> Operating Reminiscence/String-bound job...
  -> Operating Iteration-bound job...
--- FINAL FAST Balanced Showcase Completed ---
         197 perform calls in 6.063 seconds

   Ordered by: cumulative time
   Listing diminished from 52 to 10 resulting from restriction <10>

   ncalls  tottime  percall  cumtime  percall filename:lineno(perform)
        2    0.000    0.000    6.063    3.031 /house/tom/.native/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3541(run_code)
        2    0.000    0.000    6.063    3.031 {built-in technique builtins.exec}
        1    0.002    0.002    6.063    6.063 /tmp/ipykernel_173802/1803406806.py:1(<module>)
        1    0.402    0.402    6.061    6.061 /tmp/ipykernel_173802/3782967348.py:52(run_all_systems)
        1    0.000    0.000    5.152    5.152 /tmp/ipykernel_173802/3782967348.py:27(memory_heavy_string_task_fixed)
        1    4.135    4.135    4.135    4.135 /tmp/ipykernel_173802/3782967348.py:35(<listcomp>)
        1    1.017    1.017    1.017    1.017 {technique 'be a part of' of 'str' objects}
        1    0.446    0.446    0.505    0.505 /tmp/ipykernel_173802/3782967348.py:14(cpu_heavy_task_fixed)
        1    0.045    0.045    0.045    0.045 {built-in technique numpy.arange}
        1    0.000    0.000    0.014    0.014 <__array_function__ internals>:177(sum)

Das ist ein fantastisches Ergebnis, das die Leistungsfähigkeit der Profilerstellung demonstriert. Wir haben unsere Mühe auf die Teile des Codes gelenkt, die wichtig waren. Der Gründlichkeit halber habe ich auch Snakeviz für das korrigierte Skript ausgeführt.

%%snakeviz
run_all_systems()

Die bemerkenswerteste Änderung ist die Reduzierung der Gesamtlaufzeit von etwa 30 Sekunden auf etwa 6 Sekunden. Dies ist eine 5-fache Beschleunigung, die durch die Beseitigung der drei Hauptengpässe erreicht wird, die im „Vorher“-Profil sichtbar waren.

Schauen wir uns jedes einzeln an.

1. Die iteration_heavy_task

Vorher (Das Drawback)
Im ersten Bild ist der große Balken auf der linken Seite, iteration_heavy_task, der größte Engpass, der verbraucht 14,3 Sekunden.

• Warum conflict es langsam? Diese Aufgabe conflict ein klassischer „Tod durch tausend Schnitte“. Die Funktion simulieren_tiny_op hat quick nichts bewirkt, wurde aber millionenfach innerhalb einer reinen Python-for-Schleife aufgerufen. Der immense Aufwand, den der Python-Interpreter mit dem wiederholten Starten und Stoppen eines Funktionsaufrufs verursacht, conflict die alleinige Ursache für die Langsamkeit.

Die Lösung
Die feste Model iteration_heavy_task_fixed erkannte, dass das Ziel ohne die Schleife erreicht werden konnte. In unserem Fall bedeutete dies, die sinnlose Schleife vollständig zu entfernen. In einer realen Anwendung müsste dazu eine einzige „Massen“-Operation gefunden werden, um die iterative Operation zu ersetzen.

Nachher (Das Ergebnis)
Im zweiten Bild ist die iteration_heavy_task-Leiste zu sehen völlig verschwunden. Es ist jetzt so schnell, dass seine Laufzeit nur einen winzigen Bruchteil einer Sekunde beträgt und auf dem Diagramm unsichtbar ist. Wir haben ein 14,3-Sekunden-Drawback erfolgreich behoben.

2. Die cpu_heavy_task

Vorher (Das Drawback)
Der zweite große Engpass, deutlich sichtbar als großer orangefarbener Balken rechts, ist cpu_heavy_task, der in Anspruch genommen wurde 12,9 Sekunden.

• Warum conflict es langsam? Wie die Iterationsaufgabe conflict auch diese Funktion durch die Geschwindigkeit der Python-for-Schleife begrenzt. Während die darin enthaltenen mathematischen Operationen schnell waren, musste der Interpreter jede der Millionen Berechnungen einzeln verarbeiten, was für numerische Aufgaben äußerst ineffizient ist.

Die Lösung
Die Lösung conflict Vektorisierung Verwendung der NumPy-Bibliothek. Anstatt eine Python-Schleife zu verwenden, hat cpu_heavy_task_fixed ein NumPy-Array erstellt und alle mathematischen Operationen (np.sqrt, np.sin usw.) gleichzeitig für das gesamte Array ausgeführt. Diese Operationen werden in hochoptimiertem, vorkompiliertem C-Code ausgeführt, wobei die langsame Python-Interpreterschleife vollständig umgangen wird.

Nachher (Das Ergebnis).
Genau wie der erste Engpass ist auch die cpu_heavy_task-Leiste aus dem „Nachher“-Diagramm verschwunden. Seine Laufzeit wurde von 12,9 Sekunden auf wenige Millisekunden reduziert.

3. Die „memory_heavy_string_task“.

Vorher (Das Drawback):
Im ersten Diagramm lief die speicherintensive_string_task, aber ihre Laufzeit conflict im Vergleich zu den beiden anderen größeren Problemen gering, sodass sie in den kleinen, unbeschrifteten Bereich ganz rechts verbannt wurde. Es conflict ein relativ kleines Drawback.

Die Lösung
Die Lösung für diese Aufgabe bestand darin, das Ineffiziente zu ersetzen melden += „…” String-Verkettung mit einer viel effizienteren Methode: Erstellen einer Liste aller String-Teile und anschließender Aufruf „“.verbinden() ein einziges Mal am Ende.

Nachher (Das Ergebnis)
Im zweiten Diagramm sehen wir das Ergebnis unseres Erfolgs. Nachdem die beiden Engpässe von mehr als 10 Sekunden beseitigt wurden, ist nun die speicherintensive Zeichenfolgenaufgabe behoben neuer dominanter EngpassBuchhaltung 4,34 Sekunden der gesamten 5,22 Sekunden Laufzeit.

Snakeviz lässt uns sogar einen Blick in diese feste Funktion werfen. Der neue wichtigste Beitragszahler ist der orangefarbene Balken mit der Bezeichnung (Listenverständnis), was dauert 3,52 Sekunden. Dies deutet darauf hin, dass auch in der behoben Der zeitaufwändigste Teil des Codes besteht nun darin, die umfangreiche Liste der Zeichenfolgen im Speicher zu erstellen, bevor sie verknüpft werden können.

Zusammenfassung

Dieser Artikel bietet eine praktische Anleitung zum Identifizieren und Beheben von Leistungsproblemen in Python-Code und argumentiert, dass Entwickler dazu Profilierungstools verwenden sollten messen Leistung zu verbessern, anstatt sich auf Instinct oder Vermutungen zu verlassen, um die Ursache von Verlangsamungen zu ermitteln.

Ich habe einen methodischen Arbeitsablauf mit zwei Schlüsselwerkzeugen demonstriert:-

• cProfile: Pythons integrierter Profiler, der zum Sammeln detaillierter Daten zu Funktionsaufrufen und Ausführungszeiten verwendet wird.
• Schlangenviz: Ein Visualisierungstool, das die Daten von cProfile in ein interaktives „Eiszapfen“-Diagramm umwandelt und es so einfach macht, visuell zu erkennen, welche Teile des Codes die meiste Zeit verbrauchen.

Der Artikel verwendet eine Fallstudie eines absichtlich langsamen Skripts, das mit drei deutlichen und erheblichen Engpässen entwickelt wurde:

1. Eine iterationsgebundene Aufgabe: Eine Funktion, die millionenfach in einer Schleife aufgerufen wird und die Leistungseinbußen des Funktionsaufruf-Overheads von Python („Tod durch tausend Schnitte“) zeigt.
2. Eine CPU-gebundene Aufgabe: Eine for-Schleife, die Millionen mathematischer Berechnungen durchführt und die Ineffizienz von reinem Python für schwere numerische Arbeiten verdeutlicht.
3. Eine speichergebundene Aufgabe: Eine große Zeichenfolge, die durch wiederholte +=-Verkettung ineffizient erstellt wurde.

Durch die Analyse der Snakeviz-Ausgabe habe ich diese drei Probleme lokalisiert und gezielte Korrekturen vorgenommen.

• Der Iterationsengpass wurde behoben durch Eliminierung der unnötigen Schleife.
• Der CPU-Engpass wurde durch Vektorisierung mit NumPy behoben, das mathematische Operationen in schnellem, kompiliertem C-Code ausführt.
• Der Speicherengpass wurde durch das Anhängen von Zeichenfolgenteilen an eine Liste und die Verwendung eines einzigen, effizienten „“ behoben..verbinden() Anruf.

Diese Korrekturen führten zu einer erheblichen Beschleunigung und verkürzten die Laufzeit des Skripts erheblich 30 Sekunden bis knapp vorbei 6 Sekunden. Abschließend habe ich gezeigt, dass der Profiler auch nach der Lösung größerer Probleme erneut zur Identifizierung verwendet werden kann neukleinere Engpässe, was verdeutlicht, dass die Leistungsoptimierung ein iterativer Prozess ist, der durch Messungen gesteuert wird.

Ob Datenwissenschaftler oder ML-Ingenieur: Das Erlernen des Systemdesigns für maschinelles Lernen ist eine der wichtigsten Fähigkeiten, die Sie kennen müssen. Es ist die Brücke zwischen der Erstellung von Modellen und der Bereitstellung von Lösungen, die tatsächliche Geschäftsergebnisse vorantreiben.

Die Fähigkeit, ML-Ideen in Produktionssysteme umzusetzen, die Geld sparen, den Umsatz steigern und messbaren Wert schaffen, bestimmt Ihr langfristiges Karrierewachstum und Ihr Gehalt.

Ich habe Systeme für maschinelles Lernen entwickelt, mit denen Unternehmen über 1,5 Millionen US-Greenback professional Jahr einsparen können, und genau diese Fähigkeiten haben mir dabei geholfen, Stellenangebote im Wert von über 100.000 US-Greenback zu erhalten.

In diesem Leitfaden werde ich meine Meinung zum ML-Systemdesign aufschlüsseln, damit Sie dasselbe tun können.

Allgemeiner Rahmen

Nachfolgend finden Sie meinen Rahmen für den Entwurf eines maschinellen Lernsystems:

Notiz: Dies ist der häufigste Designtyp für ein angewandtes maschinelles Lernsystem in einem etablierten Technologieunternehmen. Es gibt andere, differenziertere Fälle, wie das Infrastrukturdesign und das Design von KI/ML-Forschungsexperimenten.

Wenn Sie eine PDF-Kopie dieser Vorlage wünschen, können Sie über diesen Hyperlink darauf zugreifen:

https://framework.egorhowell.com

Lassen Sie uns diese Schritte etwas detaillierter aufschlüsseln.

Geschäftsproblem

Das Ziel dieses Schrittes ist:

• Ziele klären –Was ist das Geschäfts- oder Benutzerproblem, das Sie lösen möchten, und wie können Sie es in eine Lösung für maschinelles Lernen übersetzen?
• Kennzahlen definieren –Auf welche Kennzahlen zielen wir ab: Genauigkeit, F1-Rating, ROC-AUC, Präzision/Erinnerung, RMSE usw. und wie sich dies auf die Geschäftsleistung auswirkt.
• Einschränkungen und Umfang– Wie viele Rechenressourcen stehen zur Verfügung, wollen wir Stay-Time-Vorhersagen oder Batch-Inferenz, brauchen wir überhaupt maschinelles Lernen?
• Design auf hohem Niveau— Wie wird die grobe Architektur von den Daten bis zur Schlussfolgerung aussehen?

Daten

Hier geht es um das Sammeln und Erfassen von Daten:

• Datenquellen identifizieren –Datenbanken, APIs, Protokolle oder benutzergenerierte Daten.
• Zielvariable identifizieren— Was ist die Zielvariable und wie erhalten wir sie?
• Qualitätskontrolle— In welchem ​​Zustand befinden sich die Daten? Gibt es rechtliche Probleme bei der Verwendung der Daten?

Function-Engineering

Erstellen Sie aus den Daten neuartige Funktionen, um das spezifische Downside anzugehen:

• Wichtigkeit der Funktion— Verstehen, welche Funktionen die Zielvariable wahrscheinlich beeinflussen.
• Datenbereinigung –Behandeln Sie fehlende Werte, Ausreißer und inkonsistente Einträge.
• Function-Darstellung— One-Sizzling-Kodierung, Zielkodierung, Einbettungen und Skalierung der Daten.
• Sampling und Splits— Berücksichtigen Sie unausgeglichene Datensätze und Datenlecks und sorgen Sie für eine korrekte Aufteilung in Trainings- und Testdatensätze.

Modelldesign und -auswahl

Hier stellen Sie Ihr theoretisches Wissen über Machine-Studying-Modelle unter Beweis:

• Benchmark— Beginnen Sie mit einem einfachen „dummen“ Modell oder einer Heuristik und bauen Sie dann langsam die Komplexität auf.
• Ausbildung— Kreuzvalidierung, Hyperparameter-Tuning, frühes Stoppen.
• Kompromisse– Berücksichtigen Sie Kompromisse wie Trainingsgeschwindigkeit, Inferenzgeschwindigkeit, Latenz und Interpretierbarkeit.

Service und Bereitstellung

Verstehen, wie das Modell am besten in der Produktion bereitgestellt und bereitgestellt werden kann.

• Infrastruktur –Wählen Sie Cloud/On-Prem, richten Sie CI/CD-Pipelines ein und stellen Sie Skalierbarkeit sicher.
• Service– API-Endpunkt, Edge-Modell, Batch-Vorhersagen vs. On-line-Vorhersagen.

Auswertung & Überwachung

Der letzte Teil besteht darin, Systeme und Frameworks einzurichten, um Ihr Modell in der Produktionsumgebung zu verfolgen.

• Metriken– Welche Kennzahlen sollten mit dem „On-line“-Modell im Vergleich zum „Offline“-Modell verfolgt werden?
• Überwachung— Richten Sie ein Dashboard, ein Überwachungsnotizbuch und Slack-Benachrichtigungen ein.
• Experiment— Entwerfen Sie ein A/B-Experiment.

Was kann man lernen?

Lassen Sie mich Ihnen ein Geheimnis verraten: Bei der Entwicklung von Systemen für maschinelles Lernen geht es nicht um ein Vorstellungsgespräch oder den Aufbau von Fertigkeiten für Einsteiger.

Dies liegt daran, dass das Design maschineller Lernsysteme auf mittlerer und höherer Ebene getestet wird.

Zu diesem Zeitpunkt verfügen Sie über fundierte Kenntnisse in den Bereichen maschinelles Lernen und Software program-Engineering und werden wahrscheinlich eine Spezialisierung entwickeln.

Wenn Sie jedoch eine umfassende, aber keineswegs erschöpfende Liste wünschen, ist dies das, was Sie lernen müssen.

Theorie des maschinellen Lernens

• Überwachtes Lernen –Klassifizierung (logistische Regression, Assist-Vektor-Maschinen, Entscheidungsbäume), Regression (lineare Regression, Entscheidungsbäume. Gradientenverstärkte Bäume).
• Unüberwachtes Lernen –Clustering (k-means, DBSCAN), Dimensionsreduktion, latente semantische Analyse.
• Tiefes Lernen –Neuronale Netze, Faltungs-Neuronale Netze und wiederkehrende Neuronale Netze.
• Verlustfunktionen –Genauigkeit, F1-Rating, NDCG, Präzision/Rückruf, RMSE usw.
• Funktionsauswahl –So identifizieren Sie wesentliche Merkmale wie Korrelationsanalyse, Eliminierung rekursiver Merkmale, Regularisierung, Kreuzvalidierung und Hyperparameter-Tuning.
• Statistiken —Bayesianische Statistik, Hypothesentests und A/B-Exams.
• Fachgebiete— Zeitreihen, Pc Imaginative and prescient, Operations Analysis, Empfehlungssysteme. Verarbeitung natürlicher Sprache usw. Benötigt nur 1–2.

Systemdesign und -technik

• Wolke– Das wichtigste ist AWS, und das sollten Sie wissen S3, EC2, Lambda-FunktionenUnd ECS. Die meisten Dinge sind ohnehin lediglich Hüllen für Speicher und Rechenleistung.
• Containerisierung—Docker Und Kubernetes.
• Systemdesign— Caching, Vernetzung, Quantisierung, APIs und Speicherung.
• Versionskontrolle—CircleCI, Jenkins, Fool, MLflow, Datenhund, Gewichte und Vorurteile.
• Bereitstellungs- und Orchestrierungs-Frameworks—Argo, Metaflow, Datensteine, Luftstrom Und Kubeflow.

Ressourcen

Interviews zum ML-Systemdesign

Ich habe vor, zu einem späteren Zeitpunkt ein ausführlicheres Video zum Vorstellungsgesprächsprozess für das Systemdesign für maschinelles Lernen zu veröffentlichen. Zunächst möchte ich Ihnen jedoch einen allgemeinen Überblick und einige Tipps geben, die Ihnen bei der Vorbereitung helfen.

Interviews zum Design von Systemen für maschinelles Lernen richten sich in der Regel an Ingenieure für maschinelles Lernen auf mittlerer und höherer Ebene. In diesen Vorstellungsgesprächen werden Sie normalerweise mit einem umfassenden, offenen Downside konfrontiert, beispielsweise mit der Entwicklung eines Empfehlungssystems oder eines Spamfilters.

Wenn Ihre Rolle eine bestimmte Spezialisierung umfasst, wie zum Beispiel Pc Imaginative and prescient, wird sich die Frage im Vorstellungsgespräch oft auf diesen speziellen Bereich konzentrieren.

Eine der größten Herausforderungen bei Interviews zum Design maschineller Lernsysteme ist der Mangel an Standardisierung. Im Gegensatz zu Software program-Engineering-Interviews, die einem relativ einheitlichen Format folgen, unterscheiden sich ML-Design-Interviews stark in der Struktur. Es gibt auch viel zu besprechen: unzählige Konzepte, Kompromisse und mögliche Lösungswege.

Allerdings tendieren die meisten Personalmanager dazu, Kandidaten anhand einiger Schlüsselkriterien zu bewerten:

• Problemübersetzung –Können Sie ein Geschäftsproblem als Lösung für maschinelles Lernen formulieren?
• Entscheidungsfindung –Erkennen Sie Kompromisse und begründen Sie Ihre Designentscheidungen logisch?
• Breite und Tiefe –Zeigen Sie ein solides Verständnis der ML-Theorie, einer Vielzahl von Modellen und wie Sie diese effektiv in realen Szenarien anwenden können?

So bereiten Sie sich auf Vorstellungsgespräche vor

Was die Vorbereitungen angeht, gibt es eine wichtige Sache, die ich empfehlen kann.

Arbeiten Sie vergangene Probleme durch.

Hier sind einige Ressourcen, um solche Probleme zu finden:

Ich empfehle außerdem, sich die Blogbeiträge großer Technologieunternehmen anzusehen, um mehr darüber zu erfahren, wie Algorithmen für maschinelles Lernen in großem Maßstab eingesetzt werden:

Zuvor habe ich besprochen, wie Systemdesign-Interviews mehr als nur Ihre Modellierungsfähigkeiten testen.

Aber was sind die zugrunde liegenden Grundlagen, auf die sie wirklich testen?

Genau das beschreibe ich in einem meiner vorherigen Artikel, der Sie durch alles führt, was Sie wissen müssen, zusammen mit den besten Ressourcen.

Die ultimative AI/ML-Roadmap für Anfänger

die ganze Zeit:

„Welche Projekte sollte ich tun, um einen Job in Datenwissenschaft oder maschinellem Lernen zu bekommen?“

Diese Frage ist von Anfang an fehlerhaft.

Ein großartiges Projekt ist persönlich für Sie, was bedeutet, dass jedes Projekt, das ich vorschlage, automatisch eine „schlechte“ Wahl ist.

In diesem Artikel möchte ich die Arten von Projekten aufschlüsseln, die Ihnen tatsächlich helfen, eingestellt zu werden, und den Rahmen, den Sie befolgen können, um sie zu finden.

4–5 einfache Projekte

Erstellen Sie mit 4 bis 5 kleineren Projekten, um Ihrem Portfolio ein gewisses anfängliches Gewicht zu geben.

Das Hauptziel hier ist hauptsächlich für „Optik“ und sicherzustellen, dass Ihr Lebenslauf/Lebenslauf, Ihr GitHub und Ihre LinkedIn-Profile aktiv und intestine besiedelt erscheinen.

Bitte nehmen Sie sich ein paar Wochen Zeit, um diese kleineren Projekte zu erstellen, und stellen Sie sicher, dass sie von ausreichender Qualität sind und nicht etwas, das Sie mit ChatGPT hastig generiert haben.

Ziel ist es, eine breite Palette von Projekten zu erstellen, die jeweils unterschiedliche Instruments, Datensätze und Algorithmen für maschinelles Lernen verwenden.

Algorithmen und ML -Modelle

Ich empfehle Ihnen, Projekte mit den folgenden Algorithmen zu haben:

• Gradienten steigern Bäume– Der Goldstandard -Algorithmus für tabellarische Daten. Daher werden Sie auf jeden Fall die Arbeit verwenden.
• Neuronale Netze – Gutes Verständnis für tiefe Lernrahmen wie Tensorflow oder Pytorch ist wertvoll, insbesondere wenn Sie in Laptop Imaginative and prescient, NLP oder KI arbeiten möchten.
• Clustering -Algorithmen– Modelle wie Okay-Means Und DBSCAN Demonstrieren Sie Ihr Verständnis für unbeaufsichtigtes Lernen, das für einige Rollen erforderlich ist.

Aufregende und neuartige Daten erhalten

Es ist viel besser, einen unordentlicheren und realistischeren Datensatz zu erhalten, der die Daten widerspiegelt, denen Sie in der realen Welt begegnen werden. Dies wird Arbeitgeber und Interviewer noch mehr beeindrucken und Ihre Fähigkeiten als Datenwissenschaftler direkt demonstrieren.

Vermeiden Sie es bei der Auswahl von Datensätzen für Ihre Projekte MNISTAnwesend Titanicoder Iris. Wenn ich diese sehen würde, wäre es eine sofortige Ablehnung oder zumindest viel ab.

Einige gute Orte, um Daten zu erhalten:

• Verwenden Sie öffentliche und kostenlose APIs – Sie können sich das ansehen Free-apis Web site für einige Ideen.
• Net -Scape -Daten von relevanten Web sites (stellen Sie sicher, dass Sie dies zuerst tun dürfen!) –Hier ist eine Liste von Web sites, auf denen das Net -Scraping ermöglicht wird.
• Datenquellen der öffentlichen Regierung –Knowledge.gov ist ein Beispiel, das Sie verwenden können.
• Sammeln Sie Ihre eigenen Daten durch Umfragen und Fragebögen.

Um zu entscheiden, was Ihre Projekte sein sollten, können Sie mit der Beantwortung spezifischer Fragen, die Sie für interessant halten, aus den Daten zu beantworten.

Ich empfehle, Ihre Ergebnisse mit Instruments wie zu demonstrieren Straffung oder ein einfaches Modell durch Bereitstellen über Github -Aktionen.

Stress jedoch nicht auf den Aufbau eines vollständig Finish-to-Finish-Produktionssystems mit etwas wie so etwas wie etwas wie AWS oder seine Dienstleistungen, wie z. EC2 oder ECS. In diesem Stadium ist es völlig in Ordnung, wenn Sie nicht wissen, wie das geht, und es ist nicht das Ziel dieser kleinen Projekte.

Ein großes Projekt

Hier müssen Sie sich wirklich konzentrieren und sich Zeit nehmen.

Nachdem Sie Ihre kleineren Projekte aufgebaut haben, ist es Zeit, ein großes Projekt zu erstellen. Dieser kann ein paar Monate dauern, wenn Sie jeden Tag ein oder zwei Stunden daran arbeiten.

Dies kann Sie einschüchtern, aber Sie müssen sich anstrengen, wenn Sie ein Projekt möchten, das sich von den anderen abhebt.

Die Frage ist, was sollten Sie bauen?

Wie ich bereits erwähnt habe, kann ich dieses Projekt für Sie nicht wählen, aber ich kann einen Rahmen für den folgenden Bereich bereitstellen, sodass Sie selbst ein großartiges Projekt finden können.

Beispielprojekt

Lassen Sie mich Ihnen ein Beispiel für ein großartiges Projekt geben.

Bei meinem früheren Unternehmen stellten wir für einen Junior -Datenwissenschaftler ein, an dem wir arbeiten konnten Optimierung Und Operationsforschung Probleme.

Der Kandidat, den wir eingestellt haben, stach aus einem Hauptgrund auf, sie hatten ein sehr relevantes und zutiefst persönliches Projekt, das der Rolle genau übereinstimmte.

Sie waren leidenschaftlich für den NFL -Fantasy -Fußball und wollten die Artwork und Weise verbessern, wie sie ihre wöchentlichen Aufstellungen aufgebaut haben (dies ähnelt der Fantasy Premier League in Großbritannien).

Daher entwickelten sie ihre eigene Optimierungsmotor, um Spieler effektiver innerhalb der Einschränkungen des Programms zuzuweisen.

Es warfare nicht nur der Motor selbst; Sie lesen akademische Arbeiten zu Optimierungsstrategien und untersuchten, wie sich andere dem gleichen Downside näherten.

Sehen Sie, warum dies ein so mächtiges Projekt warfare?

• Es warfare ein persönliches Downside, an dem sie interessiert waren.
• Es warfare einzigartig und wir hatten so etwas noch vorher oder seitdem nicht gesehen.
• Es zeigte ihre Leidenschaft und ihr Interesse an Optimierung und Operationsforschung.
• Es warfare direkt related für den Job, für den sie sich bewerben.

Mein Rahmen

Hier ist ein einfacher Rahmen, den Sie folgen können, um großartige Projektideen zu finden:

1. Hear Sie mindestens fünf Dinge auf, die Sie außerhalb der Arbeit und des Feldes Knowledge Science oder maschinelles Lernen interessieren.
2. Für jedes Ding stellen Sie Fragen, auf die Sie Antworten wünschen, oder andere Personen können interessant sein.
3. Überlegen Sie, wie maschinelles Lernen dazu beitragen könnte, diese Fragen zu beantworten. Mach dir keine Sorgen, wenn die Frage unmöglich erscheint. so kreativ wie möglich sein.
4. Wählen Sie eine Frage aus, die Sie am meisten begeistert. Wählen Sie im Idealfall etwas aus, das sich nur leicht außerhalb Ihrer Reichweite anfühlt. Auf diese Weise werden Sie wirklich lernen und sich aus Ihrer Komfortzone herausschieben.

Komplexität und Skalierung aufbauen

Um dieses Projekt hervorzuheben, müssen wir ihm eine gewisse Komplexität und Skalierung hinzufügen. Dies bedeutet unterschiedliche Dinge, und es gibt verschiedene Möglichkeiten, dies zu integrieren.

Wenn Sie eine Rolle als Ingenieur für maschinelles Lernen anstreben, ist es besonders wertvoll, das Projekt-Finish-to-Finish-Projekt zu erstellen und bereitzustellen.

Ihr Projekt sollte idealerweise Folgendes enthalten:

• Datenerfassung und -speicher.
• Datenvorverarbeitung.
• Modelltraining und Bewertung.
• Modellbereitstellung (über API, Net -App usw.).
• Analyse und Präsentation Ihrer Ergebnisse.

Dazu müssen Sie einige der folgenden Lernen lernen:

Es magazine viel erscheinen, aber Sie müssen nicht alles auf dieser Liste tun.

Die Hauptsache ist, diese Dinge auf dem Weg zu beginnen und zu lernen. Versuchen Sie nicht, alles auf einmal zu lernen. Das ist Aufschub.

Dokumentieren und kommunizieren

Der endgültige und wohl wichtigste Teil ist es, Ihr Lernen zu dokumentieren.

Allein technische Fähigkeiten haben Sie nicht den Job.

Kommunikation ist eine der wichtigsten Fähigkeiten als Ingenieur oder Datenwissenschaftler, insbesondere wenn Sie die Reihen nach oben bewegen.

Zeigen Sie Ihr Projekt von:

• Hinzufügen Ihrer Projekte zu Github und einem intestine dokumentierten Readme.
• Einbeziehung von Anweisungen für Setup und Nutzung, damit Benutzer Ihr Projekt erkunden und interagieren können.
• Schreiben Sie einen Weblog -Beitrag, in dem Sie Ihre Projekte erläutern und wie Sie es gemacht haben.
• Teilen Sie es auf LinkedIn, Twitter, Reddit, Discord, YouTube oder überall, wo auch immer Menschen, die daran interessiert sind, es versuchen, teilen.

Je mehr Sie Ihre Arbeit teilen, desto sichtbarer werden Sie für potenzielle Arbeitgeber und Mitarbeiter.

Es ist eigentlich nicht so schwer, ein solides Projektportfolio zu erstellen. Es erfordert nur eine konsequente Arbeit und Geduld, die die meisten Menschen nicht wollen.

Es gibt kein „schnelles“ Projekt, bei dem Sie eingestellt werden. Was Sie einstellen wird, nimmt sich die Zeit, etwas Persönliches, von guter Qualität und Roman aufzubauen.

Das ist das Geheimnis.

Eine andere Sache!

Ich biete 1: 1 -Teaching -Anrufe an, bei denen wir uns über alles unterhalten können, was Sie brauchen – sei es Projekte, Karriereberatung oder einfach nur Ihren nächsten Schritt herauszufinden. Ich bin hier, um Ihnen zu helfen, vorwärts zu kommen!

1: 1 Mentoring -Anruf mit Egor Howell
Karriereanleitung, beratende Beratung, Projekthilfe, Lebenslaufüberprüfung topmate.io

Und mittlere Unternehmen erzielen Erfolg beim Aufbau von Daten und ML -Plattformen. Aufbau von KI -Plattformen ist jetzt zutiefst herausfordernd. In diesem Beitrag werden drei wichtige Gründe erörtert, warum Sie vorsichtig sein sollten, um KI -Plattformen zu erstellen, und schlägt stattdessen meine Gedanken über vielversprechende Richtungen vor.

Haftungsausschluss: Es basiert auf persönlichen Ansichten und gilt nicht für Cloud -Anbieter und Daten/ML -SaaS -Unternehmen. Sie sollten stattdessen die Forschung von AI -Plattformen verdoppeln.

Woher ich komme

In meinem vorherigen Artikel Von der Datenplattform zur ML -Plattform In Richtung Information Science habe ich geteilt, wie sich eine Datenplattform zu einer ML -Plattform entwickelt. Diese Reise gilt für die meisten kleinen und mittelgroßen Unternehmen. Es gab jedoch keinen klaren Weg für kleine und mittlere Unternehmen, ihre Plattformen weiter auf AI-Plattformen zu entwickeln noch. Auf AI -Plattformen gaben der Pfad in zwei Richtungen ein:

• AI -Infrastruktur: Der „neue Strom“ (KI -Inferenz) ist bei der zentralen Erstellung effizienter. Es ist ein Spiel für große Techniker und große Modellanbieter.
• AI -Anwendungsplattform: Auf ständig wechselnden Boden kann das „Strandhaus“ (AI -Plattform) nicht bauen. Das sich entwickelnde KI -Fähigkeit und das aufkommende neue Entwicklungsparadigma machen die Feststellung einer dauerhaften Standardisierung herausfordernd.

Es gibt jedoch immer noch Anweisungen, die auch bei der Entwicklung von KI -Modellen wahrscheinlich wichtig bleiben. Es ist am Ende dieses Beitrags abgedeckt.

Hohe Barriere der AI -Infrastruktur

Während Databricks vielleicht nur mehrmals besser sind als Ihre eigenen Funkenjobs, könnte Deepseek bei LLM -Abschluss 100x effizienter sein als Sie. Das Coaching und das Servieren eines LLM -Modells erfordern erheblich mehr Investitionen in die Infrastruktur und die Kontrolle über die Struktur des LLM -Modells.

In Diese SerieIch teilte kurz die Infrastruktur für LLM -Schulungen, einschließlich der Einbeziehung Parallele TrainingsstrategienAnwesend Topologie -DesignsUnd Trainingsbeschleunigungen. Auf der Hardwareseite galt neben dem Hochleistungs-GPUs und TPUs ein erheblicher Teil der Kosten für Networking-Setup- und Hochleistungsspeicherdienste. Cluster benötigen ein zusätzliches RDMA-Netzwerk, um nicht blockierende, Punkt-zu-Punkt-Verbindungen für den Datenaustausch zwischen Instanzen zu ermöglichen. Die Orchestrierungsdienste müssen komplexe Stellenplanung, Failover -Strategien, Erkennung von {Hardware} sowie Abstraktion und Bündelung der GPU -Ressourcen unterstützen. Das Trainings -SDK muss asynchrone Prüfungen, Datenverarbeitung und Modellquantisierung erleichtern.

In Bezug auf das Modellieren von Modellbetreiber umfassen Modellanbieter häufig Inferenzeffizienz während der Modellentwicklungsstadien. Modellanbieter haben wahrscheinlich bessere Modellquantifizierungsstrategien, die die gleiche Modellqualität mit einer signifikant kleineren Modellgröße erzeugen würden. Modellanbieter entwickeln wahrscheinlich eine bessere Modell -Parallel -Strategie, da sie über die Modellstruktur übereinstimmen. Es kann die Chargengröße während der LLM -Inferenz erhöhen, was die GPU -Nutzung effektiv erhöht. Darüber hinaus haben große LLM -Spieler logistische Vorteile, mit denen sie günstigere Router, Mainframes und GPU -Chips zugreifen können. Noch wichtiger ist, dass eine stärkere Steuerung der Modellstruktur und bessere Modellanbieter von Modellanbietern mit Parallelfunktionen billigere GPU -Geräte nutzen können. Für Modellverbraucher, die sich auf Open-Supply-Modelle verlassen, könnte die GPU-Abschaltung ein größeres Drawback sein.

Nehmen Sie Deepseek R1 als Beispiel. Nehmen wir an, Sie verwenden p5e.48xLarge AWS -Instanz, die 8 H200 -Chips mit verbundenem NVLink anbieten. Es wird dich kosten 35 $ ​​professional Stunde. Vorausgesetzt, Sie machen es ebenso wie Nvidia und erreichen Sie 151 Token/zweite Leistung. Um 1 Million Output -Token zu generieren, kosten Sie 64 US -Greenback (1 Million / (151 * 3600) * $ 35). Wie viel verkauft Deepseek das Token bei professional Million? Nur 2 $! Deepseek kann das 60 -fache der Effizienz Ihrer Cloud -Bereitstellung erreichen (unter der Annahme von Deepseek).

LLM Inferenzleistung ist additionally in der Tat Elektrizität. Es spiegelt die Vielfalt der Anwendungen wider, die LLMs mit Strom versorgen können. Dies impliziert auch, dass es bei zentraler Erzeugung am effizientesten ist. Trotzdem sollten Sie LLM-Dienste für Privatsphäre immer noch selbsthostere Anwendungsfälle selbst veranstalten, genau wie Krankenhäuser ihre Stromerzeuger für Notfälle haben.

Ständig wechselndem Boden

Die Investition in die AI -Infrastruktur ist ein mutiges Spiel, und das Aufbau von leichten Plattformen für AI -Anwendungen ist mit seinen versteckten Fallstricken ausgestattet. Mit der schnellen Entwicklung der KI -Modellfähigkeiten gibt es kein ausgerichtetes Paradigma für AI -Anwendungen. Daher fehlen eine solide Grundlage für den Bau von AI -Anwendungen.

Die einfache Antwort darauf ist: Sei geduldig.

Nach mehreren Jahren heftiger Wettbewerb stehen noch einige große Modelspieler in der Enviornment. Die Entwicklung der KI -Fähigkeit ist jedoch noch nicht konvergiert. Mit der Weiterentwicklung der Fähigkeiten der KI -Modelle wird das bestehende Entwicklungsparadigma schnell veraltet. Große Spieler haben gerade begonnen, ihren Stich auf Agent -Entwicklungsplattformen zu machen, und neue Lösungen tauchen in einem Ofen wie Popcorn auf. Die Gewinner werden irgendwann erscheinen, glaube ich. Derzeit ist die Standardisierung der Bauagenten selbst ein schwieriger Aufruf für kleine und mittelgroße Unternehmen.

Pfadabhängigkeit des alten Erfolgs

Eine weitere Herausforderung beim Aufbau einer KI -Plattform ist ziemlich subtil. Es geht darum, die Denkweise der Plattformbauer widerzuspiegeln, unabhängig davon, ob sie die Pfadabhängigkeit vom vorherigen Erfolg des Erbaus von Daten und ML -Plattformen haben.

Wie wir zuvor geteilt haben, sind die Daten- und ML-Entwicklungsparadigmen seit 2017 intestine ausgerichtet, und die kritischste Aufgabe für die ML-Plattform ist die Standardisierung und Abstraktion. Das Entwicklungsparadigma für AI -Anwendungen ist jedoch noch nicht festgestellt. Wenn das Staff der vorherigen Erfolgsgeschichte des Erstellens einer Daten- und ML -Plattform folgt, werden möglicherweise die Standardisierung zur falschen Zeit priorisieren. Mögliche Anweisungen sind:

• Erstellen Sie ein KI -Modell -Gateway: Geben Sie LLM -Modellen mit zentraler Prüfung und Protokollierung von Anfragen an.
• Erstellen eines AI-Agenten-Frameworks: Entwickeln Sie ein selbstgebaues SDK, um KI-Agenten mit verbesserter Konnektivität zum internen Ökosystem zu erstellen.
• Standardisieren Sie Lag -Praktiken: Erstellen eines Standarddatenindexierungsflusss, um die Balken für Ingenieur -Construct -Information Providers zu senken.

Diese Initiativen können in der Tat signifikant sein. Aber der ROI hängt wirklich von der Skala Ihres Unternehmens ab. Unabhängig davon haben Sie die folgenden Herausforderungen:

• Halten Sie die neuesten KI -Entwicklungen auf dem Laufenden.
• Kundenakaditionsrate, wenn es für Kunden einfach ist, Ihre Abstraktion zu umgehen.

Angenommen, die Bauherren von Daten und ML -Plattformen sind wie „Closet -Organisatoren“, und KI -Bauherren sollten sich jetzt wie „Modedesigner“ verhalten. Es erfordert es, neue Ideen anzunehmen, schnelle Experimente durchzuführen und sogar ein Maß an Unvollkommenheit zu akzeptieren.

Meine Gedanken über vielversprechende Richtungen

Obwohl so viele Herausforderungen vor sich sind, werden Sie bitte daran erinnert, dass es immer noch erfreulich ist, jetzt auf der KI -Plattform zu arbeiten, da Sie einen erheblichen Hebelwirkung haben, der vorher nicht vorhanden struggle:

• Die Transformationsfähigkeit von KI ist erheblicher als die von Daten und maschinellem Lernen.

• Die Motivation, KI zu übernehmen, ist viel wirksamer als je zuvor.

Wenn Sie die richtige Richtung und Strategie auswählen, ist die Transformation, die Sie in Ihr Unternehmen bringen können, erheblich. Hier sind einige meiner Gedanken zu Richtungen, die weniger Störungen aufweisen könnten, wenn das KI -Modell weiter skaliert wird. Ich denke, sie sind mit AI -Plattform gleichermaßen wichtig:

• Hochwertige, reich-semantische Datenprodukte: Datenprodukte mit hoher Genauigkeit und Rechenschaftspflicht, reichhaltigen Beschreibungen und vertrauenswürdigen Metriken werden mit dem Wachstum von AI-Modellen mehr Auswirkungen „ausstrahlen“.
• Multi-Modal-Daten Servieren: OLTP, OLAP, NoSQL und Elasticsearch, ein skalierbarer Wissensdienst hinter dem MCP-Server, benötigen möglicherweise mehrere Arten von Datenbanken, um Hochleistungsdaten zu unterstützen. Es ist schwierig, eine einzige Quelle der Wahrheit und Leistung mit ständigen Reverse ETL -Jobs aufrechtzuerhalten.
• AI DevOps: AI-zentrierte Softwareentwicklung, Wartung und Analyse. Die Genauigkeit der Code-Era wird in den letzten 12 Monaten stark erhöht.
• Experimentieren und Überwachung: Angesichts der erhöhten Unsicherheit der AI -Anwendungen sind die Bewertung und Überwachung dieser Anwendungen noch kritischer.

Dies sind meine Gedanken zum Aufbau von KI -Plattformen. Bitte lassen Sie mich auch Ihre Gedanken darüber wissen. Prost!