es ist additionally grundsätzlich kostenlos.“ Ich habe das gesagt, Sie haben das wahrscheinlich gesagt, und es ist die Artwork von Behauptung, die wahr klingt, bis jemand sie misst. Additionally habe ich es gemessen.

Die Field ist „ardi“ – eine openSUSE-Maschine mit einer einzelnen RTX 3090 (24 GB). Darauf habe ich einen kontrollierten Benchmark durchgeführt: drei lokale Modelle, die von Ollama bedient wurden und jeweils unter einer identischen festen Arbeitslast betrieben wurden, während ein Dashboard jeden Lauf durch das bewertete echte GPU-Energie, die es verbrannt hat. Keine Schätzung der Thermal-Design-Leistung, keine Schätzung auf der Rückseite des Umschlags – die Leistung wird alle 10 Sekunden von nvidia-smi abgetastet und über das genaue Begin-Finish-Fenster jedes Laufs integriert, zu meinem tatsächlichen Tag-/Nacht-Stromtarif: 0,30 BGN am Tag / 0,18 BGN in der Nacht (Bulgarischer Lew – mein tatsächlicher Versorgungssatz; in diesem Artikel in EUR umgerechnet unter der festen EZB-Kopplung, 1 BGN ≈ 0,5113 €).

Das Ergebnis ist eine Zahl professional Modell: Euro professional Million ausgegebener Token. Fünf der acht von mir gemessenen Modelle waren günstiger als eine gehostete Cloud-API. Bei drei struggle das nicht der Fall – und es sind nicht die drei, die man aufgrund der Parameteranzahl allein erraten würde.

Die Behauptung, die ich testen wollte

Die Volksweisheit besagt, dass lokale Inferenz die kostengünstige Choice ist – Sie haben die GPU gekauft, der marginale Token ist kostenlos, die Cloud ist das Ding, bei dem der Zähler läuft. Jeder Teil davon verdient eine Nummer, additionally hier ist die, nach der ich gesucht habe: die Grenzenergiekosten für die lokale Generierung eines TokensModell für Modell, und wie es im Vergleich zu den Gebühren einer gehosteten „Flash“-Klasse-API für denselben Token abschneidet.

Um das zu einer Messung und nicht zu einem Argument zu machen, brauchte ich drei Dinge, die konstant gehalten wurden: die gleiche Arbeitslast für jedes Modell, die gleiche {Hardware} und ein Messgerät, dem ich vertraute, um die GPU bei jedem Lauf abzulesen. Der dritte Punkt ist der schwierige Teil zu Hause – da kommt das Instrument ins Spiel.

Die Methode

Drei Modelle, ausgewählt, um den Größenbereich abzudecken, den ich tatsächlich auf der Field habe: gemma3:1b (winzig), gemma4:26b (Googles Gemma 4–25,8B Parameter unter der Haube; ollama rundet es im Tag einfach auf „26b“) und gemma3:27b (das ältere große). Alle drei sind Q4_K_M-quantisierte GGUF-Gewichte, die durch Ollama gezogen werden, sodass der Vergleich hinsichtlich der Quantisierung gleichwertig ist. Jeder bekam das gleiche feste Arbeitsbelastung – eine Schleife von 256-Token-Generationen, die fünf feste Eingabeaufforderungen durchläuft – aufrechterhalten für ~4 Minuten (240 s)So erreichte die GPU einen stabilen Zustand und wurde nicht nach einem kalten ersten Anruf beurteilt.

Während jedes Modell lief, habe ich es als verfolgt Preisliches Experiment in HomeLab Monitor – mein eigenes Dashboard, Open Supply, MIT, ein Container. Es erfasst alle 10 s die GPU-Leistung von nvidia-smi und integriert bei einem verfolgten Lauf die Leistung über das Begin-Finish-Fenster des Laufs in kWh und multipliziert sie dann mit dem jeweils geltenden Tarif (Tag vs. Nacht) – in der Währung, mit der ich es konfiguriert habe, BGN . Das umrechnet: „Was hat dieses Modell gekostet?“ von einer Vermutung zu einer gemessenen Zahl; Zur besseren Lesbarkeit rechne ich dann in EUR um.

Dann die Arithmetik, die einen 4-Minuten-Lauf in eine vergleichbare Geschwindigkeit umwandelt:

€ per 1M output tokens = (run_cost_BGN × 0.5113) ÷ (output_tokens / 1,000,000)

Der untenstehende Benchmark der drei Modellgenerationen ist durchgängig reproduzierbar. Hier erfahren Sie, wie Sie es auf Ihrer eigenen Field aufstellen.

Schritt 1 – Monitor aufrufen (ein Container)

Auf der Maschine mit der GPU:

COMPOSE_URL=https://uncooked.githubusercontent.com/SikamikanikoBG/homelab-monitor/predominant/docker-compose.yml
curl -fsSLO "$COMPOSE_URL"
docker compose up -d

Öffnen Sie http://:9800. Der Host, auf dem es ausgeführt wird, wird sofort angezeigt – CPU, RAM, Festplatten und (falls vorhanden) die GPU mit modellspezifischem VRAM und Reside-Stromaufnahme. Keine Konfiguration. Das ist das Messgerät. Überprüfen Sie die Einstellungen für die Währung und den Tarif, mit denen es konfiguriert ist, bevor Sie einer angezeigten €-Zahl vertrauen.

Schritt 2 – Prägen Sie einen Ingest-Schlüssel

Das Benchmark-Skript muss Läufe in den Hub pushen und benötigt daher einen Schlüssel. Einstellungen → Integrationen → Schlüssel erstellen. Der Schlüssel (ein hlm_…-String) wird einmal angezeigt – kopieren Sie ihn dann, er wird nicht mehr angezeigt. Bewahren Sie es in einer Umgebungsvariable auf; Fügen Sie es nicht in das Skript ein.

export HOMELAB_KEY="hlm_xxxxxxxxxxxxxxxxxxxx"

Das gleiche Panel hat eine Shopper herunterladen Hyperlink für die Python-Datei, die Sie in Schritt 3 verwenden, und eine Schnellstartanleitung zum Kopieren und Einfügen – dieser eine Bildschirm deckt additionally die nächsten beiden Schritte ab.

Schritt 3 – Schnappen Sie sich den Tiny Shopper

Der Hub bedient seinen eigenen Python-Shopper. Es ist nur stdlib – nichts, was per Pip installiert werden muss:

CLIENT_URL=http://<hub>:9800/static/homelab_run.py
curl -O "$CLIENT_URL"

Diese eine Datei ist die gesamte Monitoring-API. Das Muster ist bewusst klein gehalten: Einmal konfigurieren, dann jeden Arbeitsblock in einen Ausführungskontextmanager einschließen und darin Metriken protokollieren.

import homelab_run as homelab

homelab.configure(url="http://<hub>:9800", key="hlm_...")

with homelab.run("llm-cost-gemma3-1b",
                 params={"mannequin": "gemma3:1b", "engine": "ollama",
                         "gpu": "RTX 3090 24GB", "num_predict": 256}) as r:
    # ... do the work ...
    r.log_metric("tokens_per_sec", tps, step=i)

Wenn der With-Block geöffnet wird, markiert der Hub einen Laufstart; Wenn es geschlossen wird, markiert es das Ende und bewertet die zwischenzeitlich verbrannte GPU-Energie. Das Fenster ist das Maß.

Schritt 4 – Benchmark schreiben

Der Arbeitsaufwand besteht nur darin, dass Ollama /api/generate in einer Schleife arbeitet und die Felder ausliest, die Ollama zurückgibt, damit wir sie erhalten actual Tokens professional Sekunde statt einer Wanduhr-Näherung. Die beiden Bereiche, auf die es ankommt, sind eval_count (generierte Token) und eval_duration (Nanosekunden, die für deren Generierung aufgewendet wurden):

import json, time, urllib.request

OLLAMA = "http://localhost:11434"

def ollama_generate(mannequin, immediate):
    physique = json.dumps({
        "mannequin": mannequin, "immediate": immediate, "stream": False,
        "choices": {"num_predict": 256, "temperature": 0.7},
    }).encode()
    req = urllib.request.Request(OLLAMA + "/api/generate", information=physique,
                                 headers={"Content material-Kind": "software/json"})
    with urllib.request.urlopen(req, timeout=600) as resp:
        return json.hundreds(resp.learn())

Fahren Sie dann jedes Modell für eine festgelegte Dauer unter Final, gefolgt von einem verfolgten Lauf:

def bench(mannequin, duration_s=240):
    ollama_generate(mannequin, "Say whats up.")  # heat up - exclude the chilly begin
    run = homelab.run(f"llm-cost-{mannequin.substitute(':', '-')}",
                      params={"mannequin": mannequin, "engine": "ollama",
                              "gpu": "RTX 3090 24GB", "num_predict": 256,
                              "workload": "fixed-prompt-loop"},
                      tags=("llm-cost", "benchmark"))
    tot_out = 0
    t0 = time.time(); step = 0
    with run as r:
        whereas time.time() - t0 < duration_s:
            res = ollama_generate(mannequin, PROMPTS(step % len(PROMPTS)))
            ec, ed = res.get("eval_count", 0), res.get("eval_duration", 1)  # ed in ns
            tps = ec / (ed / 1e9) if ed else 0.0
            tot_out += ec
            r.log_metric("tokens_per_sec", spherical(tps, 2), step=step)
            step += 1
        r.log_params({"total_output_tokens": tot_out})
    return run.id, tot_out

Durch einen Aufwärmaufruf vor dem Zeitfenster wird die Kaltstartlatenz aus der Messung ausgeschlossen. Der time.sleep(15), den ich zwischen den Modellen eingefügt habe (nicht gezeigt), hält jedes Preisfenster sauber getrennt, sodass der Schwanz eines Modells nicht in die Rechnung des nächsten Modells gelangt.

Schritt 5 – Lesen Sie den Runback und die Preise

Führen Sie das Skript für alle drei Modelle aus und öffnen Sie das ExperimenteTab. Jeder Lauf ist nun eine Reihe, die ihre wahre Energie und Kosten trägt:

Klicken Sie in einen Lauf und Sie erhalten die GPU-Leistungskurve für genau dieses Fenstermit der Preisunterschrift darunter – der Rohstoff, aus dem die Euro-Zahl berechnet wird:

Der Hub legt die Kosten jedes Laufs auch programmgesteuert offen, sodass die endgültige Aufteilung im Skript erfolgen kann:

pulled = homelab.pull(run_id)  # price, energy_kwh, avg_w, energy curve - price is in BGN
eur_per_mtok = spherical((pulled("price") * 0.5113) / (tot_out / 1e6), 4)

Die Zahlen

Später ging ich zurück und fügte fünf weitere Modelle hinzu – GLM-4.5-Air (106B), DeepSeek-R1-Distill (32.8B), Seed-OSS (36B), Devstral (24B) und Qwen3-Coder (30.5B) –, die aus einem separaten Coding-Agent-Benchmark stammten, den ich bereits auf derselben Field ausgeführt hatte (gleiche GPU, gleicher Tarif, gleiche Kostentoken-Methode, aber echte mehrstufige Agentenaufgaben anstelle einer dedizierten 240-Sekunden-Generationsschleife – vermerkt, wo es darauf ankommt, in den Vorbehalten unten). Acht Modelle, ein Maßstab:

Und die Cloud-Referenz, an der ich gemessen habe (Listenpreise, Juni 2026): Ein gehostetes Flash-Klasse-Modell – Gemini 2.5 Flash, GPT-4o-mini – läuft ungefähr 0,60 $ professional 1 Mio. Ausgabetoken (~0,55 €); Die günstigste Stufe (Gemini 3.1 Flash-Lite) ist verfügbar 0,40 $.

Die Überraschung

Fünf der acht sind günstiger als die Cloud-Referenz. Drei sind es nicht – und die drei, die es nicht sind, sind es nicht die drei, die Sie nach Parameteranzahl auswählen würden.

GLM-4.5-Air ist das größte Modell auf der Liste, 106B Parameter, und es kostet 1.040 €/1 Mio. – wirklich mehr als die Cloud-API, Strom allein, ohne einen Cent des GPU-Kaufpreises. Dieser Teil entspricht der ursprünglichen Instinct: großes Modell, langsam, teuer.

Aber DeepSeek-R1-Distill ist kaum ein Drittel so groß wie GLM – 32,8 Milliarden Parameter – und das ist es am meisten teures Modell auf der gesamten Liste, bei 1,526 €/1 Mio. €. Es verbraucht weniger Strom als gemma3:27b (155 W gegenüber 283 W) – und ist es immer noch am teuersten professional Token aller getesteten Modelle .

Ein methodischer Hinweis, der hier wichtig ist, im Vorfeld und nicht im Verborgenen: Die drei Gemma-Modelle wurden auf einem speziellen 240-Sekunden-Benchmark mit kontinuierlicher Era gemessen, den ich für dieses Stück erstellt habe. Die anderen fünf – einschließlich DeepSeek-R1-Distill – stammen aus einem früheren, separaten Benchmark echter mehrstufiger Coding-Agent-Aufgaben (Instrument-Aufrufe, Multi-Flip-Argumentation) auf derselben GPU und demselben Tarif unter Verwendung der identischen Kosten-Ausgabe-Token-Formel. Dieser Unterschied ist der Grund dafür, dass DeepSeek so aussieht, wie es aussieht: Es ist Roherzeugungsgeschwindigkeit bei aktiver Token-Produktion sind es respektable 6,7 Token/Sek. Der Zähler berechnet jedoch nicht die reine Erzeugungsgeschwindigkeit. Der Zähler berechnet die auf der Karte gespeicherte Zeit, und DeepSeek – ein Modell, das auf logischen Überlegungen basiert – verbringt die meiste Zeit damit, zwischen den Generationen zu beraten und nicht zu generieren. Es ist effektive Lieferrate(Ausgabe-Tokens ÷ Gesamtlaufzeit, inklusive Überlegung) klappt 3,7 Token/Sek der niedrigste aller getesteten Modelle – deutlich unter den effektiven 7,1 von Seed-OSS und 5,0 von GLM. Das ist es, was der Preis tatsächlich abbildet.

Größe struggle nie der Mechanismus. Die effektive Geschwindigkeit struggle – und die effektive Geschwindigkeit ist nicht der Wert, mit dem diese Modelle normalerweise gemessen werden.

Der Mechanismus

Jeder Token kostet Watt ÷ Durchsatz.Das ist die ganze Gleichung – der Trick besteht darin, die richtige Durchsatzzahl zu verwenden:

gemma3:1b ist schnell (136 tok/s) und leicht (154 W) – günstig auf beiden Achsen, insgesamt am günstigsten. Devstral zieht von allen getesteten Modellen die meiste Leistung (320 W), bleibt aber im Mittelfeld, da es immer noch recht schnell ist. Für die drei speziell entwickelten Gemma-Modelle: Roherzeugungsgeschwindigkeit Ist Die Zahl, die den Preis festlegt – Watt ÷ Uncooked Tok/s – rekonstruiert das Kostenverhältnis quick genau. Für die fünf Agenten-Benchmark-Modelle ist die Zahl, die den Preis festlegt effektiver Wanduhrdurchsatz nicht die reine Erzeugungsgeschwindigkeit, mit der sie normalerweise angegeben würden – und nach dieser Zahl sind Seed-OSS (7,1 tok/s effektiv), GLM-4.5-Air (5,0) und DeepSeek-R1-Distill (3,7) die drei langsamsten getesteten Modelle, und zwar genau in der Reihenfolge ihrer Kosten. Keiner von ihnen hat einen ungewöhnlichen Stromverbrauch (eigentlich 141–186 W). untere als mehrere günstigere Modelle); Sie sind nur langsam, wenn man Werkzeugaufrufe und Argumentationslücken berücksichtigt, und ein Modell, das langsam ist, zahlt sich für jede Sekunde aus, in der es die Karte in der Hand hält, unabhängig von der Parameteranzahl.

