QwQ 32B lokaal instellen en draaien met Ollama

QwQ-32B is het redeneermodel van Qwen, ontworpen om uit te blinken in complexe probleemoplossing en redeneertaken. Ondanks dat het slechts 32 miljard parameters heeft, behaalt het model prestaties die vergelijkbaar zijn met de veel grotere DeepSeek-R1, met 671 miljard parameters.

In deze tutorial laat ik je stap voor stap zien hoe je QwQ-32B lokaal installeert en draait met Ollama, een tool die lokale LLM-inferentie vereenvoudigt. Deze gids bevat: 

• Uitvoeren via terminal of IDE: Bevat beknopte codefragmenten om QwQ-32B via de terminal of een IDE naar keuze te draaien.
• Praktische demo: We bouwen een demo-project dat de gestructureerde denkwijze van QwQ-32B benut.

Waarom QwQ-32B lokaal draaien?

Ondanks het formaat kan QwQ-32B worden gekwantiseerd om efficiënt te draaien op consumentenhardware. Door QwQ-32B lokaal te draaien heb je volledige controle over de uitvoering van het model, zonder afhankelijk te zijn van externe servers. Enkele voordelen van lokaal draaien:

• Privacy & veiligheid: Er verlaat geen data jouw systeem.
• Ononderbroken toegang: Geen last van limieten, downtime of storingen.
• Prestaties: Snellere reacties met lokale inferentie, zonder API-latentie.
• Aanpasbaarheid: Pas parameters aan, verfijn prompts en integreer het model in lokale applicaties.
• Kostenefficiëntie: Geen API-kosten door het model lokaal te draaien.
• Offline beschikbaarheid: Werk zonder internetverbinding zodra het model is gedownload.

QwQ-32B lokaal instellen met Ollama

Ollama maakt het eenvoudig om LLM's lokaal te draaien door modeldownloads, kwantisatie en uitvoering te beheren.

Stap 1: Installeer Ollama

Download en installeer Ollama via de officiële website. 

Zodra de download is voltooid, installeer je de Ollama-app zoals je met elke andere applicatie zou doen. 

Stap 2: QwQ-32B downloaden en draaien

Laten we de setup testen en ons model downloaden. Start de terminal en voer de volgende opdracht uit om het QwQ-32B-model te downloaden en te draaien:

ollama run qwq:32bMogelijk gemaakt door

QwQ-32B is een groot model. Als jouw systeem beperkte resources heeft, kun je kiezen voor kleinere, gekwantiseerde versies. Hieronder gebruiken we bijvoorbeeld de Q4_K_M-versie, een model van 19,85 GB dat prestaties en omvang in balans houdt:

ollama run qwq:Q4_K_MMogelijk gemaakt door

Bron: Hugging Face

Je vindt meer gekwantiseerde modellen hier.

Stap 3: QwQ-32B op de achtergrond draaien

Om QwQ-32B continu te draaien en via een API aan te bieden, start je de Ollama-server:

ollama serveMogelijk gemaakt door

Hiermee komt het model beschikbaar voor applicaties, die in de volgende sectie aan bod komen.

QwQ-32B lokaal gebruiken

Nu QwQ-32B is ingesteld, kijken we hoe je ermee kunt werken.

Stap 1: Inferentie via de CLI

Zodra het model is gedownload, kun je rechtstreeks in de terminal met QwQ-32B communiceren:

ollama run qwq
How many r's are in the word "strawberry”?Mogelijk gemaakt door

De modeluitvoer bestaat meestal uit de denkstappen (ingesloten tussen <think> </think>-tags), gevolgd door het definitieve antwoord.

Stap 2: QwQ-32B benaderen via de API

Om QwQ-32B in applicaties te integreren, kun je de Ollama-API met curl gebruiken. Voer de volgende curl-opdracht uit in je terminal.

curl -X POST http://localhost:11434/api/chat -H "Content-Type: application/json" -d '{
  "model": "qwq",
  "messages": [{"role": "user", "content": "Explain Newton second law of motion"}], 
  "stream": false
}'Mogelijk gemaakt door

curl is een commandoregeltool die standaard op Linux aanwezig is en ook werkt op macOS. Je kunt er HTTP-verzoeken rechtstreeks vanuit de terminal mee doen, wat het een uitstekende tool maakt om met API's te werken.

Let op: Zorg voor correcte plaatsing van aanhalingstekens en de juiste localhost-poort om dquote-fouten te voorkomen.

