rust bert

rouille-bert

Modèles et pipelines de traitement du langage naturel de pointe natifs de Rust. Portage de la bibliothèque Transformers de Hugging Face, utilisant des liaisons tch-rs ou onnxruntime et un prétraitement à partir de rust-tokenizers. Prend en charge la tokenisation multithread et l'inférence GPU. Ce référentiel expose l'architecture de base du modèle, les têtes spécifiques aux tâches (voir ci-dessous) et les pipelines prêts à l'emploi. Des benchmarks sont disponibles à la fin de ce document.

Lancez-vous dans des tâches telles que la réponse aux questions, la reconnaissance d'entités nommées, la traduction, le résumé, la génération de texte, les agents conversationnels et bien plus encore en quelques lignes de code :

    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 ) ;

Sortir:

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

Les tâches actuellement prises en charge comprennent :

• Traduction
• Récapitulation
• Dialogue à plusieurs tours
• Classement zéro tir
• Analyse des sentiments
• Reconnaissance d'entité nommée
• Une partie du marquage vocal
• Questions-réponses
• Génération de langage
• Modèle de langage masqué
• Intégrations de phrases
• Extraction de mots-clés

Développez pour afficher la matrice des modèles/tâches pris en charge

	Classement des séquences	Classement des jetons	Réponse aux questions	Génération de texte	Récapitulation	Traduction	LM masqué	Intégrations de phrases
DistilBERT	✅	✅	✅				✅	✅
MobileBERT	✅	✅	✅				✅
DeBERTa	✅	✅	✅				✅
DeBERTa (v2)	✅	✅	✅				✅
FNet	✅	✅	✅				✅
BERTE	✅	✅	✅				✅	✅
RoBERTa	✅	✅	✅				✅	✅
Google Tag				✅
GPT2				✅
GPT-Néo				✅
GPT-J				✅
BART	✅			✅	✅
Mariale						✅
MBart	✅			✅
M2M100				✅
NLLB				✅
Electre		✅					✅
ALBERT	✅	✅	✅				✅	✅
T5				✅	✅	✅		✅
LongueT5				✅	✅
XLNet	✅	✅	✅	✅			✅
Réformateur	✅		✅	✅			✅
ProphèteNet				✅	✅
Forme longue	✅	✅	✅				✅
Pégase					✅

Commencer

Cette bibliothèque s'appuie sur la caisse tch pour les liaisons à l'API C++ Libtorch. La bibliothèque libtorch requise peut être téléchargée automatiquement ou manuellement. Ce qui suit fournit une référence sur la façon de configurer votre environnement pour utiliser ces liaisons. Veuillez vous référer au tch pour des informations détaillées ou une assistance.

De plus, cette bibliothèque s'appuie sur un dossier cache pour télécharger des modèles pré-entraînés. Cet emplacement de cache est par défaut ~/.cache/.rustbert , mais peut être modifié en définissant la variable d'environnement RUSTBERT_CACHE . Notez que les modèles de langage utilisés par cette bibliothèque sont de l’ordre de 100 Mo à Go.

Installation manuelle (recommandée)

1. Téléchargez libtorch depuis https://pytorch.org/get-started/locally/. Ce package nécessite v2.4 : si cette version n'est plus disponible sur la page "get start", le fichier devrait être accessible en modifiant le lien cible, par exemple https://download.pytorch.org/libtorch/cu124/libtorch-cxx11-abi-shared-with-deps-2.4.0%2Bcu124.zip pour une version Linux avec CUDA12. REMARQUE : lorsque vous utilisez rust-bert comme dépendance de crates.io, veuillez vérifier le LIBTORCH requis dans le fichier Lisez-moi du package publié car il peut différer de la version documentée ici (s'appliquant à la version actuelle du référentiel).
2. Extrayez la bibliothèque vers un emplacement de votre choix
3. Définissez les variables d'environnement suivantes

Linux :

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

Fenêtres

 $ 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

Installation automatique

