Gemma 3 lokaal installeren en uitvoeren met Ollama

Google DeepMind heeft zojuist Gemma 3 uitgebracht, de volgende iteratie van hun open-sourcemodellen. Gemma 3 is ontworpen om rechtstreeks te draaien op apparaten met weinig resources, zoals telefoons en laptops. Deze modellen zijn geoptimaliseerd voor snelle prestaties op één GPU of TPU en zijn er in verschillende formaten, passend bij uiteenlopende hardwarebehoeften.

In deze tutorial leg ik stap voor stap uit hoe je Gemma 3 lokaal instelt en uitvoert met Ollama. Daarna laat ik zien hoe je met Gemma 3 en Python een bestandshulp kunt bouwen.

Waarom Gemma 3 lokaal draaien?

Een groot taalmodel (LLM) zoals Gemma 3 lokaal draaien heeft meerdere belangrijke voordelen:

• Privacy: Data blijft op je apparaat, waardoor gevoelige informatie beschermd blijft.
• Lage latentie: Geen internetverkeer nodig, dus snellere reacties.
• Aanpasbaarheid: Modellen kunnen worden afgestemd op specifieke behoeften en experimenten.
• Kostenefficiënt: Minder cloudkosten door je bestaande hardware te gebruiken.
• Offline toegang: Applicaties blijven werken zonder internetverbinding.
• Controle: Betere beveiliging en controle over je computeroomgeving.

Gemma 3 lokaal instellen met Ollama

Ollama installeren

Ollama is een platform voor Windows, Mac en Linux waarmee je AI-modellen kunt draaien en distribueren, zodat ontwikkelaars ze eenvoudiger in hun projecten kunnen integreren. We gebruiken het om Gemma 3 lokaal te downloaden en te draaien.

De eerste stap is downloaden en installeren via de officiële website van Ollama.

Zorg er tijdens de installatie voor dat je de command line installeert:

Na de installatie kunnen we met de terminalopdracht ollama controleren of alles goed is gegaan. Dit zou je ongeveer moeten zien:

Gemma 3 downloaden

Om een model met Ollama te downloaden, gebruik je het commando pull:

ollama pull <model_name>:<model_version>

De lijst met beschikbare modellen vind je in de bibliotheek van Ollama.

Gemma 3 heeft specifiek vier modellen beschikbaar: 1b, 4b, 12b en 27b, waarbij b staat voor miljard, oftewel het aantal parameters in het model.

Om bijvoorbeeld gemma3 met 1b parameters te downloaden, gebruiken we het commando:

ollama pull gemma3:1b

Als we de modelversie niet specificeren, wordt standaard het 4b-model gedownload:

ollama pull gemma3

Lokale modellen weergeven

We kunnen de lokaal aanwezige modellen tonen met het volgende commando:

ollama list

In mijn geval laat de output zien dat ik twee modellen heb: 

NAME             ID              SIZE      MODIFIED       
gemma3:1b        2d27a774bc62    815 MB    38 seconds ago    
gemma3:latest    c0494fe00251    3.3 GB    22 minutes ago 

Chatten in de terminal

We kunnen met Ollama met een model chatten via het commando run:

ollama run gemma3

Let op: als we het commando run gebruiken met een model dat we niet hebben gedownload, wordt het automatisch gedownload via pull.

Gemma 3 op de achtergrond draaien

Om Gemma 3 met Python te gebruiken, moeten we het op de achtergrond draaien. Dat kan met het commando serve:

ollama serve

Krijg je bij het uitvoeren van het commando de volgende foutmelding, dan betekent dit waarschijnlijk dat Ollama al draait:

Error: listen tcp 127.0.0.1:11434: bind: address already in use

Deze fout kan optreden wanneer Ollama op de achtergrond actief blijft.

Gemma 3 lokaal gebruiken met Python

De Python-omgeving instellen

Ollama biedt een Python-pakket om eenvoudig te verbinden met modellen die op je computer draaien.

We gebruiken Anaconda om een Python-omgeving op te zetten en de benodigde dependencies toe te voegen. Zo voorkom je mogelijke conflicten met andere Python-pakketten die je al hebt.

Zodra Anaconda is geïnstalleerd, kunnen we de omgeving opzetten met het commando:

conda create -n gemma3-demo -y python=3.9

Dit commando maakt een omgeving aan met de naam gemma3-demo met Python-versie 3.9. De optie -y zorgt ervoor dat alle vragen tijdens de installatie automatisch met ja worden beantwoord.

Vervolgens activeren we de omgeving met:

conda activate gemma3-demo

Tot slot installeren we het pakket ollama met het commando:

pip install ollama

Een bericht naar Gemma 3 sturen met Python

Zo stuur je een bericht naar Gemma 3 met Python:

from ollama import chat
response = chat(
    model="gemma3",
    messages=[
        {
            "role": "user",
            "content": "Why is the sky blue?",
        },
    ],
)
print(response.message.content)

