rust bert

ferrugem-bert

Modelos e pipelines de processamento de linguagem natural de última geração nativos da Rust. Biblioteca Transformers do Port of Hugging Face, usando ligações tch-rs ou onnxruntime e pré-processamento de tokenizadores de ferrugem. Suporta tokenização multithread e inferência de GPU. Este repositório expõe a arquitetura base do modelo, cabeçotes específicos de tarefas (veja abaixo) e pipelines prontos para uso. Os benchmarks estão disponíveis no final deste documento.

Comece com tarefas que incluem resposta a perguntas, reconhecimento de entidade nomeada, tradução, resumo, geração de texto, agentes de conversação e muito mais em apenas algumas linhas de código:

    let qa_model = QuestionAnsweringModel :: new ( Default :: default ( ) ) ? ;

let question = String :: from ( "Where does Amy live ?" ) ;
let context = String :: from ( "Amy lives in Amsterdam" ) ;

let answers = qa_model . predict ( & [ QaInput { question , context } ] , 1 , 32 ) ;

Saída:

 [Answer { score: 0.9976, start: 13, end: 21, answer: "Amsterdam" }]

As tarefas atualmente suportadas incluem:

• Tradução
• Resumo
• Diálogo multivoltas
• Classificação de tiro zero
• Análise de sentimento
• Reconhecimento de Entidade Nomeada
• Marcação de parte da fala
• Resposta a perguntas
• Geração de Linguagem
• Modelo de linguagem mascarada
• Incorporações de frases
• Extração de palavras-chave

Expanda para exibir a matriz de modelos/tarefas suportadas

	Classificação de sequência	Classificação de token	Resposta a perguntas	Geração de texto	Resumo	Tradução	LM mascarado	Incorporações de frases
DistilBERT	✅	✅	✅				✅	✅
MobileBERT	✅	✅	✅				✅
DeBERTa	✅	✅	✅				✅
DeBERTa (v2)	✅	✅	✅				✅
FNet	✅	✅	✅				✅
BERTO	✅	✅	✅				✅	✅
RoBERTa	✅	✅	✅				✅	✅
GPT				✅
GPT2				✅
GPT-Neo				✅
GPT-J				✅
BARTO	✅			✅	✅
Mariana						✅
MBart	✅			✅
M2M100				✅
NLLB				✅
Eletra		✅					✅
ALBERTO	✅	✅	✅				✅	✅
T5				✅	✅	✅		✅
LongoT5				✅	✅
XLNet	✅	✅	✅	✅			✅
Reformador	✅		✅	✅			✅
ProfetaNet				✅	✅
Longformer	✅	✅	✅				✅
Pégaso					✅

Começando

Esta biblioteca depende do tch crate para ligações à API C++ Libtorch. A biblioteca libtorch é necessária e pode ser baixada automática ou manualmente. O seguinte fornece uma referência sobre como configurar seu ambiente para usar essas ligações. Consulte o tch para obter informações detalhadas ou suporte.

Além disso, esta biblioteca conta com uma pasta cache para download de modelos pré-treinados. O padrão desse local de cache é ~/.cache/.rustbert , mas pode ser alterado definindo a variável de ambiente RUSTBERT_CACHE . Observe que os modelos de linguagem usados ​​por esta biblioteca são da ordem de centenas de MBs a GBs.

Instalação manual (recomendado)

1. Baixe libtorch em https://pytorch.org/get-started/locally/. Este pacote requer v2.4 : se esta versão não estiver mais disponível na página "começar", o arquivo deverá estar acessível modificando o link de destino, por exemplo https://download.pytorch.org/libtorch/cu124/libtorch-cxx11-abi-shared-with-deps-2.4.0%2Bcu124.zip para uma versão Linux com CUDA12. NOTA: Ao usar rust-bert como dependência de crates.io, verifique o LIBTORCH necessário no leia-me do pacote publicado, pois pode ser diferente da versão documentada aqui (aplicando-se à versão atual do repositório).
2. Extraia a biblioteca para um local de sua escolha
3. Defina as seguintes variáveis ​​de ambiente

Linux:

 export LIBTORCH=/path/to/libtorch