Was ich *nicht* behaupte

Dies ist der Teil, der es ehrlich hält, additionally werde ich die Ränder ganz offen sagen:

· Dabei handelt es sich lediglich um GPU-Strom – gemessen, marginal und winzig.Ein vollständiger Lauf rundet auf den Bruchteil eines Cents. Ich messe weder CPU noch DRAM (RAPL struggle auf diesem Host nicht lesbar, daher wurden diese als Null zurückgegeben), und das tue ich ausdrücklich nicht Ich zähle den Kaufpreis der GPU, den Leerlaufverbrauch, die Kühlung oder meine Zeit. Die Zahlen für €/1 Mio. sind die Grenzenergierate nützlich für „Welches Modell ist günstiger, um es weiterhin zu erzeugen“, nicht für die Gesamtbetriebskosten.

· Die tatsächlichen Kosten für lokal sind die GPU, die Sie gekauft haben, nicht die Wattzahl. Ein 3090 amortisiert sich nur bei hoher, gleichmäßiger Auslastung. Eine Field, die ein paar Minuten am Tag ausgelastet ist, zahlt hauptsächlich für ungenutztes Silizium, und keine Stromzahl erfasst das. Die Grenzenergielinse ist ehrlich über ihren eigenen Anwendungsbereich: Es kommt auf den Boden an, nicht auf die Rechnung.

· Zwei Messmethoden (siehe „Die Überraschung“ oben, warum das wichtig ist). Die drei Gemma-Modelle: ein dedizierter 240-Sekunden-Benchmark für die nachhaltige Era. Die anderen fünf: ein separater echter Coding-Agent-Benchmark, dieselbe Kosten-Token-Formel, aber wirksam Der Durchsatz beträgt eher den Taktgeber als die bloße Generierungsgeschwindigkeit – was wohl repräsentativer dafür ist, wie diese Modelle tatsächlich genutzt werden, nicht weniger, da echte Agenten-Arbeitslasten Toolaufrufe und Überlegungen beinhalten, die eine reine Generierungsschleife niemals tun würde.

·Eine GPU, eine Engine, quantisierte GGUF-Gewichte.Ihr Tarif, Ihr Modell, Ihre Chargengröße, Ihre Quantisierung und Ihre Karte bewegen hier jede Nummer. Der Tisch ist Mein Kasten; Die Methode ist der übertragbare Teil.

Betrachten Sie additionally die absoluten Euro als Veranschaulichung und die Kind Als Ergebnis: Die Kosten professional Token verfolgen die effektive Liefergeschwindigkeit, und das verfolgt die Parameteranzahl nicht in der erwarteten Weise.

Das Essen zum Mitnehmen

Wählen Sie das kleinste und schnellste Modell, das Ihren Qualitätsmaßstäben gerecht wird – hier zahlt sich „lokal“ tatsächlich aus, und zwar bei weitem, und es hat nichts mit der Auswahl eines kleinen Modells zu tun Weil es ist klein. Qwen3-Coder ist mit 30,5B professional Token günstiger als gemma4:26b, und gemma3:27b mit 27B übertrifft jedes Argumentationsmodell auf der Liste, obwohl es sich um ein einfaches dichtes Modell ohne besondere Effizienztricks handelt. Die Variable, die zählt, sind die professional Sekunde gelieferten Token, Punkt – nicht die rohe Generationsgeschwindigkeit, mit der ein Modell normalerweise bewertet wird – und die einzige Möglichkeit, sie für Ihr Modell und Ihre Field zu ermitteln, besteht darin, sie zu messen.

Das von mir verwendete Instrument ist HomeLab-Monitor– Open Supply, MIT, ein Container – und der oben genannte Run-Pricing ist genau das, was die Registerkarte „Experimente“ standardmäßig leistet:

Fügen Sie Ihren GPU-Host hinzu, prägen Sie einen Schlüssel und Ihre nächsten Benchmark-Preise selbst – in der Währung, die Sie tatsächlich konfiguriert haben, was es wert ist, überprüft zu werden, bevor Sie die Zahl veröffentlichen.

Wenn Sie additionally über die API nach dem lokalen Modell greifen, kennen Sie dann tatsächlich die Anzahl professional Token in der richtigen Währung – oder gehen Sie, wie ich, einfach davon aus, dass die GPU sie kostenlos macht?

Wenn Börsen Liquiditätsanbieter bewerten, beginnt das Gespräch normalerweise mit Spreads, Kapital und Erfolgsbilanz. Dies sind die sichtbaren Ausgaben. Ob diese Ergebnisse im Laufe der Zeit erreichbar und nachhaltig sind, hängt von der Dateninfrastruktur ab, die dem Betrieb zugrunde liegt. Dieser Dimension wird in den meisten Bewertungen jedoch deutlich weniger Aufmerksamkeit geschenkt, obwohl sie für alles andere von grundlegender Bedeutung ist.

In diesem Artikel wird untersucht, worauf Börsenbetreiber und technische Führungskräfte bei der ernsthaften Bewertung von Liquiditätsanbietern tatsächlich achten, wie die Dateninfrastruktur eines Market-Making-Betriebs dessen Leistung bestimmt und welche Fragen zur tatsächlichen Qualität der Systeme eines Anbieters auftauchen.

Liquiditätsbereitstellung als Echtzeit-Datenoperation

Die Kernfunktion des Market Making, die gleichzeitige Aufrechterhaltung wettbewerbsfähiger zweiseitiger Kurse über mehrere Handelsplätze hinweg, basiert im Wesentlichen auf einem Datenverarbeitungsvorgang. Ein Market Maker muss Preis- und Tiefendaten von allen verbundenen Börsen in Echtzeit erfassen, optimale Angebotsparameter angesichts der aktuellen Lager- und Marktbedingungen berechnen und Aufträge schneller übermitteln oder aktualisieren, als andere Teilnehmer auf dieselben Informationen reagieren können.

Für jeden dieser Schritte gelten Anforderungen an die Datenarchitektur, die nichtlinear mit der Anzahl der abgedeckten Handelspaare und Börsen skalieren. Ein Market Maker, der über eine große Anzahl von Paaren und Handelsplätzen gleichzeitig tätig ist, verarbeitet eine enorme Menge an Echtzeitdaten unter strengen Latenzbeschränkungen, wobei Verzögerungen von Millisekunden direkt zu einer ungünstigeren Ausführung führen. Die für eine zuverlässige Bewältigung dieses Issues erforderliche Infrastruktur ist zweckgebunden und nicht aus Allzweckwerkzeugen adaptiert, und die für den ordnungsgemäßen Aufbau erforderlichen technischen Investitionen summieren sich über Jahre und nicht über Quartale.

Die Parallele zu KI-gesteuerte Workflow-Automatisierung ist aufschlussreich: Vorgänge, die Echtzeit-Entscheidungen in großem Maßstab erfordern, hängen zunehmend von einer speziell entwickelten Dateninfrastruktur ab. Market Making ist einer der anspruchsvollsten Fälle dieses Musters. Die Entscheidungsschleife läuft tausende Male professional Sekunde, und die Qualität dieser Infrastruktur zeigt sich direkt in der Qualität der von ihr erzeugten Ausführung.

Was Liquiditätsqualität für die Gesundheit der Börse bedeutet

Der Zusammenhang zwischen Orderbuchtiefe, Unfold-Qualität und Börsengesundheit ist auf den Märkten für digitale Vermögenswerte intestine etabliert. Börsen mit tieferen Büchern und engeren Spreads weisen eine geringere Preisvolatilität, eine effizientere Preisfindung und eine stärkere Händlerbindung auf. Diese Effekte verstärken sich im Laufe der Zeit gegenseitig. Eine bessere Liquidität zieht institutionelle Teilnehmer an, deren Auftragsfluss die Markteffizienz verbessert und dadurch die Kennzahlen stärkt, die mehr solche Teilnehmer anziehen. Für Börsenbetreiber bedeutet die Verschlimmerung dieser Dynamik, dass Investitionen in die Liquiditätsinfrastruktur Renditen generieren, die in den Handelsdaten lange vor ihrem Erscheinen in den Umsatzzahlen auftauchen.

Dieses Muster ist auf allen Finanzmärkten intestine dokumentiert. Analyse von wie sich die Liquiditätsqualität unter Stressbedingungen hält zeigt immer wieder, dass Veranstaltungsorte, die trotz Volatilität Tiefe und Spreads beibehalten, eine grundlegend andere und stabilere Teilnehmerbasis anziehen als solche, die dies nicht tun. Ersteres zieht Schönwetterströme an. Letzteres zieht institutionelle Teilnehmer und Hochfrequenzhändler an, deren Präsenz echte Marktqualität signalisiert und deren kontinuierliches Engagement die Requirements des Veranstaltungsortes für alle anderen erhöht.

Was die börsenseitige Datenarchitektur ermöglicht

Aus Sicht der Börse funktioniert die Frage der Dateninfrastruktur in beide Richtungen. Die Börse muss dem Liquiditätsanbieter schnelle und zuverlässige Marktdaten-Feeds bereitstellen und Zugriff auf die Auftragsverwaltungs-API mit dem vom Anbieter benötigten Volumen und der erforderlichen Latenz erhalten. Die technische Qualität dieser Schnittstelle bestimmt, wie schnell sich ein qualitativ hochwertiger Anbieter integrieren kann und wie zuverlässig er seine Leistung aufrechterhalten kann, wenn das Asset-Set der Börse wächst.

Börsen, die in eine intestine konzipierte technische Infrastruktur investieren, finden diese dediziert Liquidität der Krypto-Börse Anbieter können sich schneller integrieren, eine zuverlässigere Systemleistung aufrechterhalten und reibungsloser skalieren, wenn die Anzahl der Handelspaare wächst. Die Qualität der technischen Infrastruktur der Börse hat direkten Einfluss auf die Liquidität, die sie anziehen und aufrechterhalten kann. Dadurch entsteht eine produktive Rückkopplungsschleife: Infrastrukturinvestitionen verbessern die Liquiditätsqualität, was das Handelserlebnis verbessert, was wiederum weitere Infrastrukturinvestitionen unterstützt.

Die Geschwindigkeit, mit der ein Anbieter eine neue Börse integrieren und eine stabile, konsistente Leistung erreichen kann, ist selbst eine Errungenschaft der Dateninfrastruktur. Es spiegelt den Reifegrad der API-Verwaltungsschicht, die Tiefe der bereits abgeschlossenen Austauschkompatibilitätsarbeiten und die betrieblichen Prozesse rund um das Onboarding wider. Für Börsen, die Anbieter bewerten, ist die Integrationsgeschwindigkeit ein nützlicher Indikator für die allgemeine Qualität der zugrunde liegenden Systeme.

Die Herausforderung der Preiskonsistenz an mehreren Börsen

Einer der technisch anspruchsvollsten Aspekte des institutionellen Market-Making ist die Aufrechterhaltung der Preiskonsistenz über mehrere Handelsplätze hinweg für denselben Vermögenswert. Wenn ein Token gleichzeitig an zehn verschiedenen Börsen gehandelt wird, haben diese Börsen zu jedem Zeitpunkt leicht unterschiedliche Preise, was unterschiedliche Auftragsströme, Tiefe und Latenz bei der Verarbeitung von Informationen über Aktivitäten an anderen Orten widerspiegelt.

Ein hochentwickelter Market Maker verarbeitet das globale Preissignal aller Handelsplätze gleichzeitig und passt die Kurse an jeder Börse an, um sie mit dem globalen Marktwert in Einklang zu bringen. Dies erfordert eine Datennormalisierung über eine große Anzahl von Börsen gleichzeitig mit jeweils unterschiedlichen Zeitstempelkonventionen, API-Zuverlässigkeitsprofilen und Ratenbeschränkungen. Die Systeme, die dies intestine bewältigen, sind speziell für diesen Zweck entwickelt und stellen jahrelange technische Investitionen und betriebliche Verfeinerungen dar, wobei die Qualität der Ausgabe direkt auf die Qualität der zugrunde liegenden Datenarchitektur zurückzuführen ist.

Der praktische Nutzen für Börsen und Händler ist erheblich. Ein digitaler Vermögenswert mit einheitlichen Preisen an allen Börsenplätzen sorgt für ein besseres Ausführungserlebnis, verringert die Arbitragedynamik, die zu Reibungen zwischen den Börsenplätzen führt, und bietet institutionellen Teilnehmern, die gleichzeitig auf mehreren Plattformen tätig sind, ein attraktiveres Profil. Für die Börse ist eine konsistente standortübergreifende Preisgestaltung durch einen intestine koordinierten Market Maker ein direktes Qualitätssignal, das sich darauf auswirkt, wie der Handelsplatz vom wertvollsten Section der Händlerbasis wahrgenommen wird.

Wie Risikomanagement-Datensysteme die Börsenstabilität unterstützen

Die Risikomanagementebene einer Market-Making-Operation ist für die Börsenstabilität ebenso wichtig wie die Quotierungsebene. Ein Anbieter mit starker Echtzeit-Positionsüberwachung, automatischer Parameteranpassung, wenn sich das Risiko definierten Grenzen nähert, und proaktivem Bestandsmanagement sorgt für die stabile, zuverlässige Präsenz, auf die Börsen und ihre Händler angewiesen sind.

Bei der Bewertung von Liquiditätsanbietern profitieren Börsen davon, wenn sie gezielt nach der Architektur des Risikomanagements fragen: wie Positionslimits überwacht werden, was Anpassungen der Quotierungsparameter auslöst und wie das System auf schnelle Marktbewegungen reagiert. Anbieter mit einer robusten Risikomanagement-Infrastruktur können dies klar und konkret erklären. Die Qualität dieser Erklärung selbst zeigt die Komplexität der zugrunde liegenden Systeme.

Der Bewertungsrahmen für technische Führungskräfte

Die Fragen, die die tatsächliche Qualität der Infrastruktur eines Liquiditätsanbieters am effektivsten ans Licht bringen, sind operativer und spezifischer Natur. Wie hoch ist die Latenzzeit von der Bestellung bis zur Ausführung an einem großen Handelsplatz und wie wird diese gemessen? Wie geht das System mit API-Ratenbegrenzungen über eine große Anzahl gleichzeitiger Austauschverbindungen um? Welche Leistungsdaten zu Streuung und Tiefe sind verfügbar und in welcher Granularität und historischen Tiefe? Wie reagiert das Risikomanagementsystem auf eine schnelle Preisbewegung bei einem korrelierten Vermögenswert?

Anbieter mit echter institutioneller Infrastruktur können jede dieser Fragen konkret und mit unterstützenden Daten beantworten. Die Fähigkeit, detaillierte historische Leistungsdaten über verschiedene Marktbedingungen hinweg bereitzustellen, ist an sich schon ein starkes Sign dafür, dass die Datensysteme hinter dem Betrieb intestine aufgebaut sind und aktiv gewartet werden. Dieses Maß an Infrastruktur ermöglicht die Leistungskonsistenz, die Börsenbetreiber letztendlich bei der Bewertung einer langfristigen Liquiditätspartnerschaft anstreben.

Hervorgehobener Bildnachweis

ich habe ziemlich viel über RAG geschrieben, angefangen mit dem Per Anhalter durch RAG mit ChatGPT-API und LangChainund dann verschiedene Themen im Zusammenhang mit RAG und KI erkunden, z Chunking, Hybridsuche, Neuordnung, Kontextbezogenes Abrufenund a dreiteilige Serie zur Bewertung der Retrievalqualität. Mit anderen Worten: Wir haben auf der RAG-Seite viel abgedeckt.

Worüber wir nicht so explizit gesprochen haben, ist die andere wichtige Technik, zu der Menschen greifen, wenn sie eine LLM-App für eine bestimmte Domäne verbessern möchten. Das heißt Feinabstimmung. Und insbesondere haben wir nicht darüber gesprochen, was passiert, wenn man die beiden nebeneinander legt und versucht herauszufinden, welches man tatsächlich braucht.