Afhankelijk van je hardware kan het even duren voordat het model antwoordt. Wees dus geduldig bij het uitvoeren van het script.

We zagen eerder dat gemma3 standaard verwijst naar gemma3:4b. Als we dus model="gemma3" opgeven, wordt dat model gebruikt.

Wil je een ander model gebruiken—bijvoorbeeld het 1B-model—dan geef je in plaats daarvan het argument model=”gemma3:1b” door (mits we het eerder hebben binnengehaald met het commando ollama pull gemma3:1b). Met het commando ollama list kun je de beschikbare modellen weergeven.

Als we het antwoord woord voor woord willen streamen, kunnen we stream=True gebruiken en de response in stukjes printen:

from ollama import chat
stream = chat(
    model="gemma3",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
    stream=True,
)
for chunk in stream:
    print(chunk["message"]["content"], end="", flush=True)

Dit zorgt voor een betere gebruikerservaring, omdat je niet hoeft te wachten tot het volledige antwoord is gegenereerd.

Wil je meer weten over het pakket ollama? Bekijk dan de documentatie.

Een bestandshulp bouwen met Gemma 3

In dit onderdeel leren we een Python-script bouwen waarmee je rechtstreeks vanuit de terminal vragen kunt stellen over de inhoud van een tekstbestand. Dit script is handig voor taken zoals het opsporen van bugs in een codebestand of het opvragen van informatie uit om het even welk document.

Scriptoverzicht

Ons doel is een commandlinetool in Python te maken die een tekstbestand leest en Gemma 3 gebruikt om vragen over de inhoud te beantwoorden. Zo pak je dat stap voor stap aan:

De scriptstructuur opzetten

Eerst zetten we het Python-script op met de benodigde imports en basisstructuur:

import sys
from ollama import chat
def ask_questions_from_file(file_path):
    # Read the content of the text file
    with open(file_path, "r") as file:
        content = file.read()
    # Loop to keep asking questions
    while True:
        question = input("> ")
        print()
        if question.lower() == "exit":
            break
        # Use Gemma 3 to get answers
        stream = chat(
            model="gemma3",
            messages=[
                {"role": "user", "content": content},
                {"role": "user", "content": question},
            ],
            stream=True,
        )
        for chunk in stream:
            print(chunk["message"]["content"], end="", flush=True)

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python ask_file.py <path_to_text_file>")
    else:
        file_path = sys.argv[1]
        ask_questions_from_file(file_path)

De kernfunctionaliteit zit in de functie ask_questions_from_file(). Deze functie neemt een bestandspad als argument en begint met het openen en lezen van de inhoud van het opgegeven tekstbestand. Die inhoud gebruiken we als achtergrondinformatie om vragen te beantwoorden.

Zodra de bestandsinhoud is geladen, gaat het script een lus in waarin we continu worden gevraagd om vragen in te voeren. Wanneer we een vraag intypen, stuurt het script de inhoud van het bestand samen met onze vraag naar het Gemma 3-model, dat deze informatie verwerkt om een antwoord te genereren.

De interactie met het model gebeurt via een streamingmechanisme, waardoor antwoorden in realtime worden weergegeven terwijl ze worden gegenereerd. Als we exit typen, wordt de lus beëindigd en stopt het script.

Aan het einde van het script staat een controle om zeker te weten dat het script correct wordt uitgevoerd met één commandline-argument, namelijk het pad naar het tekstbestand. Als het argument niet wordt meegegeven, verschijnt een gebruiksbericht dat aangeeft hoe je het script correct start. Met deze opzet kun je het script effectief vanaf de command line aansturen.

Het script uitvoeren

Sla de bovenstaande code op in een bestand, bijvoorbeeld ask.py. Test het script met het commando:

python ask.py ask.py

Hiermee laat je het script vragen stellen over zichzelf (vandaar dat ask.py twee keer in het commando staat). Dit is een voorbeeld waarbij we vragen om uit te leggen hoe het script werkt:

Conclusie

We hebben Gemma 3 succesvol ingesteld en geleerd hoe je het lokaal draait met Ollama en Python. Deze aanpak waarborgt de privacy van onze data, biedt lage latentie, geeft opties voor aanpassing en kan kosten besparen. De stappen die we hebben behandeld gelden niet alleen voor Gemma 3—ze zijn ook toepasbaar op andere modellen die via Ollama beschikbaar zijn.

Als we de functionaliteit van ons script willen uitbreiden, kunnen we het bijvoorbeeld geschikt maken voor PDF’s. De beste manier is dan de Mistral OCR API te gebruiken. We kunnen PDF-bestanden omzetten naar tekst, zodat ons script ook vragen over PDF’s kan beantwoorden—nog veelzijdiger en krachtiger dus.

Met deze tools zijn we klaar om grote modellen te verkennen en ermee te werken, gewoon vanaf onze eigen apparaten.