Quantisierung von LLMs Schritt für Schritt: Konvertieren von FP16-Modellen in GGUF

In diesem Artikel erfahren Sie, wie Quantisierung große Sprachmodelle verkleinert und wie Sie einen FP16-Prüfpunkt in eine effiziente GGUF-Datei umwandeln, die Sie teilen und lokal ausführen können.

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

• Was Präzisionstypen (FP32, FP16, 8-Bit, 4-Bit) für Modellgröße und Geschwindigkeit bedeuten
• Wie zu verwenden huggingface_hub um ein Modell abzurufen und zu authentifizieren
• So konvertieren Sie mit in GGUF llama.cpp und laden Sie das Ergebnis hoch Umarmendes Gesicht

Und los geht’s.

Quantisierung von LLMs Schritt für Schritt: Konvertieren von FP16-Modellen in GGUF
Bild vom Autor

Einführung

Große Sprachmodelle wie LLaMA, Mistral und Qwen verfügen über Milliarden von Parametern, die viel Speicher und Rechenleistung erfordern. Beispielsweise kann die Ausführung von LLaMA 7B mit voller Präzision über 12 GB VRAM erfordern, was es für viele Benutzer unpraktisch macht. Die Particulars können Sie hier nachlesen Diskussion über „Umarmendes Gesicht“.. Machen Sie sich noch keine Gedanken darüber, was „volle Präzision“ bedeutet. Wir werden es bald aufschlüsseln. Die Grundidee ist folgende: Diese Modelle sind zu groß, um ohne Hilfe auf Standardhardware zu laufen. Quantisierung ist diese Hilfe.

Durch die Quantisierung können unabhängige Forscher und Bastler große Modelle auf PCs ausführen, indem sie die Größe des Modells verkleinern, ohne die Leistung erheblich zu beeinträchtigen. In diesem Leitfaden untersuchen wir, wie die Quantisierung funktioniert, was verschiedene Präzisionsformate bedeuten, und gehen dann durch die Quantisierung eines Beispiel-FP16-Modells in ein GGUF-Format und dessen Hochladen Umarmendes Gesicht.

Was ist Quantisierung?

Auf einer sehr grundlegenden Ebene geht es bei der Quantisierung darum, ein Modell zu verkleinern, ohne es zu zerstören. Große Sprachmodelle bestehen aus Milliarden aufgerufener numerischer Werte Gewichte. Diese Zahlen steuern, wie stark sich verschiedene Teile des Netzwerks gegenseitig beeinflussen, wenn sie einen Output erzeugen. Standardmäßig werden diese Gewichte in hochpräzisen Formaten wie FP32 oder FP16 gespeichert, was bedeutet, dass jede Zahl viel Speicher beansprucht und wenn man Milliarden davon hat, geraten die Dinge sehr schnell außer Kontrolle. Nehmen Sie eine einzelne Zahl wie 2.31384. In FP32 benötigt allein diese eine Zahl 32 Bit Speicher. Stellen Sie sich nun vor, Milliarden von Zahlen auf diese Weise zu speichern. Aus diesem Grund kann ein 7B-Modell im FP32 problemlos etwa 28 GB und selbst im FP16 etwa 14 GB aufnehmen. Für die meisten Laptops und GPUs ist das bereits zu viel.

Die Quantisierung behebt dieses Downside, indem sie sagt: Wir brauchen eigentlich nicht mehr so ​​viel Präzision. Statt zu lagern 2.31384 genau, wir speichern etwas in der Nähe davon mit weniger Bits. Vielleicht wird es 2.3 oder ein nahegelegener ganzzahliger Wert unter der Haube. Die Zahl ist etwas ungenauer, aber das Modell verhält sich in der Praxis immer noch gleich. Neuronale Netze können diese kleinen Fehler tolerieren, da die endgültige Ausgabe von Milliarden von Berechnungen abhängt und nicht von einer einzigen Zahl. Kleine Unterschiede gleichen sich aus, ähnlich wie die Bildkomprimierung die Dateigröße reduziert, ohne das Erscheinungsbild des Bildes zu beeinträchtigen. Aber der Gewinn ist riesig. Ein Modell, das im FP16 14 GB benötigt, kann bei 8-Bit-Quantisierung häufig mit etwa 7 GB oder bei 4-Bit-Quantisierung sogar mit etwa 4 GB betrieben werden. Dadurch ist es möglich, große Sprachmodelle lokal auszuführen, anstatt auf teure Server angewiesen zu sein.

