Wie konvertiere ich Modelle in das GGUF -Format?

Als Großsprachmodelle (LLMs) wachsen in skalierter Skalierung weiter, sodass effiziente Möglichkeiten zum Speichern, Bereitstellen und Ausführen von Geräten mit niedrigem Ressourcen erforderlich sind. Während diese Modelle leistungsstarke Funktionen bieten, können ihre Größe und der Speicheranforderungen die Bereitstellung zu einer Herausforderung machen, insbesondere für Verbraucherhardware. Hier kommen Modellquantisierung und spezialisierte Speicherformate wie GGUF (Generic GPT Unified Format) ins Spiel.

In diesem Leitfaden befassen wir uns mit dem GGUF-Format, untersuchen seine Vorteile und bieten ein schrittweisen Tutorial zum Konvertieren von Modellen in GGUF. Unterwegs werden wir die Geschichte der Modellquantisierung berühren und wie sich GGUF entwickelt hat, um moderne LLMs zu unterstützen. Am Ende haben Sie ein tiefes Verständnis dafür, warum GGUF wichtig ist und wie Sie es für Ihre eigenen Modelle verwenden können.

Lernziele

• Verfassen Sie den Zweck und die Struktur des GGUF -Formats und seine Entwicklung von GGML.
• Definieren Sie die Quantisierung und beschreiben Sie deren Bedeutung bei der Reduzierung der Modellgröße und der Verbesserung der Bereitstellungseffizienz.
• Erkennen Sie die Komponenten der GGUF -Namenskonvention und wie sie bei der Modellidentifizierung und -verwaltung helfen.
• Verwenden Sie Lama.cpp, um Modelle zum GGUF -Format zu quantisieren.
• Beziehen Sie die Konzepte von GGUF und Quantisierung mit praktischen Anwendungsfällen und ermöglichen Sie eine effektive Bereitstellung von KI-Modellen in ressourcenbezogenen Umgebungen.

Dieser Artikel wurde als Teil des Data Science -Blogathons veröffentlicht.

Inhaltsverzeichnis

• Entwicklung der Modellquantisierung
• Was ist GGUF?
• Warum GGUF verwenden?
• GGUF -Formatstruktur und Namenskonventionen
• Einrichten zur Konvertierung in das GGUF -Format
• Umwandlung von Modellen in GGUF
• Best Practices für die GGUF -Konvertierung
• Zukunft von GGUF- und Modellspeicherformaten
• Abschluss
• Häufig gestellte Fragen

Entwicklung der Modellquantisierung

Die Reise in Richtung GGUF beginnt mit dem Verständnis der Entwicklung der Modellquantisierung. Die Quantisierung verringert die Genauigkeit von Modellparametern und komprimiert sie effektiv, um den Speicher- und Rechenanforderungen zu reduzieren. Hier ist ein kurzer Überblick:

Frühe Formate und Herausforderungen

In den frühen Tagen wurden Deep Learning -Modelle in den nativen Formaten von Frameworks wie Tensorflow und Pytorch gespeichert. TensorFlow -Modelle verwendeten .PB -Dateien, während Pytorch .PT oder .PTH verwendet. Diese Formate funktionierten für kleinere Modelle, zeigten jedoch Einschränkungen:

• Größe: Modelle wurden im 32-Bit-Gleitkommaformat gespeichert, wodurch die Dateigrößen groß gemacht wurden.
• Speichergebrauch: Die Gewichte in voller Präzision forderten einen beträchtlichen Speicher, wodurch die Bereitstellung auf Geräten mit begrenztem RAM unpraktisch gestaltet wurde.

ONNX (Open Neural Network Exchange)

Der Aufstieg der Interoperabilität über Rahmenbedingungen hinweg führte zur Entwicklung von ONNX, wodurch die Modelle zwischen den Umgebungen bewegen konnten. Während ONNX einige Optimierungen lieferte, basiert es immer noch hauptsächlich auf Gewichten mit voller Präzision und bot eine begrenzte Quantisierungsunterstützung.

Quantisierungsbedarf

Als die Modelle größer wurden, wandten sich die Forscher der Quantisierung zu, wodurch Gewichte von 32-Bit-Schwimmer (FP32) bis 16-Bit (FP16) oder sogar niedriger sind, wie wie 8-Bit-Ganzzahlen (INT8). Dieser Ansatz senkte die Speicheranforderungen erheblich und ermöglicht es, Modelle auf mehr Hardware -Typen auszuführen. Zum Beispiel:

 # Notwendige Bibliotheken importieren
