relik
1.0.7
Ein loderndes schnelles und leichtes Informationsextraktionsmodell für Entitätsverbinden und Beziehungsextraktion .
Installation von PYPI
pip install relikInstallieren Sie mit allen optionalen Abhängigkeiten.
pip install relik[all]Installieren Sie mit optionalen Abhängigkeiten für Schulungen und Bewertung.
pip install relik[train]Installieren Sie mit optionalen Abhängigkeiten für FAISS
Das Faiss Pypi -Paket ist nur für die CPU erhältlich. Installieren Sie es für GPU aus der Quelle oder verwenden Sie das Conda -Paket.
Für CPU:
pip install relik[faiss]Für 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 relikInstallieren Sie mit optionalen Abhängigkeiten zum Servieren der Modelle mit Fastapi und Ray.
pip install relik[serve]git clone https://github.com/SapienzaNLP/relik.git
cd relik
pip install -e .[all] Relik Large für die Beziehungsextraktion (? Large Re V2, Colab ✅) : relik-ie/relik-relation-extraction-large
Relik Large für geschlossene Informationsextraktion (? Large El + Re, Colab ✅) : https://huggingface.co/relik-ie/relik-cie-large
Relik Extra groß für geschlossene Informationsextraktion (? Unser Thicc Boi für El + Re) : relik-ie/relik-cie-xl
Relik klein für Entitätsverbinden ( sapienzanlp/relik-entity-linking-small
Relik Small für Entitätsverknüpfung (⚡ kleiner und schneller EL) : sapienzanlp/relik-entity-linking-small
Relik Small für geschlossene Informationsextraktion (El + Re) : relik-ie/relik-cie-small
Relik Large für Entitätsverbinden (EL für die Wild) : relik-ie/relik-entity-linking-large-robust
Relik Small für Entity Linking (RE + NER) : relik-ie/relik-relation-extraction-small-wikipedia-ner
Modelle aus dem Papier:
sapienzanlp/relik-entity-linking-largesapienzanlp/relik-entity-linking-basesapienzanlp/relik-relation-extraction-nyt-largeEine vollständige Liste von Modellen finden Sie auf? Umarmtes Gesicht.
Andere Modelsgrößen werden in Zukunft verfügbar sein?
Relik ist ein leichtes und schnelles Modell für Entitätsverbinden und Beziehungsextraktion . Es besteht aus zwei Hauptkomponenten: einem Retriever und einem Leser. Der Retriever ist dafür verantwortlich, relevante Dokumente aus einer großen Sammlung abzurufen, während der Leser dafür verantwortlich ist, Entitäten und Beziehungen aus den abgerufenen Dokumenten zu extrahieren. Relik kann mit der from_pretrained Methode verwendet werden, um eine vorgebaute Pipeline zu laden.
Hier ist ein Beispiel für die Verwendung von Relik für Entitätsverbinden:
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." )Ausgabe:
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},
...
]
]
]
),
)
und für die Beziehungsextraktion:
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." )Ausgabe:
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"}},
...
]
]
]
),
)
Retriever und Leser können separat verwendet werden. Bei Retriever-Relik enthält die Ausgabe die Kandidaten für den Eingabetxt.
Beispiele für retriever:
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." )Ausgabe:
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=[],
),
)
Nur Reader-Beispiel:
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 )Ausgabe:
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 stellt eine CLI zur Verfügung, um einen Fastapi -Server für das Modell zu servieren oder einen Inferenz in einem Datensatz durchzuführen.
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. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────╯
Zum Beispiel:
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. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────╯Zum Beispiel:
relik inference sapienzanlp/relik-entity-linking-large data.txt output.jsonlDocker -Bilder für Relik sind in Docker Hub verfügbar. Sie können das neueste Bild mit:
docker pull sapienzanlp/relik:latestund führen Sie das Bild mit: aus:
docker run -p 12345:8000 sapienzanlp/relik:latest -c relik-ie/relik-cie-small Die API wird unter http://localhost:12345 erhältlich sein. Es enthält einen einzelnen Endpunkt /relik mit mehreren Parametern, die an das Modell übergeben werden können. Eine kurze Dokumentation der API finden Sie unter http://localhost:12345/docs . Hier ist ein einfaches Beispiel dafür, wie man die API abfragt:
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 'Hier die vollständige Liste der Parameter, die an das Docker -Bild übergeben werden können:
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.In den folgenden Abschnitten bieten wir eine Schritt-für-Schritt-Anleitung zum Vorbereiten der Daten, zur Ausbildung des Retrievers und des Lesers und bewerten das Modell.
Alle Ihre Daten sollten die folgende Struktur haben:
{
"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 ],
...
]
}Wir verwendeten Blink (Wu et al., 2019) und AIDA (Hoffart et al., 2011) Datensätze zur Schulung und Bewertung. Insbesondere haben wir den Blink-Datensatz verwendet, um den Retriever und den AIDA-Datensatz vorzubilden, um den Retriever zu optimieren und den Leser zu trainieren.
Der Blink -Datensatz kann mit diesem Skript aus dem Genre -Repo heruntergeladen werden. Wir haben blink-train-kilt.jsonl und blink-dev-kilt.jsonl als Trainings- und Validierungsdatensätze verwendet. Angenommen, wir haben die beiden Dateien im data/blink -Ordner heruntergeladen, haben wir das Blink -Datensatz mit dem folgenden Skript in das Relik -Format konvertiert:
# 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 Der AIDA -Datensatz ist nicht öffentlich verfügbar, aber wir geben die Datei, die wir ohne text verwendet haben, bereitgestellt. Sie finden die Datei im Relik -Format im Ordner data/aida/processed .
Der von uns verwendete Wikipedia -Index kann von hier heruntergeladen werden.
Alle Ihre Daten sollten die folgende Struktur haben:
{
"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
},
]
}Für die Beziehungsextraktion geben wir ein Beispiel dafür, wie der NYT -Datensatz von RAW_NYT von CopyRE vorbereitet wird. Laden Sie den Datensatz auf data/raw_nyt herunter und führen Sie dann aus:
python scripts/data/nyt/preprocess_nyt.py data/raw_nyt data/nyt/processed/Bitte beachten Sie, dass wir zum fairen Vergleich die Vorverarbeitung aus früheren Arbeiten reproduziert haben, was zu doppelten Triplets führt, da wiederholte Oberflächenformen für Entitätsspannen falsch behandelt werden. Wenn Sie die Originaldaten korrekt in das Relik-Format analysieren möchten, können Sie das Flag-Legacy-Format False festlegen. Beachten Sie nur, dass die zur Verfügung gestellten Modelle im Legacy -Format geschult wurden.
Wir führen einen zweistufigen Trainingsprozess für den Retriever durch. Zunächst "pre-train" den retriever mit Blink (Wu et al., 2019) und dann mit AIDA (Hoffart et al., 2011).
Der Retriever benötigt einen Datensatz in einem Format ähnlich wie DPR: Eine jsonl -Datei, in der jede Zeile ein Wörterbuch mit den folgenden Schlüssel ist:
{
"question" : " .... " ,
"positive_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}],
"negative_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}],
"hard_negative_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}]
}Der Retriever benötigt auch einen Index, um nach den Dokumenten zu suchen. Die zu indexierten Dokumente können entweder eine JSONL -Datei oder eine TSV -Datei ähnlich wie DPR sein:
jsonl : Jede Zeile ist ein JSON -Objekt mit den folgenden Schlüssel: id , text , metadatatsv : Jede Zeile ist eine tabendrichtete Zeichenfolge mit den Spalten id und text , gefolgt von einer anderen Spalte, die im Feld metadata gespeichert wird jsonl -Beispiel:
{
"id" : " ... " ,
"text" : " ... " ,
"metadata" : [ " {...} " ]
},
... tsv -Beispiel:
id t text t any other column
... Sobald Sie den Blink -Datensatz im Relik -Format haben, können Sie die Fenster mit dem folgenden Skript erstellen:
# 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.jsonlund dann in das DPR -Format umwandeln:
# 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 Da der AIDA -Datensatz nicht öffentlich verfügbar ist, können wir die Anmerkungen für den AIDA -Datensatz im Relik -Format als Beispiel bereitstellen. Angenommen, Sie haben den vollständigen AIDA -Datensatz in den data/aida , können Sie ihn in das Relik -Format konvertieren und dann die Fenster mit dem folgenden Skript erstellen:
relik data create-windows
data/aida/processed/aida-train-relik.jsonl
data/aida/processed/aida-train-relik-windowed.jsonlund dann in das DPR -Format umwandeln:
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 und dann in das DPR -Format umwandeln:
relik data convert-to-dpr
data/data/processed/nyt/train-windowed.jsonl
data/data/processed/nyt/train-windowed-dpr.jsonl Mit dem Befehl relik retriever train kann der retriever trainieren. Es erfordert die folgenden Argumente:
config_path : Der Pfad zur Konfigurationsdatei.overrides : Eine Liste von Überschreibungen in die Konfigurationsdatei im key=value . Beispiele für Konfigurationsdateien finden Sie im Ordner relik/retriever/conf .
Die Konfigurationsdateien in relik/retriever/conf sind pretrain_iterable_in_batch.yaml und finetune_iterable_in_batch.yaml , die wir verwendet haben, um den Retriever vorzuverfolgen und zu optimieren.
Zum Beispiel können Sie den folgenden Befehl ausführen, um den Retriever im AIDA -Datensatz zu trainieren:
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 Die Konfigurationsdatei in relik/retriever/conf ist finetune_nyt_iterable_in_batch.yaml , mit der wir den Retriever für den NYT-Datensatz Fein einstellen. Für CIE verwenden wir den einen im vorherigen Schritt vorgebliebenen Blink.
Zum Beispiel können Sie den folgenden Befehl ausführen, um den Retriever im NYT -Datensatz zu trainieren:
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 Durch die Übergabe train.only_test=True für den Befehl relik retriever train können das Training überspringen und das Modell nur bewerten. Es benötigt auch den Pfad zum Pytorch Lightning Checkpoint und zum Datensatz, um es zu bewerten.
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/checkpointDer Retriever -Encoder kann mit dem folgenden Befehl aus dem Kontrollpunkt gespeichert werden:
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 ) Mit push_to_hub=True wird das Modell auf die gedrückt? Umarme Face Hub mit repo_id als Repository -ID, in der das Modell gedrückt wird.
Der Retriever benötigt einen Index, um nach den Dokumenten zu suchen. Der Index kann mit dem Befehl relik retriever create-index erstellt werden
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. │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Mit dem Encoder und dem Index kann der Retriever aus einer Repo -ID oder einem lokalen Pfad geladen werden:
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"
)Und dann kann es verwendet werden, um Dokumente abzurufen:
retriever . retrieve ( "Michael Jordan was one of the best players in the NBA." , top_k = 100 ) Der Leser ist dafür verantwortlich, Entitäten und Beziehungen aus Dokumenten aus einer Reihe von Kandidaten zu extrahieren (z. B. mögliche Entitäten oder Beziehungen). Der Leser kann für die Extraktion oder die Triplett -Extraktion trainiert werden. Die RelikReaderForSpanExtraction wird für die Spannextraktion verwendet, dh eine Entitätsverbindung, während die RelikReaderForTripletExtraction für die Triplett -Extraktion verwendet wird, dh die Relationsextraktion.
Der Leser benötigt den Fensterdatensatz, den wir im Abschnitt erstellt haben, bevor Sie mit den Kandidaten aus dem Retriever erweitert werden. Die Kandidaten können mit dem Befehl relik retriever add-candidates zum Datensatz hinzugefügt werden.
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. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Wir müssen jedes Fenster Kandidaten hinzufügen, die vom Leser mit unserem zuvor trainierten Retriever verwendet werden. Hier ist ein Beispiel, das unseren bereits trainierten Retriever auf AIDA für den Zug geteilt hat:
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.jsonlDas gleiche passiert für die Beziehungsextraktion. Wenn Sie unseren ausgebildeten Retriever verwenden möchten:
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 Ähnlich wie beim Retriever kann der Befehl relik reader train zum Training des Retrievers verwendet werden. Es erfordert die folgenden Argumente:
config_path : Der Pfad zur Konfigurationsdatei.overrides : Eine Liste von Überschreibungen in die Konfigurationsdatei im key=value . Beispiele für Konfigurationsdateien finden Sie im Ordner relik/reader/conf .
base.yaml Konfigurationsdateien in relik/reader/conf sind large.yaml . Zum Beispiel, um den großen Leser im AIDA -Datensatz zu trainieren:
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 Die Konfigurationsdateien in relik/reader/conf sind large_nyt.yaml , base_nyt.yaml und small_nyt.yaml , mit denen wir den großen, Basis bzw. kleinen Leser trainiert haben. Zum Beispiel, um den großen Leser im AIDA -Datensatz zu trainieren:
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.jsonlDer Leser kann mit dem folgenden Befehl aus dem Kontrollpunkt gespeichert werden:
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 ) Mit push_to_hub=True wird das Modell auf die gedrückt? Umarme Face Hub mit repo_id als Repository -ID, in der das Modell hochgeladen wird.
Der Leser kann aus einer Repo -ID oder einem lokalen Pfad geladen werden:
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"
)und verwendet, um Entitäten und Beziehungen zu extrahieren:
# 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 )Wir bewerten die Leistung von Relik in der Entität, die mit GERBIL verknüpft ist. Die folgende Tabelle zeigt die Ergebnisse (Inkb Micro F1) von Relik Large und Base:
| Modell | Aida | MSNBC | Der | K50 | R128 | R500 | O15 | O16 | Knirps | Ood | 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 | 20:00 |
| Relik klein | 82.2 | 72.7 | 55.6 | 68,3 | 48.0 | 42.3 | 62.7 | 53.6 | 60.7 | 57.6 | 00:29 |
| Relik -Basis | 85.3 | 72.3 | 55.6 | 68.0 | 48.1 | 41.6 | 62,5 | 52.3 | 60.7 | 57,2 | 00:29 |
| Relik groß | 86,4 | 75,0 | 56,3 | 72,8 | 51.7 | 43.0 | 65.1 | 57,2 | 63.4 | 60.2 | 01:46 |
Comparison systems' evaluation (InKB Micro F1) on the in-domain AIDA test set and out-of-domain MSNBC (MSN), Derczynski (Der), KORE50 (K50), N3-Reuters-128 (R128), N3-RSS-500 (R500), OKE-15 (O15), and OKE-16 (O16) test sets. Fett zeigt das beste Modell an. Genre verwendet erwähnte Wörterbücher. Die AIT -Spalte zeigt die Zeit in Minuten und Sekunden (m: s), dass die Systeme den gesamten AIDA -Testsatz mit einem NVIDIA RTX 4090 verarbeiten müssen, mit Ausnahme von Entqa, die nicht in 24 GB RAM passt und für die ein A100 verwendet wird.
Um Relik zu bewerten, verwenden wir die folgenden Schritte:
Laden Sie hier den Gerbil -Server herunter.
Starten Sie den GERBIL -Server:
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-largeDie folgende Tabelle zeigt die Ergebnisse (Micro F1) von Relik Large im NYT -Datensatz:
| Modell | NYT | NYT (Pretr) | Ait (m: s) |
|---|---|---|---|
| REBELL | 93.1 | 93.4 | 01:45 |
| Uie | 93.5 | - | - |
| USM | 94.0 | 94.1 | - |
| Relik groß | 95.0 | 94.9 | 00:30 |
Um die Beziehungsextraktion zu bewerten, können wir den Leser direkt mit dem Skript Relik/Reader/Trainer/Predict_re.py verwenden, der auf die Datei mit bereits abgerufenen Kandidaten zeigt. Wenn Sie unseren ausgebildeten Leser verwenden möchten:
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-evalBeachten Sie, dass wir den Schwellenwert für die Vorhersage von Beziehungen basierend auf dem Entwicklungssatz berechnen. Um es während der Bewertung zu berechnen, können Sie Folgendes ausführen:
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-thresholdWenn Sie einen Teil dieser Arbeit verwenden, sollten Sie das Papier wie folgt zitieren:
@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 " ,
}Die Daten und Software sind unter Creative Commons Attribution-Noncommercial-sharealike 4.0 lizenziert.