Wenn Sie suchen „RAG vs. Feinabstimmung„On-line finden Sie viele Inhalte, die dies als einen Wettbewerb mit einem Gewinner behandeln. Für einige gewinnt RAG, weil die Einrichtung billiger ist, für andere gewinnt die Feinabstimmung, weil sie bessere Ergebnisse liefert usw. Das Drawback bei dieser Formulierung ist, dass sie grundsätzlich irreführend ist, da es sich bei RAG und Feinabstimmung nicht um konkurrierende Techniken handelt, sondern um Techniken, die unterschiedliche Probleme auf verschiedenen Ebenen einer KI-Anwendung lösen. Um eine gute Entscheidung zu treffen, ist es notwendig zu verstehen, was jeder einzelne tatsächlich tut.

Additionally schauen wir mal rein!

DataCream ist ein Publication über KI, Daten und Technologie. Wenn Sie sich für diese Themen interessieren, Abonnieren Sie hier!

Was ist RAG und was macht es eigentlich?

Wenn Sie diese Serie verfolgt haben, haben Sie bereits ein solides Gespür für RAG. Aber sagen wir es noch einmal, denn die genaue Definition ist wichtig für den Vergleich mit der anschließenden Feinabstimmung.

RAG (Retrieval-Augmented Technology) ist additionally eine Technik, die die Reaktion eines LLM verbessert, indem relevante externe Informationen zum Zeitpunkt der Inferenz abgerufen und in die Eingabeaufforderung eingefügt werden. Das Modell selbst wird in keiner Weise verändert. Was sich ändert, ist das, was es als Eingabe betrachtet.

Die Pipeline sieht in etwa so aus:

• Zunächst werden externe Dokumente (die Wissensbasis, die wir nutzen möchten) in Vektoreinbettungen verarbeitet und in einer Vektordatenbank gespeichert.
• Wenn ein Benutzer eine Abfrage sendet, wird die Abfrage auch in eine Einbettung umgewandelt und die semantisch ähnlichsten Dokumentblöcke werden aus der Datenbank abgerufen.
• Diese Blöcke werden dann zusammen mit der Anfrage des Benutzers an das LLM übergeben, sodass das Modell eine Antwort generieren kann, die auf diesem spezifischen abgerufenen Kontext basiert.

Und das ist es.

Hier ist ein minimales RAG-Beispiel mit der OpenAI-API:

from openai import OpenAI
import numpy as np

consumer = OpenAI(api_key="your_api_key")

# our tiny data base
paperwork = (
    "pialgorithms is an AI-powered doc administration platform.",
    "pialgorithms permits groups to look, extract, and automate doc workflows.",
    "pialgorithms was based in Athens, Greece.",
)

# embed the data base
def embed(texts):
    response = consumer.embeddings.create(
        mannequin="text-embedding-3-small",
        enter=texts
    )
    return (r.embedding for r in response.information)

doc_embeddings = embed(paperwork)

# embed the consumer question and retrieve probably the most related chunk
question = "The place is pialgorithms primarily based?"
query_embedding = embed((question))(0)

# cosine similarity
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

similarities = (cosine_similarity(query_embedding, doc_emb) for doc_emb in doc_embeddings)
best_match = paperwork(np.argmax(similarities))

# inject retrieved context into the immediate
response = consumer.chat.completions.create(
    mannequin="gpt-4o-mini",
    messages=(
        {
            "position": "system",
            "content material": f"Reply the consumer's query utilizing solely the next context:nn{best_match}"
        },
        {
            "position": "consumer",
            "content material": question
        }
    )
)

print(response.decisions(0).message.content material)
# pialgorithms relies in Athens, Greece.

Nehmen wir uns einen Second Zeit, um zu verstehen, was hier wirklich passiert. Natürlich hat das Mannequin keine Ahnung, was Pialgorithmen stammt aus seinem Coaching, aber da wir den richtigen Dokumentblock abgerufen und in die Eingabeaufforderung eingefügt haben, kann das Modell genau antworten. Das Wissen kommt zum Zeitpunkt der Abfrage von außerhalb des Modells und das Modell selbst bleibt unberührt.

Dies ist der Kern dessen, was RAG tut: Es gewährt dem Modell zum Zeitpunkt der Inferenz dynamisch Zugriff auf externes Wissen, auf das es nie trainiert wurde.

Und basierend auf der Artwork und Weise, wie es funktioniert, schneidet RAG bei bestimmten Arten von Aufgaben intestine ab, wie zum Beispiel:

• Beantwortung von Fragen zu Dokumenten, Wissensdatenbanken oder Daten, die das Modell noch nie gesehen hat
• Ohne Umschulung auf dem Laufenden bleiben, da die Wissensbasis jederzeit selbstständig aktualisiert werden kann
• Bereitstellung nachvollziehbarer, zitierfähiger Antworten, da Sie genau wissen, welcher Dokumentabschnitt abgerufen wurde
• Sicherer Umgang mit privaten oder geschützten Informationen, ohne diese Informationen in das Modell einzubeziehen

Auf der anderen Seite wird RAG Folgendes nicht tun: Es wird das Verhalten, den Ton, den Argumentationsstil oder die Aufgabenleistung des Modells nicht ändern. Wenn Ihr Modell dazu neigt, ausführlicher zu sein, wird RAG es nicht prägnanter machen. Wenn Probleme mit einem bestimmten Ausgabeformat auftreten, kann RAG das Drawback nicht beheben.

Was ist Feinabstimmung und was bewirkt sie eigentlich?

Unter Feinabstimmung versteht man den Prozess, bei dem ein vorab trainiertes Modell mit einem neuen, aufgabenspezifischen Datensatz weiter trainiert und aktualisiert wird Gewichte dabei. Anders ausgedrückt: Während RAG die Eingaben des Modells ändert, verändert die Feinabstimmung das Modell selbst.

Genauer gesagt, ein Basismodell wie GPT-4o-mini wird anhand eines umfangreichen allgemeinen Datensatzes vorab trainiert. Bei der Feinabstimmung wird dieses Modell verwendet und eine zusätzliche, kürzere Trainingsschleife für bestimmte Beispiele ausgeführt, die für unseren spezifischen Anwendungsfall related sind. Diese Beispiele liegen typischerweise in Kind von Eingabe-Ausgabe-Paaren vor. Auf diese Weise werden die Gewichte des Modells angepasst, sodass Ausgaben erzeugt werden, die eher diesen Beispielpaaren ähneln.

So würde eine Feinabstimmungsaufgabe mithilfe der OpenAI-API aussehen:

from openai import OpenAI
import json

consumer = OpenAI(api_key="your_api_key")

# Step 1: put together coaching information as a JSONL file
# every instance is a dialog with a desired output
training_examples = (
    {
        "messages": (
            {"position": "system", "content material": "You're a concise technical assistant. All the time reply in a single sentence."},
            {"position": "consumer", "content material": "What's a vector database?"},
            {"position": "assistant", "content material": "A vector database shops and retrieves information as high-dimensional numerical vectors, enabling quick semantic similarity search."}
        )
    },
    {
        "messages": (
            {"position": "system", "content material": "You're a concise technical assistant. All the time reply in a single sentence."},
            {"position": "consumer", "content material": "What's chunking in RAG?"},
            {"position": "assistant", "content material": "Chunking is the method of splitting massive paperwork into smaller items earlier than embedding them, in order that they match inside mannequin context limits and enhance retrieval precision."}
        )
    },
    # in observe you'll need no less than 50-100 examples
)

# save as JSONL
with open("training_data.jsonl", "w") as f:
    for instance in training_examples:
        f.write(json.dumps(instance) + "n")

# add the coaching file
with open("training_data.jsonl", "rb") as f:
    training_file = consumer.recordsdata.create(file=f, function="fine-tune")

# create the fine-tuning job
fine_tune_job = consumer.fine_tuning.jobs.create(
    training_file=training_file.id,
    mannequin="gpt-4o-mini-2024-07-18"
)
print(fine_tune_job.id)

Sobald die Feinabstimmungsaufgabe abgeschlossen ist, gibt OpenAI eine eindeutige Modellkennung für Ihr neu optimiertes Modell im Format zurück ft:base-model:your-org:your-suffix:unique-id. Dies ist jetzt ein eigenständiges Modell, das getrennt von der Foundation in Ihrem OpenAI-Konto lebt gpt-4o-mini.

An printwir würden zurückkommen id Für dieses fein abgestimmte Modell sieht es etwa so aus:

ft:gpt-4o-mini-2024-07-18:your-org:your-suffix:abc123

Wir können es dann genau wie jedes andere Modell aufrufen, indem wir einfach diesen Bezeichner im übergeben mannequin Parameter:

# as soon as the job is full, use the fine-tuned mannequin
response = consumer.chat.completions.create(
    mannequin="ft:gpt-4o-mini-2024-07-18:your-org:your-suffix:abc123",
    messages=(
        {"position": "consumer", "content material": "What's immediate caching?"}
    )
)
print(response.decisions(0).message.content material)

Der Unterschied besteht darin, dass dieses Modell das Verhalten, auf das wir es trainiert haben, bereits verinnerlicht hat: In unserem Beispiel antwortet es nun konsistent in einem prägnanten Satz, ohne dass wir es bei jeder Systemaufforderung dazu anweisen müssen. Das sind die Dinge, in denen Feinabstimmung wirklich intestine ist: konsistente Formatierung, spezifischer Ton, Einhaltung einer bestimmten Ausgabestruktur oder verbesserte Leistung bei einem ganz bestimmten Aufgabentyp. Und das ist im Wesentlichen die Aufgabe der Feinabstimmung.

Beachten Sie, wie Die Feinabstimmung hat keinen Einfluss auf die Integration spezifischer Informationen in das Modell. Anders als man intuitiv annehmen könnte, führt die Feinabstimmung eines Modells anhand der Dokumente Ihres Unternehmens nicht dazu, dass das Modell diese Informationen „erlernt“ und Fragen dazu zuverlässig beantworten kann. Es kann tatsächlich dazu führen, dass sich das Modell hier und da bestimmte Fakten aus Trainingsbeispielen merkt, aber dieses Auswendiglernen ist brüchig und unzuverlässig. Das wahrscheinlichste Ergebnis wäre, dass ein Modell über Themen halluziniert, die in den Trainingsbeispielen auftauchen, und nicht, dass sich ein Modell genau an bestimmte Particulars erinnert, die in diesen Beispielen auftauchen. Wenn Sie additionally den Abruf von Wissen benötigen, ist RAG das richtige Werkzeug, nicht die Feinabstimmung.

Genauer gesagt funktioniert die Feinabstimmung bei Folgendem tatsächlich intestine:

• Dem Modell ein einheitliches Ausgabeformat, einen einheitlichen Ton oder einen einheitlichen Stil „beibringen“.
• Verbessern der Leistung bei einem bestimmten, engen Aufgabentyp (z. B. immer gültiges JSON generieren, immer in drei Aufzählungspunkten zusammenfassen usw.)
• Reduzierung des Bedarfs an langen, sich wiederholenden Systemaufforderungen durch die Integration dieser Anweisungen in das Modell
• Anpassung des Modells an domänenspezifische Sprache oder Terminologie, damit es das richtige Vokabular versteht und verwendet

Dennoch funktioniert die Feinabstimmung nicht so intestine in:

• Durch die Hinzufügung verlässlichen Faktenwissens kann sich das Modell genau erinnern
• Das Modell mit sich ändernden Informationen auf dem neuesten Stand halten
• Bereitstellung nachvollziehbarer, zitierfähiger Antworten

Wann verwenden wir additionally jedes und wann verwenden wir beide?

Nachdem wir nun verstanden haben, was jede Technik tatsächlich bewirkt, ist das „RAG vs. FeinabstimmungDie Antwort auf diese Frage wird viel einfacher, da es sich in den meisten Fällen überhaupt nicht um eine „gegen“-Frage handelt.

RAG und Feinabstimmung erfolgen auf verschiedenen Ebenen einer KI-Anwendung. RAG arbeitet auf der Wissensebene, d. h. es steuert, auf welche Informationen das Modell Zugriff hat. Auf der anderen Seite erfolgt die Feinabstimmung auf der Verhaltensebene, das heißt, sie definiert die Artwork und Weise, wie das Modell die bereitgestellten Informationen verarbeitet und Antworten generiert. Diese beiden Ebenen sind unabhängig voneinander, was bedeutet, dass Sie RAG, Feinabstimmung oder beides verwenden können, je nachdem, was Sie erreichen möchten.

Hier ist additionally ein praktischer Entscheidungsrahmen für die Entscheidung, was verwendet werden soll:

Das Szenario, in dem wir sowohl RAG als auch Feinabstimmung verwenden, ist in realen Produktionssystemen tatsächlich das häufigste. Der einfachste Weg, die beiden in Einklang zu bringen, ist dieser: Feinabstimmung des Verhaltens, Verwendung von RAG für Wissen.

Stellen Sie sich zum Beispiel vor, wir entwickeln einen Kundensupport-Assistenten für ein Softwareprodukt und benötigen ihn für Folgendes:

1. Antworten Sie immer in einem bestimmten Ton und Format, im Einklang mit unserer Softwaremarke
2. Verfügen Sie über genaue und aktuelle Kenntnisse der Dokumentation unseres Produkts

Für eine solche Aufgabe müssten wir sowohl RAG als auch Feinabstimmung nutzen. Eine Feinabstimmung würde insbesondere die erste Anforderung erfüllen, indem es dem Modell ermöglicht, aus Beispielen idealer Antworten des Kundensupports zu lernen und ihm den richtigen Ton, den richtigen Detaillierungsgrad und das richtige Ausgabeformat beizubringen. Die zweite Anforderung würde durch RAG abgedeckt: Zum Zeitpunkt der Inferenz werden die relevantesten Informationen aus der Produktdokumentation abgerufen und in die Eingabeaufforderung eingefügt, sodass das Modell zuverlässige Antworten liefern kann, die auf der Dokumentation basieren.

In der Praxis können wir additionally Feinabstimmung und RAG kombinieren, indem wir ein feinabgestimmtes Modell auf die gleiche Weise aufrufen, wie wir jedes andere Modell aufrufen würden, aber auch abgerufenen Kontext in die Systemeingabeaufforderung einfügen, genau wie wir es in einer Customary-RAG-Pipeline tun würden.

# combining fine-tuned mannequin with RAG
response = consumer.chat.completions.create(
    mannequin="ft:gpt-4o-mini-2024-07-18:your-org:support-style:abc123",  # fine-tuned for tone/format
    messages=(
        {
            "position": "system",
            "content material": f"You're a useful help assistant for pialgorithms. "
                       f"Use solely the next documentation to reply:nn{retrieved_context}"  # RAG context
        },
        {
            "position": "consumer",
            "content material": user_question
        }
    )
)

Durch die Feinabstimmung weiß das Modell, wie es angemessen reagieren soll, und RAG sagt ihm, was es sagen soll. Es handelt sich additionally nicht um die Frage „Feinabstimmung vs. RAG“, sondern vielmehr ergänzen sich Feinabstimmung und RAG und bewirken unterschiedliche Aufgaben.

In meinen Gedanken

Was ich an der Debatte zwischen RAG und Feinabstimmung am interessantesten finde, ist, wie oft sie als Frage formuliert wird, welche Technik besser ist, während die nützlichere Frage darin besteht, welches Drawback Sie eigentlich lösen möchten.

RAG und Feinabstimmung adressieren verschiedene Fehlermodi eines Foundation-LLM. Wenn ein Basismodell scheitert, weil es etwas nicht weiß, handelt es sich um ein Wissensproblem, und RAG löst es. Wenn ein Basismodell ausfällt, weil es sich inkonsistent verhält oder Ausgaben im falschen Format erzeugt, handelt es sich um ein Verhaltensproblem, das durch Feinabstimmung gelöst werden kann. Wenn Ihr Modell aus beiden Gründen gleichzeitig ausfällt, benötigen Sie möglicherweise tatsächlich beides.

