Créez des graphiques de connaissances efficaces avec Relik et LlamaIndex : liaison d'entités et extraction de relations

La construction de graphes de connaissances à partir de textes est un domaine de recherche fascinant depuis un certain temps. Avec l'avènement des grands modèles de langage (LLM), ce domaine a gagné en popularité. Cependant, les LLM peuvent être assez coûteux. Une approche alternative consiste à affiner les modèles plus petits, ce qui a été soutenu par la recherche universitaire, ce qui donne des solutions plus efficaces. Aujourd'hui, nous allons explorer Relik , un framework permettant d'exécuter des modèles d'extraction d'informations ultra-rapides et légers, développé par le groupe NLP de l'Université Sapienza de Rome.

Un pipeline d’extraction d’informations typique sans LLM ressemble à ce qui suit :

L'image illustre un pipeline d'extraction d'informations, à partir de données d'entrée constituées d'un texte mentionnant « Tomaz aime écrire des articles de blog. Il s'intéresse particulièrement au dessin de diagrammes. » Le processus commence par une résolution de coréférence pour identifier « Tomaz » et « Lui » comme la même entité. La reconnaissance d'entités nommées (NER) identifie ensuite des entités telles que « Tomaz », « Blog » et « Diagramme ».

La liaison d'entités est le processus qui suit le NER, où les entités reconnues sont mappées aux entrées correspondantes dans une base de données ou une base de connaissances. Par exemple, « Tomaz » est lié à « Tomaz Bratanic (Q12345) » et « Blog » à « Blog (Q321) », mais « Diagramme » n'a aucune correspondance dans la base de connaissances.

L'extraction de relations est l'étape suivante au cours de laquelle le système identifie et extrait les relations significatives entre les entités reconnues. Cet exemple identifie que « Tomaz » a une relation avec « Blog » caractérisée par « ÉCRIT », indiquant que Tomaz écrit des blogs. De plus, il identifie que « Tomaz » a une relation avec « Diagramme » caractérisée par « INTERESTED_IN », indiquant que Tomaz s'intéresse aux diagrammes.

Enfin, ces informations structurées, incluant les entités et leurs relations, sont stockées dans un graphique de connaissances, permettant d'obtenir des données organisées et accessibles pour une analyse ou une récupération ultérieure.

Traditionnellement, sans la puissance des LLM, l'ensemble de ce processus repose sur une suite de modèles spécialisés, chacun gérant une tâche spécifique, de la résolution de coréférence à l'extraction de relations. Bien que l'intégration de ces modèles exige plus d'efforts et de coordination, elle offre un avantage considérable : la réduction des coûts. En affinant des modèles plus petits et spécifiques à une tâche, les dépenses globales de construction et de maintenance du système peuvent être maîtrisées.

Le code est disponible sur GitHub .

Configuration de l'environnement

Je vous suggère d'utiliser un environnement Python distinct comme Google Colab , car nous devrons jouer un peu avec les dépendances. Les modèles sont plus rapides sur GPU, vous pouvez donc utiliser un environnement d'exécution alimenté par GPU si vous avez la version Pro.

De plus, nous devons configurer Neo4j, une base de données graphique native, pour stocker les informations extraites. Il existe de nombreuses façons de configurer votre instance de base de données . Cependant, je recommande d'utiliser Neo4j Aura , qui fournit une instance cloud gratuite à laquelle on peut facilement accéder à partir d'un bloc-notes Google Colab.

Neo4j Aura – Solution cloud entièrement gérée

Une fois la base de données créée, nous pouvons définir une connexion en utilisant LlamaIndex :

 from llama_index.graph_stores.neo4j import Neo4jPGStore username="neo4j" password="rubber-cuffs-radiator" url="bolt://54.89.19.156:7687" graph_store = Neo4jPGStore( username=username, password=password, url=url, refresh_schema=False )

Ensemble de données

Nous utiliserons un ensemble de données d'actualités que j'ai obtenu via l'API Diffbot il y a quelque temps. L'ensemble de données est facilement disponible sur GitHub pour que nous puissions le réutiliser :

 import pandas as pd NUMBER_OF_ARTICLES = 100 news = pd.read_csv( "https://raw.githubusercontent.com/tomasonjo/blog-datasets/main/news_articles.csv" ) news = news.head(NUMBER_OF_ARTICLES)

Résolution de coréférence

La première étape du pipeline est un modèle de résolution de coréférence. La résolution de coréférence est la tâche consistant à identifier toutes les expressions d'un texte faisant référence à la même entité.

À ma connaissance, il n'existe pas beaucoup de modèles open source disponibles pour la résolution de coréférence. J'ai essayé le maverick-coref , mais lors de mes tests, Coreferee de spaCy a mieux fonctionné, nous allons donc l'utiliser. Le seul inconvénient de l'utilisation de Coreferee est que nous devons gérer l'enfer des dépendances, qui est résolu dans le notebook, mais nous ne l'aborderons pas ici.

Vous pouvez charger le modèle de coréférence dans spaCy avec le code suivant :

 import spacy, coreferee coref_nlp = spacy.load('en_core_web_lg') coref_nlp.add_pipe('coreferee')

Le modèle Coreferee détecte les groupes d'expressions qui font référence à la même entité ou aux mêmes entités. Pour réécrire le texte en fonction de ces groupes, nous devons implémenter notre propre fonction :

 def coref_text(text): coref_doc = coref_nlp(text) resolved_text = "" for token in coref_doc: repres = coref_doc._.coref_chains.resolve(token) if repres: resolved_text += " " + " and ".join( [ t.text if t.ent_type_ == "" else [e.text for e in coref_doc.ents if t in e][0] for t in repres ] ) else: resolved_text += " " + token.text return resolved_text

