GraphGen: Feinabstimmung von Sprachmodellen mithilfe von Wissensgraphen zur Erzeugung synthetischer Daten

Allgemeine Einführung

GraphGen ist ein Open-Source-Framework, das von OpenScienceLab, einem KI-Labor in Shanghai, entwickelt wurde und auf GitHub gehostet wird. Es konzentriert sich auf die Optimierung der überwachten Feinabstimmung von Large Language Models (LLMs), indem es die Erzeugung synthetischer Daten durch Wissensgraphen anleitet. Es konstruiert feinkörnige Wissensgraphen aus Quelltext, identifiziert blinde Flecken im Modellwissen mit Hilfe von ECE-Metriken (Expected Calibration Error) und priorisiert die Generierung von Q&A-Paaren, die auf hochwertiges Long-Tail-Wissen abzielen. GraphGen unterstützt Multi-Hop-Neighbourhood Sampling, um komplexe relationale Informationen zu erfassen, und generiert diversifizierte Daten durch Style Control. Das Projekt steht unter der Apache 2.0-Lizenz und der Code ist offen für akademische Forschung und kommerzielle Entwicklung. Benutzer können den Generierungsprozess flexibel über die Befehlszeile oder die Gradio-Schnittstelle konfigurieren, und die generierten Daten können direkt für das Modelltraining verwendet werden.

Funktionsliste

• Aufbau feinkörniger Wissensgraphen: Extrahieren von Entitäten und Beziehungen aus Text zur Erstellung strukturierter Wissensgraphen.
• Identifizierung von blinden Flecken des Wissens: Auffinden von Wissensschwächen in Sprachmodellen auf der Grundlage von ECE-Metriken (Expected Calibration Error).
• Generieren Sie hochwertige Q&A-Paare: Priorisieren Sie die Generierung von Q&A-Daten für Long-Tail-Wissen, um die Modellleistung zu verbessern.
• Multi-hop neighbourhood sampling: Erfassung von Beziehungen auf mehreren Ebenen in Wissensgraphen zur Verbesserung der Datenkomplexität.
• Style Control Generation: Unterstützung verschiedener Q&A-Stile, wie z.B. kurz oder ausführlich, zur Anpassung an unterschiedliche Szenarien.
• Individuelle Konfiguration: Anpassung von Datentypen, Eingabedateien und Ausgabepfaden über YAML-Dateien.
• Gradio Interface Support: Bietet eine visuelle Schnittstelle zur Vereinfachung der Datengenerierung.
• Modellkompatibilität: Unterstützt mehrere Sprachmodelle (z.B. Qwen, OpenAI) für die Datenerzeugung und das Training.

Hilfe verwenden

Einbauverfahren

GraphGen ist ein Python-Projekt, das die Installation von PyPI oder die Ausführung aus dem Quellcode unterstützt. Hier sind die detaillierten Installationsschritte:

Installieren aus PyPI

1. GraphGen installieren
   Stellen Sie sicher, dass die Python-Version 3.8 oder höher ist, indem Sie den folgenden Befehl ausführen:

   pip install graphg

2. Umgebungsvariablen konfigurieren
   GraphGen erfordert einen Aufruf einer Sprachmodellierungs-API (wie Qwen oder OpenAI). Setzen Sie Umgebungsvariablen im Terminal:

   export SYNTHESIZER_MODEL="your_synthesizer_model_name"
   export SYNTHESIZER_BASE_URL="your_base_url"
   export SYNTHESIZER_API_KEY="your_api_key"
   export TRAINEE_MODEL="your_trainee_model_name"
   export TRAINEE_BASE_URL="your_base_url"
   export TRAINEE_API_KEY="your_api_key"
   

   • SYNTHESIZER_MODELModelle für die Erstellung von Wissensgraphen und Daten.
   • TRAINEE_MODELModelle, die für die Ausbildung verwendet werden.
3. Starten Sie das Kommandozeilentool
   Führen Sie den folgenden Befehl aus, um Daten zu generieren:

   graphg --output_dir cache
   

Installation von der Quelle aus

