neural cherche

Neural-Cherche

Pesquisa neural

Neural-Cherche é uma biblioteca projetada para ajustar modelos de pesquisa neural como Splade, Colbert e Sparseembed em um conjunto de dados específico. O Neural Cherche também fornece aulas para executar inferência eficiente em um Retriever ou Ranker de ajuste fino. A Neural Cherche pretende oferecer um método direto e eficaz para ajustar e utilizar modelos de pesquisa neural em configurações offline e online. Ele também permite que os usuários salvem todas as incorporações computadas para evitar cálculos redundantes.

A Cherche Neural é compatível com dispositivos de CPU, GPU e MPS. Podemos ajustar Colbert a partir de qualquer ponto de verificação pré-treinado do transformador de sentença. Splade e Sparseembed são mais complicados de ajustar e precisam de um modelo pré-treinado MLM.

Instalação

Podemos instalar o Neural Cherche usando:

 pip install neural-cherche

Se planejarmos avaliar nosso modelo durante a instalação do treinamento:

 pip install "neural-cherche[eval]"

Documentação

A documentação completa está disponível aqui.

Início rápido

Seu conjunto de dados de treinamento deve ser feito de triplos (anchor, positive, negative) onde a âncora é uma consulta, positivo é um documento que está diretamente ligado à âncora e negativo é um documento que não é relevante para a âncora.

 X = [
    ( "anchor 1" , "positive 1" , "negative 1" ),
    ( "anchor 2" , "positive 2" , "negative 2" ),
    ( "anchor 3" , "positive 3" , "negative 3" ),
]

E aqui está como ajustar Colbert a partir de um ponto de verificação pré-treinado para transformador de sentença usando o Neural Cherche:

 import torch

from neural_cherche import models , utils , train

model = models . ColBERT (
    model_name_or_path = "raphaelsty/neural-cherche-colbert" ,
    device = "cuda" if torch . cuda . is_available () else "cpu" # or mps
)

optimizer = torch . optim . AdamW ( model . parameters (), lr = 3e-6 )

X = [
    ( "query" , "positive document" , "negative document" ),
    ( "query" , "positive document" , "negative document" ),
    ( "query" , "positive document" , "negative document" ),
]

for step , ( anchor , positive , negative ) in enumerate ( utils . iter (
        X ,
        epochs = 1 , # number of epochs
        batch_size = 8 , # number of triples per batch
        shuffle = True
    )):

    loss = train . train_colbert (
        model = model ,
        optimizer = optimizer ,
        anchor = anchor ,
        positive = positive ,
        negative = negative ,
        step = step ,
        gradient_accumulation_steps = 50 ,
    )

    
    if ( step + 1 ) % 1000 == 0 :
        # Save the model every 1000 steps
        model . save_pretrained ( "checkpoint" )

Recuperação

Aqui está como usar o modelo de Colbert ajustado para documentos re-classificados:

 import torch
from lenlp import sparse

from neural_cherche import models , rank , retrieve

documents = [
    { "id" : "doc1" , "title" : "Paris" , "text" : "Paris is the capital of France." },
    { "id" : "doc2" , "title" : "Montreal" , "text" : "Montreal is the largest city in Quebec." },
    { "id" : "doc3" , "title" : "Bordeaux" , "text" : "Bordeaux in Southwestern France." },
]

retriever = retrieve . BM25 (
    key = "id" ,
    on = [ "title" , "text" ],
    count_vectorizer = sparse . CountVectorizer (
        normalize = True , ngram_range = ( 3 , 5 ), analyzer = "char_wb" , stop_words = []
    ),
    k1 = 1.5 ,
    b = 0.75 ,
    epsilon = 0.0 ,
)

model = models . ColBERT (
    model_name_or_path = "raphaelsty/neural-cherche-colbert" ,
    device = "cuda" if torch . cuda . is_available () else "cpu" ,  # or mps
)

ranker = rank . ColBERT (
    key = "id" ,
    on = [ "title" , "text" ],
    model = model ,
)

documents_embeddings = retriever . encode_documents (
    documents = documents ,
)

retriever . add (
    documents_embeddings = documents_embeddings ,
)

Agora podemos recuperar documentos usando o modelo ajustado:

 queries = [ "Paris" , "Montreal" , "Bordeaux" ]