Taschenlampe importieren
taporch.nn als nn importieren
taporch.quantisierung als quant

# Schritt 1: Definieren Sie ein einfaches Modell für neuronales Netzwerk in Pytorch
Klasse SimpleModel (Nn.Module):
    def __init __ (selbst):
        Super (SimpleModel, Self) .__ init __ ()
        self.fc1 = nn.linear (10, 50) # Erste voll verbundene Schicht
        self.fc2 = nn.linear (50, 20) # zweite vollständig verbundene Schicht
        self.fc3 = nn.linear (20, 5) # Ausgangsschicht

    Def Forward (Selbst, x):
        x = fackel.relu (self.fc1 (x)) # Relu -Aktivierung nach der ersten Schicht
        x = fackel.relu (self.fc2 (x)) # Relu -Aktivierung nach der zweiten Schicht
        x = self.fc3 (x) # Ausgangsschicht
        Rückkehr x

# Schritt 2: Initialisieren Sie das Modell und wechseln Sie in den Bewertungsmodus
Modell = SimpleModel ()
model.eval ()

# Speichern Sie das Modell vor der Quantisierung als Referenz
fackler.save (Modell, "Simple_Model.PTH")

# Schritt 3: Dynamische Quantisierung auf das Modell anwenden
# Hier quantisieren wir nur die linearen Schichten und ändern ihre Gewichte in INT8
quantized_model = quant.quantize_dynamic (
    Modell, {Nn.Linear}, dType = t Torch.qint8
)

# Speichern Sie das quantisierte Modell
fackrete.save (quantized_model, "quantized_simple_model.pth")

# Beispielverbrauch des quantisierten Modells mit Dummy -Daten
dummy_input = fackel.randn (1, 10) # Beispiel Eingabezensor mit 10 Funktionen
output = quantized_model (dummy_input)
print ("Quantisierte Modellausgabe:", Ausgabe)

Überprüfen Sie die Größe des ursprünglichen und quantisierten Modells

Bei der Arbeit mit Großsprachmodellen ist das Verständnis des Größenunterschieds zwischen den ursprünglichen und den quantisierten Versionen von entscheidender Bedeutung. Dieser Vergleich zeigt nicht nur die Vorteile der Modellkomprimierung, sondern informiert auch Bereitstellungsstrategien für die effiziente Ressourcenverwendung.

 OS importieren

# Pfade zu den gespeicherten Modellen
origin_model_path = "simple_model.pth"
quantized_model_path = "quantized_simple_model.pth"

# Funktion, um die Dateigröße in KB zu erhalten
Def get_file_size (Pfad):
    size_bytes = os.path.getSize (Pfad)
    size_kb = size_bytes / 1024 # in kb konvertieren
    Return Size_KB

# Überprüfen Sie die Größen der ursprünglichen und quantisierten Modelle
original_size = get_file_size (original_model_path)
quantized_size = get_file_size (quantized_model_path)

print (f "Originalmodellgröße: {original_size: .2f} kb")
print (f "Quantisierte Modellgröße: {quantized_size: .2f} kb")
print (f "Größenreduzierung: {((original_size - quantized_size) / original_size) * 100: .2f}%"))

Selbst 8-Bit-Präzision war jedoch für extrem große Sprachmodelle wie GPT-3 oder Lama nicht ausreichend, was die Entwicklung neuer Formate wie GGML und schließlich GGUF anreichte.

Was ist GGUF?

GGUF oder generisches GPT Unified Format wurde als Erweiterung von GGML entwickelt, um noch größere Modelle zu unterstützen. Es handelt sich um ein Dateiformat zum Speichern von Modellen für die Inferenz mit GGML und Ausführern basierend auf GGML. GGUF ist ein binäres Format, das für das schnelle Laden und Einsparungen von Modellen sowie zum Lesen des Lesens ausgelegt ist. Modelle werden traditionell mit Pytorch oder einem anderen Framework entwickelt und dann zur Verwendung in GGML in GGUF konvertiert.

GGUF ist ein Nachfolgedateiformat für GGML, GGMF und GGJT und ist so konzipiert, dass alle Informationen zum Laden eines Modells erforderlich sind. Es ist auch so konzipiert, dass es erweiterbar ist, damit Modelle ohne Unterbrechbarkeit neuer Informationen hinzugefügt werden können. Es wurde mit drei Toren konzipiert:

