Aan de slag met Mixtral 8X22B

Toen OpenAI in 2022 ChatGPT uitbracht, vroegen velen zich af of andere bedrijven konden concurreren met zo’n goed product, gesteund door een gigant als Microsoft. Terwijl iedereen zijn aandacht richtte op andere grote techspelers zoals Google en Meta, kwam Mistral AI in 2023 met hun 7B-model, dat alle open-source-LLM’s met bijna tweemaal de grootte overtrof.

Sindsdien is Mistral AI een grote speler geworden in de LLM-race. In april 2024 brachten ze Mixtral 8X22B uit, een model dat het toen beste open-source LLM, Llama 2, op veel benchmarks ruim versloeg.

In deze tutorial bespreken we het Mixtral 8X22B-model in detail, van de architectuur tot het opzetten van een RAG-pijplijn.

Wat maakt het Mixtral 8x22B-model uniek?

Mixtral 8X22B is het nieuwste model van Mistral AI. Het heeft een sparse mixture of experts (SMoE)-architectuur met 141 miljard parameters. Juist deze SMoE-architectuur zorgt voor veel van de voordelen. SMoE is een type neuraal netwerk dat verschillende kleinere modellen (experts) gebruikt voor verschillende taken en alleen de benodigde experts activeert om tijd en rekenkracht te besparen.

Allereerst biedt het model ongeëvenaarde kostenefficiëntie voor zijn grootte, met de beste prestatie-kostenverhouding in de open-sourcegemeenschap:

De bovenstaande afbeelding toont enkele toonaangevende open-source-LLM’s en het aantal actieve parameters dat ze nodig hebben om een bepaalde prestatiedrempel te halen. Mixtral staat helemaal linksboven, wat betekent dat het aanzienlijk minder parameters gebruikt om +75% performance te bereiken dan een model in dezelfde categorie — Command R+.

Hoewel Mixtral 8X22B 141 miljard parameters heeft, gebruikt het dankzij het sparse-activatiepatroon tijdens inferentie slechts 39 miljard parameters. Daardoor presteert het beter en is het sneller dan elk dense model met 70 miljard parameters, zoals Llama 2 70B. Het beschikt ook over een contextvenster van 64k tokens, wat tegenwoordig zeer zeldzaam is voor open-source-LLM’s.

Het model wordt bovendien geleverd met de meest permissieve open-sourcelicentie — Apache 2.0. Gecombineerd met de lage kosten om het te draaien, is Mixtral 8X22B een uitstekende keuze voor fine-tuning-scenario’s.

Mixtral 8X22B-benchmarks

Mixtral 8x22B doorstaat standaard industriële benchmarks met vlag en wimpel. In de meeste benchmarks lag de nadruk op hoe goed het model presteerde in vergelijking met zijn belangrijkste alternatieven:

• Llama 70B: Aangeboden door Meta, geschikt voor grootschalige taalmodellering, tekstgeneratie en dialoogsysteemtoepassingen.
• Command R+: Een model met 104B parameters van Cohere, speciaal ontworpen voor long-context-taken en RAG-pijplijnen.

Zo is Mixtral 8X22B vloeiend in vijf talen: Engels, Duits, Frans, Spaans en Italiaans. Het bewijs zie je in de volgende tabel:

Het verslaat Llama 2 70B op taaltaken over drie benchmarks:

• Arc-C: De Abstraction and Reasoning Corpus (ARC)-benchmark is ontworpen om AI-prestaties in gezond verstand-redeneren te meten.
• HellaS: HellaSwag is een andere benchmark voor gezond verstand-redeneren.
• MMLU: Massive Multitask Language Understanding-benchmark.

Wat betreft puur gezond verstand-redeneren en kennisvragen in het Engels, presteert Mixtral opnieuw uitstekend:

Het scoort iets slechter dan Command R+ op twee benchmarks, maar op andere is het aanzienlijk beter.

En het meest kenmerkende punt: Mixtral 8X22B verpulvert alle alternatieven op wiskunde- en coderingstaken:

Laten we nu bekijken hoe het model zijn state-of-the-art prestaties behaalt.

De architectuur achter Mixtral 8X22B — SMoE uitgelegd

Om de sparse mixture of experts (SMoE)-architectuur beter te begrijpen, gebruiken we een eenvoudige analogie. Stel dat 100 mensen aan een project werken.

• Traditionele modellen: Het hele team (alle modelparameters) analyseert alle projectinformatie en iedereen werkt samen aan elke taak.
• SMoE-architectuur: Een slimme teamleider wijst taken toe op basis van expertise. De leider (een router of gating-netwerk) stuurt elk stukje informatie (token) naar een kleine groep specialisten (experts) die er het beste mee om kunnen gaan. Alleen de juiste experts werken aan het probleem, waardoor het proces veel sneller en gerichter is.

SMoE-modellen hebben de volgende kernelementen:

1. Experts: Kleinere neurale netwerken vergeleken met het volledige model. Mixtral gebruikt 8 experts, die elk specifieke soorten informatie of taken verwerken. Zo kan één expert wiskunde- en logische vragen behandelen, terwijl een andere Frans afhandelt.
2. Router (gating-netwerk): Het gating-netwerk bepaalt welke tokens naar welke expert worden gestuurd. De router gebruikt meestal zelf een klein neuraal netwerk om factoren zoals de inhoud van de token en de huidige context te overwegen bij het nemen van de beslissing. Hoe je een token naar een expert routeert, is een van de grote beslissingen bij elk MoE-model.
3. Aggregatie: Nadat de experts hun toegewezen tokens hebben verwerkt, worden hun outputs gecombineerd. Dit kan op verschillende manieren, zoals simpel middelen of via een complexere wegingsstrategie.

Dit type modelstructuur heeft veel voordelen:

• Efficiëntie: Door slechts een kleine subset van experts per input te activeren, verlaagt SMoE de rekenkosten en verbetert het de verwerkingssnelheid.
• Schaalbaarheid: Je kunt eenvoudig meer experts toevoegen zonder de trainings- of inferentietijd significant te beïnvloeden. Zo kun je zeer grote modellen met hoge capaciteit bouwen.
• Nauwkeurigheid: Gespecialiseerde experts voor bepaalde taken kunnen tot betere prestaties leiden dan één enkel, monolithisch netwerk. De benchmarks lieten zien dat Mixtral bijzonder goed is in taal-, wiskunde- en coderingstaken, waarschijnlijk dankzij deze gespecialiseerde experts.

Maar omdat ze nieuw zijn, brengen SMoE-modellen ook unieke uitdagingen met zich mee die nog niet effectief zijn opgelost:

• Trainingscomplexiteit: Het trainen van een SMoE-model kan erg uitdagend zijn door de extra complexiteit van het gating-netwerk en de coördinatie tussen experts.
• De juiste experts vinden: Het bepalen van het juiste aantal en type experts is cruciaal voor optimale prestaties.
• Zwaar op geheugen: Door de architectuur moeten tijdens inferentie alle parameters van het model in het geheugen geladen worden, wat je GPU-vRAM volledig opslokt. Om inferentie met Mixtral 8X22B te draaien, heb je een GPU met minstens 300 GB geheugen nodig.

Samengevat: omdat de schaal van het model een van de belangrijkste factoren is voor betere modelkwaliteit, maakt het verminderen van het aantal actieve parameters modellen aanzienlijk goedkoper en sneller te trainen. Een groter model voor minder stappen trainen is beter dan een klein model voor meer stappen wanneer het rekenbudget beperkt is.

Door mixture-of-experts-architecturen kunnen modellen met veel minder compute getraind worden, waardoor je de modelgrootte drastisch kunt opschalen binnen hetzelfde budget als een dense model. Elk SMoE-model zou tijdens pre-training veel sneller dezelfde kwaliteit moeten bereiken als zijn dense tegenhanger.

Aan de slag met Mixtral 8x22B