export LD_LIBRARY_PATH= ${LIBTORCH} /lib: $LD_LIBRARY_PATH 

Windows

 $ Env: LIBTORCH = " X:pathtolibtorch "
$ Env: Path += " ;X:pathtolibtorchlib " 

macOS + Homebrew

brew install pytorch jq
export LIBTORCH= $( brew --cellar pytorch ) / $( brew info --json pytorch | jq -r ' .[0].installed[0].version ' )
export LD_LIBRARY_PATH= ${LIBTORCH} /lib: $LD_LIBRARY_PATH

Instalação automática

Como alternativa, você pode permitir que o script build baixe automaticamente a biblioteca libtorch para você. O sinalizador do recurso download-libtorch precisa ser habilitado. A versão CPU do libtorch será baixada por padrão. Para baixar uma versão CUDA, defina a variável de ambiente TORCH_CUDA_VERSION como cu124 . Observe que a biblioteca libtorch é grande (da ordem de vários GBs para a versão habilitada para CUDA) e a primeira compilação pode, portanto, levar vários minutos para ser concluída.

Verificando a instalação

Verifique sua instalação (e vinculação com libtorch) adicionando a dependência rust-bert ao seu Cargo.toml ou clonando a fonte do ferrugem-bert e executando um exemplo:

git clone [email protected]:guillaume-be/rust-bert.git
cd rust-bert
cargo run --example sentence_embeddings

Suporte ONNX (opcional)

O suporte ONNX pode ser habilitado por meio do recurso onnx opcional. Essa caixa então aproveita a caixa ort com ligações à biblioteca C++ onnxruntime. Encaminhamos o usuário para esta página do projeto para obter mais instruções/suporte de instalação.

1. Habilite o recurso onnx opcional. A caixa rust-bert não inclui nenhuma dependência opcional para ort , o usuário final deve selecionar o conjunto de recursos que seria adequado para extrair a biblioteca C++ onnxruntime necessária.
2. A instalação atualmente recomendada é usar vinculação dinâmica apontando para um local de biblioteca existente. Use o recurso de carga load-dynamic para ort .
3. defina ORT_DYLIB_PATH para apontar para o local da biblioteca onnxruntime baixada ( onnxruntime.dll / libonnxruntime.so / libonnxruntime.dylib dependendo do sistema operacional). Eles podem ser baixados da página de lançamento do projeto onnxruntime

A maioria das arquiteturas (incluindo codificadores, decodificadores e codificadores-decodificadores) são suportadas. a biblioteca visa manter a compatibilidade com os modelos exportados através da biblioteca Optimum. Um guia detalhado sobre como exportar um modelo Transformer para ONNX usando Optimum está disponível em https://huggingface.co/docs/optimum/main/en/exporters/onnx/usage_guides/export_a_model Os recursos usados ​​para criar modelos ONNX são semelhantes a aqueles baseados em Pytorch, substituindo o pytorch pelo modelo ONNX. Como os modelos ONNX são menos flexíveis do que seus equivalentes Pytorch no tratamento de argumentos opcionais, exportar um decodificador ou modelo codificador-decodificador para ONNX geralmente resultará em vários arquivos. Esses arquivos são esperados (mas nem todos são necessários) para uso nesta biblioteca conforme tabela abaixo:

Arquitetura	Arquivo codificador	Decodificador sem arquivo passado	Decodificador com arquivo passado
Codificador (por exemplo, BERT)	obrigatório	não usado	não usado
Decodificador (por exemplo, GPT2)	não usado	obrigatório	opcional
Codificador-decodificador (por exemplo, BART)	obrigatório	obrigatório	opcional

Observe que a eficiência computacional diminuirá quando o decoder with past for opcional, mas não fornecido, uma vez que o modelo não usará chaves e valores anteriores armazenados em cache para o mecanismo de atenção, levando a um grande número de cálculos redundantes. A biblioteca Optimum oferece opções de exportação para garantir que tal decoder with past seja criado. A arquitetura do modelo base do codificador e do decodificador estão disponíveis (e expostas por conveniência) nos módulos encoder e decoder , respectivamente.