Danke fürs Lesen!

Wenn du es bis hierher geschafft hast, Vielleicht finden Sie Pialgorithmen nützlich: eine von uns entwickelte Plattform, die Groups dabei hilft, organisatorisches Wissen sicher an einem Ort zu verwalten.

Hat Ihnen dieser Beitrag gefallen? Begleiten Sie mich auf Unterstapel und LinkedIn

Alle Bilder vom Autor, sofern nicht anders angegeben.

# Einführung

Stellen Sie sich vor, Sie melden sich für einen On-line-Kurs an, klicken sich durch 40 Folien, bestehen ein Quiz, das Sie gegoogelt haben, und erhalten ein Zertifikat. Hast du eigentlich etwas gelernt? Dies ist heute die Realität der meisten On-line-Lernplattformen. Sie verfolgen Klicks, nicht das Verständnis. Sie messen die Vollendung, nicht die Fähigkeit.

Die gute Nachricht? Künstliche Intelligenz hat es ermöglicht, Lernsysteme zu bauen, die sich tatsächlich an jede Individual anpassen. Systeme, die wissen, was Sie bereits verstehen, erkennen, wo Sie Schwierigkeiten haben, und führen Sie zur Meisterschaft und nicht nur zur Ziellinie.

In diesem Tutorial erfahren Sie, wie Sie ein KI-gestütztes Lernmanagementsystem (LMS) von Grund auf aufbauen. Wir verwenden kostenlose Open-Supply-Instruments – es sind keine teuren API-Abonnements erforderlich. Am Ende verfügen Sie über ein funktionierendes System mit vier intelligenten Funktionen:

• Ein Lernpfad, der sich an jeden Lernenden anpasst
• Quizze, die von KI frisch generiert werden
• Ein Reside-Chat-Lehrer, der von einem lokalen Sprachmodell unterstützt wird
• Ein Dashboard, das den tatsächlichen Fortschritt verfolgt

Sie können das gesamte Projekt-Repository klonen Hier und vergiss nicht, es zu geben Stern!

# Was ist ein KI-gestütztes LMS?

A Lernmanagementsystem (LMS) ist eine Software program, die Bildungsinhalte bereitstellt, verwaltet und verfolgt. Traditionelle Beispiele sind: Moodle, LeinwandUnd Tafel.

Ein KI-gestütztes LMS geht noch einen Schritt weiter. Anstatt jedem Lernenden die gleichen Inhalte in der gleichen Reihenfolge zu zeigen, nutzt es künstliche Intelligenz, um:

• Personalisieren Sie die Lernsequenz basierend auf dem, was ein Lernender bereits weiß
• Generieren Sie Bewertungen dynamisch, anstatt sie aus einer festen Fragendatenbank abzurufen
• Beantworten Sie Fragen in einfachem Englisch durch einen Konversationslehrer
• Analysieren Sie Leistungsdaten, um Schwachstellen zu erkennen und nächste Schritte vorzuschlagen

Betrachten Sie es als den Unterschied zwischen einem Lehrbuch und einem Privatlehrer. Das Lehrbuch vermittelt allen den gleichen Inhalt. Ein Tutor passt sich in Echtzeit an.

# Warum herkömmliche LMS-Plattformen zu kurz kommen

Bevor wir etwas Besseres entwickeln, ist es wichtig zu verstehen, warum bestehende Plattformen Probleme haben.

• Einheitliche Inhaltsbereitstellung: Die meisten LMS-Plattformen leiten jeden durch die gleichen Inhalte in der gleichen Reihenfolge. Ein leitender Entwickler, der einen Python-Anfängerkurs belegt, verschwendet Zeit mit Konzepten, die er bereits kennt. Ein kompletter Anfänger, der einen Fortgeschrittenenkurs belegt, ist sofort verloren.
• Statische Fragenbanken.
  Vorgefertigte Quizfragen werden innerhalb weniger Tage nach Kursstart on-line geteilt. Die Lernenden merken sich Antworten, anstatt Konzepte zu verstehen. Die Bewertung wird bedeutungslos.
• Kein Echtzeit-Help: Wenn ein Lernender um 23 Uhr nicht weiterkommt, gibt es keinen Lehrer, den er fragen könnte. Sie geben entweder auf oder machen weiter, ohne den Stoff zu verstehen, was später zu größeren Problemen führt.
• Vainness-Metriken über echtes Lernen: Die Abschlussquoten lassen sich leicht erhöhen. Fortschrittsbalken und Häkchen wirken zwar lohnend, messen aber nicht, ob tatsächlich Wissen übertragen wurde.

Das sind keine kleinen Probleme. Nach Recherchen des Forschungsinstitut von Amerikabehalten Lernende nur 8–10 % der Inhalte, die durch traditionelles E-Studying vermittelt werden. Mit aktiven, personalisierten Lernmethoden steigt diese Zahl auf 25–60 %. Unser KI-gestütztes LMS soll diese Lücke schließen.

# Der Tech-Stack, den wir verwenden

Wir haben dieses System vollständig mit Open-Supply-Instruments erstellt, was bedeutet, dass Sie es kostenlos auf Ihrem eigenen Laptop ausführen können.

// Warum Ollama?

Ollama ermöglicht Ihnen das Herunterladen und Ausführen von Open-Supply-Sprachmodellen direkt auf Ihrem Laptop. Sie benötigen kein Cloud-Konto, keinen API-Schlüssel und keine Nutzungsgebühren. Sie ziehen einfach ein Modell und rufen es über einen lokalen HTTP-Endpunkt auf. Es unterstützt Modelle wie Mistral, LLaMA 3Und Phi-3.

// Warum Mistral 7B?

Mistral 7B ist ein kleines, aber leistungsstarkes Modell, das auf den meisten modernen Laptops intestine läuft. Es befolgt Anweisungen genau, erzeugt eine saubere JSON-Ausgabe und verarbeitet Konversationsfragen und -antworten zuverlässig – genau das, was unsere vier Module benötigen.

// Warum FastAPI?

FastAPI ist ein modernes Python-Webframework, das auf Geschwindigkeit ausgelegt ist. Es unterstützt nativ asynchronen Code und WebSocketswas wichtig ist, um Reside-Antworten von Lehrern an den Browser zu streamen.

# Schritt 1: Adaptive Lernpfade

Das Downside, das es löst: Ein Anfänger und ein erfahrener Entwickler, die sich für denselben Python-Kurs anmelden, sollten nicht denselben Weg einschlagen. Das adaptive Lernmodul liest das Wissensprofil jedes Lernenden und erstellt eine personalisierte Sequenz.

// Wie es funktioniert

Wenn ein Lernender sein Lernziel eingibt, sendet das System eine Aufforderung an Mistral, die Folgendes enthält:

• Die Beherrschungsergebnisse des Lernenden professional Thema (gespeichert aus früheren Quizergebnissen)
• Eine Liste aller verfügbaren Kursmodule mit ihren Schwierigkeitsgraden
• Eine Reihe von Regeln: Beherrschte Themen überspringen, Schwachstellen priorisieren, Schwierigkeitsreihenfolge respektieren

Mistral antwortet mit einer geordneten Liste von Modul-IDs – dem benutzerdefinierten Pfad des Lernenden.

Vereinfachtes Beispiel aus primary.py:

immediate = f"""
You're a curriculum knowledgeable. Return a JSON array of node IDs
in one of the best studying order for this learner.

Objective: {req.aim}
Mastery scores: {profile("mastery")}
Accomplished modules: {profile("accomplished")}
Out there modules: {nodes_summary}

Guidelines:
- Skip accomplished modules
- Prioritise weak areas
- Order from simpler to more durable
- Return ONLY a JSON array, no rationalization.
"""

Der Pfad ist nicht festgelegt. Jedes Mal, wenn ein Lernender ein Quiz abschließt, werden seine Meisterschaftsergebnisse aktualisiert und der Pfad neu berechnet. Ein Lernender, der plötzlich gute Leistungen erbringt, erhält früher fortgeschrittenes Materials. Ein Lernender, der Schwierigkeiten hat, wird zu den grundlegenden Inhalten zurückgeführt.

// Was der Lernende sieht

Auf der Registerkarte „Lernpfad“ geben die Lernenden ihr Ziel ein (z. B. „Lernen Sie Python für Information Science“) und klicken Sie auf „Pfad generieren“. Innerhalb von Sekunden erscheint eine personalisierte Abfolge von Modulen mit jeweils eigenem Thema, Schwierigkeitsgrad und Schaltflächen, um direkt in ein Quiz oder den KI-Tutor einzusteigen.

# Schritt 2: KI-generierte Assessments und Bewertungen

Das Downside, das es löst: Statische Quizbanken veralten schnell. Die Lernenden geben Antworten weiter, merken sich diese, ohne sie zu verstehen, und bestehen trotzdem. KI-generierte Assessments sind jedes Mal anders, sodass es unmöglich ist, sich durchzumogeln, ohne tatsächlich etwas zu lernen.

// Wie es funktioniert

Wenn ein Lernender ein Quiz für ein Modul anfordert, ruft das Backend den Kursinhalt dieses Moduls ab und sendet ihn mit der strikten Anweisung, ein strukturiertes JSON-Quiz zurückzugeben, an Mistral.

Vereinfachtes Beispiel aus primary.py:

immediate = f"""
Primarily based on the next course content material, generate 3 multiple-choice questions.

Subject: {node("title")}
Content material: {node("content material")}

Return ONLY legitimate JSON on this format:
{{
  "questions": (
    {{
      "query": "...",
      "choices": ("A) ...", "B) ...", "C) ...", "D) ..."),
      "right": "A",
      "rationalization": "Brief motive why that is right."
    }}
  )
}}
"""

Bei jeder Quizanfrage werden neue Fragen aus dem eigentlichen Kursmaterial erstellt. Bei Wiederholungsversuchen erhalten die Lernenden unterschiedliche Fragen, was das Lernen durch unterschiedliche Exposition verstärkt.

// Bewerten und Suggestions geben

Nach der Einreichung gibt es für jede falsche Antwort eine Erklärung – nicht nur ein rotes ✗. Das ist wichtig. Forschung in Kognitionswissenschaft Es zeigt sich immer wieder, dass erläuterndes Suggestions zu einer tieferen Bindung führt als die bloße Markierung von Antworten als richtig oder falsch (Hattie & Timperley, 2007). Eine Punktzahl von 75 % oder mehr markiert das Modul als abgeschlossen und schaltet die nächsten Schritte im Lernpfad frei.

# Schritt 3: Der KI-Lehrer für natürliche Sprache

Das Downside, das es löst: Nicht weiterzukommen ist der häufigste Grund, warum Lernende On-line-Kurse abbrechen. Ohne jemanden, den man fragen kann, wird aus einem kleinen Second der Verwirrung eine Mauer. Der KI-Tutor beseitigt diese Mauer – er ist rund um die Uhr verfügbar, unendlich geduldig und immer auf dem Laufenden mit den tatsächlichen Kursinhalten.

// Wie es funktioniert

Der Tutor überfährt a WebSocket Verbindung – ein dauerhafter Zwei-Wege-Kanal zwischen dem Browser und dem Backend. Dadurch kann die Antwort der KI Wort für Wort an den Benutzer zurückgesendet werden, genau wie beim Tippen, anstatt den Lernenden darauf warten zu lassen, dass eine vollständige Antwort geladen wird.

Der Tutor verwendet eine Technik namens Retrieval-Augmented Era (RAG). Vor der Beantwortung werden die relevanten Kursinhalte als Kontext in die Eingabeaufforderung eingefügt. Dadurch basieren Mistrals Antworten auf tatsächlichem Kursmaterial und nicht auf Allgemeinwissen, wodurch das Risiko falscher oder irrelevanter Antworten verringert wird.

Vereinfachte Eingabeaufforderungsstruktur:

immediate = f"""
You're a concise, useful programming tutor.
Reply based mostly on the context beneath. If the reply will not be within the
context, say so and provides a normal reply.

Course Context: {node_content}

Earlier dialog:
{conversation_history}

Learner: {user_message}
Tutor:
"""

Der Gesprächsverlauf ist in jeder Nachricht enthalten, sodass sich der Tutor daran erinnert, was zuvor in derselben Sitzung gesagt wurde, sodass sich das Gespräch natürlicher und nicht eintönig anfühlt.

// Was der Lernende sieht

Auf der Registerkarte „AI Tutor“ sehen Lernende eine vertraute Chat-Oberfläche. Sie geben eine Frage ein, drücken die Eingabetaste und sehen sich den Antwortstrom Token für Token an. Wenn sie von einem bestimmten Modul aus navigieren, kennt der Tutor den Inhalt dieses Moduls bereits als Kontext.

# Schritt 4: Fortschrittsverfolgung und Analyse

Das Downside, das es löst: Die meisten Dashboards zeigen Ihnen einen Prozentbalken an, der sich füllt, wenn Sie durch den Inhalt klicken. Das ist kein Maßstab für Lernen; es ist ein Maß für das Klicken. Unser Dashboard verfolgt die Beherrschung nach Thema, basierend auf der tatsächlichen Quizleistung im Laufe der Zeit.

// Wie es funktioniert

Jede Quiz-Einreichung löst zwei Dinge aus:

1. Aktualisierung des Mastery-Scores mithilfe eines exponentiellen gleitenden Durchschnitts (EMA)

New mastery = 30% latest rating + 70% historic mastery
new_mastery = 0.3 * quiz_score + 0.7 * current_mastery

Der Exponentieller gleitender Durchschnitt gibt der jüngsten Leistung mehr Gewicht und berücksichtigt gleichzeitig die Geschichte. Ein Lernender, der ständig Probleme hatte, sich aber in letzter Zeit verbessert hat, wird feststellen, dass seine Meisterschaftspunktzahl steigt, aber nicht sofort nach einem einzigen guten Ergebnis ansteigt. Dies macht die Metrik ehrlich.

2. Fortschrittsereignis protokolliert

Jede Aktion – vom Starten eines Moduls bis zum Absenden eines Quiz, vom Bestehen oder Nichtbestehen – wird mit einem Zeitstempel protokolliert. Dadurch wird eine vollständige Aufzeichnung der Lernaktivitäten erstellt, die als Grundlage für das Dashboard dient.

// Was der Lernende sieht

Auf der Registerkarte „Dashboard“ wird Folgendes angezeigt:

• Module, die von der Gesamtzahl der verfügbaren Module abgeschlossen wurden
• Abschlussquote in Prozent
• Durchschnittliche Beherrschung aller untersuchten Themen
• Balken zur Themenbeherrschung – farbcodiert grün (stark), bernsteinfarben (entwickelnd) oder rot (schwach)
• Modulstatusraster: eine visuelle Übersicht darüber, welche Module abgeschlossen sind und welche noch übrig sind

Dadurch erhalten die Lernenden ein reales Bild davon, wo sie stehen, und nicht nur, wie weit sie gescrollt haben.

# Wie alle vier Module zusammenarbeiten

Jedes Modul ist für sich genommen nützlich, aber zusammen bilden sie eine kontinuierliche Feedbackschleife.

Die Feedbackschleife des Lernenden

Diese Schleife bedeutet, dass das System niemals statisch ist. Es reagiert auf die tatsächliche Leistung der einzelnen Personen und nicht nur darauf, ob sie geklickt hat.Nächste.“

Vollständige lokale Architektur – keine Cloud, keine API-Schlüssel

# Abschluss

Der Aufbau eines KI-gestützten LMS erfordert kein großes Finances oder ein Information-Science-Group. Mit Ollama, FastAPI und React können Sie ein System erstellen, das sich wirklich an die Lernenden anpasst – eines, das neue Bewertungen generiert, Fragen in Echtzeit beantwortet und die tatsächliche Beherrschung und nicht nur den Abschluss verfolgt.

