GraphGen : amélioration des modèles de langage à l'aide de graphes de connaissances pour générer des données synthétiques

Introduction générale

GraphGen est un cadre open source développé par OpenScienceLab, un laboratoire d'IA à Shanghai, hébergé sur GitHub, qui se concentre sur l'optimisation de la mise au point supervisée des grands modèles de langage (LLM) en guidant la génération de données synthétiques par le biais de graphes de connaissances. Il construit des graphes de connaissances à grain fin à partir du texte source, identifie les angles morts de la connaissance du modèle en utilisant des métriques d'erreur de calibration attendue (ECE), et donne la priorité à la génération de paires de questions-réponses ciblant des connaissances de grande valeur et de longue traîne.GraphGen prend en charge l'échantillonnage de voisinage multi-sauts pour capturer des informations relationnelles complexes, et génère des données diversifiées grâce au contrôle du style. Le projet est soumis à la licence Apache 2.0 et le code est ouvert à la recherche universitaire et au développement commercial. Les utilisateurs peuvent configurer le processus de génération de manière flexible via la ligne de commande ou l'interface Gradio, et les données générées peuvent être directement utilisées pour l'entraînement des modèles.

Liste des fonctions

• Construction de graphes de connaissances à grain fin : extraction d'entités et de relations à partir de textes pour générer des graphes de connaissances structurés.
• Identifier les angles morts de la connaissance : localiser les faiblesses de la connaissance dans les modèles linguistiques sur la base des mesures de l'erreur d'étalonnage attendue (ECE).
• Générer des paires de questions-réponses de grande valeur : donner la priorité à la génération de données de questions-réponses pour les connaissances à longue traîne afin d'améliorer les performances du modèle.
• Multi-hop neighbourhood sampling : capturing multi-level relationships in knowledge graphs to enhance data complexity (Échantillonnage de voisinage multi-sauts : saisir les relations à plusieurs niveaux dans les graphes de connaissances pour améliorer la complexité des données).
• Génération de contrôle de style : Prise en charge de divers styles de questions et réponses, tels que concis ou détaillé, pour s'adapter à différents scénarios.
• Configuration personnalisée : Ajustez les types de données, les fichiers d'entrée et les chemins de sortie via des fichiers YAML.
• Support de l'interface Gradio : fournit une interface visuelle pour simplifier les opérations de génération de données.
• Compatibilité des modèles : prise en charge de plusieurs modèles linguistiques (par exemple Qwen, OpenAI) pour la génération de données et la formation.

Utiliser l'aide

Processus d'installation

GraphGen est un projet Python qui peut être installé à partir de PyPI ou exécuté à partir des sources. Voici les étapes détaillées de l'installation :

Installation à partir de PyPI

1. Installer GraphGen
   Assurez-vous que la version de Python est 3.8 ou supérieure en exécutant la commande suivante :

   pip install graphg

2. Configuration des variables d'environnement
   GraphGen nécessite un appel à une API de modélisation du langage (telle que Qwen ou OpenAI). Définir les variables d'environnement dans le 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_MODEL: Modèles pour la génération de graphes de connaissances et de données.
   • TRAINEE_MODELModèles utilisés pour la formation.
3. Exécuter l'outil de ligne de commande
   Exécutez la commande suivante pour générer des données :

   graphg --output_dir cache
   

Installation à partir de la source

1. entrepôt de clones
   Cloner localement le dépôt GraphGen :

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

2. Créer un environnement virtuel
   Créer et activer un environnement virtuel :

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

3. Installation des dépendances
   Installer les dépendances du projet :

   pip install -r requirements.txt
   

   Assurez-vous que PyTorch (recommandé 1.13.1 ou plus) et les bibliothèques associées (par exemple LiteLLM, DSPy) sont installés. Si vous utilisez un GPU, installez une version compatible avec CUDA :

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

4. Configuration des variables d'environnement
   Copiez le fichier d'environnement de l'exemple et modifiez-le :

   cp .env.example .env
   

   existent .env pour définir les informations relatives au modèle :

   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. Préparation de la saisie des données
   GraphGen requiert un texte d'entrée au format JSONL. Les données de l'exemple se trouvent dans le fichier resources/examples/raw_demo.jsonl. Les utilisateurs peuvent préparer des données personnalisées pour assurer un formatage cohérent.

Utilisation

GraphGen supporte à la fois la ligne de commande et l'interface Gradio. Voici les étapes détaillées :

opération en ligne de commande

1. Modifier le fichier de configuration
   compilateur configs/graphgen_config.yaml pour définir les paramètres de génération des données :

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

   • data_typeType de données d'entrée (par exemple raw).
   • input_file: Saisir le chemin d'accès au fichier.
   • output_dir: Répertoire de sortie.
   • ece_thresholdLes seuils de la CEE pour l'identification des zones d'ombre de la connaissance.
   • sampling_hops: Profondeur d'échantillonnage multi-sauts.
   • style: les styles de génération de questions-réponses (par ex. detailed peut-être concise).