Modelos de geração (arquiteturas de decodificador puro ou codificador/decodificador) estão disponíveis no módulo models . ost pipelines estão disponíveis para pontos de verificação do modelo ONNX, incluindo classificação de sequência, classificação zero-shot, classificação de token (incluindo reconhecimento de entidade nomeada e marcação de classe gramatical), resposta a perguntas, geração de texto, resumo e tradução. Esses modelos usam os mesmos arquivos de configuração e tokenizer que suas contrapartes Pytorch quando usados ​​em um pipeline. Exemplos que aproveitam os modelos ONNX são fornecidos no diretório ./examples

Pipelines prontos para uso

Com base nos pipelines do Hugging Face, pipelines de PNL ponta a ponta prontos para uso estão disponíveis como parte desta caixa. Os seguintes recursos estão disponíveis atualmente:

Isenção de responsabilidade Os contribuidores deste repositório não são responsáveis ​​por qualquer geração a partir da utilização de terceiros dos sistemas pré-treinados aqui propostos.

1. Resposta a perguntas

Resposta extrativa a perguntas de uma determinada pergunta e contexto. Modelo DistilBERT ajustado no SQuAD (Stanford Question Answering Dataset)

    let qa_model = QuestionAnsweringModel :: new ( Default :: default ( ) ) ? ;

let question = String :: from ( "Where does Amy live ?" ) ;
let context = String :: from ( "Amy lives in Amsterdam" ) ;

let answers = qa_model . predict ( & [ QaInput { question , context } ] , 1 , 32 ) ;

Saída:

 [Answer { score: 0.9976, start: 13, end: 21, answer: "Amsterdam" }]

2. Tradução

Pipeline de tradução que oferece suporte a uma ampla variedade de idiomas de origem e de destino. Aproveita duas arquiteturas principais para tarefas de tradução:

• Modelos baseados em Marian, para combinações específicas de origem/alvo
• Modelos M2M100 que permitem tradução direta entre 100 idiomas (com maior custo computacional e menor desempenho para alguns idiomas selecionados)

Modelos pré-treinados baseados em Marian para os seguintes pares de idiomas estão prontamente disponíveis na biblioteca - mas o usuário pode importar qualquer modelo baseado em Pytorch para previsões

• Inglês <-> Francês
• Inglês <-> Espanhol
• Inglês <-> Português
• Inglês <-> Italiano
• Inglês <-> Catalão
• Inglês <-> Alemão
• Inglês <-> Russo
• Inglês <-> Chinês
• Inglês <-> Holandês
• Inglês <-> Sueco
• Inglês <-> Árabe
• Inglês <-> Hebraico
• Inglês <-> Hindi
• Francês <-> Alemão

Para idiomas não suportados pelos modelos Marian pré-treinados propostos, o usuário pode aproveitar um modelo M2M100 que suporta tradução direta entre 100 idiomas (sem tradução intermediária em inglês). A lista completa de idiomas suportados está disponível na documentação da caixa

 use rust_bert :: pipelines :: translation :: { Language , TranslationModelBuilder } ;
fn main ( ) -> anyhow :: Result < ( ) > {
    let model = TranslationModelBuilder :: new ( )
        . with_source_languages ( vec ! [ Language :: English ] )
        . with_target_languages ( vec ! [ Language :: Spanish , Language :: French , Language :: Italian ] )
        . create_model ( ) ? ;
    let input_text = "This is a sentence to be translated" ;
    let output = model . translate ( & [ input_text ] , None , Language :: French ) ? ;
    for sentence in output {
        println ! ( "{}" , sentence ) ;
    }
    Ok ( ( ) )
}

Saída:

 Il s'agit d'une phrase à traduire

3. Resumo

Sumarização abstrativa usando um modelo BART pré-treinado.

    let summarization_model = SummarizationModel :: new ( Default :: default ( ) ) ? ;

