relik
1.0.7
Un modèle d'extraction d'informations rapides et léger flamboyant pour la liaison des entités et l'extraction de relations .
Installation de PYPI
pip install relikInstallez avec toutes les dépendances facultatives.
pip install relik[all]Installez avec des dépendances facultatives pour la formation et l'évaluation.
pip install relik[train]Installer avec des dépendances facultatives pour Faish
Le package FAISS PYPI est uniquement disponible pour CPU. Pour GPU, installez-le à partir de la source ou utilisez le package Conda.
Pour CPU:
pip install relik[faiss]Pour GPU:
conda create -n relik python=3.10
conda activate relik
# install pytorch
conda install -y pytorch=2.1.0 pytorch-cuda=12.1 -c pytorch -c nvidia
# GPU
conda install -y -c pytorch -c nvidia faiss-gpu=1.8.0
# or GPU with NVIDIA RAFT
conda install -y -c pytorch -c nvidia -c rapidsai -c conda-forge faiss-gpu-raft=1.8.0
pip install relikInstallez avec des dépendances en option pour servir les modèles avec FastAPI et Ray.
pip install relik[serve]git clone https://github.com/SapienzaNLP/relik.git
cd relik
pip install -e .[all] Reliquez grand pour l'extraction des relations (? Large re V2, Colab ✅) : relik-ie/relik-relation-extraction-large
Rellik Large pour l'extraction d'informations fermées (? Large El + Re, Colab ✅) : https://huggingface.co/relik-ie/relik-cie-large
Relik Extra Large pour l'extraction d'informations fermées (? Notre thicc boi pour El + Re) : relik-ie/relik-cie-xl
Rellik Small for Entity Linking (?? ⚡ Tiny et Fast El, Colab ✅) : sapienzanlp/relik-entity-linking-small
Rellik Small for Entity Linking (⚡ Small and Fast EL) : sapienzanlp/relik-entity-linking-small
Relik Small pour une extraction d'informations fermées (EL + RE) : relik-ie/relik-cie-small
Reliquez grand pour la liaison des entités (El pour le sauvage) : relik-ie/relik-entity-linking-large-robust
Relik Small for Entity Linking (RE + NER) : relik-ie/relik-relation-extraction-small-wikipedia-ner
Modèles du papier:
sapienzanlp/relik-entity-linking-largesapienzanlp/relik-entity-linking-basesapienzanlp/relik-relation-extraction-nyt-largeUne liste complète de modèles peut être trouvée sur? Visage étreint.
D'autres modèles seront disponibles à l'avenir ?.
Rellik est un modèle léger et rapide pour la liaison des entités et l'extraction de relations . Il est composé de deux composantes principales: un retriever et un lecteur. Le Retriever est responsable de la récupération des documents pertinents d'une grande collection, tandis que le lecteur est responsable de l'extraction d'entités et de relations des documents récupérés. RELIK peut être utilisé avec la méthode from_pretrained pour charger un pipeline pré-formé.
Voici un exemple de la façon d'utiliser RELIK pour la liaison des entités:
from relik import Relik
from relik . inference . data . objects import RelikOutput
relik = Relik . from_pretrained ( "sapienzanlp/relik-entity-linking-large" )
relik_out : RelikOutput = relik ( "Michael Jordan was one of the best players in the NBA." )Sortir:
RelikOutput(
text="Michael Jordan was one of the best players in the NBA.",
tokens=['Michael', 'Jordan', 'was', 'one', 'of', 'the', 'best', 'players', 'in', 'the', 'NBA', '.'],
id=0,
spans=[
Span(start=0, end=14, label="Michael Jordan", text="Michael Jordan"),
Span(start=50, end=53, label="National Basketball Association", text="NBA"),
],
triples=[],
candidates=Candidates(
span=[
[
[
{"text": "Michael Jordan", "id": 4484083},
{"text": "National Basketball Association", "id": 5209815},
{"text": "Walter Jordan", "id": 2340190},
{"text": "Jordan", "id": 3486773},
{"text": "50 Greatest Players in NBA History", "id": 1742909},
...
]
]
]
),
)
et pour l'extraction de relation:
from relik import Relik
from relik . inference . data . objects import RelikOutput
relik = Relik . from_pretrained ( "sapienzanlp/relik-relation-extraction-nyt-large" )
relik_out : RelikOutput = relik ( "Michael Jordan was one of the best players in the NBA." )Sortir:
RelikOutput(
text='Michael Jordan was one of the best players in the NBA.',
tokens=Michael Jordan was one of the best players in the NBA.,
id=0,
spans=[
Span(start=0, end=14, label='--NME--', text='Michael Jordan'),
Span(start=50, end=53, label='--NME--', text='NBA')
],
triplets=[
Triplets(
subject=Span(start=0, end=14, label='--NME--', text='Michael Jordan'),
label='company',
object=Span(start=50, end=53, label='--NME--', text='NBA'),
confidence=1.0
)
],
candidates=Candidates(
span=[],
triplet=[
[
[
{"text": "company", "id": 4, "metadata": {"definition": "company of this person"}},
{"text": "nationality", "id": 10, "metadata": {"definition": "nationality of this person or entity"}},
{"text": "child", "id": 17, "metadata": {"definition": "child of this person"}},
{"text": "founded by", "id": 0, "metadata": {"definition": "founder or co-founder of this organization, religion or place"}},
{"text": "residence", "id": 18, "metadata": {"definition": "place where this person has lived"}},
...
]
]
]
),
)
Les récupérateurs et les lecteurs peuvent être utilisés séparément. Dans le cas de Retriever uniquement, la sortie contiendra les candidats pour le texte d'entrée.
Exemple de récupération uniquement:
from relik import Relik
from relik . inference . data . objects import RelikOutput
# If you want to use only the retriever
retriever = Relik . from_pretrained ( "sapienzanlp/relik-entity-linking-large" , reader = None )
relik_out : RelikOutput = retriever ( "Michael Jordan was one of the best players in the NBA." )Sortir:
RelikOutput(
text="Michael Jordan was one of the best players in the NBA.",
tokens=['Michael', 'Jordan', 'was', 'one', 'of', 'the', 'best', 'players', 'in', 'the', 'NBA', '.'],
id=0,
spans=[],
triples=[],
candidates=Candidates(
span=[
[
{"text": "Michael Jordan", "id": 4484083},
{"text": "National Basketball Association", "id": 5209815},
{"text": "Walter Jordan", "id": 2340190},
{"text": "Jordan", "id": 3486773},
{"text": "50 Greatest Players in NBA History", "id": 1742909},
...
]
],
triplet=[],
),
)
Exemple du lecteur uniquement:
from relik import Relik
from relik . inference . data . objects import RelikOutput
# If you want to use only the reader
reader = Relik . from_pretrained ( "sapienzanlp/relik-entity-linking-large" , retriever = None )
candidates = [
"Michael Jordan" ,
"National Basketball Association" ,
"Walter Jordan" ,
"Jordan" ,
"50 Greatest Players in NBA History" ,
]
text = "Michael Jordan was one of the best players in the NBA."
relik_out : RelikOutput = reader ( text , candidates = candidates )Sortir:
RelikOutput(
text="Michael Jordan was one of the best players in the NBA.",
tokens=['Michael', 'Jordan', 'was', 'one', 'of', 'the', 'best', 'players', 'in', 'the', 'NBA', '.'],
id=0,
spans=[
Span(start=0, end=14, label="Michael Jordan", text="Michael Jordan"),
Span(start=50, end=53, label="National Basketball Association", text="NBA"),
],
triples=[],
candidates=Candidates(
span=[
[
[
{
"text": "Michael Jordan",
"id": -731245042436891448,
},
{
"text": "National Basketball Association",
"id": 8135443493867772328,
},
{
"text": "Walter Jordan",
"id": -5873847607270755146,
"metadata": {},
},
{"text": "Jordan", "id": 6387058293887192208, "metadata": {}},
{
"text": "50 Greatest Players in NBA History",
"id": 2173802663468652889,
},
]
]
],
),
)
Relik fournit une CLI pour servir un serveur FastAPI pour le modèle ou pour effectuer une inférence sur un ensemble de données.
relik serverelik serve --help
Usage: relik serve [OPTIONS] RELIK_PRETRAINED [DEVICE] [RETRIEVER_DEVICE]
[DOCUMENT_INDEX_DEVICE] [READER_DEVICE] [PRECISION]
[RETRIEVER_PRECISION] [DOCUMENT_INDEX_PRECISION]
[READER_PRECISION] [ANNOTATION_TYPE]
╭─ Arguments ─────────────────────────────────────────────────────────────────────────────────────────╮
│ * relik_pretrained TEXT [default: None] [required] │
│ device [DEVICE] The device to use for relik (e.g., │
│ ' cuda ' , ' cpu ' ). │
│ [default: None] │
│ retriever_device [RETRIEVER_DEVICE] The device to use for the retriever │
│ (e.g., ' cuda ' , ' cpu ' ). │
│ [default: None] │
│ document_index_device [DOCUMENT_INDEX_DEVICE] The device to use for the index │
│ (e.g., ' cuda ' , ' cpu ' ). │
│ [default: None] │
│ reader_device [READER_DEVICE] The device to use for the reader │
│ (e.g., ' cuda ' , ' cpu ' ). │
│ [default: None] │
│ precision [PRECISION] The precision to use for relik │
│ (e.g., ' 32 ' , ' 16 ' ). │
│ [default: 32] │
│ retriever_precision [RETRIEVER_PRECISION] The precision to use for the │
│ retriever (e.g., ' 32 ' , ' 16 ' ). │
│ [default: None] │
│ document_index_precision [DOCUMENT_INDEX_PRECISION] The precision to use for the index │
│ (e.g., ' 32 ' , ' 16 ' ). │
│ [default: None] │
│ reader_precision [READER_PRECISION] The precision to use for the reader │
│ (e.g., ' 32 ' , ' 16 ' ). │
│ [default: None] │
│ annotation_type [ANNOTATION_TYPE] The type of annotation to use (e.g., │
│ ' CHAR ' , ' WORD ' ). │
│ [default: char] │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────╮
│ --host TEXT [default: 0.0.0.0] │
│ --port INTEGER [default: 8000] │
│ --frontend --no-frontend [default: no-frontend] │
│ --help Show this message and exit. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────╯
Par exemple:
relik serve sapienzanlp/relik-entity-linking-largerelik inferencerelik inference --help
Usage: relik inference [OPTIONS] MODEL_NAME_OR_PATH INPUT_PATH OUTPUT_PATH
╭─ Arguments ─────────────────────────────────────────────────────────────────────────────────────────────╮
│ * model_name_or_path TEXT [default: None] [required] │
│ * input_path TEXT [default: None] [required] │
│ * output_path TEXT [default: None] [required] │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────────╮
│ --batch-size INTEGER [default: 8] │
│ --num-workers INTEGER [default: 4] │
│ --device TEXT [default: cuda] │
│ --precision TEXT [default: fp16] │
│ --top-k INTEGER [default: 100] │
│ --window-size INTEGER [default: None] │
│ --window-stride INTEGER [default: None] │
│ --annotation-type TEXT [default: char] │
│ --progress-bar --no-progress-bar [default: progress-bar] │
│ --model-kwargs TEXT [default: None] │
│ --inference-kwargs TEXT [default: None] │
│ --help Show this message and exit. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────╯Par exemple:
relik inference sapienzanlp/relik-entity-linking-large data.txt output.jsonlLes images Docker pour Relik sont disponibles sur Docker Hub. Vous pouvez tirer la dernière image avec:
docker pull sapienzanlp/relik:latestet exécutez l'image avec:
docker run -p 12345:8000 sapienzanlp/relik:latest -c relik-ie/relik-cie-small L'API sera disponible sur http://localhost:12345 . Il expose un seul point de terminaison /relik avec plusieurs paramètres qui peuvent être transmis au modèle. Une documentation rapide de l'API se trouve sur http://localhost:12345/docs . Voici un exemple simple de la façon d'interroger l'API:
curl -X ' GET '
' http://127.0.0.1:12345/api/relik?text=Michael%20Jordan%20was%20one%20of%20the%20best%20players%20in%20the%20NBA.&is_split_into_words=false&retriever_batch_size=32&reader_batch_size=32&return_windows=false&use_doc_topic=false&annotation_type=char&relation_threshold=0.5 '
-H ' accept: application/json 'Ici, la liste complète des paramètres qui peuvent être transmis à l'image Docker:
docker run sapienzanlp/relik:latest -h
Usage: relik [-h --help] [-c --config] [-p --precision] [-d --device] [--retriever] [--retriever-device]
[--retriever-precision] [--index-device] [--index-precision] [--reader] [--reader-device] [--reader-precision]
[--annotation-type] [--frontend] [--workers] -- start the FastAPI server for the RElik model
where:
-h --help Show this help text
-c --config Pretrained ReLiK config name (from HuggingFace) or path
-p --precision Precision, default ' 32 ' .
-d --device Device to use, default ' cpu ' .
--retriever Override retriever model name.
--retriever-device Override retriever device.
--retriever-precision Override retriever precision.
--index-device Override index device.
--index-precision Override index precision.
--reader Override reader model name.
--reader-device Override reader device.
--reader-precision Override reader precision.
--annotation-type Annotation type ( ' char ' , ' word ' ), default ' char ' .
--frontend Whether to start the frontend server.
--workers Number of workers to use.Dans les sections suivantes, nous fournissons un guide étape par étape sur la façon de préparer les données, de former le Retriever et le lecteur et évaluer le modèle.
Toutes vos données doivent avoir la structure suivante:
{
"doc_id" : int, # Unique identifier for the document
"doc_text" : txt, # Text of the document
"doc_span_annotations" : # Char level annotations
[
[ start, end, label ],
[ start, end, label ],
...
]
}Nous avons utilisé des ensembles de données Blink (Wu et al., 2019) et Aida (Hoffart et al, 2011) pour la formation et l'évaluation. Plus précisément, nous avons utilisé l'ensemble de données Blink pour pré-formation du Retriever et de l'ensemble de données AIDA pour affiner le Retriever et la formation du lecteur.
L'ensemble de données Blink peut être téléchargé à partir du repo de genre à l'aide de ce script. Nous avons utilisé blink-train-kilt.jsonl et blink-dev-kilt.jsonl comme ensembles de données de formation et de validation. En supposant que nous ayons téléchargé les deux fichiers dans le dossier data/blink , nous avons converti l'ensemble de données Blink au format de relik à l'aide du script suivant:
# Train
python scripts/data/blink/preprocess_genre_blink.py
data/blink/blink-train-kilt.jsonl
data/blink/processed/blink-train-kilt-relik.jsonl
# Dev
python scripts/data/blink/preprocess_genre_blink.py
data/blink/blink-dev-kilt.jsonl
data/blink/processed/blink-dev-kilt-relik.jsonl L'ensemble de données AIDA n'est pas accessible au public, mais nous fournissons le fichier que nous avons utilisé sans champ text . Vous pouvez trouver le fichier au format RELIK dans le dossier data/aida/processed .
L'index Wikipedia que nous avons utilisé peut être téléchargé à partir d'ici.
Toutes vos données doivent avoir la structure suivante:
{
"doc_id" : int, # Unique identifier for the document
"doc_words: list[txt] # Tokenized text of the document
"doc_span_annotations" : # Token level annotations of mentions (label is optional)
[
[ start, end, label ],
[ start, end, label ],
...
],
"doc_triplet_annotations" : # Triplet annotations
[
{
"subject" : [ start, end, label ], # label is optional
"relation" : name, # type is optional
"object" : [ start, end, label ], # label is optional
},
{
"subject" : [ start, end, label ], # label is optional
"relation" : name, # type is optional
"object" : [ start, end, label ], # label is optional
},
]
}Pour l'extraction des relations, nous fournissons un exemple de la façon de prétraiter l'ensemble de données NYT à partir de RAW_NYT pris à partir de Copyre. Téléchargez l'ensemble de données sur Data / Raw_NYT puis exécutez:
python scripts/data/nyt/preprocess_nyt.py data/raw_nyt data/nyt/processed/Veuillez noter que pour une comparaison équitable, nous avons reproduit le prétraitement des travaux précédents, ce qui conduit à des triplets en double en raison de la manipulation incorrecte des formes de surface répétées pour les étendues d'entités. Si vous souhaitez analyser correctement les données d'origine au format RELIK, vous pouvez définir le Flagacacy-Format FAUX. Sachez simplement que les modèles RE NYT fournis ont été formés sur le format hérité.
Nous effectuons un processus de formation en deux étapes pour le Retriever. Tout d'abord, nous «pré-trahir» le Retriever en utilisant un ensemble de données Blink (Wu et al., 2019), puis nous le «affinons» en utilisant Aida (Hoffart et al, 2011).
Le retriever nécessite un ensemble de données dans un format similaire à DPR: un fichier jsonl où chaque ligne est un dictionnaire avec les clés suivantes:
{
"question" : " .... " ,
"positive_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}],
"negative_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}],
"hard_negative_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}]
}Le Retriever a également besoin d'un index pour rechercher les documents. Les documents à index peuvent être un fichier JSONL ou un fichier TSV similaire à DPR:
jsonl : Chaque ligne est un objet JSON avec les touches suivantes: id , text , metadatatsv : Chaque ligne est une chaîne séparée par un onglet avec les colonnes id et text , suivie d'une autre colonne qui sera stockée dans le champ de metadata Exemple jsonl :
{
"id" : " ... " ,
"text" : " ... " ,
"metadata" : [ " {...} " ]
},
... Exemple tsv :
id t text t any other column
... Une fois que vous avez l'ensemble de données Blink dans le format Rellik, vous pouvez créer les Windows avec le script suivant:
# train
relik data create-windows
data/blink/processed/blink-train-kilt-relik.jsonl
data/blink/processed/blink-train-kilt-relik-windowed.jsonl
# dev
relik data create-windows
data/blink/processed/blink-dev-kilt-relik.jsonl
data/blink/processed/blink-dev-kilt-relik-windowed.jsonlpuis le convertir au format DPR:
# train
relik data convert-to-dpr
data/blink/processed/blink-train-kilt-relik-windowed.jsonl
data/blink/processed/blink-train-kilt-relik-windowed-dpr.jsonl
data/kb/wikipedia/documents.jsonl
--title-map data/kb/wikipedia/title_map.json
# dev
relik data convert-to-dpr
data/blink/processed/blink-dev-kilt-relik-windowed.jsonl
data/blink/processed/blink-dev-kilt-relik-windowed-dpr.jsonl
data/kb/wikipedia/documents.jsonl
--title-map data/kb/wikipedia/title_map.json Étant donné que l'ensemble de données AIDA n'est pas accessible au public, nous pouvons fournir les annotations de l'ensemble de données AIDA dans le format RELIK en tant qu'exemple. En supposant que vous disposez de l'ensemble de données AIDA complet dans les data/aida , vous pouvez le convertir au format de relik, puis créer les fenêtres avec le script suivant:
relik data create-windows
data/aida/processed/aida-train-relik.jsonl
data/aida/processed/aida-train-relik-windowed.jsonlpuis le convertir au format DPR:
relik data convert-to-dpr
data/aida/processed/aida-train-relik-windowed.jsonl
data/aida/processed/aida-train-relik-windowed-dpr.jsonl
data/kb/wikipedia/documents.jsonl
--title-map data/kb/wikipedia/title_map.jsonrelik data create-windows
data/data/processed/nyt/train.jsonl
data/data/processed/nyt/train-windowed.jsonl
--is-split-into-words
--window-size none puis le convertir au format DPR:
relik data convert-to-dpr
data/data/processed/nyt/train-windowed.jsonl
data/data/processed/nyt/train-windowed-dpr.jsonl La commande relik retriever train peut être utilisée pour former le Retriever. Il nécessite les arguments suivants:
config_path : le chemin du fichier de configuration.overrides : une liste de remplacements dans le fichier de configuration, dans le format key=value . Des exemples de fichiers de configuration peuvent être trouvés dans le dossier relik/retriever/conf .
Les fichiers de configuration dans relik/retriever/conf sont pretrain_iterable_in_batch.yaml et finetune_iterable_in_batch.yaml , que nous avons utilisé pour pré-entraîner et affiner le retriever, respectivement.
Par exemple, pour former le Retriever sur l'ensemble de données AIDA, vous pouvez exécuter la commande suivante:
relik retriever train relik/retriever/conf/finetune_iterable_in_batch.yaml
model.language_model=intfloat/e5-base-v2
data.train_dataset_path=data/aida/processed/aida-train-relik-windowed-dpr.jsonl
data.val_dataset_path=data/aida/processed/aida-dev-relik-windowed-dpr.jsonl
data.test_dataset_path=data/aida/processed/aida-test-relik-windowed-dpr.jsonl
data.shared_params.documents_path=data/kb/wikipedia/documents.jsonl Le fichier de configuration dans relik/retriever/conf est finetune_nyt_iterable_in_batch.yaml , que nous avons utilisé pour affiner le retriever pour l'ensemble de données NYT. Pour CIE, nous réutilisons celui pré-entraîné de Blink à l'étape précédente.
Par exemple, pour former le Retriever sur l'ensemble de données NYT, vous pouvez exécuter la commande suivante:
relik retriever train relik/retriever/conf/finetune_nyt_iterable_in_batch.yaml
model.language_model=intfloat/e5-base-v2
data.train_dataset_path=data/nyt/processed/nyt-train-relik-windowed-dpr.jsonl
data.val_dataset_path=data/nyt/processed/nyt-dev-relik-windowed-dpr.jsonl
data.test_dataset_path=data/nyt/processed/nyt-test-relik-windowed-dpr.jsonl En passant train.only_test=True à la commande relik retriever train , vous pouvez ignorer la formation et évaluer uniquement le modèle. Il a également besoin du chemin vers le point de contrôle Lightning Pytorch et l'ensemble de données pour évaluer.
relik retriever train relik/retriever/conf/finetune_iterable_in_batch.yaml
train.only_test=True
test_dataset_path=data/aida/processed/aida-test-relik-windowed-dpr.jsonl
model.checkpoint_path=path/to/checkpointL'encodeur Retriever peut être enregistré du point de contrôle avec la commande suivante:
from relik . retriever . lightning_modules . pl_modules import GoldenRetrieverPLModule
checkpoint_path = "path/to/checkpoint"
retriever_folder = "path/to/retriever"
# If you want to push the model to the Hugging Face Hub set push_to_hub=True
push_to_hub = False
# If you want to push the model to the Hugging Face Hub set the repo_id
repo_id = "sapienzanlp/relik-retriever-e5-base-v2-aida-blink-encoder"
pl_module = GoldenRetrieverPLModule . load_from_checkpoint ( checkpoint_path )
pl_module . model . save_pretrained ( retriever_folder , push_to_hub = push_to_hub , repo_id = repo_id ) Avec push_to_hub=True le modèle sera poussé vers le? Houging Face Hub avec repo_id comme ID de référentiel où le modèle sera poussé.
Le Retriever a besoin d'un index pour rechercher les documents. L'index peut être créé à l'aide de la commande relik retriever create-index
relik retriever create-index --help
Usage: relik retriever build-index [OPTIONS] QUESTION_ENCODER_NAME_OR_PATH
DOCUMENT_PATH OUTPUT_FOLDER
╭─ Arguments ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * question_encoder_name_or_path TEXT [default: None] [required] │
│ * document_path TEXT [default: None] [required] │
│ * output_folder TEXT [default: None] [required] │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --document-file-type TEXT [default: jsonl] │
│ --passage-encoder-name-or-path TEXT [default: None] │
│ --indexer-class TEXT [default: relik.retriever.indexers.inmemory.InMemoryDocumentIndex] │
│ --batch-size INTEGER [default: 512] │
│ --num-workers INTEGER [default: 4] │
│ --passage-max-length INTEGER [default: 64] │
│ --device TEXT [default: cuda] │
│ --index-device TEXT [default: cpu] │
│ --precision TEXT [default: fp32] │
│ --push-to-hub --no-push-to-hub [default: no-push-to-hub] │
│ --repo-id TEXT [default: None] │
│ --help Show this message and exit. │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Avec l'encodeur et l'index, le Retriever peut être chargé à partir d'un ID de référentiel ou d'un chemin local:
from relik . retriever import GoldenRetriever
encoder_name_or_path = "sapienzanlp/relik-retriever-e5-base-v2-aida-blink-encoder"
index_name_or_path = "sapienzanlp/relik-retriever-e5-base-v2-aida-blink-wikipedia-index"
retriever = GoldenRetriever (
question_encoder = encoder_name_or_path ,
document_index = index_name_or_path ,
device = "cuda" , # or "cpu"
precision = "16" , # or "32", "bf16"
index_device = "cuda" , # or "cpu"
index_precision = "16" , # or "32", "bf16"
)Et puis il peut être utilisé pour récupérer des documents:
retriever . retrieve ( "Michael Jordan was one of the best players in the NBA." , top_k = 100 ) Le lecteur est responsable de l'extraction d'entités et de relations à partir de documents d'un ensemble de candidats (par exemple, entités ou relations possibles). Le lecteur peut être formé pour l'extraction de la portée ou l'extraction du triplet. Le RelikReaderForSpanExtraction est utilisé pour l'extraction de la portée, c'est-à-dire une liaison d'entités, tandis que le RelikReaderForTripletExtraction est utilisé pour l'extraction du triplet, c'est-à-dire l'extraction des relations.
Le lecteur nécessite l'ensemble de données fenêtré que nous avons créé dans la section avant de commencer à augmenter avec les candidats du Retriever. Les candidats peuvent être ajoutés à l'ensemble de données à l'aide de la commande relik retriever add-candidates .
relik retriever add-candidates --help
Usage: relik retriever add-candidates [OPTIONS] QUESTION_ENCODER_NAME_OR_PATH
DOCUMENT_NAME_OR_PATH INPUT_PATH
OUTPUT_PATH
╭─ Arguments ─────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * question_encoder_name_or_path TEXT [default: None] [required] │
│ * document_name_or_path TEXT [default: None] [required] │
│ * input_path TEXT [default: None] [required] │
│ * output_path TEXT [default: None] [required] │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --passage-encoder-name-or-path TEXT [default: None] │
│ --relations BOOLEAN [default: False] │
│ --top-k INTEGER [default: 100] │
│ --batch-size INTEGER [default: 128] │
│ --num-workers INTEGER [default: 4] │
│ --device TEXT [default: cuda] │
│ --index-device TEXT [default: cpu] │
│ --precision TEXT [default: fp32] │
│ --use-doc-topics --no-use-doc-topics [default: no-use-doc-topics] │
│ --help Show this message and exit. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Nous devons ajouter des candidats à chaque fenêtre qui sera utilisée par le lecteur, en utilisant notre retriever précédemment formé. Voici un exemple utilisant notre Retriever déjà formé sur Aida pour la scission de train:
relik retriever add-candidates sapienzanlp/relik-retriever-e5-base-v2-aida-blink-encoder sapienzanlp/relik-retriever-e5-base-v2-aida-blink-wikipedia-index data/aida/processed/aida-train-relik-windowed.jsonl data/aida/processed/aida-train-relik-windowed-candidates.jsonlLa même chose se produit pour l'extraction des relations. Si vous souhaitez utiliser notre retriever formé:
relik retriever add-candidates sapienzanlp/relik-retriever-small-nyt-question-encoder sapienzanlp/relik-retriever-small-nyt-document-index data/nyt/processed/nyt-train-relik-windowed.jsonl data/nyt/processed/nyt-train-relik-windowed-candidates.jsonl Semblable au Retriever, la commande relik reader train peut être utilisée pour former le Retriever. Il nécessite les arguments suivants:
config_path : le chemin du fichier de configuration.overrides : une liste de remplacements dans le fichier de configuration, dans le format key=value . Des exemples de fichiers de configuration peuvent être trouvés dans le dossier relik/reader/conf .
Les fichiers de configuration dans relik/reader/conf sont large.yaml et base.yaml , que nous avons utilisé pour former le grand lecteur de base, respectivement. Par exemple, pour former le grand lecteur sur le jeu de données AIDA:
relik reader train relik/reader/conf/large.yaml
train_dataset_path=data/aida/processed/aida-train-relik-windowed-candidates.jsonl
val_dataset_path=data/aida/processed/aida-dev-relik-windowed-candidates.jsonl
test_dataset_path=data/aida/processed/aida-dev-relik-windowed-candidates.jsonl Les fichiers de configuration dans relik/reader/conf sont large_nyt.yaml , base_nyt.yaml et small_nyt.yaml , que nous avons utilisé pour former le grand, la base et le petit lecteur, respectivement. Par exemple, pour former le grand lecteur sur le jeu de données AIDA:
relik reader train relik/reader/conf/large_nyt.yaml
train_dataset_path=data/nyt/processed/nyt-train-relik-windowed-candidates.jsonl
val_dataset_path=data/nyt/processed/nyt-dev-relik-windowed-candidates.jsonl
test_dataset_path=data/nyt/processed/nyt-test-relik-windowed-candidates.jsonlLe lecteur peut être enregistré du point de contrôle avec la commande suivante:
from relik . reader . lightning_modules . relik_reader_pl_module import RelikReaderPLModule
checkpoint_path = "path/to/checkpoint"
reader_folder = "path/to/reader"
# If you want to push the model to the Hugging Face Hub set push_to_hub=True
push_to_hub = False
# If you want to push the model to the Hugging Face Hub set the repo_id
repo_id = "sapienzanlp/relik-reader-deberta-v3-large-aida"
pl_model = RelikReaderPLModule . load_from_checkpoint (
trainer . checkpoint_callback . best_model_path
)
pl_model . relik_reader_core_model . save_pretrained ( experiment_path , push_to_hub = push_to_hub , repo_id = repo_id ) Avec push_to_hub=True le modèle sera poussé vers le? Houging Face Hub avec repo_id comme ID de référentiel où le modèle sera téléchargé.
Le lecteur peut être chargé à partir d'un repo ID ou d'un chemin local:
from relik . reader import RelikReaderForSpanExtraction , RelikReaderForTripletExtraction
# the reader for span extraction
reader_span = RelikReaderForSpanExtraction (
"sapienzanlp/relik-reader-deberta-v3-large-aida"
)
# the reader for triplet extraction
reader_tripltes = RelikReaderForTripletExtraction (
"sapienzanlp/relik-reader-deberta-v3-large-nyt"
)et utilisé pour extraire les entités et les relations:
# an example of candidates for the reader
candidates = [ "Michael Jordan" , "NBA" , "Chicago Bulls" , "Basketball" , "United States" ]
reader_span . read ( "Michael Jordan was one of the best players in the NBA." , candidates = candidates )Nous évaluons les performances de Relik sur la liaison des entités à l'aide de gerbil. Le tableau suivant montre les résultats (INKB Micro F1) de Relik Large et Base:
| Modèle | Aida | Msnbc | Der | K50 | R128 | R500 | O15 | O16 | Total | Dynamique | AIT (M: S) |
|---|---|---|---|---|---|---|---|---|---|---|---|
| GENRE | 83.7 | 73.7 | 54.1 | 60.7 | 46.7 | 40.3 | 56.1 | 50.0 | 58.2 | 54.5 | 38:00 |
| Entqa | 85.8 | 72.1 | 52.9 | 64.5 | 54.1 | 41.9 | 61.1 | 51.3 | 60,5 | 56.4 | 20h00 |
| Relancez-vous petit | 82.2 | 72.7 | 55.6 | 68.3 | 48.0 | 42.3 | 62.7 | 53.6 | 60.7 | 57.6 | 00:29 |
| Relance | 85.3 | 72.3 | 55.6 | 68.0 | 48.1 | 41.6 | 62.5 | 52.3 | 60.7 | 57.2 | 00:29 |
| Relance | 86.4 | 75.0 | 56.3 | 72.8 | 51.7 | 43.0 | 65.1 | 57.2 | 63.4 | 60.2 | 01:46 |
Évaluation des systèmes de comparaison (INKB Micro F1) sur l'ensemble de tests AIDA dans le domaine et MSNBC hors du domaine (MSN), Derczynski (DER), KORE50 (K50), N3-Reuters-128 (R128), N3-RSS-500 (R500), OKE-15 (O15) et OKE-16 (O16). Bold indique le meilleur modèle. Le genre utilise des dictionnaires. La colonne AIT montre le temps en minutes et secondes (M: S) que les systèmes doivent traiter l'ensemble de tests AIDA à l'aide d'un NVIDIA RTX 4090, à l'exception de l'ENTQA qui ne correspond pas à 24 Go de RAM et pour lequel un A100 est utilisé.
Pour évaluer Rellik, nous utilisons les étapes suivantes:
Téléchargez le serveur Gerbil à partir d'ici.
Démarrez le serveur Gerbil:
cd gerbil && ./start.sh cd gerbil-SpotWrapNifWS4Test && mvn clean -Dmaven.tomcat.port=1235 tomcat:runsapienzanlp/relik-entity-linking-large ): python relik/reader/utils/gerbil.py --relik-model-name sapienzanlp/relik-entity-linking-largeLe tableau suivant montre les résultats (Micro F1) de Relik Large sur l'ensemble de données NYT:
| Modèle | NYT | NYT (Pretr) | AIT (M: S) |
|---|---|---|---|
| REBELLE | 93.1 | 93.4 | 01:45 |
| Uie | 93.5 | - | - |
| USM | 94.0 | 94.1 | - |
| Relance | 95.0 | 94.9 | 00:30 |
Pour évaluer l'extraction des relations, nous pouvons utiliser directement le lecteur avec le script Rellik / Reader / Trainer / Predict_re.py, pointant le fichier avec des candidats déjà récupérés. Si vous souhaitez utiliser notre lecteur formé:
python relik/reader/trainer/predict_re.py --model_path sapienzanlp/relik-reader-deberta-v3-large-nyt --data_path /Users/perelluis/Documents/relik/data/debug/test.window.candidates.jsonl --is-evalSachez que nous calculons le seuil pour prédire les relations en fonction de l'ensemble de développement. Pour le calculer lors de l'évaluation, vous pouvez exécuter ce qui suit:
python relik/reader/trainer/predict_re.py --model_path sapienzanlp/relik-reader-deberta-v3-large-nyt --data_path /Users/perelluis/Documents/relik/data/debug/dev.window.candidates.jsonl --is-eval --compute-thresholdSi vous utilisez une partie de ce travail, veuillez envisager de citer le papier comme suit:
@inproceedings { orlando-etal-2024-relik ,
title = " Retrieve, Read and LinK: Fast and Accurate Entity Linking and Relation Extraction on an Academic Budget " ,
author = " Orlando, Riccardo and Huguet Cabot, Pere-Llu{'i}s and Barba, Edoardo and Navigli, Roberto " ,
booktitle = " Findings of the Association for Computational Linguistics: ACL 2024 " ,
month = aug,
year = " 2024 " ,
address = " Bangkok, Thailand " ,
publisher = " Association for Computational Linguistics " ,
}Les données et les logiciels sont concédés sous licence Creative Commons Attribution-NonCommercial-Sharealike 4.0.
