Databricks DBRX-tutorial: een stapsgewijze gids

Databricks heeft onlangs DBRX geïntroduceerd, zijn open general-purpose large language model (LLM) dat is gebouwd op een mixture-of-experts-architectuur (MoE) met een fijnmazige aanpak. In plaats van één neuraal netwerk voor alle taken te gebruiken, bestaat het systeem uit meerdere gespecialiseerde „expert”-netwerken, elk geoptimaliseerd voor verschillende soorten taken of data.

Dit model presteert beter dan traditionele LLM's zoals GPT-3.5 en Llama 2 omdat het sneller en kostenefficiënter is. Volgens tests scoort DBRX 73,7%, hoger dan LLaMa2 (69,8%) bij taken voor taalbegrip.

In dit artikel bespreken we de mogelijkheden en hoe je aan de slag gaat met Databricks DBRX in meer detail.

Wat is Databricks DBRX?

DBRX gebruikt een transformer-gebaseerde decoder-only-architectuur die is getraind met next-token prediction. Het maakt gebruik van een fijnmazige mixture-of-experts (MoE)-architectuur. Deze ‘experts’ verwijzen naar gespecialiseerde agenten op basis van LLM's, verrijkt met domeinspecifieke kennis en redeneervaardigheden.

DBRX heeft een groot aantal kleinere experts (in totaal 16) en kiest voor elke invoer een subset daarvan (4 experts).

Simpel gezegd: deze fijnmazige aanpak met 65x meer mogelijke combinaties van experts verbetert de modelkwaliteit vergeleken met andere open MoE-modellen zoals Mixtral en Grok-1, die minder experts hebben en per input minder experts selecteren.

Hier zijn enkele kerngegevens over DBRX:

1. Parametergrootte: DBRX heeft in totaal 132 miljard parameters, waarvan er 36 miljard actief zijn bij een gegeven invoer.
2. Pretrainingdata: Het model is voorgetraind op 12 biljoen tokens van zorgvuldig samengestelde data en een contextlengte van 32.000 tokens, wat token-voor-token minstens 2x beter is dan de data die is gebruikt voor de pretraining van de MPT-modelfamilie.

Hoe is DBRX getraind?

Het model is voorgetraind op een indrukwekkend grote dataset, die naar schatting twee keer zo effectief is als eerdere datasets die door Databricks zijn gebruikt. Een reeks Databricks-tools, zoals Apache Spark en Databricks-notebooks voor dataverwerking en Unity Catalog voor datagovernance, is gebruikt om het model te trainen.

Tijdens de training is gebruikgemaakt van curriculum learning en is de datamix aangepast om de modelkwaliteit substantieel te verbeteren. Dergelijke strategische aanpassingen in de trainingsdatamix optimaliseerden het vermogen van het model om diverse inputs effectief te verwerken.

Enkele van de belangrijkste technologieën die voor de pretraining van DBRX zijn gebruikt, zijn:

• Rotary Position Encodings (RoPE): Een methode in transformers die tokenposities codeert via rotatietransformaties in een hoogdimensionale ruimte, wat het begrip van sequenties verbetert.
• Gated Linear Units (GLU): Een neurale-netwerklaag die een gate-mechanisme gebruikt om de informatiestroom te sturen en zo complexe patronen beter vast te leggen.
• Grouped Query Attention (GQA): Een attentiemechanisme dat gewichten binnen groepen queries berekent om de rekenkosten te verlagen en de focus te verbeteren.
• GPT-4-tokenizer uit de tiktoken-repository: Een specifieke tokenizer-implementatie voor GPT-4, die tekst omzet in modelklare tokens, geoptimaliseerd voor de verwerkingsbehoeften van GPT-4.

Hoe verhoudt DBRX zich tot vergelijkbare modellen?

Databricks stelt dat het DBRX-model superieur is aan verschillende toonaangevende open-sourcemodellen wat betreft efficiëntie en taakprestatie.

Hier is een uitgebreide vergelijking van hoe DBRX zich verhoudt tot zijn concurrenten:

1) DBRX vs. LLaMA2-70B

• Algemene kennis (MMLU): DBRX Instruct scoort 9,8% hoger dan LLaMA2-70B.
• Gezond-verstand-redeneren (HellaSwag-dataset): DBRX Instruct blijft leiden met een 3,1% hogere score.
• Databricks gauntlet (een model dat de capaciteiten van voorgetrainde LLM's beoordeelt op basis van verschillende taken): DBRX Instruct heeft een ruime voorsprong—een 14% hogere score dan LLaMA2-70B.
• Programmeren en wiskundig redeneren: DBRX Instruct valt op met 37,9% bij programmeren en 40,2% bij wiskundig redeneren.

2) DBRX Instruct vs. Mixtral Instruct

• Algemene kennis: DBRX Instruct ligt nipt voor op Mixtral Instruct met een 2,3% hogere score.
• Gezond-verstand-redeneren (HellaSwag-dataset): DBRX Instruct presteert beter met een 1,4% hogere score.
• Databricks gauntlet: DBRX Instruct overtreft Mixtral Instruct met een opvallende marge van 6,1%.
• Programmeren en wiskundig redeneren: DBRX Instruct presteerde beter dan Mixtral Instruct met 15,3% bij programmeren en 5,8% bij wiskundig redeneren.

3) DBRX vs Grok-1

• Algemene kennis: De prestaties liggen dicht bij elkaar, met DBRX Instruct dat een kleine voorsprong van 0,7% heeft op Grok-1.
• Programmeren en wiskundig redeneren: DBRX Instruct presteerde beter dan Grok-1 met 6,9% voorsprong bij programmeren en 4% bij wiskundig redeneren.