• Effizienz: Ermöglicht große Modelle, auf CPUs und Verbraucher-Hardware effizient zu laufen.
• Skalierbarkeit: Unterstützt sehr große Modelle, oft 100 GB oder mehr.
• Flexibilität: Ermöglicht Entwicklern, zwischen unterschiedlichen Quantisierungsniveaus, die Größe der Modellgröße und die Genauigkeit des Ausgleichs zu wählen.

Warum GGUF verwenden?

Das GGUF-Format leuchtet für Entwickler, die große, ressourcenlastige Modelle für begrenzte Hardware einsetzen müssen, ohne die Leistung zu beeinträchtigen. Hier sind einige Kernvorteile:

• Quantisierungsunterstützung: GGUF unterstützt einen Bereich von Quantisierungsniveaus (4-Bit, 8-Bit), was erhebliche Speichereinsparungen ermöglicht und gleichzeitig die Modellgenauigkeit aufrechterhält.
• Metadatenspeicher: GGUF kann detaillierte Metadaten wie Modellarchitektur, Tokenisierungsschemata und Quantisierungsniveaus speichern. Diese Metadaten erleichtern das Laden und Konfigurieren von Modellen.
• Inferenzoptimierung: GGUF optimiert den Speichergebrauch und ermöglicht eine schnellere Inferenz in CPU-basierten Systemen.

GGUF -Formatstruktur und Namenskonventionen

Das GGUF -Format verwendet eine spezifische Namenskonvention, um wichtige Modellinformationen auf einen Blick bereitzustellen. Diese Konvention hilft Benutzern, wichtige Modellmerkmale wie Architektur, Parametergröße, Feinabstimmungstyp, Version, Codierungstyp und Shard-Daten zu identifizieren-das Modellmanagement und die Bereitstellung einfacher.

Die GGUF -Namenskonvention folgt dieser Struktur:

Jede Komponente im Namen bietet Einblick in das Modell:

• Basisname: Deskriptiver Name für den Modellbasis oder Architektur, abgeleitet von Metadaten (z. B. Lama oder Mixtral).
• SizElabel: Zeigt die Modellgröße an, indem ein X-Format verwendet wird, dh : Anzahl der Experten (z. B. 8), : Modellparameterskala wie Q für Quadrillionen, T für Billionen, B für Milliarden, m für Million, k für tausend Parameter.
• Finetune: Modell Feinabstimmungsziel wie "Chat" oder "Anweisungen".
• Version: Modellversionsnummer in V . Format, mit v1.0 standardmäßig bei nicht spezifiziert.
• Codierung: Gewichtscodierungsschema, anpassbar pro Projekt.

• Typ: Zeigt den GGUF -Dateityp an, z. B. LORA für Adapter oder Vokabellen für Vokabulardaten.
• Shard: bezeichnet ein in Teile aufgeteiltes Modell, das als -of- formatiert ist.

Namensbeispiele

Einrichten zur Konvertierung in das GGUF -Format

Stellen Sie vor dem Eintauchen in die Konvertierung sicher, dass Sie die folgenden Voraussetzungen haben:

• Python 3.8 in Ihrem System installiert.
• Modellquelldatei: Typischerweise ein Pytorch- oder Tensorflow -Modell (z. B. Lama, Falcon) oder ein Modell vom Umarmungsgesicht.
• GGUF-Conversion-Tools: Diese Tools basieren häufig auf GGML-Bibliotheken oder spezifischen Modell-Konversionskripten.

Einige bemerkenswerte Quantisierungstechniken

Quantisierungstechniken spielen eine entscheidende Rolle bei der Optimierung neuronaler Netzwerke, indem sie ihre Größe und Rechenanforderungen reduzieren. Durch die Umwandlung hochpräziser Gewichte und Aktivierungen in niedrigere Bitdarstellungen ermöglichen diese Methoden eine effiziente Bereitstellung von Modellen, ohne die Leistung signifikant zu beeinträchtigen.

Umwandlung von Modellen in GGUF

Im Folgenden finden Sie Ihr Modell in das GGUF -Format.

Schritt 1: Wählen Sie das Modell zur Quantisierung aus

In diesem Fall wählen wir das Flan-T5-Modell von Google, um zu quantisieren. Sie können dem Befehl folgen, um das Modell direkt von Suggingface herunterzuladen

 ! Pip Installieren Sie die Huggingface-Hub

vom Huggingface_Hub importieren snapshot_download

Modell_ # Ersetzen Sie durch die ID des Modells, das Sie herunterladen möchten
snapshot_download (repo_id = model_id, local_dir = "t5")

