Databricks DBRX Tutorial: Eine Schritt-für-Schritt-Anleitung

Databricks hat kürzlich DBRX vorgestellt, ein offenes, universelles Large Language Model (LLM), das auf einer fein granulierten Mixture-of-Experts-(MoE)-Architektur basiert. Statt ein einziges neuronales Netz für alle Aufgaben zu nutzen, setzt das System auf mehrere spezialisierte „Expert:innen“-Netzwerke, die jeweils für unterschiedliche Aufgabentypen oder Daten optimiert sind.

Dieses Modell übertrifft klassische LLMs wie GPT-3.5 und Llama 2, weil es schneller und kostengünstiger ist. Laut Tests erzielt DBRX 73,7 % und liegt damit bei Sprachverständnis-Aufgaben über LLaMA2 (69,8 %).

In diesem Artikel schauen wir uns die Fähigkeiten an und zeigen dir im Detail, wie du mit Databricks DBRX startest.

Was ist Databricks DBRX?

DBRX nutzt eine Transformer-basierte Decoder-only-Architektur, trainiert per Next-Token-Prediction. Es setzt auf eine fein granulierte Mixture-of-Experts-(MoE)-Architektur. Diese „Expert:innen“ sind spezialisierte Agenten auf LLM-Basis, erweitert um domänenspezifisches Wissen und ausgeprägte Reasoning-Fähigkeiten.

DBRX verfügt über viele kleinere Expert:innen (insgesamt 16) und wählt für jede Eingabe eine Teilmenge davon aus (4 Expert:innen).

Vereinfacht gesagt verbessert dieser fein granulierte Ansatz mit 65-mal mehr möglichen Expert:innen-Kombinationen die Modellqualität gegenüber anderen offenen MoE-Modellen wie Mixtral und Grok-1, die weniger Expert:innen haben und pro Eingabe weniger auswählen.

Hier einige wichtige Details zu DBRX:

1. Parameteranzahl: DBRX hat insgesamt 132 Milliarden Parameter, davon sind bei jeder Eingabe 36 Milliarden aktiv.
2. Pretraining-Daten: Vortrainiert auf 12 Billionen sorgfältig kuratierten Tokens und einer Kontextlänge von 32.000 Tokens – mindestens doppelt so effizient (Token für Token) wie die Daten, mit denen die MPT-Modellfamilie vortrainiert wurde.

Wie wurde DBRX trainiert?

Das Modell wurde auf einem beeindruckend großen Datensatz vortrainiert, der Schätzungen zufolge doppelt so wirkungsvoll ist wie die zuvor von Databricks verwendeten Datensätze. Ein Set an Databricks-Tools – darunter Apache Spark und Databricks Notebooks für die Datenverarbeitung sowie der Unity Catalog für Data Governance – kam beim Training zum Einsatz.

Während des Trainings wurde Curriculum Learning genutzt und der Datenmix angepasst, um die Modellqualität deutlich zu steigern. Diese gezielten Anpassungen im Datenmix optimierten die Fähigkeit des Modells, vielfältige Eingaben effektiv zu verarbeiten.

Zu den wichtigsten Technologien für das Pretraining von DBRX gehören:

• Rotary Position Encodings (RoPE): Ein Verfahren in Transformern, das Token-Positionen durch rotatorische Transformationen im hochdimensionalen Raum codiert und so das Sequenzverständnis verbessert.
• Gated Linear Units (GLU): Eine Neuronenschicht mit Gating-Mechanismus zur Steuerung des Informationsflusses, die hilft, komplexe Muster zu erfassen.
• Grouped Query Attention (GQA): Ein Aufmerksamkeitsmechanismus, der Gewichte innerhalb von Query-Gruppen berechnet, um Rechenaufwand zu reduzieren und den Fokus zu verbessern.
• GPT-4-Tokenizer aus dem tiktoken-Repository: Eine spezielle Tokenizer-Implementierung für GPT-4, die Text in modeltfähige Tokens umwandelt und auf die Verarbeitung von GPT-4 optimiert ist.

Wie schneidet DBRX im Vergleich zu ähnlichen Modellen ab?

