Comment Fintuner des Modèles d'Embedding Sparses avec Sentence Transformers v5 pour des Recherches Hybrides Efficaces

Synthèse de l’article : Formation et fine-tuning de modèles d’encodage épars avec Sentence Transformers v5 Sentence Transformers est une bibliothèque Python qui permet d’utiliser et de former des modèles d’encodage et de reranking pour diverses applications comme la génération augmentée de recherche, la recherche sémantique, la similarité textuelle sémantique, l’exploration de paraphrases, etc. Les dernières versions majeures ont introduit des améliorations significatives pour la formation de modèles, en particulier la fine-tuning des modèles d’encodage épars. Qu'est-ce qu'un modèle d'encodage épars ? Les modèles d'encodage épars produisent des vecteurs de grande dimension (30,000+ dimensions) où la plupart des valeurs sont zéro. Chaque dimension active correspond généralement à un token spécifique du vocabulaire du modèle, ce qui permet une interprétation plus facile. Par exemple, le modèle naver/splade-v3 encode des phrases en vecteurs de 30,522 dimensions. En décodant ces vecteurs, on peut identifier les tokens qui contribuent le plus à l’embedding, facilitant ainsi la compréhension des similarités entre différents textes. Pourquoi utiliser des modèles d'encodage épars ? Les modèles d'encodage épars offrent un équilibre précieux entre les méthodes lexicales traditionnelles comme BM25 et les modèles d'encodage dense. Ils ont plusieurs avantages : - Interprétabilité : L'interprétation des embeddings est plus intuitive. - Efficacité : Moins de stockage et des recherches plus rapides. - Performances similaires aux modèles dense : Meilleures performances dans des scénarios de recherche hybride ou de reranking. Pourquoi effectuer un fine-tuning ? La fine-tuning permet au modèle de mieux reconnaître les termes spécifiques à un domaine ou à une langue. Par exemple, sans fine-tuning, un modèle pourrait étendre « cephalalgia » à des termes inappropriés comme « ##lal », « severe », etc., au lieu de « headache ». En ajustant le modèle, vous pouvez lui enseigner à se concentrer sur les domaines et les langues pertinents pour votre application. Composants de la formation Modèle : Le modèle à former ou à ajuster, qui peut être un modèle pré-entraîné ou un modèle de base. Jeux de données : Les données utilisées pour la formation et l'évaluation. Fonction de perte : Une fonction qui mesure la performance du modèle et guide le processus d'optimisation. Arguments de formation (optionnels) : Des paramètres influençant la performance de la formation et les outils de suivi/débogage. Évaluateur (optionnel) : Un outil pour évaluer le modèle avant, pendant ou après la formation. Classe de formateur : Combine tous les composants précédents pour entamer la formation. Architecture du modèle Splade : Utilise un MLMTransformer suivi d'un module SpladePooling. Cette architecture permet de produire des embeddings épars de la taille du vocabulaire. Inference-free Splade : Utilise un module Router avec des modules distincts pour les requêtes et les documents. Les requêtes sont traitées rapidement grâce à un module SparseStaticEmbedding, tandis que les documents sont traités en utilisant l'architecture complète Splade. Contrastive Sparse Representation (CSR) : Applique un module SparseAutoEncoder sur un modèle d'encodage dense. Les embeddings épars générés ne correspondent pas directement aux tokens du vocabulaire, ce qui limite l'interprétabilité mais augmente les performances sur des représentations de haute dimension. Jeux de données Hugging Face Hub : Les jeux de données peuvent être téléchargés à partir du hub Hugging Face, notamment avec des tags comme « sentence-transformers » pour faciliter la recherche. Données locales : Les formats CSV, JSON, Parquet, Arrow et SQL sont pris en charge. Utilisez load_dataset pour charger ces données. Fonction de perte La SpaladeLoss et la CSRLoss sont des fonctions de perte principales, ajoutant une régularisation de la sparsité sur une fonction de perte principale. Vous pouvez initialiser ces fonctions en fournissant le modèle et des paramètres optionnels. Arguments de formation Le SparseEncoderTrainingArguments offre des paramètres pour influencer la performance de la formation et le suivi. Par exemple, la détermination du nombre d'époques, la taille des batchs, le taux d'apprentissage, les stratégies d'évaluation, etc. Évaluations Utilisez des évaluations pour mesurer les performances du modèle : SparseBinaryClassificationEvaluator : Pour des paires de textes avec des labels de classe. SparseEmbeddingSimilarityEvaluator : Pour des paires de textes avec des scores de similarité. SparseInformationRetrievalEvaluator : Pour des requêtes, un corpus et des documents pertinents. SparseNanoBEIREvaluator : Utilise des données standard du hub Hugging Face pour l'évaluation. SparseTripletEvaluator : Pour des triplets (ancrage, positif, négatif). Exemple de script de formation ```python import logging from datasets import load_dataset from sentence_transformers import ( SparseEncoder, SparseEncoderTrainingArguments, SparseEncoderTrainer, ) from sentence_transformers.models import Router, MLMTransformer, SpladePooling from sentence_transformers.sparse_encoder.losses import SpladeLoss, SparseMultipleNegativesRankingLoss from sentence_transformers.sparse_encoder.evaluation import SparseNanoBEIREvaluator logging.basicConfig(format="%(asctime)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S", level=logging.INFO) 1. Charger le modèle à finetuner mlm_transformer = MLMTransformer("distilbert/distilbert-base-uncased", tokenizer_args={"model_max_length": 512}) splade_pooling = SpladePooling(pooling_strategy="max", word_embedding_dimension=mlm_transformer.get_sentence_embedding_dimension()) router = Router.for_query_document(query_modules=[SparseStaticEmbedding(tokenizer=mlm_transformer.tokenizer, frozen=False)], document_modules=[mlm_transformer, splade_pooling]) model = SparseEncoder(modules=[router]) 2. Charger le jeu de données pour la formation full_dataset = load_dataset("sentence-transformers/natural-questions", split="train").select(range(100000)) dataset_dict = full_dataset.train_test_split(test_size=1000, seed=12) train_dataset = dataset_dict["train"] eval_dataset = dataset_dict["test"] 3. Définir une fonction de perte loss = SpladeLoss(model=model, loss=SparseMultipleNegativesRankingLoss(model=model), document_regularizer_weight=3e-3) 4. Spécifier les argumennts de formation args = SparseEncoderTrainingArguments( output_dir="models/inference-free-splade-distilbert-base-uncased-nq", num_train_epochs=1, per_device_train_batch_size=16, learning_rate=2e-5, learning_rate_mapping={r"SparseStaticEmbedding.weight": 1e-3}, fp16=True, batch_sampler="NO_DUPLICATES", eval_strategy="steps", eval_steps=1000, save_strategy="steps", save_steps=1000, save_total_limit=2, logging_steps=200, run_name="inference-free-splade-distilbert-base-uncased-nq" ) 5. Créer un évaluateur et évaluer le modèle de base dev_evaluator = SparseNanoBEIREvaluator(dataset_names=["msmarco", "nfcorpus", "nq"], batch_size=16) 6. Créer un formateur et entamer la formation trainer = SparseEncoderTrainer( model=model, args=args, train_dataset=train_dataset, eval_dataset=eval_dataset, loss=loss, evaluator=dev_evaluator ) trainer.train() 7. Évaluer à nouveau le modèle après la formation dev_evaluator(model) 8. Sauvegarder le modèle formé model.save_pretrained(args.output_dir) 9. Push to Hugging Face Hub model.push_to_hub(args.run_name) ``` Conseils de formation Mesure de la sparsité : Evaluez non seulement les scores, mais aussi la sparsité des embeddings (le faible nombre de dimensions actives). Distillation : Pour des performances optimales, entraînez les modèles en utilisant des techniques de distillation depuis un modèle teacher plus fort. Intégration avec des bases de vecteurs Une étape cruciale après la formation est le déploiement en production. Les bases de vecteurs comme Qdrant, OpenSearch, Elasticsearch et Seismic fournissent l'infrastructure nécessaire pour stocker, indexer et rechercher des embeddings épars à grande échelle. Exemple d'intégration avec Qdrant ```python import time from datasets import load_dataset from sentence_transformers import SparseEncoder from sentence_transformers.sparse_encoder.search_engines import semantic_search_qdrant 1. Charger le jeu de données natural-questions dataset = load_dataset("sentence-transformers/natural-questions", split="train") num_docs = 10000 corpus = dataset["answer"][:num_docs] 2. Générer des requêtes queries = dataset["query"][:2] 3. Charger le modèle sparse_model = SparseEncoder("naver/splade-cocondenser-ensembledistil") 4. Encoder le corpus corpus_embeddings = sparse_model.encode_document(corpus, convert_to_sparse_tensor=True, batch_size=16, show_progress_bar=True) 5. Encoder les requêtes while True: start_time = time.time() query_embeddings = sparse_model.encode_query(queries, convert_to_sparse_tensor=True) print(f"Temps d'encodage: {time.time() - start_time:.6f} secondes") # 6. Effectuer la recherche sémantique avec Qdrant results, search_time, corpus_index = semantic_search_qdrant( query_embeddings, corpus_index=None, corpus_embeddings=corpus_embeddings, top_k=5, output_index=True ) # 7. Afficher les résultats print(f"Temps de recherche: {search_time:.6f} secondes") for query, result in zip(queries, results): print(f"Requête: {query}") for entry in result: print(f"(Score: {entry['score']:.4f}) {corpus[entry['corpus_id']]}, corpus_id: {entry['corpus_id']}") print("") # 8. Demander plus de requêtes queries = [input("Veuillez entrer une question: ")] ``` Évaluation finale L'évaluation montre que la combinaison de méthodes de recherche dense et épars améliore considérablement les performances, atteignant des gains de 12.3% à 18.7% sur des métriques comme NDCG@10. De plus, l'utilisation d'un reranker sur ces résultats peut encore augmenter les performances, atteignant environ 66.3 NDCG@10. Conclusion La fine-tuning de modèles d'encodage épars avec Sentence Transformers v5 offre des avantages significatifs en termes d'interprétabilité, d'efficacité et de performance. Ces modèles sont particulièrement utiles dans des scénarios de recherche hybride, où ils peuvent s'allier à des approches dense pour améliorer la pertinence des résultats tout en réduisant les latences et les coûts. Évaluation de l'événement par des professionnels de l'industrie : Les modèles d'encodage épars ajustés avec Sentence Transformers v5 sont largement reconnus pour leur capacité à améliorer les systèmes de recherche en combinant les avantages de la méthode éparses et des approches dense. Cela les rend adaptés à des applications nécessitant une interprétabilité forte tout en offrant des performances élevées. Profil de l'entreprise : Hugging Face est une entreprise de premier plan dans le domaine de l'IA et des transformers, fournissant des outils et des modèles pré-entraînés qui facilitent le développement de solutions basées sur le langage naturel. Sentence Transformers, en particulier, est une initiative phare de Hugging Face, visant à rendre l'utilisation et la formation de modèles d'embedding plus accessibles et efficaces.