Was diesen Ansatz leistungsstark macht, ist nicht eine einzelne Funktion. Es ist die Rückkopplungsschleife. Mit jedem eingereichten Quiz, jeder gestellten Frage und jedem abgeschlossenen Modul wird das System für jeden Lernenden intelligenter.

Herkömmliche LMS-Plattformen verfolgen Klicks. Dieser verfolgt das Lernen.

Das vollständige Projekt – einschließlich aller Backend-Routen, React-Komponenten und Einrichtungsanweisungen – ist unter verfügbar GitHub. Klonen Sie es und lesen Sie die README-Datei, um es lokal auszuführen.

Shittu Olumide ist ein Software program-Ingenieur und technischer Autor, der sich leidenschaftlich dafür einsetzt, modernste Technologien zu nutzen, um fesselnde Erzählungen zu erschaffen, mit einem scharfen Blick fürs Element und einem Gespür für die Vereinfachung komplexer Konzepte. Sie können Shittu auch auf finden Twitter.

Seit mehr als einem Jahrzehnt unterliegt das Web einer stillen Einschränkung: der Erschöpfung der IPv4-Adressen.

IPv4 struggle in den meisten Regionen seit Anfang der 2010er Jahre offiziell aufgebraucht und sollte durch IPv6 als nächsten Commonplace für die Internetadressierung ersetzt werden. Doch trotz der Dringlichkeit und der klaren technischen Vorteile von IPv6 verlief die Einführung weitaus langsamer und ungleichmäßiger als von vielen vorhergesagt.

Die Realität ist, dass IPv4 nicht verschwunden ist. Es ist immer noch tief in der Infrastruktur des Internets verankert, und der Übergang zu IPv6 erweist sich weniger als ein sauberer Wechsel als vielmehr als eine langwierige, komplexe Entwicklung.

IPv4 ist erschöpft, aber nicht veraltet

IPv4 verwendet einen 32-Bit-Adressraum, der etwa 4,3 Milliarden eindeutige Adressen ermöglicht. Mit dem rasanten Wachstum von mit dem Web verbundenen Geräten, Cloud-Diensten und globaler Konnektivität ist dieser Pool praktisch erschöpft. Regional Web Registries (RIRs) haben ihre letzten Blöcke längst zugeteilt.

Erschöpfung bedeutet jedoch nicht Verschwinden. IPv4-Adressen werden immer noch aktiv genutzt, gehandelt und zweckentfremdet. Es ist ein Sekundärmarkt entstanden, auf dem Unternehmen IPv4-Adressblöcke kaufen und verkaufen, manchmal zu erheblichen Kosten. Dies allein zeigt, wie abhängig das moderne Web immer noch von einem Protokoll ist, das in einer ganz anderen Zeit entwickelt wurde.

Anstatt IPv4 komplett zu ersetzen, hat die Branche Wege gefunden, seine Lebensdauer zu verlängern.

Der Aufstieg von Workarounds: CGNAT und Adressfreigabe

Eine der am häufigsten von Internetdienstanbietern (ISPs) verwendeten Strategien ist Provider-Grade NAT (CGNAT). Dieser Ansatz ermöglicht mehreren Benutzern die gemeinsame Nutzung einer einzigen öffentlichen IPv4-Adresse, wodurch die Nutzbarkeit des verbleibenden Adressraums effektiv vervielfacht wird.

Während CGNAT das unmittelbare Downside der Adressknappheit löst, führt es zu Kompromissen. Dies kann Peer-to-Peer-Verbindungen erschweren, sich auf latenzempfindliche Anwendungen auswirken und die Möglichkeiten für Benutzer einschränken, Dienste zu hosten oder auf bestimmte Ports zuzugreifen. Aus Daten- und Infrastruktursicht erhöht es die Komplexität des Netzwerkmanagements und der Fehlerbehebung um eine weitere Ebene.

Noch wichtiger ist, dass CGNAT eine Problemumgehung und keine langfristige Lösung ist.

IPv6: Der technisch überlegene Nachfolger

IPv6 wurde entwickelt, um die Einschränkungen von IPv4 durch die Einführung eines 128-Bit-Adressraums zu lösen. Dies ermöglicht eine nahezu unvorstellbar große Anzahl eindeutiger Adressen, die ausreichen, um die weitere Growth des Internets in den kommenden Jahrzehnten zu unterstützen.

Über die Adresskapazität hinaus bietet IPv6 mehrere technische Verbesserungen, darunter effizienteres Routing, vereinfachte Paketheader und integrierte Unterstützung für moderne Netzwerkanforderungen. Theoretisch sollte der Übergang eine naheliegende Wahl sein.

In der Praxis ist es nicht so einfach.

Die Akzeptanz ist ungleichmäßig und fragmentiert

Die weltweite Verbreitung von IPv6 hat stetig zugenommen, die Verteilung ist jedoch sehr ungleichmäßig. Einige Länder und Netzwerke haben IPv6 in großem Umfang eingeführt, während andere weiterhin stark auf IPv4 angewiesen sind.

Große Technologieunternehmen und Inhaltsanbieter haben IPv6 weitgehend auf ihren Plattformen aktiviert. Die wichtigsten Betriebssysteme und Geräte unterstützen es standardmäßig. Doch der Engpass liegt oft woanders im Ökosystem.

Tomas Novosad, Gründer von Glasfaser an meiner Adressestellt fest, dass die IPv6-Unterstützung zwar zunimmt, viele ISPs jedoch aufgrund veralteter Infrastruktur und Einschränkungen der Kundenausrüstung immer noch Twin-Stack- oder sogar IPv4-lastige Netzwerke betreiben.

Dieser Twin-Stack-Ansatz, bei dem Netzwerke gleichzeitig IPv4 und IPv6 ausführen, hat sich zur vorherrschenden Übergangsstrategie entwickelt. Es ermöglicht die Kompatibilität mit bestehenden Systemen bei gleichzeitiger schrittweiser Einführung von IPv6. Allerdings verlangsamt es auch die vollständige Migration, da IPv4 für einen erheblichen Teil des Datenverkehrs weiterhin erforderlich ist.

Warum ISPs der Flaschenhals sind

Die Rolle der ISPs beim Übergang zu IPv6 kann nicht genug betont werden. Während die Aktivierung von IPv6 auf Netzwerkebene technisch machbar ist, ist die Bereitstellung in großem Maßstab mit erheblichen betrieblichen und finanziellen Herausforderungen verbunden.

Erstens gibt es die Frage der Infrastruktur. Viele ISP-Netzwerke wurden rund um IPv4 aufgebaut und optimiert. Die Aktualisierung von Kernsystemen, Bereitstellungstools und Überwachungsplattformen zur vollständigen Unterstützung von IPv6 erfordert Zeit und Investitionen.

Zweitens gibt es die Ebene der Kundenausrüstung. Millionen von Routern, Modems und eingebetteten Geräten in Haushalten und Unternehmen unterstützen IPv6 möglicherweise nicht vollständig oder erfordern möglicherweise Firmware-Updates. Die Koordinierung von Upgrades in einer solchen verteilten Umgebung ist keine triviale Aufgabe.

Drittens mangelt es an unmittelbaren wirtschaftlichen Anreizen. IPv4 funktioniert trotz seiner Einschränkungen immer noch. Durch Techniken wie CGNAT und Adresshandel können ISPs ihren Betrieb ohne dringenden Migrationsdruck fortsetzen. Infolgedessen wird die Einführung von IPv6 oft zu einer schrittweisen Initiative mit geringer Priorität und nicht zu einer strategischen Überarbeitung.

Die Datenperspektive: Ein langer Übergang liegt vor uns

Aus Datensicht ist der Übergang zu IPv6 kein binäres Ereignis, sondern ein langfristiger Development. Metriken verschiedener Netzwerkmessplattformen zeigen ein stetiges Wachstum des IPv6-Verkehrs, bestätigen aber auch die Beständigkeit von IPv4.

Diese Koexistenz führt zu Komplexität bei der Datenanalyse, Netzwerkoptimierung und Leistungsmessung. Systeme müssen Unterschiede in Routing, Latenz und Konnektivität zwischen den Systemen berücksichtigen zwei Protokolle. Für Unternehmen, die auf genaue Netzwerkdaten angewiesen sind, wird das Verständnis dieser dualen Umgebung immer wichtiger.

Abschluss

Die Geschichte der IPv6-Einführung ist keine Geschichte des Scheiterns, sondern einer schrittweisen Entwicklung, die durch die reale Infrastruktur eingeschränkt wird. IPv4 magazine ausgeschöpft sein, aber es bleibt ein grundlegender Bestandteil des Internets. IPv6 ist die Zukunft, aber diese Zukunft kommt langsam und ungleichmäßig.

Im Second läuft das Web auf beiden. Und bis die wirtschaftlichen, technischen und betrieblichen Hindernisse vollständig beseitigt sind, wird diese duale Realität wahrscheinlich viel länger anhalten als ursprünglich erwartet.

Während öffentliche Debatten über Kinder und Technologie oft zwischen Alarm und Akzeptanz schwanken, ist die Realität in den Häusern vieler Technologieführer maßvoller. Die Menschen, die Plattformen, Geräte und KI-Systeme bauen, entfernen die Technologie nicht aus dem Leben ihrer Kinder. Sie bestimmen, wie und wann es eintritt und, was noch wichtiger ist, welche Rolle es spielt.

Der rote Faden ist kein striktes Verbot. Es handelt sich um eine kontrollierte Belichtung. Viele Führungskräfte verzögern den Zugang zu Smartphones und sozialen Medien, nicht weil sie die Technologie ablehnen, sondern weil sie erkennen, dass sie Auswirkungen auf die Entwicklung von Gewohnheiten hat. Ein früher Zugang wird als Risikomultiplikator angesehen, insbesondere in Kombination mit Systemen, die auf kontinuierliches Engagement ausgelegt sind. Beim Warten geht es nicht um Einschränkung. Es geht um das Timing.

Entsprechend Geschäftsinsiderdas denken Technologieführer:

• Peter Thiel, Mitbegründer von PayPal, und Evan Spiegel, CEO von Snapchat, beschränken die Bildschirmzeit ihrer kleinen Kinder auf 1,5 Stunden professional Woche.
• Meta-Gründer Mark Zuckerberg betont die Bildschirmnutzung zur Kommunikation gegenüber dem passiven Konsum.
• Kate Doerksen, Mitbegründerin und CEO von Sage Haven, legt für ihre Kinder eine Stunde tägliche Bildschirmzeit auf Geräten wie iPads oder Nintendo Change fest. Sie nannte eine Präferenz für „average Nutzung von nicht süchtig machenden Apps und Spielen mit Grenzen“.
• Niyoka McCoy, Chief Studying Officer bei Stride, betrachtet Technologie in erster Linie als Lern- und Kreativwerkzeug. Sie erklärte: „Wenn Kinder zu viel Zeit damit verbringen, zu scrollen oder zuzuschauen, anstatt etwas Sinnvolles zu erschaffen, zu lernen oder aufzubauen, dann ist die Technologie nicht mehr nützlich.“
• Hari Ravichandran, Gründer und CEO von Aura, entfernte das Smartphone seiner Tochter im Alter von 13 Jahren und plant, den Zugriff für seine jüngeren Kinder auf das Alter von 15 oder 16 Jahren zu verschieben. Er konzentriert sich auf die Auswirkungen der Technologie auf Stimmung, Schlaf und Selbstwertgefühl, nicht nur auf die Zeit vor dem Bildschirm.
• Tim Sheehan, Mitbegründer und CEO von Greenlight, erlaubte seinen Kindern mit 12 Jahren Smartphones und mit 15 Jahren soziale Medien. Er sagte, sein Ziel sei es, „sicherzustellen, dass die äußeren Einflüsse in ihrem Leben die Werte unterstützen, die wir ihnen vermitteln wollen“.
• Justice Eroline, CTO bei BairesDev, erzwingt eine Bildschirmzeitbegrenzung von einer Stunde und schränkt kurze Inhalte aufgrund ihrer möglichen Auswirkungen auf die Aufmerksamkeitsspanne ein. Er wies auch auf die Vorteile von Videospielen bei der Vermittlung von Teamarbeit und Problemlösung hin.
• Ahu Chhapgar, CTO bei Paysafe, äußerte sich besorgt über kurze Videoinhalte, die seiner Meinung nach einen „tranceähnlichen“ Zustand hervorrufen könnten. Er ermutigt seine Kinder, ChatGPT täglich 20 Minuten lang zu nutzen, und sagt: „Mir wäre es lieber, wenn sie verantwortungsbewusst erkunden, bauen und experimentieren.“
• Nik Kale, Chefingenieur bei Cisco Methods, vermeidet die Verwendung von Bildschirmen, um seinen Dreijährigen zu trösten. Er gewährleistet auch die menschliche Kontrolle bei der Inhaltsauswahl und sagt: „Ich lasse nicht zu, dass automatisierte Systeme in meinen Produktionsumgebungen bei der Arbeit unbeaufsichtigte Entscheidungen treffen.“

Die meisten betrachten die Bildschirmzeit nicht als einfaches numerisches Downside. Der Fokus verlagert sich von der Dauer auf die Qualität. Passiver Konsum, insbesondere Kurzvideos, wird als Hauptanliegen angesehen. Es fragmentiert die Aufmerksamkeit und verringert den Anreiz zum Denken oder Schaffen. Im Gegensatz dazu sind Aktivitäten, die Interaktion, Problemlösung oder Lernen beinhalten, nicht nur erlaubt, sondern werden sogar gefördert.

Dadurch entsteht eine klarere Hierarchie. Zuschauen ist die Nutzung mit dem geringsten Wert. Schaffen, Bauen und Kommunizieren stehen an der Spitze. Die Unterscheidung ist wichtig, weil sie die Artwork und Weise verändert, wie Kinder mit Technologie umgehen. Anstatt in endlose Inhaltsströme hineingezogen zu werden, werden sie dazu gedrängt, Instruments gezielt einzusetzen.

Ein weiteres durchgängiges Muster ist die Betonung des Wohlbefindens gegenüber starren Regeln. Einige Führungskräfte haben die strengen Grenzwerte aufgegeben, nachdem sie gesehen hatten, wie Geräte die Stimmung, den Schlaf und die Selbstwahrnehmung beeinflussten. Die Reaktion bestand nicht in völliger Entfernung, sondern in einer stärkeren Sensibilisierung. Gespräche, Überwachung und gemeinsames Verständnis ersetzen pauschale Einschränkungen. Das Ziel besteht darin, Urteilsvermögen aufzubauen und nicht nur die Einhaltung von Vorschriften durchzusetzen.

Es gibt auch einen Wandel in der Artwork und Weise, wie Autorität ausgeübt wird. Eltern sind immer weniger bereit, die Kontrolle an Algorithmen zu delegieren. Empfehlungssysteme, Autoplay-Funktionen und unendliche Feeds werden mit Skepsis betrachtet. In vielen Fällen wählen Eltern die Inhalte selbst aus oder begrenzen den Kontakt mit Systemen, die ohne Aufsicht funktionieren. Die Kontrolle über die Eingabe wird als wichtiger angesehen als das Zählen der Minuten.

Interessanterweise werden bestimmte Technologien unterschiedlich behandelt. Gaming wird beispielsweise oft als akzeptabel oder sogar vorteilhaft angesehen, wenn es um Strategie, Teamarbeit und Ausdauer geht. KI-Instruments kommen ebenfalls früh zum Einsatz, allerdings auf geführte Weise. Manche Eltern ermutigen aktiv zum Experimentieren, nicht zum Konsum. Die Logik ist direkt. Wenn Kinder in einer von KI geprägten Welt aufwachsen, sollten sie verstehen, wie man sie nutzt, und nicht nur, sie zu absorbieren.