2. Exécuter le script généré
   Exécutez la commande suivante pour générer des données :

   bash scripts/generate.sh
   

   ou simplement exécuter un script Python :

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

3. Voir les résultats générés
   Les paires de questions-réponses générées sont enregistrées dans le fichier cache/data/graphgen dans le format d'un fichier JSONL :

   ls cache/data/graphgen
   

Fonctionnement de l'interface Gradio

1. Lancement de l'interface Gradio
   Exécutez la commande suivante pour lancer l'interface de visualisation :

   python webui/app.py
   

   Le navigateur ouvre l'interface Gradio qui montre le processus de génération des données.

2. flux de travail
   • Charge un fichier d'entrée au format JSONL dans l'interface.
   • Configurer les paramètres de génération (par exemple, le seuil ECE, la profondeur d'échantillonnage, le style de génération).
   • Cliquez sur le bouton "Générer" et le système traitera les données d'entrée et produira les paires de questions-réponses.
   • Télécharger le fichier JSONL généré.

Fonction en vedette Fonctionnement

• construction d'un graphe de connaissancesGraphGen : GraphGen extrait automatiquement les entités et les relations du texte d'entrée, génère un graphe de connaissances et l'enregistre au format JSON. Aucune intervention manuelle n'est nécessaire.
• Identification des angles morts de la connaissancePrévoir les biais grâce au modèle d'analyse des mesures de la CEE et créer des paires de questions/réponses ciblées. Ajustement ece_threshold Contrôle de la rigueur de la sélection à l'aveugle.
• Échantillonnage de voisinage multi-sautsLa recherche d'une solution à la question de savoir s'il y a des relations à plusieurs niveaux dans les graphes de connaissances afin de générer des paires de questions-réponses complexes. Mise en place sampling_hops Contrôle la profondeur d'échantillonnage.
• Génération de contrôle de styleLes utilisateurs ont la possibilité de poser des questions et de répondre à des questions en fonction de leurs besoins. Les utilisateurs peuvent style Le paramètre sélectionne le style.

Modèles de formation

Les données générées peuvent être utilisées pour le réglage fin supervisé (SFT). Importez le fichier de sortie dans un cadre qui prend en charge le SFT (par exemple XTuner) :

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

mise en garde

• Assurez-vous que la clé API et la connexion réseau sont stables et que le processus de génération appelle un modèle externe.
• Les données d'entrée doivent être au format JSONL. raw_demo.jsonl.
• Les dispositifs GPU sont recommandés pour la génération de données à grande échelle afin d'optimiser les performances.
• Vérifier les versions des dépendances pour éviter les conflits. Mettre à jour si nécessaire requirements.txt.

Ressources complémentaires

• Centre d'application OpenXLabLes utilisateurs peuvent accéder à l'information par le biais du site web de la Commission européenne. OpenXLab Expérience GraphGen.
• FAQ officielle: se référer à la page GitHub FAQ Résoudre les problèmes courants.
• analyse techniqueLe projet de loi sur l'immigration et la protection des réfugiés : avec l'autorisation de DeepWiki Analyse de l'architecture du systèmeCette section décrit en détail le déroulement des opérations de GraphGen.

scénario d'application

1. recherche universitaire
   Les chercheurs peuvent utiliser GraphGen pour générer des données de questions-réponses pour des domaines spécialisés. Par exemple, la génération de données d'entraînement pour un modèle de chimie ou de médecine améliore la couverture des connaissances du modèle.
2. Optimisation de l'IA en entreprise
   Les entreprises peuvent utiliser GraphGen pour générer des paires de questions-réponses personnalisées pour le service client ou les systèmes de recommandation, optimisant ainsi la réactivité de leurs modèles de dialogue.
3. Développement d'une plateforme d'éducation
   Les développeurs peuvent générer diverses données de questions-réponses sur l'enseignement afin de créer des outils éducatifs intelligents pour soutenir l'apprentissage personnalisé.

QA

1. Quels sont les modèles pris en charge par GraphGen ?
   GraphGen supporte OpenAI, Qwen, Ollama et d'autres modèles à travers LiteLLM. Les clés et adresses API des modèles sont nécessaires.
2. Comment préparer les données d'entrée ?
   Les données d'entrée doivent être au format JSONL, chaque ligne contenant du texte. Référence resources/examples/raw_demo.jsonl.
3. Combien de temps faut-il pour générer des données ?
   Les données de petite taille (100 entrées) peuvent prendre quelques minutes, et les données de grande taille peuvent prendre des heures, en fonction de la quantité d'entrées et des performances du matériel.
4. Comment fonctionne l'interface de Gradio ?
   être en mouvement python webui/app.pyLes données sont générées en téléchargeant le fichier d'entrée via le navigateur et en configurant les paramètres.