Alternativement, vous pouvez laisser le script build télécharger automatiquement la bibliothèque libtorch pour vous. L'indicateur de fonctionnalité download-libtorch doit être activé. La version CPU de libtorch sera téléchargée par défaut. Pour télécharger une version CUDA, veuillez définir la variable d'environnement TORCH_CUDA_VERSION sur cu124 . Notez que la bibliothèque libtorch est volumineuse (de l'ordre de plusieurs Go pour la version compatible CUDA) et la première build peut donc prendre plusieurs minutes.

Vérification de l'installation

Vérifiez votre installation (et la liaison avec libtorch) en ajoutant la dépendance rust-bert à votre Cargo.toml ou en clonant la source rust-bert et en exécutant un exemple :

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

Prise en charge ONNX (facultatif)

La prise en charge d'ONNX peut être activée via la fonctionnalité onnx en option. Cette caisse exploite ensuite la caisse ort avec des liaisons à la bibliothèque C++ onnxruntime. Nous renvoyons l'utilisateur à ce projet de page pour des instructions d'installation/assistance supplémentaires.

1. Activez la fonctionnalité onnx facultative. La caisse rust-bert n'inclut aucune dépendance facultative pour ort , l'utilisateur final doit sélectionner l'ensemble de fonctionnalités qui seraient adéquates pour extraire la bibliothèque C++ onnxruntime requise.
2. L'installation actuellement recommandée consiste à utiliser des liens dynamiques en pointant vers un emplacement de bibliothèque existant. Utilisez la fonctionnalité de chargement load-dynamic pour ort .
3. définissez ORT_DYLIB_PATH pour qu'il pointe vers l'emplacement de la bibliothèque onnxruntime téléchargée ( onnxruntime.dll / libonnxruntime.so / libonnxruntime.dylib selon le système d'exploitation). Ceux-ci peuvent être téléchargés depuis la page de publication du projet onnxruntime

La plupart des architectures (y compris les encodeurs, décodeurs et encodeurs-décodeurs) sont prises en charge. la bibliothèque vise à garder la compatibilité avec les modèles exportés à l'aide de la bibliothèque Optimum. Un guide détaillé sur la façon d'exporter un modèle Transformer vers ONNX à l'aide d'Optimum est disponible sur https://huggingface.co/docs/optimum/main/en/exporters/onnx/usage_guides/export_a_model. Les ressources utilisées pour créer des modèles ONNX sont similaires à ceux basés sur Pytorch, remplaçant le pytorch par le modèle ONNX. Étant donné que les modèles ONNX sont moins flexibles que leurs homologues Pytorch dans la gestion des arguments facultatifs, l'exportation d'un modèle de décodeur ou d'encodeur-décodeur vers ONNX entraînera généralement la création de plusieurs fichiers. Ces fichiers sont attendus (mais tous ne sont pas nécessaires) pour être utilisés dans cette bibliothèque selon le tableau ci-dessous :

Architecture	Fichier d'encodeur	Décodeur sans fichier passé	Décodeur avec fichier passé
Encodeur (par exemple BERT)	requis	non utilisé	non utilisé
Décodeur (par exemple GPT2)	non utilisé	requis	facultatif
Encodeur-décodeur (par exemple BART)	requis	requis	facultatif

Notez que l'efficacité du calcul diminuera lorsque le decoder with past est facultatif mais n'est pas fourni puisque le modèle n'utilisera pas les clés et valeurs passées mises en cache pour le mécanisme d'attention, ce qui entraînera un nombre élevé de calculs redondants. La bibliothèque Optimum propose des options d'exportation pour garantir la création d'un tel decoder with past . L'architecture de modèle de codeur et de décodeur de base est disponible (et exposée pour plus de commodité) dans les modules encoder et decoder , respectivement.

Des modèles de génération (architectures décodeur pur ou codeur/décodeur) sont disponibles dans le module models . La plupart des pipelines sont disponibles pour les points de contrôle du modèle ONNX, y compris la classification des séquences, la classification sans tir, la classification des jetons (y compris la reconnaissance des entités nommées et le marquage des parties du discours), la réponse aux questions, la génération de texte, le résumé et la traduction. Ces modèles utilisent les mêmes fichiers de configuration et de tokenizer que leurs homologues Pytorch lorsqu'ils sont utilisés dans un pipeline. Des exemples exploitant les modèles ONNX sont donnés dans le répertoire ./examples

Pipelines prêts à l'emploi

Basés sur les pipelines de Hugging Face, des pipelines NLP de bout en bout prêts à l'emploi sont disponibles dans le cadre de cette caisse. Les fonctionnalités suivantes sont actuellement disponibles :

Avis de non-responsabilité Les contributeurs de ce référentiel ne sont responsables d'aucune génération issue de l'utilisation par des tiers des systèmes pré-entraînés proposés ici.

1. Réponse aux questions

Réponses aux questions extractives à partir d’une question et d’un contexte donnés. Modèle DistilBERT affiné sur 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 ) ;

Sortir:

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

2. Traduction

Pipeline de traduction prenant en charge un large éventail de langues sources et cibles. Tire parti de deux architectures principales pour les tâches de traduction :

• Modèles basés sur Marian, pour des combinaisons source/cible spécifiques
• Modèles M2M100 permettant une traduction directe entre 100 langues (à un coût de calcul plus élevé et des performances inférieures pour certaines langues sélectionnées)

Des modèles pré-entraînés basés sur Marian pour les paires de langues suivantes sont facilement disponibles dans la bibliothèque - mais l'utilisateur peut importer n'importe quel modèle basé sur Pytorch pour les prédictions

• Anglais <-> Français
• Anglais <-> Espagnol
• Anglais <-> Portugais
• Anglais <-> Italien
• Anglais <-> Catalan
• Anglais <-> Allemand
• Anglais <-> Russe
• Anglais <-> Chinois
• Anglais <-> Néerlandais
• Anglais <-> Suédois
• Anglais <-> Arabe
• Anglais <-> Hébreu
• Anglais <-> Hindi
• Français <-> Allemand

Pour les langues non prises en charge par les modèles mariaux pré-entraînés proposés, l'utilisateur peut exploiter un modèle M2M100 prenant en charge la traduction directe entre 100 langues (sans traduction intermédiaire en anglais). La liste complète des langues prises en charge est disponible dans la documentation de la caisse.

 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 ( ( ) )
}