1. Klon-Lager
   Klonen Sie das GraphGen-Repository lokal:

   git clone https://github.com/open-sciencelab/GraphGen.git
   cd GraphGen
   

2. Erstellen einer virtuellen Umgebung
   Erstellen und aktivieren Sie eine virtuelle Umgebung:

   python -m venv venv
   source venv/bin/activate  # Linux/Mac
   venv\Scripts\activate     # Windows
   

3. Installation von Abhängigkeiten
   Installieren Sie die Projektabhängigkeiten:

   pip install -r requirements.txt
   

   Stellen Sie sicher, dass PyTorch (empfohlen 1.13.1 oder höher) und zugehörige Bibliotheken (z. B. LiteLLM, DSPy) installiert sind. Wenn Sie eine GPU verwenden, installieren Sie eine CUDA-kompatible Version:

   pip install torch==1.13.1+cu117 torchvision==0.14.1+cu117 --extra-index-url https://download.pytorch.org/whl/cu117
   

4. Umgebungsvariablen konfigurieren
   Kopieren Sie die Beispiel-Umgebungsdatei und bearbeiten Sie sie:

   cp .env.example .env
   

   existieren .env Datei, um modellbezogene Informationen festzulegen:

   SYNTHESIZER_MODEL=your_synthesizer_model_name
   SYNTHESIZER_BASE_URL=your_base_url
   SYNTHESIZER_API_KEY=your_api_key
   TRAINEE_MODEL=your_trainee_model_name
   TRAINEE_BASE_URL=your_base_url
   TRAINEE_API_KEY=your_api_key
   

5. Vorbereiten der Dateneingabe
   GraphGen benötigt Eingabetext im JSONL-Format. Die Beispieldaten befinden sich in der Datei resources/examples/raw_demo.jsonl. Die Benutzer können benutzerdefinierte Daten vorbereiten, um eine einheitliche Formatierung zu gewährleisten.

Verwendung

GraphGen unterstützt sowohl die Befehlszeile als auch die Gradio-Schnittstelle. Hier sind die detaillierten Schritte:

Befehlszeilenbetrieb

1. Ändern Sie die Konfigurationsdatei
   Compiler configs/graphgen_config.yaml Datei, um die Parameter für die Datenerzeugung festzulegen:

   data_type: "raw"
   input_file: "resources/examples/raw_demo.jsonl"
   output_dir: "cache"
   ece_threshold: 0.1
   sampling_hops: 2
   style: "detailed"
   

   • data_type: Eingangsdatentyp (z.B. raw).
   • input_file: Geben Sie den Dateipfad ein.
   • output_dir: Ausgabeverzeichnis.
   • ece_thresholdECE-Schwellenwerte für die Erkennung blinder Flecken.
   • sampling_hopsMulti-hop sampling depth.
   • styleQ&A Generierungsstile (z.B. detailed vielleicht concise).
2. Führen Sie das generierte Skript aus
   Führen Sie den folgenden Befehl aus, um Daten zu generieren:

   bash scripts/generate.sh
   

   oder führen Sie einfach ein Python-Skript aus:

   python -m graphg --config configs/graphgen_config.yaml
   

3. Generierte Ergebnisse anzeigen
   Die erzeugten Q&A-Paare werden in der Datei cache/data/graphgen Verzeichnis im Format einer JSONL-Datei:

   ls cache/data/graphgen
   

Gradio Interface Betrieb

1. Starten der Gradio-Schnittstelle
   Führen Sie den folgenden Befehl aus, um die Visualisierungsoberfläche zu starten:

   python webui/app.py
   

   Der Browser öffnet die Gradio-Oberfläche, die den Prozess der Datengenerierung anzeigt.

2. Arbeitsablauf
   • Lädt eine JSONL-formatierte Eingabedatei in die Schnittstelle hoch.
   • Konfigurieren Sie die Generierungsparameter (z. B. ECE-Schwellenwert, Probentiefe, Generierungsstil).
   • Klicken Sie auf die Schaltfläche "Generieren" und das System verarbeitet die Eingaben und gibt die Q&A-Paare aus.
   • Laden Sie die generierte JSONL-Datei herunter.

