: Grenz-KI-Modelle laufen zunehmend Gefahr, strengen Exportkontrollen oder steigenden API-Kosten ausgesetzt zu sein.

Während diese Technologie in unser tägliches Leben Einzug hält, ist die Open-Supply-Bewegung nicht nur eine philosophische Präferenz, sondern ein notwendiger Mechanismus, um die KI in den Händen alltäglicher Benutzer zu halten. Wir sind noch nicht gleichberechtigt; Die proprietären Modelle aus den riesigen Technologielabors haben immer noch einen souveränen Vorsprung in Sachen reiner Leistung. Aber wir können hoffen, dass sich die Lücke schnell schließt. Eine unabhängige Gemeinschaft von Forschern und Entwicklern arbeitet rund um die Uhr daran, sicherzustellen, dass diese Technologie für jeden mit einem Pc zugänglich ist.

Heute ist die Grundlage für eine echte Demokratisierung bereits gelegt: Sie können ein leistungsstarkes Modell vollständig auf Ihrem eigenen Laptop computer ausführen. Für das heutige Experiment habe ich mir vorgenommen, ein großes Sprachmodell zu finden, das vollständig auf meinem Laptop computer ausgeführt werden kann – und es für die einfachen Aufgaben zu verwenden, die ich normalerweise einem großen Labormodell überlassen würde.

Wir installieren Qwen 3 8B auf meinem MacBook Air, führe es vollständig offline aus und habe endlich ein Sprachmodell, das auf meinem eigenen Pc statt in einem entfernten Rechenzentrum läuft. Der Qwen Die Modellfamilie wurde von Alibaba (dem chinesischen Unternehmen) geschult und ist vollständig Open Supply und im Web für jedermann zum Herunterladen verfügbar. Das Modell verfügt über 9 Milliarden Gewichte und belegt im geladenen Zustand etwa 6 GB Ihres RAM.
Was nun folgt, ist eine praktische, umfassende Anleitung zum Ausführen eines ordnungsgemäßen lokalen LLM auf einem Apple Silicon Mac und enthält die Terminalbefehle, die Sie benötigen. Doch bevor wir das Terminal öffnen, müssen wir darüber sprechen, warum sich das überhaupt lohnt.

---

Warum das tun?

Meistens sind Cloud-Modelle besser und einfacher. Ich behaupte nicht, dass ein 8-Milliarden-Parameter-Modell auf einem Laptop computer die Spitzen-KI übertrifft. Das ist nicht der Fall und ich werde weiterhin die Large-Cloud-Modelle für schwere Lasten verwenden.

Aber die ständigen Preis- und Souveränitätskriege rund um KI könnten Open-Supply- und lokale Modelle für eine Zukunft, in der der Zugang zu der Technologie einen großen Unterschied machen wird, sehr related machen. Jedes Mal, wenn Sie Claude oder ChatGPT verwenden, senden Sie Ihre Daten an einige Distant-Server, wo der Zugriff jederzeit blockiert werden kann.

„Digitale Souveränität„ist ein großartiger Ausdruck für einen ganz gewöhnlichen Wunsch: Vielleicht möchten wir das Ding besitzen, das unsere empfindlichsten Gedanken liest, genauso wie Sie ein physisches Notizbuch besitzen oder etwas Bargeld zu Hause aufbewahren.

Ein lokales Modell beantwortet dies in der KI-Welt sauber. Sobald es heruntergeladen ist, verlässt nichts die Maschine. Keine API-Schlüssel, keine wechselnden Nutzungsbedingungen, keine stillschweigenden Richtlinien zur Datenaufbewahrung. Sie können die WLAN-Karte herausziehen und sie funktioniert weiter. Für den hochsensiblen Teil Ihrer Arbeit kann allein das den Eintrittspreis wert sein.

Die Leute sagen gerne, dass lokale Fashions „demokratisierend„KI. Ich möchte, dass das wahr ist, aber wir sind noch nicht am Ziel. Das Ausführen dieses Stacks setzt immer noch voraus, dass Sie einen 1.500-Euro-Laptop computer mit riesigem einheitlichem Speicher besitzen und sich mit einer Befehlszeile auskennen. Das ist ein schmaler, glücklicher Ausschnitt der Welt.“

Aber die Flugbahn ist demokratisierend. Vor zwei Jahren erforderte der Betrieb eines anständigen Offline-Modells eine dedizierte Workstation und erhebliche technische Probleme. Dieses Wochenende habe ich ein paar Stunden und 5 Gigabyte Festplattenspeicher gebraucht.

Additionally lasst uns das Ding installieren.

---

Die Maschine und die Spezifikationen

Ich habe das auf einem gebaut MacBook Air M4 mit 24 GB einheitlicher Speicher und etwa 235 GB freier Speicherplatz. Das battle ein Neuanfang: kein Homebrew, keine Albträume in der Python-Umgebung.

Die Zahl, die hier wirklich zählt, ist die 24 GB. Der „Unified Reminiscence“ von Apple Silicon ist der Zaubertrick, der Macs dabei so außergewöhnlich intestine macht. Da sich CPU und GPU genau den gleichen Speicherpool teilen, müssen große neuronale Netzwerkgewichte nicht mühsam hin- und hergeschoben werden.

Ein 8B-Modell belegt etwa 5 GB auf der Festplatte und verfügt im geladenen Zustand über etwa 6 GB Speicher. Auf einer 24-GB-Maschine ist das äußerst komfortabel. Sie könnten ein 14B-Modell verwenden und trotzdem Dutzende Browser-Registerkarten geöffnet lassen. (Wenn Sie einen 8-GB-Mac verwenden, bleiben Sie bei den 1,5B- oder 3B-Modellen und schließen Sie Ihre anderen Apps.)