In dit gedeelte leren we hoe je het Mixtral 8X22B-model gebruikt via de Mistral API. Omdat het model ongeveer 80 gigabyte groot is en een GPU van 300 gigabyte vereist, is het lastig en duur om het op welke cloudprovider dan ook te draaien, laat staan op consumentenhardware.

Accountinstelling

Mistral AI vraagt je een account aan te maken en factuurgegevens in te voeren om je API-sleutel te krijgen. Ga dus naar mistral.ai om je account te maken. Zodra je inlogt met je gegevens, word je doorgestuurd naar je Mistral-console op console.mistral.ai.

Ga daarna naar “Billing” en voeg je betaalgegevens toe:

Voeg vervolgens tegoed toe:

Dit stelt je in staat een API-sleutel te genereren via het gedeelte “API KEYS”:

Wanneer je een sleutel maakt, wordt die maar één keer weergegeven, dus sla hem ergens veilig op. We gebruiken hem in het volgende gedeelte.

Omgevingsinstelling

Laten we nu een virtuele omgeving instellen om de Mistral API te gebruiken. We gebruiken Conda:

$ conda init  # Run if your Conda executable is new
$ conda env create -n mistral python==3.8 -y
$ conda activate mistral
Mogelijk gemaakt door

Vervolgens kunnen we het Python-pakket mistralai installeren, samen met een paar andere essentials:

$ pip install mistralai
$ pip install python-dotenv ipykernel
$ ipython kernel install --user --name=mistral
Mogelijk gemaakt door

De laatste opdracht voegt de zojuist geïnstalleerde Conda-omgeving toe als een Jupyter-kernel.

We gebruiken het python-dotenv-pakket om onze Mistral API-sleutel veilig vanuit een notebook te lezen. Maak daarvoor een .env-bestand in je werkmap:

$ touch .envMogelijk gemaakt door

Bewerk het bestand vervolgens zodat je sleutel in de volgende syntaxis staat:

MISTRAL_API_KEY=YOUR_KEY_HEREMogelijk gemaakt door

Zorg er ook voor dat je het .env-bestand aan .gitignore toevoegt, zodat het niet per ongeluk op GitHub terechtkomt:

$ echo ".env" >> .gitignore
Mogelijk gemaakt door

Om de zojuist opgeslagen sleutel te lezen, kunnen we de functie load_dotenv gebruiken samen met de os-bibliotheek:

import os
from dotenv import load_dotenv

load_dotenv()

api_key = os.getenv("MISTRAL_API_KEY")
Mogelijk gemaakt door

Een chatclient gebruiken

Tot slot gebruiken we het object MistralClient om met elk Mistral-model te communiceren:

from mistralai.client import MistralClient

client = MistralClient(api_key=api_key)
Mogelijk gemaakt door

De client heeft onze API-sleutel nodig om verbinding te maken met de Mistral-servers. Vervolgens importeren we de klasse ChatMessage om dialogen met Mistral-modellen vast te leggen:

from mistralai.models.chat_completion import ChatMessage

model = "open-mixtral-8x22b"

message = "Who is the best French football player of all time?"

chat_response = client.chat(
   model=model,
   messages=[ChatMessage(role="user", content=message)],
)

print(chat_response.choices[0].message.content[:300])
Mogelijk gemaakt door

Determining the "best" French football player of all time can be subjective and depends on personal opinion. However, one player who is often mentioned in this context is Zinedine Zidane. He had an impressive career both for the French national team and at club level. He was a key player in France'sMogelijk gemaakt door

We kregen een reactie — dus alles is correct ingesteld.

Een ChatResponse-object bevat meestal meer dan één antwoord, dus we kiezen de eerste en printen een deel van de tekst.

Praktische toepassingen van Mixtral 8X22B

Naast pure tekstgeneratie kun je veel meer met Mixtral:

• Embeddings genereren
• Een parafrasedetector maken
• Een volledige RAG-pijplijn
• Function calling

enzovoort. We bekijken elk van deze scenario’s één voor één.