Featured Function Bedienung

• Konstruktion von WissensgraphenGraphGen extrahiert automatisch Entitäten und Beziehungen aus dem Eingabetext, erzeugt einen Wissensgraphen und speichert ihn im JSON-Format. Ein manuelles Eingreifen ist nicht erforderlich.
• Wissen über die Erkennung des toten WinkelsVorhersage von Verzerrungen durch das ECE-Metrik-Analysemodell und Erstellung gezielter Q&A-Paare. Anpassung ece_threshold Strenge Blindscreening-Kontrollen.
• Mehrstufige NachbarschaftsprobenahmeQ&A: Erfassen von mehrstufigen Beziehungen in Wissensgraphen, um komplexe Q&A-Paare zu erzeugen. Einrichtung sampling_hops Steuert die Abtasttiefe.
• Erzeugung von StilkontrollenMehrere Q&A-Stile werden für unterschiedliche Szenarien unterstützt. Benutzer können style Mit dem Parameter wird der Stil ausgewählt.

Ausbildungsmodelle

Die erzeugten Daten können für die überwachte Feinabstimmung (SFT) verwendet werden. Importieren Sie die Ausgabedatei in ein Framework, das SFT unterstützt (z. B. XTuner):

xtuner train --data cache/data/graphgen/output.jsonl --model qwen-7b

caveat

• Stellen Sie sicher, dass der API-Schlüssel und die Netzwerkverbindung stabil sind und dass der Generierungsprozess ein externes Modell aufruft.
• Die Eingabedaten sollten im JSONL-Format vorliegen, siehe raw_demo.jsonl.
• GPU-Geräte werden für die Erzeugung großer Datenmengen empfohlen, um die Leistung zu optimieren.
• Überprüfen Sie die Versionen der Abhängigkeiten, um Konflikte zu vermeiden. Falls erforderlich aktualisieren requirements.txt.

Ergänzende Ressourcen

• OpenXLab AnwendungszentrumBenutzer können auf die Informationen über das OpenXLab Erleben Sie GraphGen.
• Offizielle FAQ: siehe die GitHub FAQ Gemeinsame Probleme lösen.
• technische Analyse: Mit freundlicher Genehmigung von DeepWiki Analyse der SystemarchitekturIn diesem Abschnitt wird der Arbeitsablauf von GraphGen im Detail beschrieben.

Anwendungsszenario

1. akademische Forschung
   Forscher können GraphGen verwenden, um Q&A-Daten für spezielle Bereiche zu erzeugen. Die Generierung von Trainingsdaten für ein chemisches oder medizinisches Domänenmodell verbessert beispielsweise die Wissensabdeckung des Modells.
2. KI-Optimierung für Unternehmen
   Unternehmen können GraphGen nutzen, um benutzerdefinierte Q&A-Paare für den Kundenservice oder Empfehlungssysteme zu generieren und die Reaktionsfähigkeit ihrer Dialogmodelle zu optimieren.
3. Entwicklung von Bildungsplattformen
   Entwickler können verschiedene Lehr- und Q&A-Daten generieren, um intelligente Bildungswerkzeuge zur Unterstützung des personalisierten Lernens zu entwickeln.

QA

1. Welche Modelle werden von GraphGen unterstützt?
   GraphGen unterstützt OpenAI, Qwen, Ollama und andere Modelle über LiteLLM. Modell-API-Schlüssel und Adressen sind erforderlich.
2. Wie bereite ich die Eingabedaten vor?
   Die Eingabedaten sollten im JSONL-Format vorliegen, wobei jede Zeile Textinhalte enthält. Referenz resources/examples/raw_demo.jsonl.
3. Wie lange dauert es, Daten zu generieren?
   Kleine Datenmengen (100 Einträge) können einige Minuten, große Datenmengen Stunden dauern, abhängig von der Menge der Eingaben und der Leistung der Hardware.
4. Wie funktioniert die Gradio-Schnittstelle?
   in Bewegung sein python webui/app.pyDie Daten werden generiert, indem die Eingabedatei über den Browser hochgeladen und die Parameter konfiguriert werden.