Tutoriel Databricks DBRX : guide pas à pas

Databricks a récemment présenté DBRX, son grand modèle de langage (LLM) généraliste open source, conçu sur une architecture « mixture-of-experts » (MoE) à grain fin. Plutôt que d'utiliser un seul réseau de neurones pour toutes les tâches, le système repose sur plusieurs réseaux « experts » spécialisés, chacun optimisé pour différents types de tâches ou de données.

Ce modèle surpasse des LLM traditionnels comme GPT-3.5 et Llama 2, car il est plus rapide et plus économique. D'après les tests, DBRX atteint un score de 73,7 %, supérieur à LLaMA 2 (69,8 %) sur des tâches de compréhension du langage.

Dans cet article, nous allons détailler ses capacités et comment bien démarrer avec Databricks DBRX.

Qu'est-ce que Databricks DBRX ?

DBRX utilise une architecture de décodeur de type transformer, entraînée via la prédiction du prochain jeton. Il s'appuie sur une architecture MoE à grain fin. Ces « experts » désignent des agents spécialisés basés sur des LLM, enrichis de connaissances métiers et de capacités de raisonnement.

DBRX embarque un grand nombre de petits experts (16 au total) et en sélectionne un sous-ensemble (4 experts) pour chaque entrée.

En bref, cette approche fine, avec 65× plus de combinaisons d'experts possibles, améliore la qualité du modèle par rapport à d'autres MoE open source comme Mixtral et Grok-1, qui comportent moins d'experts et en activent moins par entrée.

Voici quelques détails clés sur DBRX :

1. Taille en paramètres : DBRX totalise 132 milliards de paramètres, dont 36 milliards sont actifs pour une entrée donnée.
2. Données de pré-entraînement : il a été pré-entraîné sur 12 billions de jetons de données soigneusement sélectionnées, avec une longueur de contexte de 32 000 jetons, soit au moins 2× mieux à jeton égal que les données utilisées pour pré-entraîner la famille MPT.

Comment DBRX a-t-il été entraîné ?

Le modèle a été pré-entraîné sur un jeu de données très volumineux, estimé deux fois plus efficace que les jeux de données précédemment utilisés par Databricks. Un ensemble d'outils Databricks, comme Apache Spark et les notebooks Databricks pour le traitement de données, ainsi que Unity Catalog pour la gouvernance, a servi à entraîner le modèle.

Pendant l'entraînement, un apprentissage curriculaire a été appliqué et le mix de données a été ajusté afin d'améliorer sensiblement la qualité du modèle. Ces ajustements stratégiques ont optimisé sa capacité à traiter efficacement des entrées variées.

Parmi les technologies clés utilisées pour le pré-entraînement de DBRX :

• Rotary Position Encodings (RoPE) : une méthode des transformers qui code les positions des jetons via des transformations rotationnelles dans un espace de grande dimension, améliorant la compréhension des séquences.
• Gated Linear Units (GLU) : une couche de réseau de neurones utilisant un mécanisme de porte pour contrôler le flux d'information et mieux capter les motifs complexes.
• Grouped Query Attention (GQA) : un mécanisme d'attention qui calcule les poids au sein de groupes de requêtes pour réduire le coût de calcul et améliorer la focalisation.
• Tokenizer GPT-4 du dépôt tiktoken : une implémentation de tokenizer spécifique à GPT-4, convertissant le texte en jetons prêts pour le modèle, optimisée pour ses besoins de traitement.

Comment DBRX se compare-t-il à des modèles similaires ?

Databricks affirme que son modèle DBRX est supérieur à plusieurs modèles open source de référence en matière d'efficacité et de performance sur les tâches.

Voici une comparaison détaillée de la manière dont DBRX se positionne face à ses concurrents :

1) DBRX vs LLaMA2-70B

