Waarom ik Gemma 3n niet lokaal kon trainen (en waarom ik in plaats daarvan Vertex AI gebruik)
Ik werk aan een uitspraakcoach-app waarvoor een multimodale AI nodig is die zowel tekst als audio kan begrijpen. De app gebruikt momenteel de native audio-modellen van Google Gemini, maar ik wilde een specifiek model finetunen voor uitspraakcoaching. De Gemma 3n van Google leek perfect met zijn native audio-ondersteuning via de Universal Speech Model-encoder. Ik heb een MacBook Pro M4 Pro met 48 GB RAM. Dat is vast genoeg om een model met 5 miljard parameters lokaal te trainen, toch?
Spoiler: dat is het niet. Hier is wat ik heb geleerd van het falen.
Waarom ik lokale training probeerde
De aantrekkingskracht was duidelijk:
- Geen kosten: Cloud GPU-training kost $2-5 per poging op services zoals RunPod of Vast.ai
- Privacy: Mijn trainingsgegevens blijven lokaal
- Snelle iteratie: Geen uploads van datasets of configuratie van cloudomgevingen
- Praktische leerervaring: Ik wilde experimenteren met PyTorch-trainingsscripts, geheugenoptimalisatietechnieken begrijpen en leren door vallen en opstaan. Lokaal kan ik code wijzigen en binnen enkele seconden opnieuw proberen, vergeleken met implementeren in de cloud en wachten tot scripts draaien
Ik had 988 trainingsvoorbeelden die fouten in de uitspraak, analyse van spreeklevering en coachingsgesprekken dekten. Het leek een perfecte kandidaat voor nachtelijke lokale training.
Wat betekent het trainen van een model eigenlijk?
Korte verduidelijking: als mensen het over "trainen" hebben, kunnen ze twee zeer verschillende dingen bedoelen.
Trainen vanaf nul is wat Google en OpenAI doen. Je begint met willekeurige getallen en leert een neuraal netwerk alles vanaf het begin. Dit vereist miljarden tekstvoorbeelden, honderden GPU's en maanden rekentijd. Het is duur en traag.
Finetunen is het nemen van een bestaand getraind model en het leren van je specifieke taak. Het zware werk is al gedaan. Het model kent taal en redenering. Je laat het alleen je specifieke formaat en domein zien. Net als iemand inhuren die al kan coderen en diegene je codebase aanleren, versus iemand vanaf nul leren coderen.
Voor mijn gebruikssituatie wil ik finetunen. Het model begrijpt Engels en uitspraak al. Ik hoef het alleen maar feedback in mijn formaat te laten geven.
Hoe te finetunen met Hugging Face
Hugging Face maakt dit hele proces veel eenvoudiger dan het zou moeten zijn. Ze hosten duizenden vooraf getrainde modellen en bieden Python-bibliotheken om ze te finetunen. Je hebt hier geen PhD voor nodig.
Hier is de basisworkflow:
from transformers import AutoProcessor, AutoModelForImageTextToText
# Download het model en de processor
processor = AutoProcessor.from_pretrained("google/gemma-3n-E2B-it")
model = AutoModelForImageTextToText.from_pretrained("google/gemma-3n-E2B-it")
Twee regels code. Dat downloadt een AI-model met 5,4 miljard parameters naar je laptop. De processor converteert je gegevens naar het juiste formaat, en model is het neurale netwerk zelf.
Vervolgens gebruik je de Trainer-klasse om de training daadwerkelijk uit te voeren:
from transformers import Trainer, TrainingArguments
training_args = TrainingArguments(
output_dir="outputs/gemma3n",
num_train_epochs=3,
per_device_train_batch_size=1,
learning_rate=3e-5,
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=my_dataset,
)
trainer.train() # Start de training!
Dit is geweldig omdat je alle laag-niveau zaken overslaat, zoals het schrijven van gradiëntdaling-loops en het beheren van checkpoints. Het nadeel? Je weet niet echt wat er onder de motorkap gebeurt, vooral hoeveel geheugen alles verbruikt. Wat precies het probleem was waar ik tegenaan liep.
Het geheugenprobleem
Het trainen van een groot taalmodel vereist dat verschillende zaken tegelijkertijd in het geheugen passen:
- Modelgewichten: Voor Gemma 3n E2B (5,4 miljard parameters) is dat ongeveer 11 GB in float16
- Gradiënten: Nog eens ongeveer 11 GB (dezelfde grootte als gewichten)
- Optimizer-statussen: Adam houdt 2 statussen per parameter bij, wat ongeveer 22 GB toevoegt
- Activations: Tussentijdse berekeningsresultaten
- Batchgegevens: De trainingsvoorbeelden die worden verwerkt
Totaal: 50-60 GB voor het kleinere E2B-model, 70-80 GB voor E4B. Mijn 48 GB RAM ging het niet redden.
Wat ik probeerde
Poging 1: Volledig finetunen met E4B
Geheugenprobleem tijdens de initialisatie van de optimizer. Het model werd geladen (16 GB), maar de optimizer kon zijn status niet toewijzen.
Poging 2: Kleinere batchgroottes
Het verlagen van batch_size van 2 naar 1 stelde de OOM-fout alleen maar uit tot de backward pass.
Poging 3: LoRA met E4B
LoRA (Low-Rank Adaptation) traint alleen kleine adapterlagen in plaats van het volledige model, waardoor het aantal trainbare parameters van 7,8 miljard naar 40 miljoen (0,5%) wordt verminderd. Maar het bevroren basismodel moet nog steeds in het geheugen passen: 59 GB alleen al voor E4B.
Poging 4: LoRA met E2B
Dit werkte bijna. Het kleinere E2B-model met LoRA gebruikte 40-45 GB, waardoor 3-8 GB overbleef. De training begon en liep een paar uur voordat het geheugenproblemen kreeg bij specifieke batches met langere sequenties.
Waarom het uiteindelijk mislukte
Zelfs met agressieve optimalisaties (LoRA, batch_size=1, geen gradient checkpointing) was 48 GB niet genoeg voor consistente training. Het geheugengebruik varieerde per voorbeeld:
- Korte voorbeelden: 38-42 GB (goed)
- Lange voorbeelden: 46-50 GB (crashes)
Ik had het waarschijnlijk werkend kunnen krijgen door langere voorbeelden te filteren of max_length te verlagen naar 1024 tokens, maar op dat moment compromitteer ik de capaciteiten van het model om aan de hardwarebeperkingen te voldoen.
Overstappen naar Vertex AI
Na drie dagen van mislukte pogingen, stap ik over op de Vertex AI van Google Cloud voor training:
- A100 40GB GPU: Meer dan genoeg geheugen voor het E4B-model met LoRA
- Beheerde infrastructuur: Geen geheugendebugging, geen crashes
- Kosten: ~$3-5 voor een volledige trainingsrun (3 epochs)
- Tijd: 2-3 uur versus mijn poging van 6-9 uur lokaal
Ik zal een aparte blogpost schrijven over het Vertex AI-trainingsproces, inclusief:
- Het instellen van aangepaste trainingsjobs met Gemma 3n
- Het uploaden van datasets naar Cloud Storage
- Het monitoren van de training met TensorBoard
- Het implementeren van het getrainde model op Vertex AI-endpoints
Wanneer kun je lokaal trainen?
Lokale training op Apple Silicon is haalbaar als:
- Je model kleiner is: Modellen met 1-3 miljard parameters met LoRA passen comfortabel in 48 GB
- Je meer RAM hebt: De M4 Max met 128 GB zou Gemma 3n E2B gemakkelijk aankunnen
- Je kwantisering gebruikt: 4-bit of 8-bit kwantisering vermindert het geheugen verder, maar voegt complexiteit toe
Belangrijkste lessen
- Geheugen is de bottleneck: 48 GB uniform geheugen klinkt veel totdat je probeert modellen met 5 miljard+ parameters te trainen. Alleen al de optimizer-statussen kunnen je geheugenvereisten verdubbelen of verdrievoudigen
- LoRA helpt, maar is geen wondermiddel: Het vermindert trainbare parameters met 99%, maar de bevroren basismodelgewichten moeten nog steeds in het geheugen passen tijdens de forward- en backward passes
- Cloudtraining is kosteneffectief: $3-5 voor een trainingsrun is redelijk in vergelijking met dagenlang debuggen van OOM-fouten en mislukte experimenten
- Ken je hardwarelimieten: Het uniforme geheugen van Apple Silicon is uitstekend voor inferentie en training van kleinere modellen (1-3 miljard parameters), maar het betrouwbaar trainen van modellen met 5 miljard+ vereist speciale GPU VRAM