4) DBRX vs Mixtral Base

• Algemene kennis: DBRX Instruct leidt licht met een 1,8% hogere score dan Mixtral Base.
• Gezond-verstand-redeneren (HellaSwag-dataset): DBRX scoort hoger met een verschil van 2,5%.
• Databricks gauntlet: DBRX leidt met 10% ten opzichte van Mixtral Base.
• Programmeren en wiskundig redeneren: DBRX Instruct laat een opmerkelijke prestatiewinst zien met een 29,9% hogere score dan Mixtral Base.

Vergelijkingstabel

Hieronder hebben we de vergelijkingen samengebracht in een tabel en een grafiek getoond op basis van enkele resultaten:

Vergelijking van de kwaliteit van DBRX met andere open-source LLM's - bron

DBRX gebruiken: een stapsgewijze gids

Zorg ervoor dat je systeem minstens 320GB geheugen heeft voordat je DBRX gebruikt. Volg daarna deze stappen om toegang te krijgen tot DBRX:

Toegang krijgen tot DBRX

• Installeer de bibliotheek transformers

pip install "transformers>=4.40.0"

• Vraag vervolgens een toegangstoken met leesrechten aan bij Hugging Face (dit is nodig om het model te downloaden.)
• Zodra je toegang hebt, importeer en laad je het model met de volgende 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")

# Directing tensors to "cuda" (GPU) for faster computation as GPUs are better at handling parallel tasks.
input_text = "Databricks was founded in "
input_ids = tokenizer(input_text, return_tensors="pt").to("cuda")

# DBRX accepts a context length of up to 32768 tokens. Here`max_new_tokens` specifies the maximum number of tokens to generate.
outputs = model.generate(**input_ids, max_new_tokens=100)
print(tokenizer.decode(outputs[0]))

Wil je leren werken met Transformers en Hugging Face? Lees onze tutorial over het gebruik van Transformers en Hugging Face.

Basistaken met DBRX

DRBX kan je helpen met basiscontentcreatie en promptantwoorden zoals elke LLM. Dit kun je doen met DBRX:

• Tekstaanvulling: DBRX kan tekstuele antwoorden genereren op basis van je prompts.
• Taalbegrip: Het kan taken uitvoeren zoals het parseren van natuurlijke taal, het samenvatten van lange documenten of het vertalen van tekst tussen programmeertalen of scriptstijlen.
• Queryoptimalisatie: DBRX kan ook databasequery's optimaliseren om de uitvoeringstijd te minimaliseren en data engineers te helpen zich op andere kritieke taken te richten zonder prestatieverlies.

Codeertaken met DBRX

DBRX kan ook geavanceerde coderelated taken uitvoeren om dataprofessionals of coders te helpen:

• Code en uitleg: Het kan code genereren voor diverse programmeertaken en bestaande functies uitleggen of algoritmen voor specifieke problemen voorstellen om code te begrijpen en te optimaliseren.

DBRX reageert op eenvoudige opdrachten - bron

• Debuggen met DBRX: Het geeft voorgestelde codecorrecties om de productiviteit van ontwikkelaars te verbeteren en je debugproces te versnellen.
• S Kwetsbaarheden identificeren: Het kan ook problemen in code opsporen en oplossingen voorstellen om deze te verhelpen.

DBRX fijn-afstemmen

Je kunt DBRX fijn-afstemmen met de open-source LLM Foundry van Github. Fijn-afstemmen vereist echter dat trainingsvoorbeelden worden geformatteerd als dictionaries:

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

Prompt: Dit is de startvraag of instructie die je aan het model geeft.

Response: Dit is het antwoord dat het model wordt getraind om te genereren.

Je kunt drie verschillende datasets gebruiken om een LLM fijn af te stemmen:

1. Een dataset die beschikbaar is op de HuggingFace Hub.
2. Een dataset die lokaal is opgeslagen op je apparaat of machine.
3. Een dataset in het StreamingDataset .mds-formaat.

1) Hugging Face Hub gebruiken

Als je wilt fijn-afstemmen met een dataset van de HuggingFace Hub en de

dataset heeft een vooraf gedefinieerde preprocessingfunctie of volgt al het

„prompt”/„response”-formaat, dan kun je de dataloader eenvoudig naar die dataset laten verwijzen.

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

Als er geen preprocessingfunctie is gedefinieerd, gebruik dan preprocessing_fn om een aangepaste preprocessingfunctie voor de dataloader op te geven.

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

2) Een lokale dataset gebruiken

Als je al een fijn-afstemdataset op je apparaat hebt, definieer dan lokale JSONL-bestanden in

de YAML-config 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
        ...

Sla preprocessing_fn over als je lokale data al het „prompt”/„response”-formaat heeft.

3) StreamingDataset gebruiken

Zet je HuggingFace-dataset om naar MDS-formaat met het

convert_finetuning_dataset.py-script.

Nadat je je HuggingFace-dataset hebt omgezet naar een streamingformaat, pas je je YAML-configuratie als volgt aan.

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

Als je volledige parameter-finetuning wilt zien, bekijk dan de YAML-config op

dbrx-full-ft.yaml

Conclusie

Databricks DBRX gebruikt meerdere gespecialiseerde netwerken om de snelheid en kostenefficiëntie van het model te verbeteren. Deze fijnmazige aanpak stelt het in staat om andere LLM's te overtreffen bij het uitvoeren van complexe taken.

Wil je meer leren over large language models en hoe je ze fijn-afstemt? Bekijk dan deze resources:

• Werken met Hugging Face
• Llama 2 fijn-afstemmen
• Google Gemma fijn-afstemmen
• Het Phi-2-model fijn-afstemmen