Stap 3: QwQ-32B draaien met Python

We kunnen Ollama in elke integrated development environment (IDE) gebruiken. Je kunt het Python-pakket van Ollama installeren met de volgende code: 

pip install ollamaMogelijk gemaakt door

Zodra Ollama is geïnstalleerd, kun je met het volgende script met het model communiceren:

import ollama
response = ollama.chat(
    model="qwq",
    messages=[
        {"role": "user", "content": "Explain Newton's second law of motion"},
    ],
)
print(response["message"]["content"])Mogelijk gemaakt door

De functie ollama.chat() krijgt de modelnaam en een gebruikersprompt mee en verwerkt dit als een conversatie. Het script extraheert vervolgens de reactie van het model en print die.

Lokaal een logisch-redeneerapp draaien met QwQ-32B

We kunnen een eenvoudige assistent voor logisch redeneren maken met QwQ-32B en Gradio. Deze accepteert door de gebruiker ingevoerde vragen en genereert gestructureerde, logische antwoorden. De app gebruikt de stapsgewijze denkaanpak van QwQ-32B om duidelijke, goed onderbouwde antwoorden te geven, wat handig is voor probleemoplossing, tutoring en AI-ondersteunde besluitvorming.

Stap 1: Vereisten

Voordat we beginnen met de implementatie, controleren we of de volgende tools en libraries zijn geïnstalleerd:

• Python 3.8+
• Gradio: Voor het bouwen van een gebruiksvriendelijke webinterface.
• Ollama: Een library om lokaal toegang te krijgen tot modellen

Voer de volgende opdrachten uit om de benodigde dependencies te installeren:

pip install gradio ollamaMogelijk gemaakt door

Zodra de bovenstaande dependencies zijn geïnstalleerd, voer je deze import-opdrachten uit:

import gradio as gr
import ollama
import reMogelijk gemaakt door

Stap 2: QwQ 32B bevragen met Ollama

Nu de dependencies klaarstaan, bouwen we een queryfunctie die onze vraag naar het model stuurt en een gestructureerde reactie teruggeeft.

def query_qwq(question):
    response = ollama.chat(
        model="qwq",
        messages=[{"role": "user", "content": question}]
    )
    full_response = response["message"]["content"]
    # Extract the <think> part and the final answer
    think_match = re.search(r"<think>(.*?)</think>", full_response, re.DOTALL)
    think_text = think_match.group(1).strip() if think_match else "Thinking process not explicitly provided."
    final_response = re.sub(r"<think>.*?</think>", "", full_response, flags=re.DOTALL).strip()
    return think_text, final_responseMogelijk gemaakt door

De functie query_qwq() communiceert via Ollama met het Qwen QwQ-32B-model. Ze stuurt een door de gebruiker aangeleverde vraag en ontvangt een gestructureerd antwoord. Er worden twee onderdelen uitgehaald:

1. Denkproces: De redeneerstappen van het model (geëxtraheerd uit <think>...</think>-tags).
2. Definitieve antwoord:  Dit veld bevat het gestructureerde eindantwoord na de redenering (exclusief de <think>-sectie).

Zo scheiden we het redeneertraject en het definitieve antwoord, waardoor duidelijk is hoe het model tot zijn conclusie komt.

Stap 3: De Gradio-interface bouwen

Nu de kernfunctie klaar is, bouwen we de Gradio-UI.

interface = gr.Interface(
    fn=query_qwq,
    inputs=gr.Textbox(label="Ask a logical reasoning question"),
    outputs=[gr.Textbox(label="Thinking Process"), gr.Textbox(label="Final Response")],
    title="QwQ-32B Powered: Logical Reasoning Assistant",
    description="Ask a logical reasoning question and the assistant will provide an explanation."
)
interface.launch(debug = True)Mogelijk gemaakt door

Deze Gradio-interface zet een logisch-redeneerassistent op die een door de gebruiker ingevoerde vraag verwerkt via de functie gr.Textbox() en vervolgens afhandelt met query_qwq(). Tot slot start interface.launch() de Gradio-app met debugging ingeschakeld, zodat je realtime fouten en logs kunt volgen voor troubleshooting.

Conclusie

QwQ-32B lokaal draaien met Ollama maakt privé, snelle en kostenefficiënte modelinferentie mogelijk. Met deze tutorial kun je de geavanceerde redeneercapaciteiten in realtime verkennen. Dit model is inzetbaar voor AI-ondersteunde tutoring, logische probleemoplossing en meer.