Es entsteht kein Widerspruch, sondern ein Rahmen. Technologie ist weder von Natur aus schädlich noch von Natur aus nützlich. Seine Wirkung hängt vom Kontext, dem Zeitpunkt und der Absicht ab. Führungskräfte in diesem Bereich wenden die gleiche Denkweise wie beim Produktdesign auf ihre eigenen Familien an. Reduzieren Sie schädliche Muster, stärken Sie nützliche Muster und bleiben Sie in die Artwork und Weise eingebunden, wie Systeme genutzt werden.

Im weiteren Sinne geht es weniger um spezifische Regeln als vielmehr um die Orientierung. Auf Angst basierende Ansätze tendieren dazu, das Downside zu stark zu vereinfachen. Uneingeschränkter Zugriff ignoriert es. Der Mittelweg erfordert mehr Aufwand, spiegelt aber wider, wie Technologie im täglichen Leben tatsächlich funktioniert.

Hervorgehobener Bildnachweis

Aktie

Publish


Aktie

In diesem Artikel erfahren Sie, wie Sie die KI-gestützten Codierungsfunktionen von Google Colab – insbesondere KI-Eingabeaufforderungszellen – verwenden, um Python-Code direkt in der Pocket book-Umgebung zu generieren, zu erklären und zu verfeinern.

Zu den Themen, die wir behandeln werden, gehören:

• Wie KI-Eingabezellen in Colab funktionieren und wo man sie findet
• Ein praktischer Workflow zum Generieren von Code und dessen sicherer Ausführung in ausführbaren Codezellen
• Wichtige Einschränkungen, die Sie beachten sollten und wann Sie stattdessen das „Zauberstab“-Gemini-Panel verwenden sollten

Lasst uns weitermachen.

Einrichten einer KI-gestützten Codierungsumgebung von Google Colab, die tatsächlich funktioniert
Bild vom Herausgeber

Einführung

Dieser Artikel konzentriert sich auf Google Colabeine zunehmend beliebte, kostenlose und zugängliche, cloudbasierte Python-Umgebung, die sich intestine für die Prototypenerstellung von Datenanalyse-Workflows und experimentellem Code vor der Umstellung auf Produktionssysteme eignet.

Basierend auf der zum Zeitpunkt des Verfassens dieses Artikels neuesten frei verfügbaren Model von Google Colab verwenden wir einen Schritt-für-Schritt-Anleitungsstil, um zu untersuchen, wie die kürzlich eingeführten KI-gestützten Codierungsfunktionen effektiv genutzt werden können. Ja: Colab enthält jetzt Instruments für KI-gestütztes Codieren, wie z. B. Codegenerierung aus natürlicher Sprache, Erklärungen zu geschriebenem Code, automatische Vervollständigung und intelligente Fehlerbehebung.

Ein Blick auf die KI-gestützten Fähigkeiten von Colab

Zuerst melden wir uns an Google Colab mit einem Google-Konto unserer Wahl und klicken Sie auf „Neues Notizbuch“, um einen neuen Codierungsarbeitsbereich zu starten. Die gute Nachricht: All dies geschieht in der Cloud und Sie benötigen lediglich einen Webbrowser (idealerweise Chrome); Es muss nichts lokal installiert werden.

Hier ist die große Neuheit: Wenn Sie mit Colab vertraut sind, kennen Sie die beiden grundlegenden Zelltypen: Codezellen zum Schreiben und Ausführen von Code; und Textzellen, um Ihren Code mit Beschreibungen, Erklärungen und sogar eingebetteten Bildern zu ergänzen, um zu erklären, was in Ihrem Code vor sich geht. Nun gibt es noch einen dritten Zelltyp, der auf den ersten Blick nicht eindeutig zu erkennen ist: Sein Title ist KI-Eingabeaufforderungszelle.

Hierbei handelt es sich um einen brandneuen, speziellen Zelltyp, der die direkte One-Shot-Interaktion mit Googles leistungsstärksten generativen KI-Modellen aus der Gemini-Familie unterstützt und besonders hilfreich für Personen mit begrenzten Programmierkenntnissen ist.

Das Erstellen einer AI-Eingabeaufforderungszelle ist einfach: Klicken Sie in der oberen Symbolleiste direkt unter den Menüs auf den kleinen Dropdown-Pfeil neben „Code“ und wählen Sie „AI-Eingabeaufforderungszelle hinzufügen“. So etwas sollte in Ihrem noch leeren Notizbuch erscheinen.

Erstellen einer KI-Eingabeaufforderungszelle, um Code aus natürlicher Sprache zu generieren

Probieren wir es aus, indem wir Folgendes in das Textfeld „Fragen Sie mich etwas…“ schreiben: Schreiben Sie Python-Code, der 100 Werte für fünf verschiedene Arten von Wettervorhersagewerten generiert und ein Histogramm dieser Werte zeichnet

Seien Sie ein paar Sekunden geduldig, auch wenn es zunächst so aussieht, als würde nichts passieren. Die KI arbeitet hinter den Kulissen an Ihrer Anfrage. Möglicherweise erhalten Sie vom ausgewählten Gemini-Modell eine Antwort, die wie folgt aussieht:

Nutzen Sie die Vorteile von KI-Eingabeaufforderungszellen und ausführbaren Codezellen

Diese neue Funktion sorgt für ein komfortables KI-gestützte Codierung Umgebung, die nicht nur very best ist zur Codegenerierungsondern auch für schnelles Prototyping, Erforschung neuer Ideenoder sogar Vorhandenen Code selbsterklärender machenB. durch die Aufforderung an die KI, erklärbare Funktionen oder informative Druckanweisungen in relevante Teile eines Programms einzufügen. Das Verständnis der Fähigkeiten dieses neuen Zelltyps ist der Schlüssel zur korrekten Nutzung der neuesten KI-gestützten Codierungsfunktionen von Colab.

Eine Standardcodezelle direkt unter jeder Ihrer KI-Eingabeaufforderungszellen sorgt für eine praktische Symbiose. Warum? Denn die Ausgabe von KI-Eingabeaufforderungszellen ist kein direkt ausführbarer Code, da sie oft mit Textbeschreibungen vor und/oder nach dem Code versehen ist. Kopieren Sie einfach den Codeteil der Antwort und fügen Sie ihn in eine Codezelle unten ein, um es auszuprobieren.

Nicht alles funktioniert wie erwartet? Kein Downside. Der Die KI-Eingabeaufforderungszelle bleibt dortan seinem dafür vorgesehenen Platz in Ihrem Notizbuch, additionally Sie können die Interaktion fortsetzen und Ihren Code verfeinern, bis er Ihren Anforderungen vollständig entspricht.

Beachten Sie jedoch einige Einschränkungen dieses neu eingeführten Zelltyps. Unabhängig davon, wo sich in Ihrem Notizbuch eine KI-Eingabeaufforderungszelle befindet, erkennt sie nicht automatisch den Inhalt im Relaxation Ihres Notizbuchs. Sie müssen Ihren Code einer KI-Eingabeaufforderungszelle zur Verfügung stellen, um etwas dazu zu erfragen.

Stellen Sie sich zum Beispiel vor, wir platzieren den zuvor generierten Code in mehreren Codezellen, um ihn Schritt für Schritt auszuführen. Dann fügen wir am unteren Rand des Notizbuchs eine weitere AI-Eingabeaufforderungszelle hinzu und fragen Folgendes:

KI-Antwort, wenn nach Code außerhalb der KI-Eingabeaufforderungszelle gefragt wird

Beachten Sie die Antwort: Die KI fordert Sie dazu auf, den Code, den Sie analysieren, erklären usw. analysieren, explizit einfügen (einfügen) zu müssen, unabhängig davon, wo dieser Code im Pocket book vorhanden ist. Sie können Zellen auch nicht mit Bezeichnern wie #7 oder #16 referenzieren oder etwas fragen wie „Schreiben Sie die dritte Codezelle in einem prägnanteren Python-Stil um„.

Hier ist eine Zusammenfassung des Greatest-Apply-Workflows, mit dem wir uns vertraut machen sollten:

1. Fügen Sie KI-Eingabeaufforderungszellen direkt nach einer Zelle (oder einer kleinen Gruppe von Zellen) hinzu, wenn Sie viel Analyse, Verfeinerung und mögliche Änderungen im Code erwarten.
2. Fügen Sie den Zielcode ein und verwenden Sie explizite Anweisungen mit Aktionsverben wie „erklären“, „umgestalten“, „vereinfachen“, „Fehlerbehandlung hinzufügen“ usw.
3. Überprüfen Sie die Ergebnisse und führen Sie sie manuell in einer Backup-Codezelle aus, die je nach Datentransformations-Workflow sorgfältig platziert wird (möglicherweise muss sie vor oder nach der Zelle mit dem Originalcode platziert werden).

KI-Eingabezellen eignen sich hervorragend für komfortable Code-Erstellungsexperimente auf dem Hauptspielplatzaber denken Sie daran für andere KI-unterstützte Aufgaben wie das Erklären eines Codeabschnitts in einer Zelle oder dessen Transformation das Zauberstab-Image in einer Codezelle verfügbar – die auf der rechten Seite von Colab eine Gemini-Registerkarte für die weitere Interaktion öffnet – ist immer noch der beste und flexibelste Ansatz.

Zusammenfassung

Google Colab veröffentlicht kontinuierlich neue KI-gestützte Codierungsfunktionen mit klaren Stärken, aber auch wichtigen Einschränkungen. In diesem Artikel haben wir die neuesten Funktionen besprochen, mit besonderem Fokus auf die KI-Eingabeaufforderungszelle als eine der neuesten Ergänzungen, und wir haben beschrieben, wie man sie am besten nutzt – und wann man für Aufgaben wie das Erklären oder Refactoring von vorhandenem Code auf andere Funktionen zurückgreifen sollte.

Aktie

Publish


Aktie

Die meisten KI-Programme versagen im Labor nicht. Sie scheitern bei der Übergabe: in dem Second, in dem ein vielversprechendes Pilotprojekt auf Beschaffung, Legacy-Integration, Audit-Anforderungen und die Realität der Überwachung und Verantwortung am zweiten Tag trifft. Der schnellste Weg, „vom Pilotprojekt zur Produktion“ zu gelangen, besteht darin, die Skalierung als Downside des Geschäftssystemdesigns und nicht als Modellauswahlproblem zu behandeln. Die Initiative wird daher mit einem Betriebsmodell, einem Beweispfad und Risikokontrollen ausgeliefert, die die Umsetzung nicht behindern.

Strategie vor Stack: Finanzierung von „Modellen“ stoppen, Finanzierungsfähigkeit starten

In den meisten Organisationen wird der Begriff „KI-Strategie“ oft auf eine Liste von Anwendungsfällen reduziert. Das hört sich umsetzbar an, verwandelt das Portfolio aber in der Regel in einen Friedhof von Pilotprojekten: isolierte Konzeptnachweise, die echten Einschränkungen (Datenrechte, Latenz, Kontrollen, Änderungsmanagement) nicht standhalten können, sobald der Demo-Glanz verblasst. Eine effektivere Strategie beschreibt, wie das Unternehmen KI nutzen will und welche Arten von KI es zu implementieren bereit ist – denn Autonomie, Lerndynamik und eingeschränkte Interpretierbarkeit verändern den strategischen Designraum im Vergleich zu früheren IT-Wellen.

Hofmann und Kollegen stellen die KI-Strategie als Taxonomie und nicht als Slogan dar, was Führungskräften hilft, eine häufige Falle zu vermeiden: den Versuch, alles mit den gleichen Betriebsannahmen zu skalieren. Sobald Sie akzeptieren, dass sich Strategien bündeln (z. B. effizienzorientierte Automatisierung vs. Erweiterung vs. neue KI-native Angebote), wird es einfacher, jedem Stream die richtigen Erfolgskriterien, Governance-Aufwand und technische Architektur zuzuweisen – insbesondere in regulierten Umgebungen, in denen die „billigste“ Architektur die teuerste sein kann, sobald Kontrollen, Nachweise und Abhilfemaßnahmen eingepreist sind.

Wert bedeutet nicht „späterer ROI“: Wert ist ein Mechanismus, den Sie entwerfen können

Wenn der ROI als zukünftiges Ergebnis betrachtet wird, optimieren die Groups die kurzfristige Modellleistung in der Hoffnung, dass sich im weiteren Verlauf ein Geschäftswert ergibt. Forschung Der Geschäftswert von KI legt nahe, dass Wert durch Mechanismen wie die Neugestaltung von Prozessen, ergänzende Vermögenswerte und organisatorische Fähigkeiten entsteht – und nicht durch isolierte Algorithmen.

Diese Unterscheidung ist wichtig, wenn Sie skalieren. Ein Pilot kann mit heldenhaftem Einsatz, maßgeschneiderten Datenabrufen und informellen Genehmigungen erfolgreich sein. Die Produktion erfordert wiederholbare Mechanismen, einschließlich stabiler Datenversorgung, Eigentums- und Entscheidungsrechte. Ohne diese entsteht ein teures Paradoxon – hohe KI-Aktivität mit geringen geschäftlichen Auswirkungen.

Können schlägt Brillanz: Was Interviews zum Thema KI-Implementierung immer wieder verraten.

Weber und Co-Autoren untersuchten die KI-Implementierung durch Experteninterviews und destillierten vier organisatorische Fähigkeiten heraus, die skalierbare Programme immer wieder von ständigem Experimentieren trennen: strukturierte KI-Projektplanung, gemeinsame Entwicklung mit Stakeholdern, Datenmanagement und Lebenszyklusmanagement für Modelle, die sich weiterentwickeln müssen, wenn sich Daten und Umgebungen ändern.

Beachten Sie, was fehlt: „Stellen Sie bessere Datenwissenschaftler ein.“ Fähigkeiten sind wichtig, doch die Skalierung bricht häufiger zusammen, weil die Organisation die Arbeit unter Unsicherheit (Unergründlichkeit) nicht planen kann, keine stabilen, vertrauenswürdigen Daten aufrechterhalten kann und den Lebenszyklus nicht aufrechterhalten kann, sobald Modelle in Produktion gehen. In regulierten Branchen wird dies noch gravierender: Dieselben Fähigkeitslücken führen nicht nur zu Lieferrisiken, sondern auch zu Compliance-Gefährdungen, da die Organisation Herkunft, Kontrollen und betriebliche Entscheidungen nicht zuverlässig erklären kann.

In Abbildung 1 geht es nicht darum, Aufgaben aufzuzählen. Es soll gezeigt werden, dass die Skalierung an vorhersehbaren Haltepunkten scheitert und jeder Haltepunkt ein Fähigkeitsproblem und kein algorithmisches Downside darstellt.

MLOps ist der Produktionsvertrag, keine Toolchain

Das MLOps-Label wird oft als Tooling verkauft. In der Praxis handelt es sich um einen Vertrag zwischen Groups: Was wird versioniert, validiert, bereitgestellt, überwacht und zurückgesetzt – und wem gehört jeder Schritt, wenn sich etwas ändert? Kreuzberger, Kühl und Hirschl Stellen Sie MLOps als ganzheitliche Praxis mit Prinzipien, Rollen und Architektur dar, gerade weil es vielen ML-Bemühungen nicht gelingt, den Weg von der Entwicklung bis zum zuverlässigen Betrieb zu operationalisieren und zu automatisieren.

John, Holmström Olsson und Bosch Gehen Sie noch einen Schritt weiter, indem Sie die MLOps-Einführung an bestimmte Aktivitäten und Reifestadien knüpfen und argumentieren, dass sich Organisationen von der Advert-hoc-Modellbereitstellung hin zu einer strukturierten, kontinuierlichen Entwicklung entwickeln, die durch explizite Praktiken und Governance unterstützt wird. Ihre Arbeit ist für Führungskräfte hilfreich, weil sie die unbequeme Wahrheit legitimiert: Man kann Reife nicht „kaufen“. Sie bauen es durch wiederholbare Arbeit und institutionelles Lernen auf.