Schritt 2: Klonen Sie das Lama.cpp -Repository klonen

Wir verwenden LLAMA.CPP, um das Modell zum GGUF -Format zu quantisieren

 ! Git Clone https://github.com/ggerganov/llama.cpp

Schritt 3: Installieren Sie die erforderlichen Abhängigkeiten

Wenn Sie in Google Collaboratory den folgenden Code befolgen, können Sie sich ansonsten zum Anforderungsverzeichnis navigieren, um die „Anforderungen zu konvert_hf_to_gguf.txt“ zu installieren.

 !

Schritt 4: Wählen Sie die Quantisierungsstufe aus

Das Quantisierungsniveau bestimmt den Kompromiss zwischen Modellgröße und Genauigkeit. Die Quantisierung mit niedrigerer Bit (wie 4-Bit) spart Speicher, kann jedoch die Genauigkeit verringern. Wenn Sie beispielsweise auf eine CPU-Bereitstellung abzielen und keine maximale Präzision benötigen, ist INT4 möglicherweise eine gute Wahl. Hier wählen wir "Q8_0".

Schritt 5: Führen Sie das Konvertierungsskript aus

Wenn in Google Collab Collaby das folgende Skript ausführen, folgen Sie sonst dem Kommentar.

 #! Python {Pfad zu convert_hf_to_gguf.py} {Pfad zu hf_model} - -outfile {name_of_outputfile.gguf} -outtyp {Quantisierungstyp}}

!

• Pfad zu hf_model: Pfad zum Modellverzeichnis.
• name_of_outputfile.gguf: Name der Ausgabedatei, in der das GGUF -Modell gespeichert wird. Verwenden Sie die GGUF -Naming -Konvention, wenn Sie das quantisierte Modell zurück in das umarmende Gesicht drücken.
• Quantisierungstyp: Gibt den Quantisierungstyp an (in diesem Fall quantisierte 8-Bit-Ganzzahl).

Vergleich der Größe des ursprünglichen VS -quantisierten Modells

Bei der Bereitstellung maschineller Lernmodelle ist das Verständnis des Größenunterschieds zwischen den ursprünglichen und quantisierten Versionen von entscheidender Bedeutung. In diesem Vergleich wird hervorgehoben, wie die Quantisierung die Modellgröße erheblich verringern kann, was zu einer verbesserten Effizienz und schnelleren Inferenzzeiten ohne erheblichen Genauigkeitsverlust führt.

 # Überprüfen Sie die Größen der ursprünglichen und quantisierten Modelle
original_model_path = "/content/t5/model.safetensors"
quantized_model_path = "t5.gguf"
original_size = get_file_size (original_model_path)
quantized_size = get_file_size (quantized_model_path)

print (f "Originalmodellgröße: {original_size: .2f} kb")
print (f "Quantisierte Modellgröße: {quantized_size: .2f} kb")
print (f "Größenreduzierung: {((original_size - quantized_size) / original_size) * 100: .2f}%"))

Wir konnten eine Größenreduzierung von erstaunlichen 73,39% unter Verwendung der GGUF -Quantisierungstechnik sehen.

Best Practices für die GGUF -Konvertierung

Um die besten Ergebnisse zu erzielen, denken Sie an diese Tipps:

• Experimentieren Sie mit Quantisierungsniveaus: Testen Sie mehrere Ebenen (z. B. 4-Bit, 8-Bit), um das beste Gleichgewicht zwischen Modellgenauigkeit und Gedächtniseffizienz zu finden.
• Verwenden Sie Metadaten zu Ihrem Vorteil: Der umfangreiche Metadatenspeicher von GGUF kann das Laden von Modellen vereinfachen und die Laufzeitkonfigurationsanforderungen reduzieren.
• Benchmark -Inferenz: Benchmarke das GGUF -Modell auf Ihrer Zielhardware immer, um sicherzustellen, dass es den Anforderungen an die Geschwindigkeit und Genauigkeit entspricht.

Zukunft von GGUF- und Modellspeicherformaten

Wenn Modelle weiter wachsen, spielen Formate wie GGUF eine zunehmend kritische Rolle bei der Ergänzung von KI in großem Maßstab. Möglicherweise sehen wir bald fortgeschrittenere Quantisierungstechniken, die noch mehr Genauigkeit bewahren und gleichzeitig die Speicheranforderungen weiter verringern. Derzeit bleibt GGUF im Vordergrund und ermöglicht eine effiziente Bereitstellung von Großsprachmodellen für CPUs und Kantengeräte.

