relik
1.0.7
Um modelo de extração de informações rápidas e leves em chamas para vinculação de entidades e extração de relação .
Instalação da Pypi
pip install relikInstale com todas as dependências opcionais.
pip install relik[all]Instale com dependências opcionais para treinamento e avaliação.
pip install relik[train]Instale com dependências opcionais para o FAISS
O pacote FAISS Pypi está disponível apenas para CPU. Para GPU, instale -a da fonte ou use o pacote 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 com dependências opcionais para servir os modelos com FASTAPI e RAY.
pip install relik[serve]git clone https://github.com/SapienzaNLP/relik.git
cd relik
pip install -e .[all] Relik grande para extração de relação (? Large Re V2, Colab ✅) : relik-ie/relik-relation-extraction-large
Relik grande para extração de informações fechadas (? Large El + Re, Colab ✅) : https://huggingface.co/relik-ie/relik-cie-large
Relik Extra grande para extração de informações fechadas (? Nosso thicc boi para el + re) : relik-ie/relik-cie-xl
Relik Small for Entity ligando sapienzanlp/relik-entity-linking-small ?
Relik Small for Entity Linking (⚡ Small and Fast El) : sapienzanlp/relik-entity-linking-small
Relik Small para extração de informações fechadas (EL + RE) : relik-ie/relik-cie-small
Relik Large for Entity Linking (EL for the Wild) : relik-ie/relik-entity-linking-large-robust
Relik Small for Entity Linking (Re + Ner) : relik-ie/relik-relation-extraction-small-wikipedia-ner
Modelos do artigo:
sapienzanlp/relik-entity-linking-largesapienzanlp/relik-entity-linking-basesapienzanlp/relik-relation-extraction-nyt-largeUma lista completa de modelos pode ser encontrada? Abraçando o rosto.
Outros tamanhos de modelos estarão disponíveis no futuro?
Relik é um modelo leve e rápido para vinculação de entidades e extração de relação . É composto por dois componentes principais: um retriever e um leitor. O Retriever é responsável por recuperar documentos relevantes de uma grande coleção, enquanto o leitor é responsável por extrair entidades e relações dos documentos recuperados. O Relik pode ser usado com o método from_pretrained para carregar um pipeline pré-treinado.
Aqui está um exemplo de como usar o Relik para vincular a entidade:
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." )Saída:
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},
...
]
]
]
),
)
e para extração de relação:
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." )Saída:
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 e leitores podem ser usados separadamente. No caso do RETRIEVER SOMENTE RELIK, a saída conterá os candidatos para o texto de entrada.
Exemplo somente para 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." )Saída:
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=[],
),
)
Exemplo somente para leitores:
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 )Saída:
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 fornece uma CLI para servir um servidor FASTAPI para o modelo ou para executar a inferência em um conjunto de dados.
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 exemplo:
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 exemplo:
relik inference sapienzanlp/relik-entity-linking-large data.txt output.jsonlAs imagens do Docker para Relik estão disponíveis no Docker Hub. Você pode puxar a imagem mais recente com:
docker pull sapienzanlp/relik:lateste execute a imagem com:
docker run -p 12345:8000 sapienzanlp/relik:latest -c relik-ie/relik-cie-small A API estará disponível em http://localhost:12345 . Ele expõe um único terminal /relik com vários parâmetros que podem ser passados para o modelo. Uma documentação rápida da API pode ser encontrada em http://localhost:12345/docs . Aqui está um exemplo simples de como consultar a 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 'Aqui a lista completa de parâmetros que podem ser passados para a imagem do 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.Nas seções a seguir, fornecemos um guia passo a passo sobre como preparar os dados, treinar o retriever e o leitor e avaliar o modelo.
Todos os seus dados devem ter a seguinte estrutura:
{
"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 o Blink (Wu et al., 2019) e Aida (Hoffart et al, 2011) para treinamento e avaliação. Mais especificamente, usamos o conjunto de dados Blink para pré-treinamento do conjunto de dados Retriever e AIDA para ajustar o Retriever e treinar o leitor.
O conjunto de dados Blink pode ser baixado do repositório de gênero usando este script. Utilizamos blink-train-kilt.jsonl e blink-dev-kilt.jsonl como conjuntos de dados de treinamento e validação. Supondo que baixemos os dois arquivos na pasta data/blink , convertemos o conjunto de dados Blink no formato Relik usando o seguinte 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 O conjunto de dados AIDA não está disponível ao público, mas fornecemos o arquivo que usamos sem campo text . Você pode encontrar o arquivo no formato relik na pasta data/aida/processed .
O índice da Wikipedia que usamos pode ser baixado a partir daqui.
Todos os seus dados devem ter a seguinte estrutura:
{
"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 extração de relações, fornecemos um exemplo de como pré -processar o conjunto de dados NYT do RAW_NYT retirado do copyre. Faça o download do conjunto de dados para dados/RAW_NYT e depois execute:
python scripts/data/nyt/preprocess_nyt.py data/raw_nyt data/nyt/processed/Esteja ciente de que, para comparação justa, reproduzimos o pré -processamento de trabalhos anteriores, o que leva a trigêmeos duplicados devido ao manuseio incorreto de formas de superfície repetidas para sãos de entidade. Se você deseja analisar corretamente os dados originais para o formato Relik, você pode definir o sinalizador-Falso do formato da legacação. Esteja ciente de que os modelos de renyt fornecidos foram treinados no formato herdado.
Realizamos um processo de treinamento em duas etapas para o Retriever. Primeiro, "pré-trep" o retriever usando o conjunto de dados Blink (Wu et al., 2019) e, em seguida, "ajustamos" o AIDA (Hoffart et al, 2011).
O retriever requer um conjunto de dados em um formato semelhante ao DPR: um arquivo jsonl , onde cada linha é um dicionário com as seguintes chaves:
{
"question" : " .... " ,
"positive_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}],
"negative_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}],
"hard_negative_ctxs" : [{
"title" : " ... " ,
"text" : " .... "
}]
}O Retriever também precisa de um índice para pesquisar os documentos. Os documentos a serem indicadores podem ser um arquivo jsonl ou um arquivo TSV semelhante ao DPR:
jsonl : Cada linha é um objeto JSON com as seguintes teclas: id , text , metadatatsv : Cada linha é uma corda separada por guia com as colunas de id e text , seguido de qualquer outra coluna que será armazenada no campo metadata Exemplo jsonl :
{
"id" : " ... " ,
"text" : " ... " ,
"metadata" : [ " {...} " ]
},
... Exemplo tsv :
id t text t any other column
... Depois de ter o conjunto de dados Blink no formato Relik, você pode criar o Windows com o seguinte 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.jsonle depois converta -o para o 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 Como o conjunto de dados AIDA não está disponível ao público, podemos fornecer as anotações para o conjunto de dados AIDA no formato Relik como exemplo. Supondo que você tenha o conjunto de dados AIDA completo nos data/aida , você pode convertê -los no formato Relik e criar o Windows com o seguinte script:
relik data create-windows
data/aida/processed/aida-train-relik.jsonl
data/aida/processed/aida-train-relik-windowed.jsonle depois converta -o para o 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 e depois converta -o para o formato DPR:
relik data convert-to-dpr
data/data/processed/nyt/train-windowed.jsonl
data/data/processed/nyt/train-windowed-dpr.jsonl O comando relik retriever train pode ser usado para treinar o Retriever. Requer os seguintes argumentos:
config_path : o caminho para o arquivo de configuração.overrides : uma lista de substituições para o arquivo de configuração, na key=value . Exemplos de arquivos de configuração podem ser encontrados na pasta relik/retriever/conf .
Os arquivos de configuração em relik/retriever/conf são pretrain_iterable_in_batch.yaml e finetune_iterable_in_batch.yaml , que costumávamos pré-treinar e ajustar o retriever, respectivamente.
Por exemplo, para treinar o retriever no conjunto de dados da AIDA, você pode executar o seguinte 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 O arquivo de configuração em relik/retriever/conf é finetune_nyt_iterable_in_batch.yaml , que usamos para ajustar o retriever para o conjunto de dados NYT. Para a CIE, reaproveitamos o pré -terenciado de Blink na etapa anterior.
Por exemplo, para treinar o Retriever no conjunto de dados NYT, você pode executar o seguinte 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 Ao passar train.only_test=True para o comando relik retriever train , você pode pular o treinamento e avaliar apenas o modelo. Ele também precisa do caminho para o ponto de verificação do Pytorch Lightning e o conjunto de dados para avaliar.
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/checkpointO codificador Retriever pode ser salvo do ponto de verificação com o seguinte 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 ) Com push_to_hub=True o modelo será empurrado para o? Abraçando o hub de rosto com repo_id como o ID do repositório onde o modelo será empurrado.
O Retriever precisa de um índice para procurar os documentos. O índice pode ser criado usando o 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. │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Com o codificador e o índice, o retriever pode ser carregado de um ID do repo ou de um caminho 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"
)E então ele pode ser usado para recuperar documentos:
retriever . retrieve ( "Michael Jordan was one of the best players in the NBA." , top_k = 100 ) O leitor é responsável por extrair entidades e relações de documentos de um conjunto de candidatos (por exemplo, possíveis entidades ou relações). O leitor pode ser treinado para extração de span ou extração de trigêmeos. O RelikReaderForSpanExtraction é usado para extração de span, ou seja, a entidade vinculando, enquanto o RelikReaderForTripletExtraction é usado para extração de trigêmeos, ou seja, extração de relação.
O leitor exige o conjunto de dados janela que criamos na seção antes de começar a aumentar com os candidatos do retriever. Os candidatos podem ser adicionados ao conjunto de dados usando o 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. │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Precisamos adicionar candidatos a cada janela que será usada pelo leitor, usando nosso Retriever anteriormente treinado. Aqui está um exemplo usando o nosso Retriever já treinado no AIDA para a divisão do trem:
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.jsonlO mesmo acontece com a extração de relação. Se você quiser usar nosso Retriever treinado:
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 Semelhante ao Retriever, o comando relik reader train pode ser usado para treinar o Retriever. Requer os seguintes argumentos:
config_path : o caminho para o arquivo de configuração.overrides : uma lista de substituições para o arquivo de configuração, na key=value . Exemplos de arquivos de configuração podem ser encontrados na pasta relik/reader/conf .
Os arquivos de configuração no relik/reader/conf são large.yaml e base.yaml , que costumávamos treinar o leitor grande e base, respectivamente. Por exemplo, para treinar o grande leitor no conjunto de dados AIDA Run:
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 Os arquivos de configuração em relik/reader/conf são large_nyt.yaml , base_nyt.yaml e small_nyt.yaml , que costumávamos treinar o leitor grande, base e pequeno, respectivamente. Por exemplo, para treinar o grande leitor no conjunto de dados AIDA Run:
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.jsonlO leitor pode ser salvo do ponto de verificação com o seguinte 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 ) com push_to_hub=True o modelo será empurrado para o? Abraçando o hub de rosto com repo_id como o ID do repositório em que o modelo será carregado.
O leitor pode ser carregado de um ID do repo ou de um caminho 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"
)e usado para extrair entidades e relações:
# 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 )Avaliamos o desempenho do Relik na entidade vinculando usando Gerbil. A tabela a seguir mostra os resultados (InkB Micro F1) de Relik Large and Base:
| Modelo | Aida | Msnbc | Der | K50 | R128 | R500 | O15 | O16 | Tot | Ood | 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 Small | 82.2 | 72.7 | 55.6 | 68.3 | 48.0 | 42.3 | 62.7 | 53.6 | 60.7 | 57.6 | 00:29 |
| Relik Base | 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 |
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. Bold indica o melhor modelo. O gênero usa dicionários mencionados. A coluna AIT mostra o tempo em minutos e segundos (M: S) que os sistemas precisam processar todo o conjunto de testes AIDA usando um NVIDIA RTX 4090, exceto o ENTQA, que não se encaixa em 24 GB de RAM e para o qual um A100 é usado.
Para avaliar o Relik, usamos as seguintes etapas:
Faça o download do servidor Gerbil daqui.
Inicie o 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-largeA tabela a seguir mostra os resultados (micro f1) da Relik Large no conjunto de dados 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 avaliar a extração de relação, podemos usar diretamente o leitor com o script relik/leitor/treinador/previct_re.py, apontando para o arquivo com candidatos já recuperados. Se você quiser usar nosso leitor treinado:
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-evalEsteja ciente de que calculamos o limite para prever as relações com base no conjunto de desenvolvimento. Para calculá -lo durante a avaliação, você pode executar o seguinte:
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-thresholdSe você usar alguma parte deste trabalho, considere citar o papel da seguinte forma:
@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 " ,
}Os dados e o software são licenciados no Creative Commons Attribution-NonCommercial-Sharealike 4.0.