Eine aktuelle systematische Übersicht von Zarour und Kollegen fassen wiederkehrende Herausforderungen und Reifemodelle in der gesamten MLOps-Literatur zusammen und stellen fest, dass die Reibungspunkte konsistent sind: Mangel an standardisierten Praktiken, Schwierigkeiten bei der Aufrechterhaltung der Konsistenz im Maßstab und Unklarheit bei der Beurteilung der Reife. Für Führungskräfte: Wenn Ihr Unternehmen seine MLOps-Reife nicht in operativen Begriffen beschreiben kann, ist es unwahrscheinlich, dass es KI vorhersehbar skalieren wird – egal, wie viele Plattformen es lizenziert.

Governance, die den Durchsatz ermöglicht: Risikokontrollen, die auf Liefergeschwindigkeit ausgelegt sind

In regulierten Sektoren wird die Governance regelmäßig für die langsame Umsetzung verantwortlich gemacht. Das tiefere Downside ist das Design: Governance, die zu spät kommt, verhält sich wie eine Bremse; Die in den Lebenszyklus integrierte Governance verhält sich wie ein Steuerungssystem. Das NIST AI Danger Administration Framework strukturiert die Risikomanagementarbeit in den Bereichen Governance, Kontextzuordnung, Messung und fortlaufendes Administration und verankert ausdrücklich die Verantwortlichkeit bei der Geschäftsleitung und den Entscheidungsträgern der Organisation.

Papagiannidis, Mikalef und Conboy Synthetisieren Sie verantwortungsvolle KI-Governance als eine Reihe struktureller, relationaler und prozeduraler Praktiken und bewegen Sie die Diskussion über abstrakte Prinzipien hinaus hin zur Operationalisierung über den gesamten KI-Lebenszyklus hinweg. Dieser Rahmen ist konstruktiv, wenn Sie unter Einschränkungen einen ROI erzielen müssen, da er die Erstellung von Kontrollen unterstützt, die wiederholbar, überprüfbar und mit der kontinuierlichen Bereitstellung kompatibel sind, anstatt sich auf „einmaligen Papierkram“ zu verlassen.

ROI, der der Prüfung standhält: Bauen Sie eine Beweiskette auf, keine Erzählung

Viele Führungsteams fragen nach ROI, akzeptieren aber die Aussage: „Das Modell wird nach der Einführung Geld sparen.“ In einem regulierten Unternehmen bricht diese Geschichte aufgrund von Audits, Modellabweichungen und Prozesskomplexität zusammen. Der stärkere Ansatz behandelt den ROI als eine Beweiskette, die das eingesetzte System mit einem messbaren Entscheidungsergebnis verknüpft und so Rückverfolgbarkeit und Transparenz gewährleistet.

Finanzen Forschung bietet einen geeigneten Anker, weil es Spezifität erzwingt. Fraisse und Laporte analysieren den ROI für einen KI-Anwendungsfall, der an den Kapitalbedarf der Financial institution gebunden ist – ein Umfeld, in dem Wert untrennbar mit Regeln, Einschränkungen und messbaren finanziellen Auswirkungen verbunden ist. Auch wenn Ihre Domäne unterschiedlich ist, gilt die Lektion: ROI-Ansprüche werden glaubwürdig, wenn sie mit einem eingeschränkten Entscheidungssystem mit expliziten Grundlagen und beobachtbaren Ergebnissen verbunden sind.

Auf Unternehmensebene gibt es zunehmend empirische Belege für die Produktivitätseffekte der KI-Einführung. Zum Beispiel, Czarnitzki, Fernández und Rammer Schätzen Sie Produktivitätseffekte auf Unternehmensebene anhand von Umfragedaten und berichten Sie über optimistic Zusammenhänge zwischen KI-Einsatz und Produktivität in ihrer Stichprobe, während Sie gleichzeitig Endogenitätsbedenken mit IV-Ansätzen berücksichtigen. Dies verspricht keinen automatischen ROI; Es unterstützt die differenziertere These, dass die Einführung in die Organisation – wenn sie intestine durchgeführt wird – zu messbarer Leistung führen kann, was die Rechtfertigung für die Investition in Fähigkeiten statt in ständiges Pilotieren darstellt. Abbildung 3 stellt den ROI als etwas Geplantes dar.

Je stärker die Umgebung reguliert ist, desto stärker hängt der ROI von der Integrität der Beweisschicht ab, da „Werte“, die nicht verteidigt werden können, oft nicht erhalten bleiben können.

Hervorgehobener Bildnachweis

Wenn Sie Entwicklungsumgebungen (IDEs) in Kombination mit Codierungsagenten verwenden, haben Sie wahrscheinlich Codevorschläge und -änderungen gesehen, die überraschend genau und related sind.

Dieses Maß an Qualität und Präzision ist darauf zurückzuführen, dass die Agenten auf einem tiefen Verständnis Ihrer Codebasis basieren.

Nehmen Sie als Beispiel Cursor. Im Index & Dokumente Auf der Registerkarte können Sie einen Abschnitt sehen, der zeigt, dass Cursor die Codebasis Ihres Projekts bereits „aufgenommen“ und indiziert hat:

Wie können wir additionally überhaupt ein umfassendes Verständnis einer Codebasis aufbauen?

Im Kern lautet die Antwort Retrieval-Augmented Technology (RAG)ein Konzept, mit dem viele Leser möglicherweise bereits vertraut sind. Wie die meisten RAG-basierten Systeme basieren diese Instruments auf semantische Suche als Schlüsselfähigkeit.

Anstatt Wissen rein nach Rohtext zu organisieren, wird die Codebasis indiziert und basierend auf der Bedeutung abgerufen.

Dadurch können Abfragen in natürlicher Sprache die relevantesten Codes abrufen, die Programmierer dann nutzen können, um effektiver zu argumentieren, zu modifizieren und Antworten zu generieren.

In diesem Artikel untersuchen wir das RAG-Pipeline in Cursor, der es Codieragenten ermöglicht, ihre Arbeit unter Verwendung des Kontextbewusstseins der Codebasis zu erledigen.

Inhalt

(1) Erkundung der Codebase RAG Pipeline
(2) Den Codebase-Index auf dem neuesten Stand halten
(3) Zum Abschluss

(1) Erkundung der Codebase RAG Pipeline

Sehen wir uns die Schritte in der RAG-Pipeline von Cursor zum Indizieren und Kontextualisieren von Codebasen an:

Schritt 1 – Chunking

In den meisten RAG-Pipelines müssen wir zunächst das Laden von Daten, die Textvorverarbeitung und das Parsen von Dokumenten aus mehreren Quellen verwalten.

Bei der Arbeit mit einer Codebasis kann jedoch ein Großteil dieses Aufwands vermieden werden. Der Quellcode ist innerhalb eines Projekt-Repositorys bereits intestine strukturiert und sauber organisiert, sodass wir das übliche Parsen von Dokumenten überspringen und direkt mit dem Chunking beginnen können.

In diesem Zusammenhang besteht das Ziel des Chunking darin, Code aufzuteilen sinnvolle, semantisch kohärente Einheiten (z. B. Funktionen, Klassen und logische Codeblöcke), anstatt den Codetext willkürlich aufzuteilen.

Durch semantisches Code-Chunking wird sichergestellt, dass jeder Block die Essenz eines bestimmten Codeabschnitts erfasst, was zu einem genaueren Abruf und einer nützlichen Generierung im weiteren Verlauf führt.

Um dies konkreter zu machen, schauen wir uns an, wie Code-Chunking funktioniert. Betrachten Sie das folgende Python-Beispielskript (machen Sie sich keine Gedanken darüber, was der Code tut; der Fokus liegt hier auf seiner Struktur):

Nach der Anwendung von Code-Chunking ist das Skript sauber in vier strukturell sinnvolle und zusammenhängende Blöcke unterteilt:

Wie Sie sehen, sind die Blöcke aussagekräftig und kontextrelevant, da sie die Codesemantik berücksichtigen. Mit anderen Worten: Beim Chunking wird die Aufteilung des Codes in der Mitte eines logischen Blocks vermieden, es sei denn, dies ist aufgrund von Größenbeschränkungen erforderlich.

In der Praxis bedeutet dies, dass Chunk-Splits eher zwischen Funktionen als innerhalb von Funktionen und zwischen Anweisungen und nicht in der Mittelzeile erstellt werden.

Für das obige Beispiel habe ich verwendet Chonkieein leichtes Open-Supply-Framework, das speziell für das Code-Chunking entwickelt wurde. Es bietet neben vielen anderen verfügbaren Chunking-Techniken eine einfache und praktische Möglichkeit, Code-Chunking zu implementieren.

(Optionale Lektüre) Unter der Haube des Code Chunking

Das obige Code-Chunking ist kein Zufall und wird auch nicht durch naives Aufteilen des Codes mithilfe von Zeichenanzahlen oder regulären Ausdrücken erreicht.

Es beginnt mit einem Verständnis der Syntax des Codes. Der Prozess beginnt normalerweise mit der Verwendung eines Quellcode-Parsers (z. B Baumsitter), um den Rohcode in einen umzuwandeln abstrakter Syntaxbaum (AST).

Ein abstrakter Syntaxbaum ist im Wesentlichen eine baumförmige Darstellung des Codes, der dessen Struktur und nicht den eigentlichen Textual content erfasst. Anstatt Code als Zeichenfolge zu betrachten, sieht das System ihn jetzt als logische Codeeinheiten wie Funktionen, Klassen, Methoden und Blöcke.

Betrachten Sie die folgende Python-Codezeile:

x = a + b

Anstatt als reiner Textual content behandelt zu werden, wird der Code in eine konzeptionelle Struktur wie diese umgewandelt:

Task
├── Variable(x)
└── BinaryExpression(+)
├── Variable(a)
└── Variable(b)

Dieses strukturelle Verständnis ermöglicht ein effektives Code-Chunking.

Jedes sinnvolle Codekonstrukt, z. B. eine Funktion, ein Block oder eine Anweisung, wird dargestellt als ein Knoten im Syntaxbaum.

Anstatt Rohtext zu bearbeiten, wirkt sich das Chunking direkt auf den Syntaxbaum aus.

Der Chunker durchläuft diese Knoten und gruppiert benachbarte Knoten, bis ein Token-Restrict erreicht ist, wodurch semantisch kohärente und größenbegrenzte Chunks entstehen.

Hier ist ein Beispiel für einen etwas komplizierteren Code und den entsprechenden abstrakten Syntaxbaum:

whereas b != 0:
    if a > b:
        a := a - b
    else:
        b := b - a
return 

Schritt 2 – Einbettungen und Metadaten generieren

Sobald die Blöcke vorbereitet sind, wird ein Einbettungsmodell angewendet, um eine Vektordarstellung (auch Einbettungen genannt) für jeden Codeblock zu generieren.

Diese Einbettungen erfassen die semantische Bedeutung des Codes und ermöglichen den Abruf für Benutzerabfragen und Generierungsaufforderungen, die mit semantisch verwandtem Code abgeglichen werden, selbst wenn sich genaue Schlüsselwörter nicht überschneiden.

Dies verbessert die Abrufqualität für Aufgaben wie Codeverständnis, Refactoring und Debugging erheblich.

Über die Generierung von Einbettungen hinaus ist ein weiterer wichtiger Schritt Anreicherung jedes Chunks mit relevanten Metadaten.

Zum Beispiel Metadaten wie die Dateipfad und den entsprechenden Codezeilenbereich denn jeder Block wird zusammen mit seinem Einbettungsvektor gespeichert.

Diese Metadaten liefern nicht nur wichtigen Kontext darüber, woher ein Block stammt, sondern ermöglichen auch eine metadatenbasierte Schlüsselwortfilterung während des Abrufs.

Schritt 3 – Verbesserung des Datenschutzes

Wie bei jedem RAG-basierten System ist der Datenschutz ein vorrangiges Anliegen. Dies wirft natürlich die Frage auf ob Dateipfade selbst vertrauliche Informationen enthalten können.

In der Praxis verraten Datei- und Verzeichnisnamen oft mehr als erwartet, beispielsweise interne Projektstrukturen, Produktcodenamen, Shopper-IDs oder Eigentumsgrenzen innerhalb einer Codebasis.

Daher werden Dateipfade als vertrauliche Metadaten behandelt und erfordern eine sorgfältige Handhabung.

Um dieses Drawback zu beheben, gilt Cursor Verschleierung des Dateipfads (auch bekannt als Pfadmaskierung) auf der Clientseite, bevor Daten übertragen werden. Jede Komponente des Pfades, geteilt durch / Und .wird mit einem geheimen Schlüssel und einer kleinen festen Nonce maskiert.

Dieser Ansatz verbirgt die tatsächlichen Datei- und Ordnernamen und behält gleichzeitig genügend Verzeichnisstruktur bei, um effektives Abrufen und Filtern zu unterstützen.

Zum Beispiel, src/funds/invoice_processor.py kann umgewandelt werden in a9f3/x72k/qp1m8d.f4.

Hinweis: Benutzer können steuern, welche Teile ihrer Codebasis mit Cursor geteilt werden, indem sie a verwenden .cursorignore Datei. Cursor bemüht sich nach besten Kräften, zu verhindern, dass der aufgelistete Inhalt in LLM-Anfragen übertragen oder darauf verwiesen wird.

Schritt 4 – Einbettungen speichern

Nach der Generierung werden die Chunk-Einbettungen (mit den entsprechenden Metadaten) in einer Vektordatenbank gespeichert Turbopufferdas für die schnelle semantische Suche in Millionen von Codeblöcken optimiert ist.

Turbopuffer ist eine serverlose Hochleistungssuchmaschine, die Vektor- und Volltextsuche kombiniert und durch kostengünstigen Objektspeicher unterstützt wird.

Um die Neuindizierung zu beschleunigen, werden Einbettungen auch in AWS zwischengespeichert und durch den Hash jedes Blocks verschlüsselt, sodass unveränderter Code bei der nachfolgenden Indizierungsausführung wiederverwendet werden kann.

Aus datenschutzrechtlicher Sicht ist dies wichtig zu beachten Lediglich Einbettungen und Metadaten werden in der Cloud gespeichert. Das bedeutet, dass unser ursprünglicher Quellcode auf unserem lokalen Laptop verbleibt und ist nie gespeichert auf Cursor-Servern oder in Turbopuffer.

Schritt 5 – Semantische Suche ausführen

Wenn wir eine Abfrage in Cursor senden, wird diese zunächst in einen Vektor umgewandelt, wobei dasselbe Einbettungsmodell für die Generierung von Chunk-Einbettungen verwendet wird. Es stellt sicher, dass sowohl Abfragen als auch Codeblöcke im selben semantischen Raum leben.

Aus Sicht der semantischen Suche läuft der Prozess wie folgt ab:

1. Cursor vergleicht die Abfrageeinbettung mit Codeeinbettungen in der Vektordatenbank, um die semantisch ähnlichsten Codeblöcke zu identifizieren.
2. Diese Kandidatenblöcke werden von Turbopuffer in der Rangfolge basierend auf ihren Ähnlichkeitswerten zurückgegeben.
3. Da der Rohquellcode niemals in der Cloud oder der Vektordatenbank gespeichert wird, bestehen die Suchergebnisse nur aus Metadaten, insbesondere die maskierten Dateipfade und entsprechenden Codezeilenbereiche.
4. Durch das Auflösen der Metadaten entschlüsselter Dateipfade und Zeilenbereiche ist der lokale Shopper dann in der Lage, die tatsächlichen Codeblöcke aus der lokalen Codebasis abzurufen.
5. Die abgerufenen Codeblöcke werden dann in ihrer ursprünglichen Textform als Kontext zusammen mit der Abfrage an das LLM bereitgestellt, um eine kontextbezogene Antwort zu generieren.