Tekstgeneratie

In het vorige gedeelte konden we met de chatclient een grote hoeveelheid tekst genereren. In sommige gevallen, wanneer we vermoeden dat het antwoord langer is, is het logisch om de output te streamen, net als in ChatGPT. Dat kan met Mixtral ook

messages = [ChatMessage(role="user", content="What led to Zidane's ban from football?")]

# With streaming
stream_response = client.chat_stream(model=model, messages=messages)

for chunk in stream_response:
   print(chunk.choices[0].delta.content, end="")
Mogelijk gemaakt door

In plaats van de methode chat kunnen we chat_stream gebruiken, die het antwoord op aanvraag en in stukjes teruggeeft:

Embeddings genereren

Embeddings zijn sleutelcomponenten van LLM-toepassingen. Een embedding is een vectorrepresentatie van tekst die de semantische betekenis vastlegt via de positie in een hoog-dimensionale vectorruimte. Als de afstand tussen twee embeddings klein is, betekent dit dat ze qua betekenis op elkaar lijken. Zo zal het woord apple in de embeddingruimte dichter bij orange liggen dan bij keyboard.

De Mistral API biedt state-of-the-art embeddingmodellen voor tekst. Laten we kort kijken hoe ze werken:

to_embed = ["Is Messi better than Zidane?", "How about Ronaldo?"]

embeddings_batch_response = client.embeddings(
   model="mistral-embed",
   input=to_embed,
)

type(embeddings_batch_response)
Mogelijk gemaakt door

mistralai.models.embeddings.EmbeddingResponse
Mogelijk gemaakt door

Eerst maken we een lijst zinnen om te embedden in to_embed. Vervolgens geven we ze door aan de methode embeddings samen met een embeddingmodelnaam — mistral-embed. Het resultaat is een EmbeddingResponse-object. Als we de lengte van het data-attribuut printen, zien we dat het twee vectoren bevat voor de twee ge-embedde zinnen:

len(embeddings_batch_response.data)Mogelijk gemaakt door

2Mogelijk gemaakt door

We kunnen ook de dimensies van de vectoren opvragen:

first_sentence = embeddings_batch_response.data[0]

len(first_sentence.embedding)  # Embedding dimension
Mogelijk gemaakt door

1024Mogelijk gemaakt door

We krijgen 1024 als resultaat, wat betekent dat Mistral elke tekst, ongeacht de lengte, embedt in een vector van 1024 dimensies.

Let op: embeddings met een hogere dimensie kunnen tekstaande informatie beter vastleggen en de prestaties verbeteren, maar vereisen meer rekenkracht voor hosting en inferentie.

Hoewel we in dit gedeelte niet het Mixtral 8X22B-model gebruikten, is het begrijpen van embeddings belangrijk wanneer we een eenvoudige RAG-pijplijn maken.

Parafrase-detectie met embeddings

Zoals we eerder stelden: als de afstand tussen twee embeddings klein is, dan liggen hun betekenissen dicht bij elkaar. Door dit idee uit te breiden, kunnen we een primitieve parafrasedetector bouwen, want als de afstand tussen twee zinnen klein is, is de kans groot dat het parafrases zijn.

Eerst maken we een functie die de embeddingvector voor een gegeven input teruggeeft:

def get_text_embedding(input, client):
   embeddings_batch_response = client.embeddings(
model="mistral-embed", input=input
)

   return embeddings_batch_response.data[0].embedding
Mogelijk gemaakt door

Vervolgens definiëren we de lijst met zinnen die we op parafrasering tegen elkaar willen controleren en halen we hun embeddings op:

sentences = [
   "What led to Zidane's ban from football?",
   "This is a totally different sentence.",
   "What caused Zidane to get banned from football?",
]

sentence_embeddings = [get_text_embedding(t, client) for t in sentences]
Mogelijk gemaakt door

Daarna maken we alle mogelijke paren van twee zinnen met itertools:

import itertools