• Connaissances générales (MMLU) : DBRX Instruct obtient un score supérieur de 9,8 % à LLaMA2-70B.
• Raisonnement de bon sens (jeu de données HellaSwag) : DBRX Instruct conserve l'avantage avec +3,1 %.
• Databricks gauntlet (batterie de tests évaluant les capacités des LLM pré-entraînés sur différentes tâches) : DBRX Instruct creuse l'écart avec +14 % par rapport à LLaMA2-70B.
• Programmation et raisonnement mathématique : DBRX Instruct se distingue avec 37,9 % en programmation et 40,2 % en raisonnement mathématique.

2) DBRX Instruct vs Mixtral Instruct

• Connaissances générales : DBRX Instruct devance Mixtral Instruct de 2,3 %.
• Raisonnement de bon sens (jeu de données HellaSwag) : DBRX Instruct fait mieux avec +1,4 %.
• Databricks gauntlet : DBRX Instruct surpasse Mixtral Instruct de 6,1 %.
• Programmation et raisonnement mathématique : DBRX Instruct dépasse Mixtral Instruct de 15,3 % en programmation et de 5,8 % en raisonnement mathématique.

3) DBRX vs Grok-1

• Connaissances générales : performances proches, DBRX Instruct gardant une légère avance de 0,7 % sur Grok-1.
• Programmation et raisonnement mathématique : DBRX Instruct fait mieux que Grok-1 avec +6,9 % en programmation et +4 % en raisonnement mathématique.

4) DBRX vs Mixtral Base

• Connaissances générales : DBRX Instruct mène légèrement avec +1,8 % par rapport à Mixtral Base.
• Raisonnement de bon sens (jeu de données HellaSwag) : DBRX obtient un score supérieur de 2,5 %.
• Databricks gauntlet : DBRX devance Mixtral Base de 10 %.
• Programmation et raisonnement mathématique : DBRX Instruct affiche un net avantage avec +29,9 % par rapport à Mixtral Base.

Tableau comparatif

Ci-dessous, nous avons récapitulé les comparaisons dans un tableau et proposé un graphique basé sur certains résultats :

Comparaison de la qualité de DBRX avec d'autres LLM open source - source

Comment utiliser DBRX : guide pas à pas

Avant d'accéder à DBRX, vérifiez que votre système dispose d'au moins 320 Go de mémoire. Suivez ensuite ces étapes pour y accéder :

Accès à DBRX

• Installez la bibliothèque transformers

pip install "transformers>=4.40.0"

• Demandez ensuite un jeton d'accès avec droits de lecture sur Hugging Face (nécessaire pour télécharger le modèle).
• Une fois l'accès obtenu, importez et chargez le modèle avec le code suivant.

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tokenizer = AutoTokenizer.from_pretrained("databricks/dbrx-base", token="hf_YOUR_TOKEN")
model = AutoModelForCausalLM.from_pretrained("databricks/dbrx-base", device_map="auto", torch_dtype=torch.bfloat16, token="hf_YOUR_TOKEN")

# Orientation des tenseurs vers "cuda" (GPU) pour un calcul plus rapide, les GPU étant mieux adaptés au parallélisme.
input_text = "Databricks was founded in "
input_ids = tokenizer(input_text, return_tensors="pt").to("cuda")

# DBRX accepte une longueur de contexte jusqu'à 32 768 jetons. Ici, `max_new_tokens` spécifie le nombre maximal de nouveaux jetons à générer.
outputs = model.generate(**input_ids, max_new_tokens=100)
print(tokenizer.decode(outputs[0]))

Vous voulez apprendre à utiliser Transformers et Hugging Face ? Lisez notre tutoriel sur Transformers et Hugging Face.

Tâches de base avec DBRX

DBRX peut vous aider pour des tâches de création de contenu et de réponse à des invites, comme tout LLM. Voici ce que vous pouvez faire avec DBRX :

• Complétion de texte : DBRX génère des réponses textuelles à partir de vos invites.
• Compréhension du langage : il peut parser des entrées en langage naturel, résumer de longs documents ou traduire du texte entre langages de programmation ou styles de scripts.
• Optimisation de requêtes : DBRX peut optimisé des requêtes de base de données pour réduire le temps d'exécution et permettre aux data engineers de se concentrer sur d'autres tâches critiques sans compromis de performance.

