relik
1.0.7
Un modelo de extracción de información rápida y liviana para la vinculación de la entidad y la extracción de relaciones .
Instalación desde PYPI
pip install relikInstale con todas las dependencias opcionales.
pip install relik[all]Instale con dependencias opcionales para capacitación y evaluación.
pip install relik[train]Instalar con dependencias opcionales para FAISS
El paquete Faiss Pypi solo está disponible para CPU. Para GPU, instálelo desde la fuente o use el paquete de conda.
Para CPU:
pip install relik[faiss]Para 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 relikInstale con dependencias opcionales para servir a los modelos con Fastapi y Ray.
pip install relik[serve]git clone https://github.com/SapienzaNLP/relik.git
cd relik
pip install -e .[all] Relik grande para la extracción de relación (? Gran RE V2, Colab ✅) : relik-ie/relik-relation-extraction-large
Relik grande para extracción de información cerrada (? Grande el + re, colab ✅) : https://huggingface.co/relik-ie/relik-cie-large
Relik extra grande para extracción de información cerrada ( relik-ie/relik-cie-xl
Relik Small For Entity Vinking ( sapienzanlp/relik-entity-linking-small
Relik Small For Entity Vinking (⚡ Small and Fast EL) : sapienzanlp/relik-entity-linking-small
Relik Small para extracción de información cerrada (el + re) : relik-ie/relik-cie-small
Relik grande para la vinculación de la entidad (El para la naturaleza) : relik-ie/relik-entity-linking-large-robust
Relik Small For Entity Vinking (Re + Ner) : relik-ie/relik-relation-extraction-small-wikipedia-ner
Modelos del papel:
sapienzanlp/relik-entity-linking-largesapienzanlp/relik-entity-linking-basesapienzanlp/relik-relation-extraction-nyt-large¿Se puede encontrar una lista completa de modelos? Cara abrazada.
¿Otros tamaños de modelos estarán disponibles en el futuro?
Relik es un modelo ligero y rápido para la vinculación de la entidad y la extracción de relaciones . Se compone de dos componentes principales: un retriever y un lector. El Retriever es responsable de recuperar documentos relevantes de una gran colección, mientras que el lector es responsable de extraer entidades y relaciones de los documentos recuperados. Relik se puede utilizar con el método from_pretrained para cargar una tubería previamente capacitada.
Aquí hay un ejemplo de cómo usar Relik para la vinculación de la entidad:
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." )Producción:
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},
...
]
]
]
),
)
y para la extracción de relación:
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." )Producción:
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"}},
...
]
]
]
),
)
Retrievers y lectores se pueden usar por separado. En el caso de Relik solo de Retriever, la salida contendrá los candidatos para el texto de entrada.
Ejemplo solo de 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." )Producción:
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=[],
),
)
Ejemplo de solo lector:
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 )Producción:
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 proporciona una CLI para servir a un servidor FASTAPI para el modelo o para realizar una inferencia en un conjunto de datos.
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. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────╯
Por ejemplo:
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. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────╯Por ejemplo:
relik inference sapienzanlp/relik-entity-linking-large data.txt output.jsonlLas imágenes de Docker para Relik están disponibles en Docker Hub. Puedes extraer la última imagen con:
docker pull sapienzanlp/relik:latesty ejecuta la imagen con:
docker run -p 12345:8000 sapienzanlp/relik:latest -c relik-ie/relik-cie-small La API estará disponible en http://localhost:12345 . Expone un único punto final /relik con varios parámetros que se pueden pasar al modelo. Se puede encontrar una documentación rápida de la API en http://localhost:12345/docs . Aquí hay un simple ejemplo de cómo consultar la 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 'Aquí la lista completa de parámetros que se pueden pasar a la imagen 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.En las siguientes secciones, proporcionamos una guía paso a paso sobre cómo preparar los datos, capacitar al Retriever y al lector, y evaluar el modelo.
Todos sus datos deben tener la siguiente estructura:
{
"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 ],
...
]
}Utilizamos conjuntos de datos Blink (Wu et al., 2019) y Aida (Hoffart et al, 2011) para capacitación y evaluación. Más específicamente, utilizamos el conjunto de datos Blink para la capacitación previa al recolector de datos y el conjunto de datos AIDA para ajustar el receptor y capacitar al lector.
El conjunto de datos Blink se puede descargar desde el repositorio de género utilizando este script. Utilizamos blink-train-kilt.jsonl y blink-dev-kilt.jsonl como conjuntos de datos de entrenamiento y validación. Suponiendo que hemos descargado los dos archivos en la carpeta data/blink , convertimos el conjunto de datos de Blink al formato Relik utilizando el siguiente script:
# 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 El conjunto de datos AIDA no está disponible públicamente, pero proporcionamos el archivo que utilizamos sin campo text . Puede encontrar el archivo en formato Relik en la carpeta data/aida/processed .
El índice Wikipedia que utilizamos se puede descargar desde aquí.
Todos sus datos deben tener la siguiente estructura:
{
"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
},
]
}Para la extracción de relaciones, proporcionamos un ejemplo de cómo preprocesar el conjunto de datos NYT de RAW_NYT tomado de Copyre. Descargue el conjunto de datos a Data/RAW_NYT y luego ejecute:
python scripts/data/nyt/preprocess_nyt.py data/raw_nyt data/nyt/processed/Tenga en cuenta que para una comparación justa reproducimos el preprocesamiento de los trabajos anteriores, lo que conduce a trillizos duplicados debido al manejo incorrecto de formas de superficie repetidas para los tramos de entidad. Si desea analizar correctamente los datos originales en formato Relik, puede configurar el Falso FALLO DE FLAG-FORMAT. Solo tenga en cuenta que los modelos RE NYT proporcionados fueron entrenados en el formato Legacy.
Realizamos un proceso de capacitación de dos pasos para el Retriever. Primero, "pre-entrenamos" el retriever que usa el conjunto de datos Blink (Wu et al., 2019), y luego lo "ajustamos" usando AIDA (Hoffart et al, 2011).
El Retriever requiere un conjunto de datos en un formato similar a DPR: un archivo jsonl donde cada línea es un diccionario con las siguientes claves:
{
"question" : " .... " ,
"positive_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}],
"negative_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}],
"hard_negative_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}]
}El Retriever también necesita un índice para buscar los documentos. Los documentos al índice pueden ser un archivo JSONL o un archivo TSV similar a DPR:
jsonl : Cada línea es un objeto JSON con las siguientes claves: id , text , metadatatsv : cada línea es una cadena separada con pestañas con la id y las columnas text , seguida de cualquier otra columna que se almacenará en el campo metadata Ejemplo jsonl :
{
"id" : " ... " ,
"text" : " ... " ,
"metadata" : [ " {...} " ]
},
... Ejemplo tsv :
id t text t any other column
... Una vez que tenga el conjunto de datos Blink en el formato Relik, puede crear las ventanas con el siguiente script:
# 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.jsonly luego conviértalo en el formato 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 Dado que el conjunto de datos AIDA no está disponible públicamente, podemos proporcionar las anotaciones para el conjunto de datos AIDA en formato Relik como ejemplo. Suponiendo que tenga el conjunto de datos AIDA completo en los data/aida , puede convertirlo en el formato Relik y luego crear las ventanas con el siguiente script:
relik data create-windows
data/aida/processed/aida-train-relik.jsonl
data/aida/processed/aida-train-relik-windowed.jsonly luego conviértalo en el formato 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 y luego conviértalo en el formato DPR:
relik data convert-to-dpr
data/data/processed/nyt/train-windowed.jsonl
data/data/processed/nyt/train-windowed-dpr.jsonl El comando relik retriever train se puede usar para entrenar al Retriever. Requiere los siguientes argumentos:
config_path : la ruta al archivo de configuración.overrides : una lista de anulaciones al archivo de configuración, en la key=value . Se pueden encontrar ejemplos de archivos de configuración en la carpeta relik/retriever/conf .
Los archivos de configuración en relik/retriever/conf son pretrain_iterable_in_batch.yaml y finetune_iterable_in_batch.yaml , que usamos para pre-entrenar y ajustar el retriever, respectivamente.
Por ejemplo, para entrenar al Retriever en el conjunto de datos AIDA, puede ejecutar el siguiente comando:
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 El archivo de configuración en relik/retriever/conf es finetune_nyt_iterable_in_batch.yaml , que utilizamos para ajustar el retriever para el conjunto de datos NYT. Para CIE reutilizamos el que está provocado de parpadeo en el paso anterior.
Por ejemplo, para entrenar el receptor en el conjunto de datos NYT, puede ejecutar el siguiente comando:
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 Al pasar train.only_test=True al comando relik retriever train , puede omitir la capacitación y solo evaluar el modelo. También necesita la ruta al punto de control Pytorch Lightning y el conjunto de datos para evaluar.
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/checkpointEl codificador Retriever se puede guardar desde el punto de control con el siguiente comando:
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 ) Con push_to_hub=True El modelo se empujará al? Abrazando Face Hub con repo_id como ID de repositorio donde se empujará el modelo.
El Retriever necesita un índice para buscar los documentos. El índice se puede crear usando el comando 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. │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Con el codificador y el índice, el Retriever se puede cargar desde una identificación de reposio o una ruta 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"
)Y luego se puede usar para recuperar documentos:
retriever . retrieve ( "Michael Jordan was one of the best players in the NBA." , top_k = 100 ) El lector es responsable de extraer entidades y relaciones de documentos de un conjunto de candidatos (por ejemplo, posibles entidades o relaciones). El lector puede ser entrenado para la extracción del truco o la extracción de triplete. El RelikReaderForSpanExtraction se usa para la extracción de la amplia forma, es decir, la vinculación de la entidad, mientras que la extracción RelikReaderForTripletExtraction para la extracción de triplete, es decir, la extracción de relación.
El lector requiere el conjunto de datos de ventana que creamos en la sección antes de comenzar a aumentar con los candidatos del Retriever. Los candidatos se pueden agregar al conjunto de datos utilizando el comando 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. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Necesitamos agregar candidatos a cada ventana que sea utilizada por el lector, utilizando nuestro Retriever previamente capacitado. Aquí hay un ejemplo usando nuestro Retriever ya entrenado en AIDA para la división del tren:
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.jsonlLo mismo sucede para la extracción de relación. Si quieres usar nuestro Retriever entrenado:
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 Similar al Retriever, el comando relik reader train se puede usar para entrenar al Retriever. Requiere los siguientes argumentos:
config_path : la ruta al archivo de configuración.overrides : una lista de anulaciones al archivo de configuración, en la key=value . Se pueden encontrar ejemplos de archivos de configuración en la carpeta relik/reader/conf .
Los archivos de configuración en relik/reader/conf son large.yaml y base.yaml , que usamos para entrenar al lector grande y base, respectivamente. Por ejemplo, para entrenar al gran lector en el conjunto de datos AIDA Ejecutar:
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 Los archivos de configuración en relik/reader/conf son large_nyt.yaml , base_nyt.yaml y small_nyt.yaml , que usamos para entrenar al lector grande, base y pequeño, respectivamente. Por ejemplo, para entrenar al gran lector en el conjunto de datos AIDA Ejecutar:
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.jsonlEl lector se puede guardar desde el punto de control con el siguiente comando:
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 ) con push_to_hub=True El modelo se empujará al? Abrazando Face Hub con repo_id como ID de repositorio donde se cargará el modelo.
El lector se puede cargar desde una identificación de repo o una ruta 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"
)y utilizado para extraer entidades y relaciones:
# 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 )Evaluamos el rendimiento de Relik en la vinculación de la entidad usando Gerbil. La siguiente tabla muestra los resultados (Inkb Micro F1) de Relik grande y base:
| Modelo | Aida | MSNBC | Derrota | K50 | R128 | R500 | O15 | O16 | Nene | Ácido | AIT (M: S) |
|---|---|---|---|---|---|---|---|---|---|---|---|
| GÉNERO | 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 pequeño | 82.2 | 72.7 | 55.6 | 68.3 | 48.0 | 42.3 | 62.7 | 53.6 | 60.7 | 57.6 | 00:29 |
| Base de relik | 85.3 | 72.3 | 55.6 | 68.0 | 48.1 | 41.6 | 62.5 | 52.3 | 60.7 | 57.2 | 00:29 |
| Relik grande | 86.4 | 75.0 | 56.3 | 72.8 | 51.7 | 43.0 | 65.1 | 57.2 | 63.4 | 60.2 | 01:46 |
Evaluación de los sistemas de comparación (Inkb Micro F1) en el conjunto de pruebas AIDA en dominio y MSNBC (MSN) fuera del dominio , Derczynski (DER), Kore50 (K50), N3-Reuters-128 (R128), N3-RSS-500 (R500), OKE-15 (O15) y OKE-16 (O16) Tests. Bold indica el mejor modelo. El género utiliza diccionarios de mención. La columna AIT muestra el tiempo en minutos y segundos (m: s) que los sistemas necesitan procesar todo el conjunto de pruebas AIDA utilizando un NVIDIA RTX 4090, excepto ENTQA que no se ajusta en 24 GB de RAM y para el cual se usa un A100.
Para evaluar a Relik usamos los siguientes pasos:
Descargue el servidor Gerbil desde aquí.
Inicie el servidor 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-largeLa siguiente tabla muestra los resultados (Micro F1) de Relik grande en el conjunto de datos NYT:
| Modelo | NYT | NYT (Pretr) | AIT (M: S) |
|---|---|---|---|
| REBELDE | 93.1 | 93.4 | 01:45 |
| Uie | 93.5 | - | - |
| Usm | 94.0 | 94.1 | - |
| Relik grande | 95.0 | 94.9 | 00:30 |
Para evaluar la extracción de relaciones, podemos usar directamente el lector con el script Relik/Reader/Trainer/Predict_re.py, señalando el archivo con candidatos ya recuperados. Si quieres usar nuestro lector capacitado:
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-evalTenga en cuenta que calculamos el umbral para predecir las relaciones basadas en el conjunto de desarrollo. Para calcularlo mientras evalúa, puede ejecutar lo siguiente:
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 usa alguna parte de este trabajo, considere citar el documento de la siguiente manera:
@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 " ,
}Los datos y el software tienen licencia bajo Creative Commons Attribution-No Commercial-Sharealike 4.0.