Nach der Quantisierung speichern wir das Modell häufig in einem einheitlichen Dateiformat. Ein beliebtes Format ist GGUFerstellt von Georgi Gerganov (Autor von llama.cpp). GGUF ist ein Einzeldateiformat, das sowohl die quantisierten Gewichte als auch nützliche Metadaten enthält. Es ist für schnelles Laden und Inferenzieren auf CPUs oder anderen leichtgewichtigen Laufzeiten optimiert. GGUF unterstützt auch mehrere Quantisierungstypen (wie Q4_0, Q8_0) und funktioniert intestine auf CPUs und Low-Finish-GPUs. Hoffentlich verdeutlicht dies sowohl das Konzept als auch die Motivation hinter der Quantisierung. Kommen wir nun zum Schreiben von Code.

Schritt-für-Schritt: Quantisierung eines Modells zu GGUF

1. Abhängigkeiten installieren und bei Hugging Face protokollieren

Bevor wir ein Modell herunterladen oder konvertieren, müssen wir die erforderlichen Python-Pakete installieren und uns authentifizieren Umarmendes Gesicht. Wir werden verwenden Huggingface_hub, TransformatorenUnd Satzstück. Dadurch wird sichergestellt, dass wir fehlerfrei auf öffentliche oder geschlossene Modelle zugreifen können:

2. Herunterladen eines vorab trainierten Modells

Wir werden ein kleines FP16-Modell auswählen Umarmendes Gesicht. Hier verwenden wir TinyLlama 1.1B, das klein genug ist, um in Colab zu laufen, aber dennoch eine gute Demonstration bietet. Mit Python können wir es herunterladen huggingface_hub:

Dieser Befehl speichert die Modelldateien im model_folder Verzeichnis. Sie können ersetzen model_id mit einer beliebigen Hugging Face-Modell-ID, die Sie quantisieren möchten. (Bei Bedarf können Sie auch verwenden AutoModel.from_pretrained mit torch.float16 um es zuerst zu laden, aber snapshot_download ist einfach, die Dateien zu holen.)

3. Einrichten der Konvertierungstools

Als nächstes klonen wir die lama.cpp Repository, das die Konvertierungsskripte enthält. In Colab:

Dadurch erhalten Sie Zugriff auf convert_hf_to_gguf.py. Die Python-Anforderungen stellen sicher, dass Sie über alle erforderlichen Bibliotheken zum Ausführen des Skripts verfügen.

4. Konvertieren des Modells in GGUF mit Quantisierung

Führen Sie nun das Konvertierungsskript aus und geben Sie dabei den Eingabeordner, den Namen der Ausgabedatei und den Quantisierungstyp an. Wir werden verwenden q8_0 (8-Bit-Quantisierung). Dadurch wird der Speicherbedarf des Modells ungefähr halbiert:

Hier /content material/model_folder Hier haben wir das Modell heruntergeladen. /content material/tinyllama-1.1b-chat.Q8_0.gguf ist die Ausgabe-GGUF-Datei und die --outtype q8_0 Flag bedeutet „Auf 8 Bit quantisieren“. Das Skript lädt die FP16-Gewichte, wandelt sie in 8-Bit-Werte um und schreibt eine einzelne GGUF-Datei. Diese Datei ist jetzt viel kleiner und kann mit GGUF-kompatiblen Instruments abgeleitet werden.

Sie können die Ausgabe überprüfen:

Sie sollten eine Datei mit einer Größe von einigen GB sehen, die gegenüber dem ursprünglichen FP16-Modell verkleinert ist.

5. Hochladen des quantisierten Modells auf Hugging Face

Schließlich können Sie das GGUF-Modell veröffentlichen, damit andere es einfach herunterladen und verwenden können huggingface_hub Python-Bibliothek:

Dadurch wird ein neues Repository erstellt (falls noch nicht vorhanden) und Ihre quantisierte GGUF-Datei hochgeladen. Jeder kann es jetzt laden llama.cpp, llama-cpp-pythonoder Ollama. Sie können auf die von uns erstellte quantisierte GGUF-Datei zugreifen Hier.

Zusammenfassung

Wenn Sie die oben genannten Schritte ausführen, können Sie alle unterstützten Dateien verwenden Umarmendes Gesicht Modell, quantisieren Sie es (z. B. auf 4-Bit oder 8-Bit) und speichern Sie es als GGUF. Schieben Sie es dann zum Teilen oder Bereitstellen auf Hugging Face. Dies macht es einfacher denn je, große Sprachmodelle auf alltäglicher {Hardware} zu komprimieren und zu verwenden.