Databricks behauptet, dass DBRX mehreren führenden Open-Source-Modellen in Effizienz und Aufgabenerfüllung überlegen ist.

Hier gibt es einen detaillierten Vergleich, wie DBRX im Wettbewerb dasteht:

1) DBRX vs. LLaMA2-70B

• Allgemeinwissen (MMLU): DBRX Instruct erzielt 9,8 % mehr als LLaMA2-70B.
• Alltagslogik (HellaSwag-Datensatz): DBRX Instruct liegt mit 3,1 % Vorsprung vorn.
• Databricks Gauntlet (ein Benchmark, der die Fähigkeiten vortrainierter LLMs über verschiedene Aufgaben misst): DBRX Instruct führt deutlich mit +14 % gegenüber LLaMA2-70B.
• Programmierung und mathematisches Reasoning: DBRX Instruct sticht heraus mit 37,9 % in Programmierung und 40,2 % im mathematischen Schlussfolgern.

2) DBRX Instruct vs. Mixtral Instruct

• Allgemeinwissen: DBRX Instruct liegt mit 2,3 % knapp vor Mixtral Instruct.
• Alltagslogik (HellaSwag-Datensatz): DBRX Instruct ist mit +1,4 % besser.
• Databricks Gauntlet: DBRX Instruct übertrifft Mixtral Instruct deutlich um 6,1 %.
• Programmierung und mathematisches Reasoning: DBRX Instruct lag 15,3 % in Programmierung und 5,8 % im mathematischen Reasoning vor Mixtral Instruct.

3) DBRX vs. Grok-1

• Allgemeinwissen: Die Leistungen sind ähnlich, DBRX Instruct hat einen leichten Vorsprung von 0,7 % gegenüber Grok-1.
• Programmierung und mathematisches Reasoning: DBRX Instruct lag 6,9 % in Programmierung und 4 % im mathematischen Reasoning vor Grok-1.

4) DBRX vs. Mixtral Base

• Allgemeinwissen: DBRX Instruct liegt mit +1,8 % leicht vorn.
• Alltagslogik (HellaSwag-Datensatz): DBRX erzielt +2,5 %.
• Databricks Gauntlet: DBRX führt mit +10 % gegenüber Mixtral Base.
• Programmierung und mathematisches Reasoning: DBRX Instruct zeigt eine starke Überlegenheit mit +29,9 % gegenüber Mixtral Base.

Vergleichstabelle

Unten haben wir die Vergleiche tabellarisch zusammengefasst und eine Grafik zu ausgewählten Ergebnissen ergänzt:

Vergleich der DBRX-Qualität mit anderen Open-Source-LLMs – Quelle

DBRX nutzen: Schritt-für-Schritt-Anleitung

Bevor du auf DBRX zugreifst, stell sicher, dass dein System mindestens 320 GB Arbeitsspeicher hat. Folge dann diesen Schritten:

Zugriff auf DBRX

• Installiere die Bibliothek transformers

pip install "transformers>=4.40.0"

• Fordere anschließend bei Hugging Face ein Zugriffstoken mit Leserechten an (wird zum Herunterladen des Modells benötigt).
• Wenn du Zugriff hast, importiere und lade das Modell mit folgendem Code.

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

# Leitet Tensoren für schnellere Berechnungen an "cuda" (GPU) weiter, da GPUs parallele Aufgaben besser verarbeiten.
input_text = "Databricks was founded in "
input_ids = tokenizer(input_text, return_tensors="pt").to("cuda")

# DBRX akzeptiert eine Kontextlänge von bis zu 32768 Tokens. Hier gibt `max_new_tokens` die maximale Anzahl neu zu generierender Tokens an.
outputs = model.generate(**input_ids, max_new_tokens=100)
print(tokenizer.decode(outputs[0]))

Du willst lernen, wie man Transformers und Hugging Face nutzt? Lies unser Tutorial zu Transformers und Hugging Face.

Grundlegende Aufgaben mit DBRX

DBRX hilft dir – wie jedes LLM – bei grundlegender Inhaltserstellung und Prompt-Antworten. Das kannst du mit DBRX tun:

• Textvervollständigung: DBRX kann textbasierte Antworten auf deine Prompts generieren.
• Sprachverständnis: Es kann natürliche Sprache parsen, lange Dokumente zusammenfassen oder Text zwischen Programmiersprachen oder Skriptstilen „übersetzen“.
• Abfrageoptimierung: DBRX kann Datenbankabfragen optimieren, um Laufzeiten zu minimieren – so können Data Engineers sich auf wichtigere Aufgaben konzentrieren, ohne Performance einzubüßen.

Coding-Aufgaben mit DBRX

DBRX kann auch fortgeschrittene Coding-Aufgaben für Data Professionals oder Entwickler:innen übernehmen:

• Code und Erklärungen: Es generiert Code für verschiedene Programmieraufgaben, erklärt bestehende Funktionen oder schlägt Algorithmen für spezifische Probleme vor, um Code zu verstehen und zu optimieren.

DBRX reagiert auf einfache Befehle – Quelle

• Debugging mit DBRX: Es schlägt Code-Korrekturen vor, steigert die Entwicklerproduktivität und beschleunigt das Debugging.
• Erkennung von Schwachstellen: Es kann Probleme im Code identifizieren und Lösungen zu deren Behebung vorschlagen.

DBRX feinabstimmen (Fine-Tuning)

Du kannst DBRX mit der Open-Source-LLM Foundry auf GitHub feinabstimmen. Fürs Fine-Tuning müssen Trainingsbeispiele allerdings als Dictionaries formatiert sein:

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

Prompt: Die Ausgangsfrage oder Anweisung, die du dem Modell gibst.

Response: Die Antwort, zu deren Generierung das Modell trainiert wird.

Zum Fine-Tuning eines LLM kannst du drei verschiedene Datensätze verwenden:

1. Einen Datensatz aus dem Hugging Face Hub.
2. Einen lokal auf deinem Gerät gespeicherten Datensatz.
3. Einen Datensatz im StreamingDataset-.mds-Format.

1) Hugging Face Hub verwenden

Wenn du mit einem Datensatz aus dem Hugging Face Hub feinabstimmen willst und der

Datensatz bereits eine vordefinierte Preprocessing-Funktion hat oder dem

„prompt“/„response“-Format folgt, kannst du den Dataloader direkt auf diesen Datensatz zeigen lassen.

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

Ist keine Preprocessing-Funktion definiert, nutze preprocessing_fn, um eine eigene Preprocessing-Funktion für den Dataloader anzugeben.

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

2) Lokalen Datensatz verwenden

Wenn du bereits einen Fine-Tuning-Datensatz auf deinem Gerät hast, definiere lokale JSONL-Dateien in

der YAML-Konfiguration yamls/finetune/1b_local_data_sft.yaml.

train_loader:
    name: finetuning
    dataset:
        hf_name: json # assuming data files are json formatted
        hf_kwargs:
            data_dir: /path/to/data/dir/
        preprocessing_fn: my.import.path:my_preprocessing_fn
        split: train
        ...

Überspringe preprocessing_fn, wenn deine lokalen Daten bereits im „prompt“/„response“-Format vorliegen.

3) StreamingDataset verwenden

Konvertiere deinen Hugging Face-Datensatz mit dem Skript

convert_finetuning_dataset.py ins MDS-Format.

Nachdem du deinen Hugging Face-Datensatz in ein Streaming-Format konvertiert hast, passe deine YAML-Konfiguration einfach so an.

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

Wenn du vollständiges Parameter-Fine-Tuning sehen möchtest, schau dir die YAML-Konfiguration an:

dbrx-full-ft.yaml

Fazit

Databricks DBRX nutzt mehrere spezialisierte Netzwerke, um Geschwindigkeit und Kosteneffizienz zu steigern. Dieser fein granulierte Ansatz ermöglicht es dem Modell, andere LLMs bei komplexen Aufgaben zu übertreffen.

Du willst mehr über Large Language Models und Fine-Tuning lernen? Dann sieh dir diese Ressourcen an:

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