Hardware, Kvantizacija i Optimizacija

# Provjera RAM-a (ukupni i dostupni)
Get-WmiObject Win32_PhysicalMemory | Measure-Object Capacity -Sum |
  Select-Object @{N="Total RAM (GB)"; E={[Math]::Round($_.Sum / 1GB, 1)}}

# Provjera GPU-a i VRAM-a
Get-WmiObject Win32_VideoController |
  Select-Object Name,
    @{N="VRAM (GB)"; E={[Math]::Round($_.AdapterRAM / 1GB, 1)}},
    DriverVersion

# Provjera CPU-a
Get-WmiObject Win32_Processor |
  Select-Object Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed

# Provjera slobodnog prostora na disku
Get-PSDrive C | Select-Object @{N="Slobodno (GB)"; E={[Math]::Round($_.Free / 1GB, 1)}}

# Provjera Ollama okoline i GPU detekcije
ollama --version

# Provjera detektovanih GPU-ova (Ollama automatski prikazuje info o GPU-u)
# Pokrenite Ollamu u posebnom terminalu ako nije pokrenuta:
# ollama serve

# Ispis detalja o modelu (uključuje kvantizacijski nivo)
ollama show llama3.2

# Pokretanje modela sa verbose outputom koji pokazuje GPU korištenje
# Otvorite novi PowerShell terminal i pokrenite:
OLLAMA_DEBUG=1 ollama run llama3.2

"""
benchmark.py
Mjerenje performansi lokalnih Ollama modela:
- Tokens per second (tok/s) - ključna metrika brzine
- Time to first token (TTFT) - latency do prvog odgovora
- Ukupno generisanje za standardni test prompt
"""

import ollama
import time
import json

# ================================================================
# KONFIGURACIJA BENCHMARKA
# ================================================================
# Lista modela za testiranje (morat ćete imati ih preuzete!)
MODELI_ZA_TEST = ['llama3.2']  # Dodajte više modela po želji

# Standardni test prompt (isti za sve modele radi poređenja)
TEST_PROMPT = """Explain in exactly 200 words how a TCP/IP handshake works.
Include the three phases: SYN, SYN-ACK, ACK.
Describe what happens at each phase and why it's important."""

# Broj ponavljanja za svaki model (za pouzdanije rezultate)
BROJ_PONAVLJANJA = 2

# ================================================================
# BENCHMARK FUNKCIJA
# ================================================================
def benchmark_model(model_ime: str, prompt: str) -> dict:
    """
    Mjeri performanse jednog modela.
    Vraća dict sa svim metrikama.
    """
    print(f"\n🔬 Testiram model: {model_ime}")
    print(f"📝 Prompt ({len(prompt)} znakova)...")

    rezultati_ponavljanja = []

    for ponavljanje in range(BROJ_PONAVLJANJA):
        print(f"   Ponavljanje {ponavljanje + 1}/{BROJ_PONAVLJANJA}...", end='', flush=True)

        # Bilježimo vrijeme početka
        start_ukupno = time.perf_counter()

        # Varijabla za vrijeme prvog tokena
        start_prvog_tokena = time.perf_counter()
        prvi_token_zabiljezen = False
        ttft = 0.0

        # Capture tekst odgovora za analizu
        svi_tokeni = []

        try:
            # Streaming mode radi da mjerimo TTFT (Time to First Token)
            stream = ollama.chat(
                model=model_ime,
                messages=[{'role': 'user', 'content': prompt}],
                stream=True,
                options={
                    'temperature': 0,    # 0 = deterministički = reproducibilni rezultati
                    'num_predict': 250,  # Ograničavamo output za konzistentno mjerenje
                }
            )

            for chunk in stream:
                # Bilježimo kada je stigao prvi token
                if not prvi_token_zabiljezen:
                    ttft = time.perf_counter() - start_prvog_tokena
                    prvi_token_zabiljezen = True

                # Skupljamo generirani tekst
                token_tekst = chunk['message']['content']
                svi_tokeni.append(token_tekst)

            # Kraj generisanja
            end_ukupno = time.perf_counter()

            ukupno_trajanje = end_ukupno - start_ukupno
            ukupni_tekst = ''.join(svi_tokeni)
            # Aproksimacija: 1 token ≈ 4 znaka (gruba procjena za engleski)
            aproks_tokeni = len(ukupni_tekst) / 4
            tok_per_sekundi = aproks_tokeni / ukupno_trajanje

            rezultat = {
                'ttft_ms': ttft * 1000,               # Milisekunde
                'ukupno_trajanje_s': ukupno_trajanje,
                'aproks_tokeni': int(aproks_tokeni),
                'tok_per_sekundi': tok_per_sekundi,
                'znakova_generisano': len(ukupni_tekst),
            }

            rezultati_ponavljanja.append(rezultat)
            print(f" {tok_per_sekundi:.1f} tok/s ✅")

        except Exception as e:
            print(f" GREŠKA: {e} ❌")
            continue

    if not rezultati_ponavljanja:
        return None

    # Prosječne vrijednosti svih ponavljanja
    prosjek = {
        'model': model_ime,
        'ttft_ms': sum(r['ttft_ms'] for r in rezultati_ponavljanja) / len(rezultati_ponavljanja),
        'ukupno_trajanje_s': sum(r['ukupno_trajanje_s'] for r in rezultati_ponavljanja) / len(rezultati_ponavljanja),
        'aproks_tokeni': int(sum(r['aproks_tokeni'] for r in rezultati_ponavljanja) / len(rezultati_ponavljanja)),
        'tok_per_sekundi': sum(r['tok_per_sekundi'] for r in rezultati_ponavljanja) / len(rezultati_ponavljanja),
        'znakova_generisano': int(sum(r['znakova_generisano'] for r in rezultati_ponavljanja) / len(rezultati_ponavljanja)),
    }
    return prosjek

