中文版文档
La technologie RAG (Retrieval Augmentation Generation) favorise l'intégration d'applications de domaine avec de grands modèles de langage. Cependant, RAG présente des problèmes tels qu'un écart important entre la similarité vectorielle et la corrélation du raisonnement des connaissances, et une insensibilité à la logique des connaissances (telle que les valeurs numériques, les relations temporelles, les règles d'experts, etc.), qui entravent la mise en œuvre de services de connaissances professionnels.
Le 24 octobre 2024, OpenSPG a publié la version 0.5, publiant officiellement le cadre de service de connaissances de domaine professionnel de génération augmentée de connaissances (KAG). KAG vise à exploiter pleinement les avantages du Knowledge Graph et de la récupération vectorielle, et à améliorer de manière bidirectionnelle les grands modèles de langage et les graphes de connaissances à travers quatre aspects pour résoudre les défis du RAG : (1) représentation des connaissances conviviale LLM, (2) Knowledge Graph et texte original L'index mutuel entre fragments, (3) un moteur de raisonnement hybride guidé par des formes logiques, (4) l'alignement des connaissances avec le raisonnement sémantique.
KAG est nettement meilleur que NaiveRAG, HippoRAG et d'autres méthodes dans les tâches de questions et réponses multi-sauts. Le score F1 sur hotpotQA est relativement augmenté de 19,6 %, et le score F1 sur 2wiki est relativement augmenté de 33,5 %. Nous avons appliqué avec succès KAG aux deux tâches de questions et réponses de connaissances professionnelles d'Ant Group, y compris les questions et réponses sur le gouvernement électronique et les questions et réponses sur la santé en ligne, et le professionnalisme a été considérablement amélioré par rapport à la méthode RAG.
Le framework KAG comprend trois parties : kg-builder, kg-solver et kag-model. Cette version ne concerne que les deux premières parties, kag-model sera progressivement une version open source dans le futur.
kg-builder implémente une représentation des connaissances compatible avec les modèles de langage à grande échelle (LLM). Basé sur la structure hiérarchique de DIKW (données, informations, connaissances et sagesse), l'informatique améliore la capacité de représentation des connaissances SPG et est compatible avec l'extraction d'informations sans contraintes de schéma et la construction de connaissances professionnelles avec des contraintes de schéma sur le même type de connaissances (comme le type d'entité). et type d'événement), il prend également en charge la représentation d'index mutuel entre la structure graphique et le bloc de texte d'origine, ce qui prend en charge la récupération efficace de l'étape de question et de réponse de raisonnement.
kg-solver utilise un moteur de résolution et de raisonnement hybride logique guidé par des symboles qui comprend trois types d'opérateurs : la planification, le raisonnement et la récupération, pour transformer les problèmes de langage naturel en un processus de résolution de problèmes combinant langage et symboles. Dans ce processus, chaque étape peut utiliser différents opérateurs, tels que la récupération de correspondances exactes, la récupération de texte, le calcul numérique ou le raisonnement sémantique, afin de réaliser l'intégration de quatre processus différents de résolution de problèmes : Récupération, raisonnement Knowledge Graph, raisonnement linguistique et calcul numérique. .
Dans le contexte de bases de connaissances privées, données non structurées, informations structurées et expérience d’experts métier coexistent souvent. KAG fait référence à la hiérarchie DIKW pour mettre à niveau SPG vers une version conviviale pour les LLM. Pour les données non structurées telles que les actualités, les événements, les journaux et les livres, ainsi que les données structurées telles que les transactions, les statistiques et les approbations, ainsi que les règles d'expérience commerciale et de connaissance du domaine, KAG utilise des techniques telles que l'analyse de la disposition, l'extraction de connaissances, la normalisation des propriétés, et l'alignement sémantique pour intégrer les données métier brutes et les règles expertes dans un graphe de connaissances métier unifié.
Cela le rend compatible avec l'extraction d'informations sans schéma et la construction d'expertises contraintes par un schéma sur le même type de connaissances (par exemple, type d'entité, type d'événement), et prend en charge la représentation d'index croisés entre la structure du graphe et le bloc de texte d'origine. . Cette représentation d'index mutuel est utile à la construction d'index inversés basés sur une structure graphique et favorise la représentation et le raisonnement unifiés des formes logiques.
KAG propose une solution hybride guidée logiquement formelle et un moteur d'inférence. Le moteur comprend trois types d'opérateurs : la planification, le raisonnement et la récupération, qui transforment les problèmes de langage naturel en processus de résolution de problèmes combinant langage et notation. Dans ce processus, chaque étape peut utiliser différents opérateurs, tels que la récupération de correspondances exactes, la récupération de texte, le calcul numérique ou le raisonnement sémantique, afin de réaliser l'intégration de quatre processus différents de résolution de problèmes : Récupération, raisonnement Knowledge Graph, raisonnement linguistique et calcul numérique. .
Après optimisation, nous avons non seulement vérifié l'adaptabilité de KAG dans les champs verticaux, mais l'avons également comparé à la méthode RAG existante dans les questions et réponses multi-sauts des ensembles de données générales. Nous avons constaté qu'elle est évidemment meilleure que la méthode SOTA, avec une augmentation de F1 de 33,5 % sur 2wiki et de 19,6 % sur hotpotQA. Nous continuons d'affiner ce cadre et avons démontré son efficacité grâce à des expériences de bout en bout et des mesures d'expérimentation d'ablation. Nous démontrons la validité de ce cadre au moyen d'un raisonnement basé sur des symboles logiques et d'un alignement conceptuel.
définition des règles d'identification des « apps de jeu »
définir la règle RiskAppTaxo
Define (s:App)-[p:belongTo]->(o:`TaxOfRiskApp`/`GamblingApp`) {
Structure {
(s)
}
Constraint {
R1("risk label marked as gambling") s.riskMark like "%Gambling%"
}
}définir les règles d'identification "Développeur d'application"
définir la règle du développeur d'applications
Define (s:Person)-[p:developed]->(o:App) {
Structure {
(s)-[:hasDevice]->(d:Device)-[:install]->(o)
}
Constraint {
deviceNum = group(s,o).count(d)
R1("device installed same app"): deviceNum > 5
}
}définir les règles d'identification des "développeurs d'applications de jeu"
définir une règle RiskUser de l'application de jeu
Define (s:Person)-[p:belongTo]->(o:`TaxOfRiskUser`/`DeveloperOfGamblingApp`) {
Structure {
(s)-[:developed]->(app:`TaxOfRiskApp`/`GamblingApp`)
}
Constraint {
}
}
Les étapes clés du processus de raisonnement sont les suivantes.
Convertissez les problèmes de langage naturel en expressions logiques exécutables, qui s'appuient sur la modélisation conceptuelle dans le cadre du projet, et faites référence au document d'exploration de produits Black.
Soumettez l'expression logique convertie au raisonneur OpenSPG pour exécution afin d'obtenir le résultat de la classification de l'utilisateur.
Générez des réponses aux résultats de classification de l'utilisateur.
Combiné à la modélisation conceptuelle OpenSPG, KAG peut réduire la difficulté de la requête graphique de conversion en langage naturel, modifier la conversion orientée données en conversion orientée concept de classification et réaliser rapidement l'application sur le terrain des questions et réponses en langage naturel sur le projet OpenSPG original.
Version du système recommandée :
macOS User：macOS Monterey 12.6 or later
Linux User：CentOS 7 / Ubuntu 20.04 or later
Windows User：Windows 10 LTSC 2021 or laterConfiguration logicielle requise :
macOS / Linux User：Docker，Docker Compose
Windows User：WSL 2 / Hyper-V，Docker，Docker ComposeUtilisez les commandes suivantes pour télécharger le fichier docker-compose.yml et lancer les services avec Docker Compose.
# définissez la variable d'environnement HOME (seuls les utilisateurs Windows doivent exécuter cette commande)# set HOME=%USERPROFILE%curl -sSL https://raw.githubusercontent.com/OpenSPG/openspg/refs/heads/master/dev/release/ docker-compose.yml -o docker-compose.yml docker compose -f docker-compose.yml up -d
Accédez à l'URL par défaut du produit KAG avec votre navigateur : http://127.0.0.1:8887
Consultez le guide produit pour une introduction détaillée.
Reportez-vous à la section 3.1 pour terminer l'installation du moteur et de l'image dépendante.
Développeurs macOS / Linux
# Create conda env: conda create -n kag-demo python=3.10 && conda activate kag-demo
# Clone code: git clone https://github.com/OpenSPG/KAG.git
# Install KAG: cd KAG && pip install -e .Développeurs Windows
# Install the official Python 3.8.10 or later, install Git.
# Create and activate Python venv: py -m venv kag-demo && kag-demoScriptsactivate
# Clone code: git clone https://github.com/OpenSPG/KAG.git
# Install KAG: cd KAG && pip install -e .Veuillez vous référer au guide de démarrage rapide pour une introduction détaillée de la boîte à outils. Vous pouvez ensuite utiliser les composants intégrés pour reproduire les résultats de performances des ensembles de données intégrés et appliquer ces composants à de nouveaux scénarios métier.
Si les composants intégrés fournis par KAG ne répondent pas à vos besoins, vous pouvez étendre vous-même l'implémentation de kag-builder et kag-solver. Veuillez vous référer à l'extension KAG-Builder et à l'extension KAG-Solver.
KAG utilise BuilderChain pour concaténer des composants tels que le lecteur, le séparateur, le mappage, l'extracteur, l'aligneur et le vectoriseur. Les développeurs peuvent utiliser le BuilderChain prédéfini par kag pour terminer la construction de graphiques, ou assembler des composants prédéfinis et obtenir BuilderChain.
Dans le même temps, les développeurs peuvent personnaliser les composants du générateur et les intégrer dans BuilderChain pour exécution.
kag
├──interface
│ ├── builder
│ │ ├── aligner_abc.py
│ │ ├── extractor_abc.py
│ │ ├── mapping_abc.py
│ │ ├── reader_abc.py
│ │ ├── splitter_abc.py
│ │ ├── vectorizer_abc.py
│ │ └── writer_abc.pyLe kag-solver exécute des pipelines de solveur composés de composants de raisonnement, de générateur et de réflecteur. KAG fournit un raisonneur, un générateur et un réflecteur par défaut. Les développeurs peuvent également fournir des implémentations personnalisées basées sur les API suivantes :
kag
├── solver
│ ├── logic
│ │ └── solver_pipeline.py
├── interface
├── retriever
│ ├── chunk_retriever_abc.py
│ └── kg_retriever_abc.py
└── solver
├── kag_generator_abc.py
├── kag_memory_abc.py
├── kag_reasoner_abc.py
├── kag_reflector_abc.py
└── lf_planner_abc.pyKAG prend en charge l'amarrage avec les API MaaS compatibles avec les services OpenAI tels que Qwen/DeepSeek/GPT, et prend également en charge l'amarrage avec les modèles locaux déployés par vLLM/Ollama. Les développeurs peuvent ajouter la prise en charge des services de modèles personnalisés basés sur l'interface llm_client.
kag
├── common
├── llm
├── client
│ ├── llm_client.py
│ ├── ollama_client.py
│ ├── openai_client.py
│ ├── vllm_client.pyKAG prend en charge l'appel des modèles de représentation OpenAI et autres, y compris les services d'intégration OpenAI, modèle bge-m3 déployé par Ollama. Il prend également en charge le chargement et l'utilisation de modèles d'intégration locaux.
kag
├── common
├── vectorizer
│ ├── vectorizer.py
│ ├── openai_vectorizer.py
│ ├── local_bge_m3_vectorizer.py
│ ├── local_bge_vectorizer.pyLorsqu'elles sont intégrées à d'autres frameworks, les données commerciales externes et les connaissances d'experts peuvent être utilisées comme entrées pour appeler le pipeline kag-builder afin de terminer la construction du graphe de connaissances. Vous pouvez également appeler le kag-solver pour terminer le processus de raisonnement questions-réponses, et le résultat du raisonnement et le processus intermédiaire sont révélés au système métier.
La façon dont d'autres frameworks intègrent kag peut être simplement décrite comme :
injection de connaissances de domaine pour réaliser la fusion du graphe de concept de domaine et du graphe d'entité
Optimisation du modèle Kag pour améliorer l'efficacité de la construction KG et des questions et réponses
hallucination inhibition des connaissances contraintes logiques
Si vous utilisez ce logiciel, veuillez le citer comme ci-dessous :
KAG : Stimuler les LLM dans les domaines professionnels via la génération augmentée de connaissances
KGFabric : un entrepôt de graphiques de connaissances évolutif pour l'interconnexion des données d'entreprise
@article{liang2024kag, title={KAG : Stimuler les LLM dans les domaines professionnels via la génération de connaissances augmentée}, author={Liang, Lei et Sun, Mengshu et Gui, Zhengke et Zhu, Zhongshu et Jiang, Zhouyu et Zhong, Ling et Qu, Yuan et Zhao, Peilong et Bo, Zhongpu et Yang, Jin et autres}, journal={arXiv preprint arXiv:2409.13731}, year={2024}}@article{yikgfabric, title={KGFabric : un entrepôt de graphiques de connaissances évolutif pour les entreprises Interconnexion de données}, auteur={Yi, Peng et Liang, Lei et Da Zhang, Yong Chen et Zhu, Jinye et Liu, Xiangyu et Tang, Kun et Chen, Jialin et Lin, Hao et Qiu, Leijie et Zhou, juin}}Licence Apache 2.0