queries_embeddings = retriever . encode_queries (
    queries = queries ,
)

ranker_queries_embeddings = ranker . encode_queries (
    queries = queries ,
)

candidates = retriever (
    queries_embeddings = queries_embeddings ,
    batch_size = 32 ,
    k = 100 ,  # number of documents to retrieve
)

# Compute embeddings of the candidates with the ranker model.
# Note, we could also pre-compute all the embeddings.
ranker_documents_embeddings = ranker . encode_candidates_documents (
    candidates = candidates ,
    documents = documents ,
    batch_size = 32 ,
)

scores = ranker (
    queries_embeddings = ranker_queries_embeddings ,
    documents_embeddings = ranker_documents_embeddings ,
    documents = candidates ,
    batch_size = 32 ,
)

scores 

[[{ 'id' : 0 , 'similarity' : 22.825355529785156 },
  { 'id' : 1 , 'similarity' : 11.201947212219238 },
  { 'id' : 2 , 'similarity' : 10.748161315917969 }],
 [{ 'id' : 1 , 'similarity' : 23.21628189086914 },
  { 'id' : 0 , 'similarity' : 9.9658203125 },
  { 'id' : 2 , 'similarity' : 7.308732509613037 }],
 [{ 'id' : 1 , 'similarity' : 6.4031805992126465 },
  { 'id' : 0 , 'similarity' : 5.601611137390137 },
  { 'id' : 2 , 'similarity' : 5.599479675292969 }]]

O Neural Cherche fornece um SparseEmbed , um SPLADE , um TFIDF , um BM25 Retriever e um ColBERT Ranker que pode ser usado para reordenar a saída de um retriever. Para mais informações, consulte a documentação.

Modelos pré-treinados

Fornecemos pontos de verificação pré-treinados especificamente projetados para Chesterche Neural: Raphaelsty/Neural-Cherche-Sparse-Enchebed e Raphaelsty/Neural-Cherche-Colbert. Esses pontos de verificação são ajustados em um subconjunto do conjunto de dados MS-Marco e se beneficiariam de ser ajustado no seu conjunto de dados específico. Você pode ajustar o Colbert a partir de qualquer ponto de verificação pré-treinado do transformador de sentença para se ajustar ao seu idioma específico. Você deve usar um ponto de verificação baseado em MLM para ajustar o Sparseembed.

		DataSet Scifact
modelo	Ponto de verificação de huggingface	ndcg@10	hits@10	hits@1
Tfidf	-	0,62	0,86	0,50
BM25	-	0,69	0,92	0,56
Sparseembed	Raphaelsty/Neural-Cherche-Sparse-embebido	0,62	0,87	0,48
Transformador de frases	Sentença-Transformers/All-MPNET-BASE-V2	0,66	0,89	0,53
Colbert	Raphaelsty/Neural-Cherche-Colbert	0,70	0,92	0,58
Tfidf retriever + Colbert Ranker	Raphaelsty/Neural-Cherche-Colbert	0,71	0,94	0,59
BM25 Retriever + Colbert Ranker	Raphaelsty/Neural-Cherche-Colbert	0,72	0,95	0,59

Contribuidores de Cherche Neural

• Benjamin Clavié
• Arthur Satouf

Referências

• Splade: modelo escasso lexical e de expansão para o ranking de primeiro estágio, de autoria de Thibault Formal, Benjamin Piwowarski, Stéphane ClinChant, Sigir 2021.

• Splade V2: modelo escasso lexical e de expansão para recuperação de informações de autoria de Thibault Formal, Carlos Lassance, Benjamin Piwowarski, Stéphane CLINCHANT, SIGIR 2022.

• Sparseembed: Aprendendo representações lexicais esparsas com incorporações contextuais para recuperação de autoria de Weize Kong, Jeffrey M. Dudek, Cheng Li, Mingyang Zhang e Mike Bendersky, Sigir 2023.

• Colbert: Pesquisa de passagem eficiente e eficaz por meio de interação tardia contextualizada sobre Bert de autoria de Omar Khattab, Matei Zaharia, Sigir 2020.

Licença

Esta biblioteca Python é licenciada sob a licença de código aberto do MIT e o modelo Splade é licenciado como não comercial apenas pelos autores. Sparseembed e Colbert são totalmente de código aberto, incluindo o uso comercial.