sentence_embeddings_pairs = list(itertools.combinations(sentence_embeddings, 2))
sentence_pairs = list(itertools.combinations(sentences, 2))

print(sentence_pairs[0])
Mogelijk gemaakt door

("What led to Zidane's ban from football?", 'This is a totally different sentence.')Mogelijk gemaakt door

Vervolgens printen we de Euclidische afstand tussen elk paar zinsembeddings en tonen we de resultaten:

from sklearn.metrics.pairwise import euclidean_distances

for s, e in zip(sentence_pairs, sentence_embeddings_pairs):
   distance = euclidean_distances([e[0]], [e[1]])

   print(s, distance)
Mogelijk gemaakt door

("What led to Zidane's ban from football?", 'This is a totally different sentence.') [[0.84503319]]
("What led to Zidane's ban from football?", 'What caused Zidane to get banned from football?') [[0.28662641]]
('This is a totally different sentence.', 'What caused Zidane to get banned from football?') [[0.83794058]]
Mogelijk gemaakt door

De afstand tussen het tweede paar is klein, wat erop wijst dat het parafrases van elkaar kunnen zijn.

Mixtral 8X22B gebruiken in een RAG-pijplijn

LLM’s zijn getraind op bergen data, maar ze zijn niet altijd up-to-date en hebben geen toegang tot jouw private datasets. Ze fine-tunen is te duur als je alleen wilt dat het model vragen beantwoordt over andere bestaande datasets.

Daarom zijn Retrieval Augmented Generation (RAG)-pijplijnen zo populair geworden. Zonder dure fine-tuning kun je een LLM leren om aangepaste informatie te verwerken die geen onderdeel was van de training en er vragen over te beantwoorden.

In dit gedeelte bouwen we een basis-RAG-pijplijn die de informatie uit het nieuws van gisteren leert in dit 1440-artikel. Ik heb een deel van het nieuws opgeslagen in dit tekstbestand, dat je kunt downloaden van mijn GitHub of simpelweg kopiëren/plakken en opslaan als news_piece.txt.

Om de inhoud van het bestand te lezen, kunnen we de pathlib-bibliotheek gebruiken:

from pathlib import Path

file = Path("news_piece.txt")
text = file.read_text()
Mogelijk gemaakt door

Daarna splitsen we het document in chunks, omdat RAG-systemen beter presteren wanneer tekst in stukken is verdeeld. In dit voorbeeld splitsen we de tekst in stukken van elk 512 tekens:

chunk_size = 512
chunks = [text[i : i + chunk_size] for i in range(0, len(text), chunk_size)]

len(chunks)
4Mogelijk gemaakt door

Vervolgens halen we de embeddings op van elke chunk met de functie get_text_embedding uit het vorige gedeelte:

text_embeddings = np.array([get_text_embedding(chunk, client) for chunk in chunks])Mogelijk gemaakt door

Daarna is het gebruikelijk om embeddings op te slaan in een vectordatabank voor efficiënte verwerking en retrieval. Er zijn veel opties voor vectordatabanken. We gebruiken faiss — een open-sourcedatabase voor gelijkeniszoekopdrachten.

import faiss  # pip install faiss

d = text_embeddings.shape[1]
index = faiss.IndexFlatL2(d)

index.add(text_embeddings)
Mogelijk gemaakt door

index is een instantie van een Index-klasse, die de structuur van onze database definieert. d is de dimensie van de embeddingruimte.

Met de methode add voegen we de informatie uit ons document toe aan de vectordatabank, wat betekent dat we er vragen over kunnen stellen. Maar voordat we dat doen, moeten alle vragen die we hebben ook naar een embedding worden omgezet:

import numpy as np

questions = [
   "How much is Microsoft going to spend for its new data center?",
   "When did FTX collapse?",
]

question_embeddings = np.array([get_text_embedding(q, client) for q in questions])
Mogelijk gemaakt door

Vervolgens kunnen we de array question_embeddings doorgeven aan de methode search van het Index-object:

D, I = index.search(question_embeddings, k=4)  # distance, index