Sortir:

 Il s'agit d'une phrase à traduire

3. Résumé

Résumé abstrait à l'aide d'un modèle BART pré-entraîné.

    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 ) ;

(exemple tiré de : WikiNews)

Sortir:

 "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. Modèle de dialogue

Modèle de conversation basé sur DialoGPT de Microsoft. Ce pipeline permet de générer des conversations à un ou plusieurs tours entre un humain et un modèle. La page DialoGPT indique que

Les résultats de l'évaluation humaine indiquent que la réponse générée par DialoGPT est comparable à la qualité de la réponse humaine dans le cadre d'un test de Turing de conversation à un seul tour. (référentiel DialoGPT)

Le modèle utilise un ConversationManager pour suivre les conversations actives et générer des réponses.

 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 ) ;

Exemple de sortie :

 "The Big Lebowski."

5. Génération de langage naturel

Générez un langage basé sur une invite. GPT2 et GPT disponibles comme modèles de base. Incluez des techniques telles que la recherche de faisceaux, l'échantillonnage top-k et noyau, le réglage de la température et la pénalité de répétition. Prend en charge la génération par lots de phrases à partir de plusieurs invites. Les séquences seront complétées à gauche avec le jeton de remplissage du modèle s'il est présent, le jeton inconnu sinon. Cela peut avoir un impact sur les résultats. Il est recommandé de soumettre des invites de longueur similaire pour de meilleurs résultats.

    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 ) ;

Exemple de sortie :

 [
    "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. Classement zéro tir

Effectue une classification zéro sur les phrases d'entrée avec les étiquettes fournies à l'aide d'un modèle affiné pour l'inférence du langage naturel.

    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 ,
) ;

Sortir:

 [
  [ 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. Analyse des sentiments

Prédit le sentiment binaire d'une phrase. Modèle DistilBERT affiné sur 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 ) ;

(Exemple avec l'aimable autorisation d'IMDb)

Sortir:

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

8. Reconnaissance d'entité nommée

Extrait les entités (Personne, Emplacement, Organisation, Divers) du texte. BERT a présenté un grand modèle affiné sur CoNNL03, fourni par l'équipe de la bibliothèque numérique MDZ de la Bibliothèque d'État de Bavière. Les modèles sont actuellement disponibles en anglais, allemand, espagnol et néerlandais.

    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 ) ;

Sortir:

 [
  [
    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. Extraction de mots-clés/phrases-clés

Extraire des extractions de mots-clés et d'expressions clés à partir de documents d'entrée

 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 ] ) ? ;
}

Sortir:

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

10. Une partie du marquage vocal

Extrait les balises d'une partie du discours (nom, verbe, adjectif...) du texte.

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

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

let output = pos_model . predict ( & input ) ;

Sortir:

 [
    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. Intégrations de phrases

Générez des incorporations de phrases (représentation vectorielle). Ceux-ci peuvent être utilisés pour des applications incluant la recherche d’informations denses.

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

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

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

Sortir:

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

12. Modèle de langage masqué

Prédisez les mots masqués dans les phrases de saisie.

    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 ) ;

Sortir:

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

Repères

Pour les pipelines simples (classification de séquences, classification de jetons, réponse aux questions), les performances entre Python et Rust devraient être comparables. En effet, la partie la plus coûteuse de ces pipelines est le modèle de langage lui-même, partageant une implémentation commune dans le backend Torch. Les pipelines NLP de bout en bout dans Rust fournissent une section de référence couvrant tous les pipelines.

Pour les tâches de génération de texte (résumé, traduction, conversation, génération de texte libre), des bénéfices significatifs peuvent être attendus (traitement jusqu'à 2 à 4 fois plus rapide selon la saisie et l'application). L'article Accélérer la génération de texte avec Rust se concentre sur ces applications de génération de texte et fournit plus de détails sur la comparaison des performances avec Python.

Chargement de poids de modèles pré-entraînés et personnalisés

Le modèle de base et les têtes spécifiques à des tâches sont également disponibles pour les utilisateurs souhaitant exposer leurs propres modèles basés sur un transformateur. Des exemples sur la façon de préparer la date à l'aide d'une bibliothèque Rust de tokenizers natifs sont disponibles dans ./examples pour BERT, DistilBERT, RoBERTa, GPT, GPT2 et BART. Notez que lors de l'importation de modèles depuis Pytorch, la convention de dénomination des paramètres doit être alignée sur le schéma Rust. Le chargement des poids pré-entraînés échouera si l'un des poids des paramètres du modèle est introuvable dans les fichiers de poids. Si ce contrôle de qualité doit être ignoré, une méthode alternative load_partial peut être invoquée à partir du magasin de variables.

Les modèles pré-entraînés sont disponibles sur le hub de modèles de Hugging face et peuvent être chargés à l'aide RemoteResources définies dans cette bibliothèque.

Un script utilitaire de conversion est inclus dans ./utils pour convertir les poids Pytorch en un ensemble de poids compatibles avec cette bibliothèque. Ce script nécessite la configuration de Python et torch