Tâches de code avec DBRX

DBRX peut également réaliser des tâches avancées liées au code pour aider les data practitioners ou les développeurs :

• Génération et explication de code : il peut générer du code pour diverses tâches de programmation, expliquer des fonctions existantes ou suggérer des algorithmes pour des problèmes spécifiques afin de comprendre et optimiser le code.

DBRX répondant à des commandes simples - source

• Débogage avec DBRX : il propose des corrections de code pour améliorer la productivité des développeurs et accélérer le débogage.
• Identification des vulnérabilités : il peut repérer des problèmes dans le code et proposer des solutions pour les atténuer.

Comment affiner (fine-tune) DBRX

Vous pouvez affiner DBRX avec la LLM foundry open source de Github. Cependant, l'affinage nécessite des exemples d'entraînement formatés sous forme de dictionnaires :

formatted_example = {'prompt': <prompt_text>, 'response': <response_text>}

Prompt : c'est la question ou l'instruction de départ que vous donnez au modèle.

Response : c'est la réponse que le modèle est entraîné à générer.

Vous pouvez utiliser trois types de jeux de données pour affiner un LLM :

1. Un jeu de données disponible sur Hugging Face Hub.
2. Un jeu de données stocké localement sur votre machine.
3. Un jeu de données au format StreamingDataset .mds.

1) Utiliser Hugging Face Hub

Si vous souhaitez affiner à partir d'un jeu de données du Hub Hugging Face et que le

jeu de données dispose d'une fonction de prétraitement prédéfinie ou suit déjà le

format « prompt »/« response », il suffit d'indiquer ce jeu de données au dataloader.

train_loader:
    name: finetuning
    dataset:
        hf_name: tatsu-lab/alpaca
        split: train
        ...

Si aucune fonction de prétraitement n'est définie, utilisez preprocessing_fn pour spécifier une fonction de prétraitement personnalisée pour le dataloader.

train_loader:
    name: finetuning
    dataset:
        hf_name: mosaicml/doge-facts
        preprocessing_fn: my_data.formatting:dogefacts_prep_fn
        split: train
        ...

2) Utiliser un jeu de données local

Si vous disposez déjà d'un jeu d'affinage sur votre machine, définissez les fichiers JSONL locaux dans

la configuration YAML yamls/finetune/1b_local_data_sft.yaml.

train_loader:
    name: finetuning
    dataset:
        hf_name: json # en supposant que les fichiers de données soient au format JSON
        hf_kwargs:
            data_dir: /path/to/data/dir/
        preprocessing_fn: my.import.path:my_preprocessing_fn
        split: train
        ...

Omettez preprocessing_fn si vos données locales sont déjà au format « prompt »/« response ».

3) Utiliser StreamingDataset

Convertissez votre jeu de données Hugging Face en format MDS à l'aide du script

convert_finetuning_dataset.py.

Après conversion de votre jeu de données Hugging Face au format streaming, ajustez simplement votre configuration YAML comme suit.

train_loader:
    name: finetuning
    dataset:
        remote: s3://my-bucket/my-copy-doge-facts
        local: /tmp/mds-cache/
        split: train
        ...

Pour un exemple d'affinage à paramètres complets, consultez la configuration YAML :

dbrx-full-ft.yaml

Conclusion

Databricks DBRX s'appuie sur plusieurs réseaux spécialisés pour améliorer la vitesse et la maîtrise des coûts. Cette approche fine lui permet de surpasser d'autres LLM sur des tâches complexes.

Vous souhaitez en savoir plus sur les grands modèles de langage et comment les affiner ? Découvrez ces ressources :

• Working with Hugging Face
• Fine-Tuning Llama 2
• Fine-Tuning Google Gemma
• Fine-Tuning the Phi-2 Model