retrieved_chunk = [chunks[i] for i in I.tolist()[0]]
Mogelijk gemaakt door

De methode search geeft de vectoren terug die het meest waarschijnlijk het antwoord op onze vragen bevatten (via gelijkeniszoektocht):

len(retrieved_chunk)
4Mogelijk gemaakt door

print(retrieved_chunk[2])
Mogelijk gemaakt door

ay defrauded investors in full and provide the vast majority with interest. The failed cryptocurrency exchange platform filed its proposal late Tuesday to a federal bankruptcy court for approval.

Since FTX collapsed in 2022, CEO John Ray III (see previous write-up) has worked to track down more than $8B in missing assets to repay an estimated $11.2B owed to creditors. This week, Ray said the company has recovered between $14.5B and $16.3B, with much of the funds tied to government-seized FTX properties or
Mogelijk gemaakt door

Nu kunnen we deze tekst als context doorgeven aan het Mixtral 8X22B-model en onze vragen erover stellen. Laten we de prompt opbouwen:

prompt = f"""
Context information is below.
---------------------
{retrieved_chunk}
---------------------
Given the context information and not prior knowledge, answer the query.
Query: {questions}
Answer:
"""
Mogelijk gemaakt door

Nu kunnen we dit via de client aan het model doorgeven:

chat_response = client.chat(
   model=model,  # Mixtral 8x22B
   messages=[ChatMessage(role="user", content=prompt)],
)

print(chat_response.choices[0].message.content)
Mogelijk gemaakt door

Microsoft will spend $3 billion for its new data center in Racine, Wisconsin. FTX collapsed in 2022.
Mogelijk gemaakt door

De antwoorden kloppen!

We hebben een heel basale RAG-pijplijn gebouwd. In de praktijk zijn RAG-pijplijnen zeer krachtig — ze kunnen met allerlei inputs overweg (tekst, beeld, audio, video) en op enorme schaal werken, in tegenstelling tot onze versie die één tekstbestand verwerkte.

Wil je leren hoe je krachtige RAG-pijplijnen bouwt, bekijk dan onze How to Build LLM Applications with LangChain Tutorial.

Function calling

Een van de native mogelijkheden van het Mixtral 8X22B-model is function calling. In de context van LLM’s is function calling een techniek waarmee LLM’s prompts begrijpen en beantwoorden op een manier die het uitvoeren van specifieke functies triggert. Hier is een uiteenzetting van wat dat betekent:

• Standaard LLM-respons: LLM’s genereren tekst voor een prompt op basis van hun trainingsdata. Deze respons is meestal onvoorspelbaar en ongestructureerd.
• Function calling met Mixtral: Met function calling kan Mixtral 8X22B vooraf gedefinieerde, aangepaste functies aanroepen om de output te structureren op basis van het prompttype. Mixtral geeft doorgaans output terug in gestructureerd JSON-formaat, dat je vooraf kunt definiëren. Dit maakt de reacties veel voorspelbaarder en gestructureerder.

Uitleggen hoe function calling werkt, valt buiten de scope van dit artikel. Je kunt echter deze pagina van de Mistral AI-documentatie bekijken om het in actie te zien.

Conclusie

In dit artikel hebben we het Mixtral 8X22B-model van Mistral AI, uitgebracht in april 2024, besproken. Door de architectonische voordelen is het nu een van de toonaangevende open-source-LLM’s, dat populaire modellen zoals Llama 2 en Command R+ op veel benchmarks verslaat.

Naast de architectuurdetails hebben we geleerd hoe je het gebruikt in een paar praktische scenario’s, zoals tekstgeneratie, parafrasedetectie en het maken van een RAG-pijplijn. Wil je het volledige potentieel van het Mixtral 8X22B-model benutten, bekijk dan deze gerelateerde bronnen:

• Gids voor werken met het Mistral Large-model
• Cursus Large Language Models (LLM’s) Concepts
• Tutorial: Hoe train je een LLM met Pytorch
• Tutorial over het fine-tunen van LLM’s