# ================================================================
# POKRETANJE BENCHMARKA
# ================================================================
if __name__ == "__main__":
    print("="*65)
    print("⚡ OLLAMA PERFORMANCE BENCHMARK")
    print("="*65)
    print(f"📋 Modeli za test: {', '.join(MODELI_ZA_TEST)}")
    print(f"🔁 Ponavljanja: {BROJ_PONAVLJANJA}")
    print(f"📝 Prompt: {TEST_PROMPT[:80]}...")

    svi_rezultati = []

    # Testiranje svakog modela
    for model in MODELI_ZA_TEST:
        rezultat = benchmark_model(model, TEST_PROMPT)
        if rezultat:
            svi_rezultati.append(rezultat)

    # Ispis rezultata
    print("\n" + "="*65)
    print("📊 REZULTATI BENCHMARKA")
    print("="*65)

    for r in svi_rezultati:
        print(f"\n🤖 Model: {r['model']}")
        print(f"   ⚡ Brzina: {r['tok_per_sekundi']:.1f} tok/s")
        print(f"   ⏱️  Trajanje: {r['ukupno_trajanje_s']:.2f} s")
        print(f"   🚀 TTFT: {r['ttft_ms']:.0f} ms (do 1. tokena)")
        print(f"   📝 ~{r['aproks_tokeni']} tokena generisano")
        print(f"   📄 {r['znakova_generisano']} znakova")

    print("\n" + "="*65)
    print("💡 INTERPRETACIJA REZULTATA:")
    print("   • > 30 tok/s = Odlično (GPU inferenza)")
    print("   • 10-30 tok/s = Dobro (GPU ili brz CPU)")
    print("   • 3-10 tok/s = Prihvatljivo (CPU inferenza)")
    print("   • < 3 tok/s = Sporo (slab CPU ili prevelik model)")
    print("   • TTFT < 500 ms = Dobra latency")
    print("   • TTFT > 2000 ms = Visoka latency (model se učitava)")
    print("="*65)

cd C:\Users\$env:USERNAME\Desktop\AI_Kurs
.\venv\Scripts\Activate.ps1
python benchmark.py

# Možete preuzeti specifičnu kvantizacijsku verziju modela:
# Format: ollama pull [ime]:[tag]

# Q4_K_M (default - ~4 GB fajl, preporučeno)
ollama pull llama3.2

# Isti model u punoj F16 preciznosti (~6 GB, za poređenje kvaliteta)
ollama pull llama3.2:latest

# Provjera svih verzija koje imate
ollama list

# Pokrenite benchmark za oba i usporedite tok/s i kvalitet odgovora!
# Zatim modificirajte MODELI_ZA_TEST listu u benchmark.py