let input = [ "In findings published Tuesday in Cornell University's arXiv by a team of scientists 
from the University of Montreal and a separate report published Wednesday in Nature Astronomy by a team 
from University College London (UCL), the presence of water vapour was confirmed in the atmosphere of K2-18b, 
a planet circling a star in the constellation Leo. This is the first such discovery in a planet in its star's 
habitable zone — not too hot and not too cold for liquid water to exist. The Montreal team, led by Björn Benneke, 
used data from the NASA's Hubble telescope to assess changes in the light coming from K2-18b's star as the planet 
passed between it and Earth. They found that certain wavelengths of light, which are usually absorbed by water, 
weakened when the planet was in the way, indicating not only does K2-18b have an atmosphere, but the atmosphere 
contains water in vapour form. The team from UCL then analyzed the Montreal team's data using their own software 
and confirmed their conclusion. This was not the first time scientists have found signs of water on an exoplanet, 
but previous discoveries were made on planets with high temperatures or other pronounced differences from Earth. 
" This is the first potentially habitable planet where the temperature is right and where we now know there is water, " 
said UCL astronomer Angelos Tsiaras. " It's the best candidate for habitability right now. " " It's a good sign " , 
said Ryan Cloutier of the Harvard–Smithsonian Center for Astrophysics, who was not one of either study's authors. 
" Overall, " he continued, " the presence of water in its atmosphere certainly improves the prospect of K2-18b being 
a potentially habitable planet, but further observations will be required to say for sure. "
K2-18b was first identified in 2015 by the Kepler space telescope. It is about 110 light-years from Earth and larger 
but less dense. Its star, a red dwarf, is cooler than the Sun, but the planet's orbit is much closer, such that a year 
on K2-18b lasts 33 Earth days. According to The Guardian, astronomers were optimistic that NASA's James Webb space 
telescope — scheduled for launch in 2021 — and the European Space Agency's 2028 ARIEL program, could reveal more 
about exoplanets like K2-18b." ] ;

let output = summarization_model . summarize ( & input ) ;

(exemplo de: WikiNews)

Saída:

 "Scientists have found water vapour on K2-18b, a planet 110 light-years from Earth. 
This is the first such discovery in a planet in its star's habitable zone. 
The planet is not too hot and not too cold for liquid water to exist."

4. Modelo de Diálogo

Modelo de conversação baseado no DialoGPT da Microsoft. Este pipeline permite a geração de conversas únicas ou múltiplas entre um humano e um modelo. A página do DialoGPT afirma que

Os resultados da avaliação humana indicam que a resposta gerada pelo DialoGPT é comparável à qualidade da resposta humana em um teste de Turing de conversação de turno único. (repositório DialoGPT)

O modelo usa um ConversationManager para acompanhar conversas ativas e gerar respostas para elas.

 use rust_bert :: pipelines :: conversation :: { ConversationModel , ConversationManager } ;

let conversation_model = ConversationModel :: new ( Default :: default ( ) ) ;
let mut conversation_manager = ConversationManager :: new ( ) ;

let conversation_id = conversation_manager . create ( "Going to the movies tonight - any suggestions?" ) ;
let output = conversation_model . generate_responses ( & mut conversation_manager ) ;

Exemplo de saída:

 "The Big Lebowski."

5. Geração de Linguagem Natural

Gere linguagem com base em um prompt. GPT2 e GPT disponíveis como modelos básicos. Inclui técnicas como busca de feixe, amostragem top-k e de núcleo, ajuste de temperatura e penalidade de repetição. Suporta geração em lote de frases a partir de vários prompts. As sequências serão preenchidas à esquerda com o token de preenchimento do modelo, se presente, e com o token desconhecido, caso contrário. Isso pode afetar os resultados. Recomenda-se enviar prompts de tamanho semelhante para obter melhores resultados

    let model = GPT2Generator :: new ( Default :: default ( ) ) ? ;

let input_context_1 = "The dog" ;
let input_context_2 = "The cat was" ;

let generate_options = GenerateOptions {
max_length : 30 ,
.. Default :: default ( )
} ;

let output = model . generate ( Some ( & [ input_context_1 , input_context_2 ] ) , generate_options ) ;

Exemplo de saída:

 [
    "The dog's owners, however, did not want to be named. According to the lawsuit, the animal's owner, a 29-year"
    "The dog has always been part of the family. "He was always going to be my dog and he was always looking out for me"
    "The dog has been able to stay in the home for more than three months now. "It's a very good dog. She's"
    "The cat was discovered earlier this month in the home of a relative of the deceased. The cat's owner, who wished to remain anonymous,"
    "The cat was pulled from the street by two-year-old Jazmine."I didn't know what to do," she said"
    "The cat was attacked by two stray dogs and was taken to a hospital. Two other cats were also injured in the attack and are being treated."
]

6. Classificação de tiro zero

Executa classificação zero-shot em sentenças de entrada com rótulos fornecidos usando um modelo ajustado para inferência de linguagem natural.

    let sequence_classification_model = ZeroShotClassificationModel :: new ( Default :: default ( ) ) ? ;

let input_sentence = "Who are you voting for in 2020?" ;
let input_sequence_2 = "The prime minister has announced a stimulus package which was widely criticized by the opposition." ;
let candidate_labels = & [ "politics" , "public health" , "economics" , "sports" ] ;

let output = sequence_classification_model . predict_multilabel (
& [ input_sentence , input_sequence_2 ] ,
candidate_labels ,
None ,
128 ,
) ;

Saída:

 [
  [ Label { "politics", score: 0.972 }, Label { "public health", score: 0.032 }, Label {"economics", score: 0.006 }, Label {"sports", score: 0.004 } ],
  [ Label { "politics", score: 0.975 }, Label { "public health", score: 0.0818 }, Label {"economics", score: 0.852 }, Label {"sports", score: 0.001 } ],
]

7. Análise de sentimento

Prevê o sentimento binário de uma frase. Modelo DistilBERT ajustado em SST-2.

    let sentiment_classifier = SentimentModel :: new ( Default :: default ( ) ) ? ;

let input = [
"Probably my all-time favorite movie, a story of selflessness, sacrifice and dedication to a noble cause, but it's not preachy or boring." ,
"This film tried to be too many things all at once: stinging political satire, Hollywood blockbuster, sappy romantic comedy, family values promo..." ,
"If you like original gut wrenching laughter you will like this movie. If you are young or old then you will love this movie, hell even my mom liked it." ,
] ;

let output = sentiment_classifier . predict ( & input ) ;

(Exemplo cortesia da IMDb)

Saída:

 [
    Sentiment { polarity: Positive, score: 0.9981985493795946 },
    Sentiment { polarity: Negative, score: 0.9927982091903687 },
    Sentiment { polarity: Positive, score: 0.9997248985164333 }
]

8. Reconhecimento de Entidade Nomeada

Extrai entidades (Pessoa, Local, Organização, Diversos) do texto. Modelo grande revestido com BERT ajustado em CoNNL03, contribuído pela equipe da Biblioteca Digital MDZ da Biblioteca Estadual da Baviera. Os modelos estão atualmente disponíveis em inglês, alemão, espanhol e holandês.

    let ner_model = NERModel :: new ( default :: default ( ) ) ? ;

let input = [
"My name is Amy. I live in Paris." ,
"Paris is a city in France."
] ;

let output = ner_model . predict ( & input ) ;

Saída:

 [
  [
    Entity { word: "Amy", score: 0.9986, label: "I-PER" }
    Entity { word: "Paris", score: 0.9985, label: "I-LOC" }
  ],
  [
    Entity { word: "Paris", score: 0.9988, label: "I-LOC" }
    Entity { word: "France", score: 0.9993, label: "I-LOC" }
  ]
]

9. Extração de palavras-chave/frases-chave

Extraia extrações de palavras-chave e frases-chave de documentos de entrada

 fn main ( ) -> anyhow :: Result < ( ) > {
    let keyword_extraction_model = KeywordExtractionModel :: new ( Default :: default ( ) ) ? ;

    let input = "Rust is a multi-paradigm, general-purpose programming language. 
       Rust emphasizes performance, type safety, and concurrency. Rust enforces memory safety—that is, 
       that all references point to valid memory—without requiring the use of a garbage collector or 
       reference counting present in other memory-safe languages. To simultaneously enforce 
       memory safety and prevent concurrent data races, Rust's borrow checker tracks the object lifetime 
       and variable scope of all references in a program during compilation. Rust is popular for 
       systems programming but also offers high-level features including functional programming constructs." ;

    let output = keyword_extraction_model . predict ( & [ input ] ) ? ;
}

Saída:

 "rust" - 0.50910604
"programming" - 0.35731024
"concurrency" - 0.33825397
"concurrent" - 0.31229728
"program" - 0.29115444

10. Marcação de parte do discurso

Extrai tags de classes gramaticais (substantivo, verbo, adjetivo...) do texto.

    let pos_model = POSModel :: new ( default :: default ( ) ) ? ;

let input = [ "My name is Bob" ] ;

let output = pos_model . predict ( & input ) ;

Saída:

 [
    Entity { word: "My", score: 0.1560, label: "PRP" }
    Entity { word: "name", score: 0.6565, label: "NN" }
    Entity { word: "is", score: 0.3697, label: "VBZ" }
    Entity { word: "Bob", score: 0.7460, label: "NNP" }
]

11. Incorporações de frases

Gere embeddings de frases (representação vetorial). Eles podem ser usados ​​para aplicações que incluem recuperação densa de informações.

    let model = SentenceEmbeddingsBuilder :: remote (
SentenceEmbeddingsModelType :: AllMiniLmL12V2
) . create_model ( ) ? ;

let sentences = [
"this is an example sentence" ,
"each sentence is converted"
] ;

let output = model . encode ( & sentences ) ? ;

Saída:

 [
    [-0.000202666, 0.08148022, 0.03136178, 0.002920636 ...],
    [0.064757116, 0.048519745, -0.01786038, -0.0479775 ...]
]

12. Modelo de linguagem mascarada

Preveja palavras mascaradas em frases de entrada.

    let model = MaskedLanguageModel :: new ( Default :: default ( ) ) ? ;

let sentences = [
"Hello I am a <mask> student" ,
"Paris is the <mask> of France. It is <mask> in Europe." ,
] ;

let output = model . predict ( & sentences ) ;

Saída:

 [
    [MaskedToken { text: "college", id: 2267, score: 8.091}],
    [
        MaskedToken { text: "capital", id: 3007, score: 16.7249}, 
        MaskedToken { text: "located", id: 2284, score: 9.0452}
    ]
]

Referências

Para pipelines simples (classificação de sequência, classificação de tokens, resposta a perguntas), espera-se que o desempenho entre Python e Rust seja comparável. Isso ocorre porque a parte mais cara desse pipeline é o próprio modelo de linguagem, compartilhando uma implementação comum no backend do Torch. Os pipelines de PNL ponta a ponta em Rust fornecem uma seção de benchmarks que cobre todos os pipelines.

Para tarefas de geração de texto (resumo, tradução, conversação, geração de texto livre), podem ser esperados benefícios significativos (processamento até 2 a 4 vezes mais rápido, dependendo da entrada e da aplicação). O artigo Acelerando a geração de texto com Rust concentra-se nesses aplicativos de geração de texto e fornece mais detalhes sobre a comparação de desempenho com Python.

Carregando pesos de modelo pré-treinados e personalizados

O modelo básico e os cabeçotes específicos para tarefas também estão disponíveis para usuários que desejam expor seus próprios modelos baseados em transformadores. Exemplos de como preparar a data usando uma biblioteca Rust de tokenizers nativos estão disponíveis em ./examples para BERT, DistilBERT, RoBERTa, GPT, GPT2 e BART. Observe que ao importar modelos do Pytorch, a convenção para nomenclatura de parâmetros precisa estar alinhada com o esquema Rust. O carregamento dos pesos pré-treinados falhará se algum dos pesos dos parâmetros do modelo não puder ser encontrado nos arquivos de peso. Se esta verificação de qualidade for ignorada, um método alternativo load_partial poderá ser invocado a partir do armazenamento de variáveis.

Modelos pré-treinados estão disponíveis no hub de modelo do Hugging Face e podem ser carregados usando RemoteResources definidos nesta biblioteca.

Um script utilitário de conversão está incluído em ./utils para converter pesos Pytorch em um conjunto de pesos compatível com esta biblioteca. Este script requer que Python e torch sejam configurados