Im Rahmen einer hybriden Suchstrategie (Semantik + Schlüsselwort) kann der Codierungsagent auch Instruments wie verwenden grep Und ripgrep um Codeausschnitte basierend auf genauen Zeichenfolgenübereinstimmungen zu finden.

OpenCode ist ein beliebtes Open-Supply-Coding-Agent-Framework, das in Terminal-, IDEs- und Desktop-Umgebungen verfügbar ist.

Im Gegensatz zu Cursor arbeitet es direkt auf der Codebasis und verwendet Textsuche, Dateiabgleich und LSP-basierte Navigation anstelle einer einbettungsbasierten semantischen Suche.

Infolgedessen bietet OpenCode ein starkes Strukturbewusstsein, es fehlen jedoch die tieferen semantischen Abruffunktionen von Cursor.

Zur Erinnerung: Unser Authentic-Quellcode ist nicht auf Cursor-Servern oder im Turbopuffer gespeichert.

Bei der Beantwortung einer Anfrage muss Cursor jedoch immer noch vorübergehend die relevanten ursprünglichen Codeblöcke an den Codierungsagenten übergeben, damit er eine genaue Antwort erzeugen kann.

Dies liegt daran, dass die Chunk-Einbettungen nicht zur direkten Rekonstruktion des Originalcodes verwendet werden können.

Klartextcode wird nur zum Zeitpunkt der Inferenz und nur für die spezifischen benötigten Dateien und Zeilen abgerufen. Außerhalb dieser kurzlebigen Inferenzlaufzeit wird die Codebasis nicht distant gespeichert oder beibehalten.

(2) Den Codebase-Index auf dem neuesten Stand halten

Überblick

Unsere Codebasis entwickelt sich schnell weiter, da wir entweder die vom Agenten generierten Änderungen akzeptieren oder manuelle Codeänderungen vornehmen.

Um die Genauigkeit des semantischen Abrufs zu gewährleisten, synchronisiert Cursor den Codeindex automatisch durch regelmäßige Überprüfungen, normalerweise alle fünf Minuten.

Bei jeder Synchronisierung erkennt das System sicher Änderungen und aktualisiert nur die betroffenen Dateien, indem es veraltete Einbettungen entfernt und neue generiert.

Darüber hinaus werden Dateien stapelweise verarbeitet, um die Leistung zu optimieren und Störungen unseres Entwicklungsworkflows zu minimieren.

Verwendung von Merkle-Bäumen

Wie sorgt Cursor dafür, dass das so reibungslos funktioniert? Es scannt den geöffneten Ordner und berechnet ein Merkle-Baum von Datei-Hasheswodurch das System Änderungen in der gesamten Codebasis effizient erkennen und verfolgen kann.

Additionally intestine, was ist ein Merkle-Baum?

Es handelt sich um eine Datenstruktur, die wie ein System digitaler kryptografischer Fingerabdrücke funktioniert und es ermöglicht, Änderungen in einer großen Menge von Dateien effizient zu verfolgen.

Jede Codedatei wird in einen kurzen Fingerabdruck umgewandelt, und diese Fingerabdrücke werden hierarchisch zu einem einzigen Fingerabdruck der obersten Ebene kombiniert, der den gesamten Ordner darstellt.

Wenn sich eine Datei ändert, müssen nur ihr Fingerabdruck und eine kleine Anzahl zugehöriger Fingerabdrücke aktualisiert werden.

Der Merkle-Baum der Codebasis wird mit dem Cursor-Server synchronisiert, der regelmäßig nach Fingerabdruck-Nichtübereinstimmungen sucht, um festzustellen, was sich geändert hat.

Dadurch kann festgestellt werden, welche Dateien geändert wurden, und bei der Indexsynchronisierung nur diese Dateien aktualisiert werden, wodurch der Prozess schnell und effizient bleibt.

Umgang mit verschiedenen Dateitypen

So verarbeitet Cursor im Rahmen des Indizierungsprozesses effizient verschiedene Dateitypen:

• Neue Dateien: Automatisch zum Index hinzugefügt
• Geänderte Dateien: Alte Einbettungen entfernt, neue geschaffen
• Gelöschte Dateien: Sofort aus dem Index entfernt
• Große/komplexe Dateien: Kann aus Leistungsgründen übersprungen werden

Hinweis: Die Codebasis-Indizierung von Cursor beginnt automatisch, wenn Sie einen Arbeitsbereich öffnen.

(3) Zusammenfassung

In diesem Artikel haben wir einen Blick über die LLM-Generierung hinaus geworfen und die Pipeline hinter Instruments wie Cursor untersucht, die über RAG den richtigen Kontext aufbaut.

Durch die Aufteilung des Codes entlang sinnvoller Grenzen, seine effiziente Indizierung und die kontinuierliche Aktualisierung dieses Kontexts im Zuge der Weiterentwicklung der Codebasis können Codierungsagenten weitaus relevantere und zuverlässigere Vorschläge liefern.

Bild vom Autor

# Einführung in das Experiment

Die Optimierung von Hyperparametern wird oft als Wundermittel für maschinelles Lernen angepriesen. Das Versprechen ist einfach: Passen Sie ein paar Stunden lang einige Parameter an, führen Sie eine Rastersuche durch und beobachten Sie, wie die Leistung Ihres Modells steigt.

Aber funktioniert es tatsächlich in der Praxis?

Bild vom Autor

Wir haben diese Prämisse anhand von Leistungsdaten portugiesischer Schüler mithilfe von vier verschiedenen Klassifikatoren und einer strengen statistischen Validierung getestet. Unser Ansatz nutzte verschachtelte Kreuzvalidierung (CV), robuste Vorverarbeitungs-Pipelines und statistische Signifikanztests – und das alles.

Das Ergebnis? Die Leistung sank um 0,0005. Das ist richtig – durch das Tuning wurden die Ergebnisse tatsächlich etwas schlechter, obwohl der Unterschied statistisch nicht signifikant conflict.

Dies ist jedoch keine Misserfolgsgeschichte. Es ist etwas Wertvolleres: ein Beweis dafür, dass Standardeinstellungen in vielen Fällen bemerkenswert intestine funktionieren. Manchmal ist es am besten zu wissen, wann man mit dem Tuning aufhört und sich auf andere Dinge konzentriert.

Möchten Sie das vollständige Experiment sehen? Schauen Sie sich das an Komplettes Jupyter-Pocket book mit sämtlichem Code und Analysen.

# Einrichten des Datensatzes

Bild vom Autor

Wir haben den Datensatz von verwendet StrataScratch’s Projekt „Studierende Leistungsanalyse“. Es enthält Aufzeichnungen für 649 Schüler mit 30 Merkmalen zu Demografie, familiärem Hintergrund, sozialen Faktoren und schulbezogenen Informationen. Das Ziel bestand darin, vorherzusagen, ob die Schüler ihre Abschlussnote in Portugiesisch bestehen (eine Punktzahl von ≥ 10).

Eine entscheidende Entscheidung bei diesem Aufbau conflict der Ausschluss der Klassen G1 und G2. Dabei handelt es sich um Noten der ersten und zweiten Unterrichtsstunde, die 0,83–0,92 mit der Abschlussnote G3 korrelieren. Ihre Einbeziehung macht die Vorhersage trivial einfach und macht den Zweck des Experiments zunichte. Wir wollten herausfinden, was den Erfolg über die vorherige Leistung im selben Kurs hinaus vorhersagt.

Wir haben das genutzt Pandas Bibliothek zum Laden und Vorbereiten der Daten:

# Load and put together knowledge
df = pd.read_csv('student-por.csv', sep=';')

# Create go/fail goal (grade >= 10)
PASS_THRESHOLD = 10
y = (df('G3') >= PASS_THRESHOLD).astype(int)

# Exclude G1, G2, G3 to stop knowledge leakage
features_to_exclude = ('G1', 'G2', 'G3')
X = df.drop(columns=features_to_exclude)

Die Klassenverteilung ergab, dass 100 Schüler durchfielen (15,4 %), während 549 bestanden (84,6 %). Da die Daten unausgeglichen sind, haben wir die Optimierung eher auf den F1-Rating als auf einfache Genauigkeit ausgerichtet.

# Bewertung der Klassifikatoren

Wir haben vier Klassifikatoren ausgewählt, die unterschiedliche Lernansätze repräsentieren:

Bild vom Autor

Jedes Modell wurde zunächst mit Standardparametern betrieben, gefolgt von einer Optimierung per Rastersuche mit 5-fachem CV.

# Etablierung einer robusten Methodik

Viele Tutorials zum maschinellen Lernen zeigen beeindruckende Optimierungsergebnisse, da sie wichtige Validierungsschritte überspringen. Wir haben einen hohen Commonplace eingehalten, um sicherzustellen, dass unsere Ergebnisse zuverlässig sind.

Unsere Methodik umfasste:

• Kein Datenverlust: Die gesamte Vorverarbeitung wurde innerhalb von Pipelines durchgeführt und passte nur auf Trainingsdaten
• Verschachtelte Kreuzvalidierung: Wir haben eine innere Schleife zur Optimierung der Hyperparameter und eine äußere Schleife zur endgültigen Auswertung verwendet
• Angemessene Zug-/Testaufteilung: Wir haben eine 80/20-Aufteilung mit Schichtung verwendet und den Testsatz bis zum Ende getrennt gehalten (d. h. kein „Peeking“).
• Statistische Validierung: Wir haben uns beworben McNemars Check um zu überprüfen, ob die Leistungsunterschiede statistisch signifikant waren
• Metrikauswahl: Wir haben dem F1-Rating für unausgeglichene Klassen Vorrang vor der Genauigkeit gegeben

Bild vom Autor

Die Pipelinestruktur conflict wie folgt:

# Preprocessing pipeline - match solely on coaching folds
numeric_transformer = Pipeline((
    ('imputer', SimpleImputer(technique='median')),
    ('scaler', StandardScaler())
))

categorical_transformer = Pipeline((
    ('imputer', SimpleImputer(technique='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
))

# Mix transformers
from sklearn.compose import ColumnTransformer
preprocessor = ColumnTransformer(transformers=(
    ('num', numeric_transformer, X.select_dtypes(embrace=('int64', 'float64')).columns),
    ('cat', categorical_transformer, X.select_dtypes(embrace=('object')).columns)
))

# Full pipeline with mannequin
pipeline = Pipeline((
    ('preprocessor', preprocessor),
    ('classifier', mannequin)
))

# Analyse der Ergebnisse

Nach Abschluss des Tuning-Prozesses waren die Ergebnisse überraschend:

Die durchschnittliche Verbesserung über alle Modelle hinweg betrug -0,0005.

Drei Modelle schnitten nach dem Tuning tatsächlich etwas schlechter ab. XGBoost zeigte eine Verbesserung von etwa 1 %, was vielversprechend erschien, bis wir statistische Checks anwendeten. Bei der Auswertung mit dem Maintain-out-Testsatz zeigte keines der Modelle statistisch signifikante Unterschiede.

Wir sind gerannt McNemars Check Vergleich der beiden leistungsstärksten Modelle (Random Forest versus XGBoost). Der p-Wert betrug 1,0, was keinen signifikanten Unterschied zwischen der Standardversion und der optimierten Model bedeutet.

# Erklären, warum die Optimierung fehlgeschlagen ist

Bild vom Autor

Mehrere Faktoren erklären diese Ergebnisse:

• Starke Ausfälle. scikit-lernen und XGBoost werden mit hochoptimierten Standardparametern ausgeliefert. Bibliotheksverwalter haben diese Werte im Laufe der Jahre verfeinert, um sicherzustellen, dass sie in einer Vielzahl von Datensätzen effektiv funktionieren.
• Begrenztes Sign. Nach dem Entfernen der G1- und G2-Bewertungen (die zu Datenlecks geführt hätten) hatten die verbleibenden Funktionen eine geringere Vorhersagekraft. Es conflict einfach nicht mehr genug Sign vorhanden, um die Hyperparameteroptimierung auszunutzen.
• Kleine Datensatzgröße. Da nur 649 Proben in Trainingsfalten aufgeteilt waren, lagen für die Rastersuche nicht genügend Daten vor, um wirklich aussagekräftige Muster zu identifizieren. Die Rastersuche erfordert umfangreiche Daten, um zuverlässig zwischen verschiedenen Parametersätzen unterscheiden zu können.
• Leistungsobergrenze. Die meisten Basismodelle erzielten bereits Werte zwischen 92 und 93 % F1. Der Spielraum für Verbesserungen ist natürlich begrenzt, ohne bessere Funktionen oder mehr Daten einzuführen.
• Strenge Methodik. Wenn Sie Datenlecks beseitigen und verschachtelte CVs verwenden, verschwinden die überhöhten Verbesserungen, die häufig bei unsachgemäßer Validierung auftreten.

# Aus den Ergebnissen lernen

Bild vom Autor

Dieses Experiment bietet jedem Praktiker mehrere wertvolle Lektionen:

• Methodik ist wichtiger als Metriken. Das Beheben von Datenlecks und die Verwendung einer ordnungsgemäßen Validierung verändern das Ergebnis eines Experiments. Die beeindruckenden Ergebnisse, die durch eine unsachgemäße Validierung erzielt werden, verschwinden, wenn der Prozess korrekt gehandhabt wird.
• Eine statistische Validierung ist unerlässlich. Ohne den Check von McNemar hätten wir XGBoost möglicherweise fälschlicherweise basierend auf einer nominellen Verbesserung von 1 % eingesetzt. Der Check ergab, dass es sich lediglich um Lärm handelte.
• Adverse Ergebnisse haben einen immensen Wert. Nicht jedes Experiment muss eine huge Verbesserung zeigen. Zu wissen, wann eine Optimierung nicht hilft, spart Zeit bei zukünftigen Projekten und ist ein Zeichen für einen ausgereiften Arbeitsablauf.
• Commonplace-Hyperparameter werden unterschätzt. Für Standarddatensätze sind häufig Standardwerte ausreichend. Gehen Sie nicht davon aus, dass Sie jeden Parameter von Anfang an anpassen müssen.

# Zusammenfassung der Ergebnisse

Wir haben versucht, die Modellleistung durch umfassende Optimierung der Hyperparameter zu steigern, indem wir die Greatest Practices der Branche befolgten und statistische Validierung auf vier verschiedene Modelle anwendeten.

Das Ergebnis: keine statistisch signifikante Verbesserung.

Bild vom Autor

Das ist *kein* Fehler. Stattdessen stellt es ehrliche Ergebnisse dar, die es Ihnen ermöglichen, in der realen Projektarbeit bessere Entscheidungen zu treffen. Es sagt Ihnen, wann Sie mit der Optimierung der Hyperparameter aufhören und wann Sie sich auf andere kritische Aspekte wie Datenqualität, Function-Engineering oder das Sammeln zusätzlicher Stichproben konzentrieren müssen.

Beim maschinellen Lernen geht es nicht darum, auf irgendeine Weise die höchstmögliche Zahl zu erreichen; Es geht darum, Modelle zu bauen, denen Sie vertrauen können. Dieses Vertrauen beruht auf dem methodischen Prozess, der zur Erstellung des Modells verwendet wurde, und nicht auf der Jagd nach geringfügigen Gewinnen. Die schwierigste Fähigkeit beim maschinellen Lernen besteht darin, zu wissen, wann man aufhören muss.

Bild vom Autor

Nate Rosidi ist Datenwissenschaftler und in der Produktstrategie tätig. Er ist außerdem außerordentlicher Professor für Analytik und Gründer von StrataScratch, einer Plattform, die Datenwissenschaftlern hilft, sich mit echten Interviewfragen von Prime-Unternehmen auf ihre Interviews vorzubereiten. Nate schreibt über die neuesten Traits auf dem Karrieremarkt, gibt Ratschläge zu Vorstellungsgesprächen, stellt Information-Science-Projekte vor und behandelt alles rund um SQL.