---

Warum Ollama?

Es gibt ein Dutzend Möglichkeiten, lokale KI auszuführen, und die meisten erfordern, dass Sie sich um Compiler-Flags und Abhängigkeitsbäume kümmern. Das solltest du nicht müssen.

Ollama ist ein Open-Supply-Framework und -Device, das einfach funktioniert. Es handelt sich um eine einzelne Binärdatei, die einen hochoptimierten Modellläufer bündelt (llama.cpp unter Verwendung von Apples Steel zur GPU-Beschleunigung), einer Modellregistrierung im Docker-Stil und einer lokalen HTTP-API. Sie installieren es, ziehen ein Modell und sprechen mit ihm. Das ist es!

---

Schritt 1: Ollama installieren (kein Homebrew erforderlich)

Ollama wird als Customary-MacOS-App in einer ZIP-Datei geliefert. Die Befehlszeilenschnittstelle (CLI) befindet sich verborgen im App-Bundle, sodass wir sie vollständig von Hand einrichten können.

# Obtain the Apple Silicon construct
cd ~/Downloads
curl -L -o Ollama-darwin.zip https://ollama.com/obtain/Ollama-darwin.zip
# Unzip and transfer the app into your Functions folder
unzip -o -q Ollama-darwin.zip
mv Ollama.app /Functions/

Wenn Sie nicht wissen, wie Sie das Terminal öffnen, gehen Sie einfach zu Ihren Mac-Anwendungen und suchen Sie nach „Terminal“:

Schritt 2: Setzen Sie Ollama auf Ihren WEG

Ich wollte nicht mit ihm kämpfen sudo Berechtigungen in /usr/native/binadditionally habe ich die gebündelte CLI mit einem lokalen Verzeichnis, das ich besitze, symbolisch verknüpft – dies ist nur eine praktische Verknüpfung, um die Set up zu beschleunigen und das LLM hochzufahren.

# Create a neighborhood bin listing and symlink the CLI
mkdir -p ~/.native/bin
ln -sf /Functions/Ollama.app/Contents/Assets/ollama ~/.native/bin/ollama

# Make it everlasting in your zsh profile
echo 'export PATH="$HOME/.native/bin:$PATH"' >> ~/.zshrc
# Apply it to your present shell
export PATH="$HOME/.native/bin:$PATH"
ollama --version

Schritt 3: Starten Sie den Server

Ollama führt einen schlanken Hintergrundserver aus, um die API verfügbar zu machen und den Speicher Ihres Computer systems zu verwalten.

# Begin the server and log output
mkdir -p ~/.ollama/logs
nohup ollama serve > ~/.ollama/logs/serve.log 2>&1 &

# Ping it to verify if it is alive
curl -s http://127.0.0.1:11434/api/model

Wenn der obige Befehl eine „Model“ zurückgibt, ist Ollama eingerichtet!

Hinweis: Sie können auch einfach auf die Ollama-App in Ihrem Anwendungsordner doppelklicken, um diesen Server über Ihre Menüleiste auszuführen. Ich habe es über das Terminal gemacht, um genau zu sehen, was unter der Haube passiert.

---

Schritt 4: Ziehen Sie das Modell

Nun, das hier ist so einfach wie es nur geht:

ollama pull qwen3:8b     
ollama record

Geh und mach einen Kaffee. Der Obtain ist ca. 5,2 GB groß.

Nachdem Sie ollama record ausgeführt haben, sehen Sie das für Sie verfügbare Modell:

---

Schritt 5: Sprechen Sie mit dem neuen digitalen Gehirn in Ihrem Pc

Sie haben drei verschiedene Möglichkeiten, mit Ihrem neuen lokalen Modell zu interagieren.

1. Interaktiver Chat (am einfachsten)

ollama run qwen3:8b

Durch Ausführen des folgenden Befehls wird der interaktive Chat gestartet:

Im Standardmodus gibt das Modell die „Denk-Tokens“ aus, etwas, das in den meisten kommerziellen Instruments normalerweise abstrahiert und verborgen ist.

Ich werde damit beginnen, mein lokales Modell zu fragen, was es über Open-Supply-Modelle denkt:

Der hellgraue Textual content stellt den internen Argumentationsprozess des Modells dar. Diese Modelle führen umfangreiche Berechnungen durch, bevor sie eine Antwort generieren, und bei lokalen Modellen macht diese Denkphase einen erheblichen Teil der Gesamtzeit aus, bis das Modell eine Antwort ausgibt.

Nach dem Denkprozess ist hier die Antwort des Modells:

Bei den meisten Instruments behalten diese Modelle auch einen gewissen Kontext aus früheren Interaktionen bei:

Da ich mich im Batteriesparmodus befinde, gibt das Modell 5,7 Token professional Sekunde aus. Wenn ich es ablehne, werden wir wahrscheinlich einen Wert von 15–20 Token professional Sekunde sehen.

---

2. One-Shot-Terminalbefehle
Um mit Ihrem lokalen Modell zu interagieren, können Sie die Frage auch außerhalb des interaktiven Modus stellen:

ollama run qwen3:8b "write a python script that tells me what number of vowels a phrase has"

Hier ist das Skript, das unser lokales großes Sprachmodell erstellt hat:

```python
# Immediate the person for a phrase
phrase = enter("Enter a phrase: ")

# Outline the set of vowels
vowels = {'a', 'e', 'i', 'o', 'u'}

# Initialize a counter
rely = 0

# Convert the phrase to lowercase and verify every character
for char in phrase.decrease():
    if char in vowels:
        rely += 1

# Output the end result
print(f"Variety of vowels: {rely}")

---

3. Die HTTP-API (für Skripte und Apps)

Können Sie dies nur innerhalb der Terminalbefehle verwenden?

Natürlich nicht! Wenn Sie mit Python vertraut sind, können Sie jedes lokale Skript mit Ihrem lokalen Modell erstellen:

import json, urllib.request

req = urllib.request.Request(
    "http://127.0.0.1:11434/api/generate",
    knowledge=json.dumps({
        "mannequin": "qwen3:8b",
        "immediate": "Give me three makes use of for a neighborhood LLM.",
        "stream": False,
        "assume": False,
    }).encode(),
    headers={"Content material-Kind": "software/json"},
)
print(json.hundreds(urllib.request.urlopen(req).learn())("response"))

Hier ist die Antwort des Modells nach der Ausführung dieses Python-Skripts:

Positive! Listed below are three widespread and sensible makes use of for a **native LLM (Massive Language Mannequin)**:

1. **Personalised Help and Productiveness**
An area LLM can act as a personal AI assistant, serving to with duties like e-mail drafting, scheduling, note-taking, and even coding. Because it runs regionally, it maintains person privateness and does not depend on web connectivity.

2. **Content material Creation and Language Processing**
You should utilize a neighborhood LLM to generate artistic content material resembling weblog posts, tales, scripts, or advertising copy. It could possibly additionally help with language translation, grammar checking, and summarizing textual content.

3. **Customized Functions and Integration**
An area LLM could be built-in into customized functions or workflows, resembling chatbots, buyer assist techniques, or knowledge evaluation instruments. This enables for tailor-made options with out exposing delicate knowledge to exterior servers.

Let me know if you would like examples of the right way to implement these makes use of!

Cool! Sie können jetzt ganz einfach Ihre eigenen Anwendungen mit Ihrem eigenen lokalen Modell erstellen.

---

Feinabstimmung der Erfahrung – Zähmung der „Denk“-Token

Qwen 3 ist ein hybrides Argumentationsmodell. Standardmäßig wird eine ausführliche Meldung generiert <assume>...</assume> Block skizziert seinen Gedankengang, bevor er die eigentliche Antwort gibt. Manchmal möchten Sie die Mathematik sehen, aber meistens möchten Sie einfach nur schnell eine Antwort erhalten (und etwas Zeit sparen, indem Sie auf die Ausgabe-Tokens des Denkprozesses warten).

So umgehen Sie den Argumentationsdurchgang:

• Deaktivieren Sie es vollständig: ollama run qwen3:8b --think=false
• Führen Sie es aus, aber verstecken Sie es auf der Benutzeroberfläche: ollama run qwen3:8b --hidethinking
• In Skripten: Passieren "assume": false in Ihrer JSON-Nutzlast.

---

Eine Warnung zur Websuche

Modelle sind bis zu ihren Trainingsdaten statisch. Das bedeutet, dass sie nach der Schulung nicht mehr auf Daten zugreifen können und Unternehmen sich auf Websuchtools verlassen, um die Leistungsfähigkeit der Modelle zu erweitern. Zum Beispiel für unser lokales Modell:

Mit Ollama können Sie dem Modell jedoch ein Websuchtool zur Verfügung stellen. Das klingt unglaublich, aber es gibt einen Haken.

Die Suche selbst wird auf dem gehosteten Cloud-Dienst von Ollama ausgeführt. Sobald Sie es aktivieren, werden Ihre Eingabeaufforderungen über das Web gesendet, um Suchergebnisse abzurufen. Das Modell bleibt lokal, Ihre Abfragen jedoch nicht. Dies verstößt möglicherweise gegen den Grundsatz der Privatsphäre, den Sie mit der Einrichtung gewährleisten möchten.

---

Bonus: VS-Code-Integration

Das ultimative Endspiel für mich battle die Anschaffung eines Offline-Codierungsassistenten. Der sauberste und völlig freie Weg hierfür ist der Proceed.dev Verlängerung.

• Installieren Sie VS Code und die Proceed-Erweiterung.
• Öffnen Sie die Konfigurationsdatei von Proceed unter ~/.proceed/config.yaml.
• Richten Sie es auf Ihren lokalen Ollama-Server:

identify: Native Assistant
model: 1.0.0
fashions:
  - identify: Qwen3 8B (native)
    supplier: ollama
    mannequin: qwen3:8b
    roles:
      - chat
      - edit
      - apply
  - identify: Qwen3 8B Autocomplete
    supplier: ollama
    mannequin: qwen3:8b
    roles:
      - autocomplete

Profi-Tipp: Ein 8B-Modell ist etwas zu schwer für die Latenz von Sekundenbruchteilen, die Sie für die automatische Vervollständigung von Inline-Code wünschen. Ich empfehle dringend, speziell für diese Aufgabe ein kleineres Modell zu verwenden (ollama pull qwen2.5-coder:1.5b-base), ordnet es dem zu autocomplete Rolle und überlassen Qwen3 8B die schwerere Rolle chat Aufgaben.

---

Was ist, wenn ich einen Home windows-Pc habe?

Da ich für dieses Tutorial kein Home windows verwende, habe ich es nicht ausführlich ausprobiert. Die gute Nachricht ist jedoch, dass das Ollama-Paket für Home windows-Pc verfügbar ist Hier.

Der Installationsprozess unterscheidet sich möglicherweise etwas, aber die Logik hinter der Verwendung von Ollama und dem Ziehen der Modelle ist genau dieselbe.

---

Wohin mich das führt

Mein Gesamtspeicherplatz für dieses Projekt betrug 156 MB für die Software program und 5,2 GB für das Modell selbst.

Ich habe jetzt ein hochleistungsfähiges Sprachmodell, das dauerhaft auf meiner Festplatte gespeichert ist. Für öffentliche, komplexe Arbeiten werde ich weiterhin zur Cloud greifen. Aber für die Entwürfe, die ich nicht in die Trainingsdaten, die Offline-Flüge und die rechtlich gebundenen Kundendokumente einfließen lassen möchte? Diese Informationen befinden sich jetzt auf meinem Pc.

Für die meisten Menschen magazine das immer noch etwas zu technisch sein, aber die Dinge werden immer demokratisierter. Dabei kommt es nicht nur auf die Verfügbarkeit an. Was die Leistung betrifft, verbessern sich Open-Supply-Modelle rasant und liefern Ergebnisse, die die Zukunft der lokalen KI unglaublich vielversprechend erscheinen lassen. Zum Beispiel, GLM 5.2 Und Qwen 3,7 Max holen mit der Leistung der großen Labormodelle auf:

Da die technischen Anforderungen immer weiter sinken, wird „der Besitz einer eigenen KI“ kein Luxus mehr sein, der Entwicklern mit teuren Laptops vorbehalten ist. Das ist die Model der KI-Demokratisierung, an die ich tatsächlich glaube.

Geben Sie Ihrem Laptop computer dieses Wochenende ein neues Gehirn und es lebe Open Supply!

Ein Sprachmodell ist ein mathematisches Modell, das eine menschliche Sprache als Wahrscheinlichkeitsverteilung über ihren Wortschatz beschreibt. Um ein Deep-Studying-Netzwerk zum Modellieren einer Sprache zu trainieren, müssen Sie das Vokabular identifizieren und seine Wahrscheinlichkeitsverteilung lernen. Sie können das Modell nicht aus dem Nichts erstellen. Sie benötigen einen Datensatz, aus dem Ihr Modell lernen kann.

In diesem Artikel erfahren Sie mehr über Datensätze, die zum Trainieren von Sprachmodellen verwendet werden, und wie Sie gängige Datensätze aus öffentlichen Repositorys beziehen.

Fangen wir an.

Ein guter Datensatz zum Trainieren eines Sprachmodells

Ein gutes Sprachmodell sollte den korrekten Sprachgebrauch erlernen, frei von Vorurteilen und Fehlern. Im Gegensatz zu Programmiersprachen mangelt es menschlichen Sprachen an formaler Grammatik und Syntax. Sie entwickeln sich ständig weiter, sodass es unmöglich ist, alle Sprachvarianten zu katalogisieren. Daher sollte das Modell anhand eines Datensatzes trainiert werden, anstatt anhand von Regeln erstellt zu werden.

Das Einrichten eines Datensatzes für die Sprachmodellierung ist eine Herausforderung. Sie benötigen einen großen, vielfältigen Datensatz, der die Nuancen der Sprache darstellt. Gleichzeitig muss es hochwertig sein und den korrekten Sprachgebrauch wiedergeben. Idealerweise sollte der Datensatz manuell bearbeitet und bereinigt werden, um Störungen wie Tippfehler, Grammatikfehler und nichtsprachliche Inhalte wie Symbole oder HTML-Tags zu entfernen.

Die Erstellung eines solchen Datensatzes von Grund auf ist kostspielig, es sind jedoch mehrere hochwertige Datensätze frei verfügbar. Zu den gängigen Datensätzen gehören:

• Gemeinsames Kriechen. Ein riesiger, kontinuierlich aktualisierter Datensatz von über 9,5 Petabyte mit vielfältigen Inhalten. Es wird von führenden Modellen wie GPT-3, Llama und T5 verwendet. Da die Quelle jedoch aus dem Web stammt, enthält sie minderwertige und doppelte Inhalte sowie Vorurteile und anstößiges Materials. Um es nutzbar zu machen, sind gründliche Reinigung und Filterung erforderlich.
• C4 (Colossal Clear Crawled Corpus). Ein 750-GB-Datensatz aus dem Web. Im Gegensatz zu Frequent Crawl wird dieser Datensatz vorbereinigt und gefiltert, was die Verwendung erleichtert. Dennoch müssen Sie mit möglichen Vorurteilen und Fehlern rechnen. Das T5-Modell wurde auf diesem Datensatz trainiert.
• Wikipedia. Allein der englische Inhalt umfasst etwa 19 GB. Es ist riesig und dennoch überschaubar. Es ist intestine kuratiert, strukturiert und nach Wikipedia-Requirements bearbeitet. Obwohl es ein breites Spektrum an Allgemeinwissen mit hoher sachlicher Genauigkeit abdeckt, sind sein enzyklopädischer Stil und sein Ton sehr spezifisch. Das alleinige Coaching dieses Datensatzes kann dazu führen, dass Modelle zu stark an diesen Stil angepasst werden.
• WikiText. Ein Datensatz, der aus verifiziert guten und vorgestellten Wikipedia-Artikeln abgeleitet wurde. Es gibt zwei Versionen: WikiText-2 (2 Millionen Wörter aus Hunderten von Artikeln) und WikiText-103 (100 Millionen Wörter aus 28.000 Artikeln).
• BookCorpus. Ein wenige GB großer Datensatz langformatiger, inhaltsreicher und hochwertiger Buchtexte. Nützlich zum Erlernen kohärenten Geschichtenerzählens und weitreichender Abhängigkeiten. Es sind jedoch Urheberrechtsprobleme und soziale Vorurteile bekannt.
• Der Haufen. Ein 825 GB großer, kuratierter Datensatz aus mehreren Quellen, einschließlich BookCorpus. Es mischt verschiedene Textgenres (Bücher, Artikel, Quellcode und wissenschaftliche Arbeiten) und bietet so eine breite thematische Abdeckung, die auf multidisziplinäres Denken ausgelegt ist. Diese Vielfalt führt jedoch zu unterschiedlicher Qualität, doppelten Inhalten und inkonsistenten Schreibstilen.

Abrufen der Datensätze

Sie können on-line nach diesen Datensätzen suchen und sie als komprimierte Dateien herunterladen. Sie müssen jedoch das Format jedes Datensatzes verstehen und benutzerdefinierten Code schreiben, um ihn zu lesen.

Alternativ können Sie im Hugging Face-Repository unter nach Datensätzen suchen https://huggingface.co/datasets. Dieses Repository stellt eine Python-Bibliothek bereit, mit der Sie Datensätze in Echtzeit in einem standardisierten Format herunterladen und lesen können.

Laden wir den WikiText-2-Datensatz von Hugging Face herunter, einen der kleinsten Datensätze, die zum Aufbau eines Sprachmodells geeignet sind:

Die Ausgabe könnte so aussehen:

Falls Sie dies noch nicht getan haben, installieren Sie die Hugging Face-Datensatzbibliothek:

Wenn Sie diesen Code zum ersten Mal ausführen, load_dataset() lädt den Datensatz auf Ihren lokalen Laptop herunter. Stellen Sie sicher, dass Sie über ausreichend Speicherplatz verfügen, insbesondere bei großen Datensätzen. Standardmäßig werden Datensätze heruntergeladen ~/.cache/huggingface/datasets.

Alle Hugging Face-Datensätze folgen einem Standardformat. Der dataset Das Objekt ist ein iterierbares Objekt, wobei jedes Ingredient als Wörterbuch fungiert. Für das Sprachmodelltraining enthalten Datensätze normalerweise Textzeichenfolgen. In diesem Datensatz wird Textual content unter gespeichert "textual content" Schlüssel.

Der obige Code probiert einige Elemente aus dem Datensatz. Sie sehen Klartextzeichenfolgen unterschiedlicher Länge.

Nachbearbeitung der Datensätze

Bevor Sie ein Sprachmodell trainieren, möchten Sie möglicherweise den Datensatz nachbearbeiten, um die Daten zu bereinigen. Dazu gehört die Neuformatierung von Textual content (Abschneiden langer Zeichenfolgen, Ersetzen mehrerer Leerzeichen durch einzelne Leerzeichen), das Entfernen nichtsprachlicher Inhalte (HTML-Tags, Symbole) und das Entfernen unerwünschter Zeichen (zusätzliche Leerzeichen um Satzzeichen). Die spezifische Verarbeitung hängt vom Datensatz und davon ab, wie Sie dem Modell Textual content präsentieren möchten.

Wenn Sie beispielsweise ein kleines Modell im BERT-Stil trainieren, das nur Kleinbuchstaben verarbeitet, können Sie die Vokabulargröße reduzieren und den Tokenizer vereinfachen. Hier ist eine Generatorfunktion, die nachbearbeiteten Textual content bereitstellt:

Eine gute Nachbearbeitungsfunktion zu erstellen ist eine Kunst. Es sollte das Sign-Rausch-Verhältnis des Datensatzes verbessern, um dem Modell zu helfen, besser zu lernen, und gleichzeitig die Fähigkeit bewahren, unerwartete Eingabeformate zu verarbeiten, auf die ein trainiertes Modell möglicherweise stößt.

Weitere Lektüre

Nachfolgend finden Sie einige Ressourcen, die für Sie nützlich sein könnten:

Zusammenfassung

In diesem Artikel haben Sie etwas über Datensätze erfahren, die zum Trainieren von Sprachmodellen verwendet werden, und darüber, wie Sie allgemeine Datensätze aus öffentlichen Repositorys beziehen. Dies ist nur ein Ausgangspunkt für die Erkundung von Datensätzen. Erwägen Sie die Nutzung vorhandener Bibliotheken und Instruments, um die Ladegeschwindigkeit von Datensätzen zu optimieren, damit diese nicht zu einem Engpass in Ihrem Trainingsprozess werden.

Zusammenfassung

• Cross -Entropy -Maßnahmen in Bits, wie überraschend das wahre Token unter der vorhergesagten Verteilung Ihres Modells steht.
• Das Ziel ist nicht nur das Ziel, das Sie sowohl während der Vorab- als auch bei der Feinabstimmung aktiv optimieren, sondern es wird auch passiv als Bewertungsmetrik verwendet.
• Es ist zwar glatt, differenzierbar und rechnerisch effizient, was es ideally suited für die Gradientenoptimierung ist, kann es numerisch instabil sein.

Der Verlust von Cross -Entropie gilt als eines der Eckpfeilermetriken bei der Bewertung von Sprachmodellen und dient sowohl als Trainingsziel als auch als Evaluierungsmetrik. In diesem umfassenden Leitfaden untersuchen wir, was der Kreuzentropieverlust ist, wie er speziell im Kontext von funktioniert Großspracher Modelle (LLMs)und warum es so wichtig ist, die Modellleistung zu verstehen.

Egal, ob Sie ein maschinelles Lernpraktiker, ein Forscher oder ein jemand verstehen, der verstehen, wie moderne KI -Systeme geschult und bewertet werden, dieser Artikel bietet Ihnen ein gründliches Verständnis des Cross -Entropy -Verlusts und ihrer Bedeutung in der Welt der Sprachmodellierung.

Was ist Cross -Entropy -Verlust?

Cross -Entropy -Verlust misst die Leistung von a Einstufung Modell, dessen Ausgabe eine Wahrscheinlichkeitsverteilung ist. Im Kontext von Sprachmodellen quantifiziert es den Unterschied zwischen der vorhergesagten Wahrscheinlichkeitsverteilung des nächsten Tokens und der tatsächlichen Verteilung (normalerweise einem hot-codierten Vektor, der das wahre Subsequent-Token darstellt).

Schlüsselmerkmale des Cross-Entropy-Verlusts

• Informationstheoriestiftung: Die in der Informationstheorie verwurzelte Cross -Entropie misst, wie viele Informationen erforderlich sind, um Ereignisse aus einer Wahrscheinlichkeitsverteilung (die wahre Verteilung) zu identifizieren, wenn ein Codierungsschema für eine andere Verteilung (die vorhergesagte) optimiert wird.
• Probabilistische Ausgabe: Arbeitet mit Modellen, die Wahrscheinlichkeitsverteilungen und nicht deterministische Ausgaben erzeugen.
• Asymmetrisch: Im Gegensatz zu einigen anderen Distanzmetriken ist die Kreuzentropie nicht symmetrisch – die Reihenfolge der wahren und vorhergesagten Verteilungen.
• Differenzierbar: Kritisch für gradientenbasierte Optimierungsmethoden, die im neuronalen Netzwerktraining verwendet werden.
• Vertrauensempfindlich.

Lesen Sie auch: Wie bewerten Sie ein großes Sprachmodell (LLM)?

Binärkreuzentropie & Formel

Für binäre Klassifizierungsaufgaben (wie einfach Ja/Nein Fragen oder Stimmungsanalyse), binäre Kreuzentropie wird verwendet:

Wo:

• y_i ist das wahre Etikett (0 oder 1)
• yⁱ ist die vorhergesagte Wahrscheinlichkeit
• N ist die Anzahl der Proben

Binärer Kreuzentropie ist auch als bekannt als Protokollverlustinsbesondere bei maschinellen Lernwettbewerben.

Kreuzentropie als Verlustfunktion

Während des Trainings dient Cross Entropy als objektive Funktion, die das Modell minimieren versucht. Durch Vergleich der vorhergesagten Wahrscheinlichkeitsverteilung des Modells mit der Grundwahrheit passt der Trainingsalgorithmus die Modellparameter an, um die Diskrepanz zwischen Vorhersagen und Realität zu verringern.

Die Rolle von Entropy in LLMs überschreiten

In Großsprachenmodellen spielt der Verlust von Cross Entropy mehrere entscheidende Rollen:

1. Trainingsziel: Das Hauptziel während der Voraussetzung und der Feinabstimmung ist die Minimierung des Verlusts.
2. Bewertungsmetrik: Wird verwendet, um die Modellleistung an gehaltenen Daten zu bewerten.
3. Verwirrungsberechnung: Verwirrung, eine weitere häufige LLM -Bewertungsmetrik, wird von der Kreuzentropie abgeleitet: Verwirrung = 2^{Crossentropy}.
4. Modellvergleich: Verschiedene Modelle können basierend auf ihrem Verlust auf demselben Datensatz verglichen werden.
5. Bewertung der Lernung von Übertragung: Dies kann angeben, wie intestine ein Modell das Wissen von der Vorausbildung auf nachgeschaltete Aufgaben überträgt.

Wie funktioniert es?

Für Sprachmodelle funktioniert der Verlust von Cross Entropy wie folgt:

1. Das Modell prognostiziert eine Wahrscheinlichkeitsverteilung über den gesamten Wortschatz für das nächste Token.
2. Diese Verteilung wird mit der tatsächlichen Verteilung verglichen (normalerweise ein HOT-Vektor, bei dem das tatsächliche Subsequent-Token Wahrscheinlichkeit 1 hat).
3. Die damaging Log-Chance des wahren Tokens unter der Verteilung des Modells wird berechnet.
4. Dieser Wert wird in der Sequenz oder dem Datensatz über alle Token gemittelt.

Formeln und Erklärung

Die allgemeine Formel für den Verlust des Kreuzentropie -Verlusts bei der Sprachmodellierung lautet:

Wo:

• N ist die Anzahl der Token in der Sequenz
• V ist die Wortschatzgröße
• y_ichJ ist 1, wenn Token J das richtige neben Token an Place I ist, sonst 0
• y^ichJ ist die vorhergesagte Wahrscheinlichkeit von Token J an Place I.

Da wir uns normalerweise mit einer mit einem heißen kodierten Bodenwahrheit zu beschäftigen, vereinfacht dies zu:

Wo t_ichIst der Index des wahren Tokens an Place i.

Implementierung der Entropieverlust im Pytorch- und Tensorflow -Code

# PyTorch Implementation

import torch

import torch.nn as nn

import torch.nn.purposeful as F

import numpy as np

import matplotlib.pyplot as plt

# Easy Language Mannequin in PyTorch

class SimpleLanguageModel(nn.Module):

    def __init__(self, vocab_size, embedding_dim, hidden_dim):

        tremendous(SimpleLanguageModel, self).__init__()

        self.embedding = nn.Embedding(vocab_size, embedding_dim)

        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)

        self.fc = nn.Linear(hidden_dim, vocab_size)

    def ahead(self, x):

        # x form: (batch_size, sequence_length)

        embedded = self.embedding(x)  # (batch_size, sequence_length, embedding_dim)

        lstm_out, _ = self.lstm(embedded)  # (batch_size, sequence_length, hidden_dim)

        logits = self.fc(lstm_out)  # (batch_size, sequence_length, vocab_size)

        return logits

# Guide Cross Entropy Loss calculation

def manual_cross_entropy_loss(logits, targets):

    """

    Computes cross entropy loss manually

    Args:

        logits: Uncooked mannequin outputs (batch_size, sequence_length, vocab_size)

        targets: True token indices (batch_size, sequence_length)

    """

    batch_size, seq_len, vocab_size = logits.form

    # Reshape for simpler processing

    logits = logits.reshape(-1, vocab_size)  # (batch_size*sequence_length, vocab_size)

    targets = targets.reshape(-1)  # (batch_size*sequence_length)

    # Convert logits to chances utilizing softmax

    probs = F.softmax(logits, dim=1)

    # Get chance of the right token for every place

    correct_token_probs = probs(vary(len(targets)), targets)

    # Compute damaging log chance

    nll = -torch.log(correct_token_probs + 1e-10)  # Add small epsilon to stop log(0)

    # Common over all tokens

    loss = torch.imply(nll)

    return loss

# Instance utilization

def pytorch_example():

    # Parameters

    vocab_size = 10000

    embedding_dim = 128

    hidden_dim = 256

    batch_size = 32

    seq_length = 50

    # Pattern knowledge

    inputs = torch.randint(0, vocab_size, (batch_size, seq_length))

    targets = torch.randint(0, vocab_size, (batch_size, seq_length))

    # Create mannequin

    mannequin = SimpleLanguageModel(vocab_size, embedding_dim, hidden_dim)

    # Get mannequin outputs

    logits = mannequin(inputs)

    # PyTorch's built-in loss perform

    criterion = nn.CrossEntropyLoss()

    # For CrossEntropyLoss, we have to reshape

    pytorch_loss = criterion(logits.view(-1, vocab_size), targets.view(-1))

    # Our guide implementation

    manual_loss = manual_cross_entropy_loss(logits, targets)

    print(f"PyTorch CrossEntropyLoss: {pytorch_loss.merchandise():.4f}")

    print(f"Guide CrossEntropyLoss: {manual_loss.merchandise():.4f}")

    return mannequin, logits, targets

# TensorFlow Implementation

def tensorflow_implementation():

    import tensorflow as tf

    # Parameters

    vocab_size = 10000

    embedding_dim = 128

    hidden_dim = 256

    batch_size = 32

    seq_length = 50

    # Easy Language Mannequin in TensorFlow

    class TFSimpleLanguageModel(tf.keras.Mannequin):

        def __init__(self, vocab_size, embedding_dim, hidden_dim):

            tremendous(TFSimpleLanguageModel, self).__init__()

            self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)

            self.lstm = tf.keras.layers.LSTM(hidden_dim, return_sequences=True)

            self.fc = tf.keras.layers.Dense(vocab_size)

        def name(self, x):

            embedded = self.embedding(x)

            lstm_out = self.lstm(embedded)

            return self.fc(lstm_out)

    # Create mannequin

    tf_model = TFSimpleLanguageModel(vocab_size, embedding_dim, hidden_dim)

    # Pattern knowledge

    tf_inputs = tf.random.uniform((batch_size, seq_length), minval=0, maxval=vocab_size, dtype=tf.int32)

    tf_targets = tf.random.uniform((batch_size, seq_length), minval=0, maxval=vocab_size, dtype=tf.int32)

    # Get mannequin outputs

    tf_logits = tf_model(tf_inputs)

    # TensorFlow's built-in loss perform

    tf_loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

    tf_loss = tf_loss_fn(tf_targets, tf_logits)

    # Guide cross entropy calculation in TensorFlow

    def tf_manual_cross_entropy(logits, targets):

        batch_size, seq_len, vocab_size = logits.form

        # Reshape

        logits_flat = tf.reshape(logits, (-1, vocab_size))

        targets_flat = tf.reshape(targets, (-1))

        # Convert to chances

        probs = tf.nn.softmax(logits_flat, axis=1)

        # Get right token chances

        indices = tf.stack((tf.vary(tf.form(targets_flat)(0), dtype=tf.int32), tf.solid(targets_flat, tf.int32)), axis=1)

        correct_probs = tf.gather_nd(probs, indices)

        # Compute loss

        loss = -tf.reduce_mean(tf.math.log(correct_probs + 1e-10))

        return loss

    manual_tf_loss = tf_manual_cross_entropy(tf_logits, tf_targets)

    print(f"TensorFlow CrossEntropyLoss: {tf_loss.numpy():.4f}")

    print(f"Guide TF CrossEntropyLoss: {manual_tf_loss.numpy():.4f}")

    return tf_model, tf_logits, tf_targets

# Visualizing Cross Entropy

def visualize_cross_entropy():

    # True label is 1 (one-hot encoding could be (0, 1))

    true_label = 1

    # Vary of predicted chances for sophistication 1

    predicted_probs = np.linspace(0.01, 0.99, 100)

    # Calculate cross entropy loss for every predicted chance

    cross_entropy = (-np.log(p) if true_label == 1 else -np.log(1-p) for p in predicted_probs)

    # Plot

    plt.determine(figsize=(10, 6))

    plt.plot(predicted_probs, cross_entropy)

    plt.title('Cross Entropy Loss vs. Predicted Chance (True Class = 1)')

    plt.xlabel('Predicted Chance for Class 1')

    plt.ylabel('Cross Entropy Loss')

    plt.grid(True)

    plt.axvline(x=1.0, colour="r", linestyle="--", alpha=0.5, label="True Chance = 1.0")

    plt.legend()

    plt.present()

    # Visualize loss panorama for binary classification

    probs_0 = np.linspace(0.01, 0.99, 100)

    probs_1 = 1 - probs_0

    # Calculate loss for true label = 0

    loss_true_0 = (-np.log(1-p) for p in probs_0)

    # Calculate loss for true label = 1

    loss_true_1 = (-np.log(p) for p in probs_0)

    plt.determine(figsize=(10, 6))

    plt.plot(probs_0, loss_true_0, label="True Label = 0")

    plt.plot(probs_0, loss_true_1, label="True Label = 1")

    plt.title('Cross Entropy Loss for Completely different True Labels')

    plt.xlabel('Predicted Chance for Class 1')

    plt.ylabel('Cross Entropy Loss')

    plt.legend()

    plt.grid(True)

    plt.present()

# Run examples

if __name__ == "__main__":

    print("PyTorch Instance:")

    pt_model, pt_logits, pt_targets = pytorch_example()

    print("nTensorFlow Instance:")

    strive:

        tf_model, tf_logits, tf_targets = tensorflow_implementation()

    besides ImportError:

        print("TensorFlow not put in. Skipping TensorFlow instance.")

    print("nVisualizing Cross Entropy:")

    visualize_cross_entropy()

Codeanalyse:

Ich habe den Verlust von Cross-Entropy-Verlust sowohl in Pytorch als auch in TensorFlow implementiert und sowohl integrierte Funktionen als auch manuelle Implementierungen angezeigt. Gehen wir durch die Schlüsselkomponenten:

1. SimpleAluagemodel: Ein grundlegendes LSTM-basierter Sprachmodell, das die Wahrscheinlichkeiten für das nächste Token vorhersagt.
2. Manuelle Cross -Entropie -Implementierung: Zeigt, wie die Kreuzentropie aus den ersten Prinzipien berechnet wird:
   • Konvertieren Sie die Protokolls mit Softmax in Wahrscheinlichkeiten
   • Extrahieren Sie die Wahrscheinlichkeit des richtigen Tokens
   • Nehmen Sie das damaging Protokoll dieser Wahrscheinlichkeiten
   • Durchschnitt über alle Token
3. Visualisierungen: Der Code enthält Visualisierungen, die zeigen, wie sich der Verlust mit unterschiedlichen vorhergesagten Wahrscheinlichkeiten ändert.

Ausgabe:

PyTorch Instance:
PyTorch CrossEntropyLoss: 9.2140
Guide CrossEntropyLoss: 9.2140
TensorFlow Instance:
TensorFlow CrossEntropyLoss: 9.2103
Guide TF CrossEntropyLoss: 9.2103

Die Visualisierungen veranschaulichen, wie der Verlust dramatisch zunimmt, wenn Vorhersagen von den wahren Beschriftungen abweichen, insbesondere wenn das Modell zuversichtlich falsch ist.

Vorteile und Einschränkungen

Praktische Anwendungen

Der Verlust des Kreuzentropieverlusts wird ausführbar in Sprachmodellanwendungen verwendet:

1. Schulungsfundamentmodelle: Cross-Entropy-Verlust ist die Customary-Objektivfunktion für Großsprachenmodelle vor dem Coaching zu massiven Textkorpora.
2. Feinabstimmung: Bei der Anpassung vor ausgebildeter Modelle an bestimmte Aufgaben bleibt die Cross-Entropie die Fachfunktion.
3. Sequenzgenerierung: Auch wenn Textual content generiert wird, beeinflusst der Verlust während des Trainings die Qualität der Ausgaben des Modells.
4. Modellauswahl: Beim Vergleich verschiedener Modellarchitekturen oder Hyperparametereinstellungen ist der Verlust der Validierungsdaten eine Schlüsselmetrik.
5. Domänenanpassung: Messen Sie, wie sich die Veränderungen der Kreuzentropie zwischen Domänen ändert, zeigen an, wie intestine ein Modell verallgemeinert wird.
6. Wissensdestillation: Wird verwendet, um das Wissen von größeren „Lehrer“ -Modellen auf kleinere „Schüler“ -Modelle zu übertragen.

Vergleich mit anderen Metriken

Während der Verlust von Kreuzentropie grundlegend ist, wird er häufig neben anderen Bewertungsmetriken verwendet:

• Verwirrung: Exponential der Kreuzentropie; Interpretierbarer, wie es darstellt, wie „verwirrt“ das Modell ist
• Bleu/ROUGE: Für Erzeugungsaufgaben erfassen diese Metriken die N-Gramm-Überlappung mit Referenztexten
• Genauigkeit: Einfacher Prozentsatz der korrekten Vorhersagen, weniger informativ als Kreuzentropie
• F1 -Punktzahl: Gleiche Präzision und Rückruf für Klassifizierungsaufgaben
• KL -Divergenz: Misst, wie eine Wahrscheinlichkeitsverteilung von einer anderen abweicht
• Entfernung von Earth Mover: Im Gegensatz zur Kreuzentropie berücksichtigt die semantische Ähnlichkeit zwischen Tokens

Lesen Sie auch: High 15 LLM -Bewertungsmetriken, die 2025 untersucht werden sollen

Abschluss

Der Verlust von Cross Entropy ist ein unverzichtbares Werkzeug bei der Bewertung und Ausbildung von Sprachmodellen. Seine theoretischen Grundlagen in der Informationstheorie, kombiniert mit ihren praktischen Vorteilen für die Optimierung, machen es für die meisten NLP -Aufgaben zur Standardwahl.

Das Verständnis des Cross-Entropy-Verlusts bietet Einblicke nicht nur in die Ausbildung von Modellen, sondern auch in ihre grundlegenden Einschränkungen und die Kompromisse bei der Sprachmodellierung. Während sich die Sprachmodelle weiterentwickeln, bleibt der Verlust von Cross Entropy eine Eckpfeilermetrik, die Forschern und Praktikern hilft, den Fortschritt zu messen und Innovationen zu leiten.

Unabhängig davon, ob Sie Ihre Sprachmodelle aufbauen oder vorhandene bewerten, ist ein gründliches Verständnis des Verlusts von Kreuzentropie für fundierte Entscheidungen und die korrekte Interpretation der Ergebnisse von wesentlicher Bedeutung.