Abschluss

Das GGUF-Format ist ein Game-Changer für die effiziente Bereitstellung von großsprachigen Modellen auf begrenzten Ressourcengeräten. Von frühen Bemühungen zur Modellquantisierung bis zur Entwicklung von GGUF hat sich die Landschaft der KI -Modellspeicherung entwickelt, um leistungsstarke Modelle für ein breiteres Publikum zugänglich zu machen. Wenn Sie diesem Handbuch folgen, können Sie jetzt Modelle in das GGUF-Format konvertieren, sodass sie für Anwendungen in der realen Welt einfacher bereitgestellt werden können.

Die Quantisierung wird sich weiterentwickeln, aber die Fähigkeit von GGUF, unterschiedliche Präzisionsniveaus und ein effizientes Metadatenmanagement zu unterstützen, stellt sicher, dass es relevant bleibt. Versuchen Sie, Ihre Modelle in GGUF zu konvertieren und die Vorteile aus erster Hand zu erkunden!

Key Takeaways

• Das Generic GPT Unified Format (GGUF) ermöglicht eine effiziente Speicherung und Bereitstellung von großsprachigen Modellen (LLMs) auf Geräten mit niedrigem Ressourcen und berücksichtigt die Herausforderungen, die mit Modellgröße und Speicheranforderungen verbunden sind.
• Die Quantisierung reduziert die Modellgröße signifikant durch Komprimierungsparameter, sodass Modelle auf Hardware der Verbraucherqualität ausgeführt werden und gleichzeitig die wesentlichen Leistungsstufen aufrechterhalten werden können.
• Das GGUF -Format verfügt über eine strukturierte Namenskonvention, mit der wichtige Modelleigenschaften identifiziert und das Management und die Bereitstellung erleichtert werden können.
• Mithilfe von Tools wie LLAMA.CPP können Benutzer Modelle problemlos in das GGUF -Format konvertieren und diese für die Bereitstellung optimieren, ohne die Genauigkeit zu beeinträchtigen.
• GGUF unterstützt fortschrittliche Quantisierungsniveaus und umfangreiche Metadatenspeicher und macht es zu einer zukunftsgerichteten Lösung für den effizienten Einsatz immer großer KI-Modelle.

Häufig gestellte Fragen

Q1. Was ist GGUF und wie unterscheidet es sich von GGML?

A. GGUF (Generic GPT Unified Format) ist ein fortschrittliches Modellspeicherformat, mit dem quantisierte große Sprachmodelle effizient gespeichert und ausgeführt werden können. Im Gegensatz zu seinem Vorgänger, GGML, das nur eine begrenzte Skalierbarkeit von Modellen von mehr als 100 GB hat, unterstützt GGUF umfangreiche 4-Bit- und 8-Bit-Quantisierungsoptionen und bietet eine reichhaltige Speicherfähigkeit der Metadaten, die Verbesserung des Modellmanagements und die Bereitstellung.

Q2. Wie wirkt sich die Quantisierungsmodellleistung aus?

A. Quantisierung verringert die Genauigkeit der Parameter eines Modells und verringert seine Größe und den Speicherverbrauch erheblich. Während es zu einem leichten Rückgang der Genauigkeit führen kann, können gut gestaltete Quantisierungstechniken (wie die in GGUF) akzeptable Leistungsniveaus aufrechterhalten, was es möglich macht, große Modelle für ressourcenbezogene Geräte bereitzustellen.

Q3. Was sind die Hauptkomponenten der GGUF -Namenskonvention?

A. Die GGUF-Namenskonvention besteht aus mehreren Komponenten, einschließlich des Basisnamens (Modellarchitektur), Sizelabel (Parametergewichtsklasse), Finetune (Feinabstimmungsziel), Version (Modellversionsnummer), Codierung (Gewichtscodierungsschema), Typ (Dateizweck) und Shard (für Split-Modelle). Zusammen enthalten diese Komponenten wesentliche Informationen über das Modell.

Q4. Wie kann ich GGUF -Dateinamen validieren?

A. Sie können GGUF -Dateinamen unter Verwendung eines regulären Ausdrucks validieren, der mindestens dem Grundnamen, Sizelabel und der Version in der richtigen Reihenfolge prüft. Dadurch wird sichergestellt, dass die Datei die Namenskonvention hält und die erforderlichen Informationen für die Modellidentifikation enthält.

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Das obige ist der detaillierte Inhalt vonWie konvertiere ich Modelle in das GGUF -Format?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!