Testons la fonction pour nous assurer que les modèles et les dépendances sont correctement configurés :

 print( coref_text("Tomaz is so cool. He can solve various Python dependencies and not cry") ) # Tomaz is so cool . Tomaz can solve various Python dependencies and not cry

Dans cet exemple, le modèle a identifié que « Tomaz » et « He » font référence à la même entité. À l'aide de la fonction coref_text, nous remplaçons « He » par « Tomaz ».

Nous appliquons maintenant la résolution de coréférence à notre ensemble de données d’actualités et enveloppons les résultats sous forme de documents LlamaIndex :

 from llama_index.core import Document news["coref_text"] = news["text"].apply(coref_text) documents = [ Document(text=f"{row['title']}: {row['coref_text']}") for i, row in news.iterrows() ]

Liaison d'entités et extraction de relations

Relik est une bibliothèque avec des modèles pour la liaison d'entités (EL) et l'extraction de relations (RE), et elle prend également en charge les modèles qui combinent les deux. Dans la liaison d'entités, Wikipédia est utilisée comme base de connaissances cible pour faire correspondre les entités du texte à leurs entrées correspondantes dans l'encyclopédie.

D'autre part, l'extraction de relations implique l'identification et la catégorisation des relations entre les entités au sein d'un texte, permettant l'extraction d'informations structurées à partir de données non structurées.

Si vous utilisez une version gratuite de Colab, utilisez le modèle relik-ie/relik-relation-extraction-small, qui effectue uniquement l'extraction des relations. Si vous possédez une version Pro, ou si vous l'utilisez sur une machine locale plus puissante, vous pouvez tester le modèle relik-ie/relik-cie-small, qui effectue la liaison d'entités et l'extraction des relations.

 from llama_index.extractors.relik.base import RelikPathExtractor relik = RelikPathExtractor( model="relik-ie/relik-relation-extraction-small" ) # Use on Pro Collab with GPU # relik = RelikPathExtractor( # model="relik-ie/relik-cie-small", model_config={"skip_metadata": True, "device":"cuda"} # )

De plus, nous devons définir le modèle d'intégration qui sera utilisé pour intégrer les entités et le LLM pour le flux de questions-réponses :

 import os from llama_index.embeddings.openai import OpenAIEmbedding from llama_index.llms.openai import OpenAI os.environ["OPENAI_API_KEY"] = "sk-" llm = OpenAI(model="gpt-4o", temperature=0.0) embed_model = OpenAIEmbedding(model_name="text-embedding-3-small")

Notez que le LLM ne sera pas utilisé lors de la construction du graphique.

Maintenant que tout est en place, nous pouvons instancier un PropertyGraphIndex et utiliser les documents d’actualité comme données d’entrée pour un graphique de connaissances.

De plus, nous devons transmettre le modèle relik comme valeur kg_extractors pour extraire les relations :

 from llama_index.core import PropertyGraphIndex index = PropertyGraphIndex.from_documents( documents, kg_extractors=[relik], llm=llm, embed_model=embed_model, property_graph_store=graph_store, show_progress=True, )

Après avoir construit le graphique, vous pouvez ouvrir le navigateur Neo4j pour valider le graphique importé. Vous devriez obtenir une visualisation similaire en exécutant l'instruction Cypher suivante :

 MATCH p=(:__Entity__)--(:__Entity__) RETURN p LIMIT 250

Résultats

Réponse aux questions

Grâce à LlamaIndex, il est désormais facile de répondre à des questions. Pour utiliser les récupérateurs de graphiques par défaut, vous pouvez poser des questions aussi simples que :

 query_engine = index.as_query_engine(include_text=True) response = query_engine.query("What happened at Ryanair?") print(str(response))

C'est ici que le LLM défini et le modèle d'intégration entrent en jeu. Bien entendu, vous pouvez également implémenter des récupérateurs personnalisés pour une précision potentiellement meilleure.

Résumé

La création de graphes de connaissances sans recours aux LLM est non seulement faisable, mais également rentable et efficace. En affinant des modèles plus petits et spécifiques à une tâche, tels que ceux du framework Relik, vous pouvez obtenir une extraction d'informations à hautes performances pour vos applications de génération augmentée de récupération (RAG).

La liaison d’entités, une étape critique de ce processus, garantit que les entités reconnues sont mappées avec précision aux entrées correspondantes dans une base de connaissances, préservant ainsi l’intégrité et l’utilité du graphique de connaissances.

En utilisant des frameworks comme Relik et des plateformes comme Neo4j, il est possible de construire des graphes de connaissances avancés qui facilitent les tâches complexes d'analyse et de récupération de données, le tout sans les coûts élevés généralement associés au déploiement de LLM. Cette méthode rend non seulement les outils de traitement de données puissants plus accessibles, mais favorise également l'innovation et l'efficacité des flux de travail d'extraction d'informations.

Assurez-vous de donner une étoile à la bibliothèque Relik . Le code est disponible sur GitHub .

Pour en savoir plus sur ce sujet, rejoignez-nous à NODES 2024 le 7 novembre, notre conférence virtuelle gratuite pour développeurs sur les applications intelligentes, les graphes de connaissances et l'IA. Inscrivez-vous MAINTENANT !