Lokalny model czy API: ile naprawdę kosztuje AI z własnej karty

👁 116 przeczytań

Lokalny model czy API to pytanie o pieniądze, prywatność i jakość naraz. Policzyłem to 26 września 2026 roku na prawdziwych pomiarach: pobór prądu karty RTX 4090 przy 13 zadaniach po polsku kontra rachunki z OpenRouter za te same zadania w chmurze. Prąd za lokalny model jest tańszy niż najtańsze API, ale różnica to grosze. Zakup karty zwraca się dopiero po setkach godzin ciągłej pracy.

Jak liczyłem

Podczas testu siedmiu modeli lokalnych skrypt co pół sekundy odczytywał pobór mocy karty z narzędzia nvidia-smi. Czas generowania pomnożony przez średnią moc daje energię. Cenę prądu przyjąłem 1,05 zł za kWh: taryfa G11 z opłatą dystrybucyjną zmienną, średnio u pięciu sprzedawców z urzędu we wrześniu 2026 (od 0,96 do 1,10 zł). Liczę tylko kartę graficzną. Reszta komputera to zwykle 80-150 W więcej, więc podaję też wariant „+100 W”. Koszty chmury to faktyczne rachunki z OpenRouter za te same 13 poleceń, z Laboratorium Promptowego.

Tekst: prąd kontra API

* Wynik z tej samej rundy oceniania co modele lokalne. Koszt miliona tokenów dla API to rachunek za 13 zadań podzielony przez liczbę tokenów wyjścia, więc zawiera też koszt poleceń i myślenia. To realny koszt na tych zadaniach, nie stawka z cennika. Kurs 3,857 zł za dolara (NBP, 24.09.2026).

Wniosek z tabeli: lokalna Gemma 4 12B jest około dwa razy tańsza w prądzie niż GPT-6 Luna w API (1,22 zł wobec 2,16 zł za milion tokenów, licząc cały komputer). Luna pisze jednak po polsku wyraźnie lepiej: 86 pkt wobec 72. Z Claude Haiku 4.5 sytuacja się odwraca. Lokalna Gemma jest i lepsza (72 wobec 63 pkt), i 17 razy tańsza w eksploatacji.

Kiedy zwróci się karta

Prąd to tylko część rachunku. Liczę na każde 1000 zł wydane na kartę graficzną, bez amortyzacji reszty komputera:

• Zamiast GPT-6 Luna: oszczędzasz 0,94 zł na milionie tokenów. 1000 zł zwraca się po około 1,06 mld tokenów, czyli po 2900 godzinach ciągłego generowania przy 100 tokenach na sekundę. To ponad 120 dni bez przerwy, a Luna i tak pisze lepiej.
• Zamiast Claude Haiku 4.5: oszczędzasz 19,7 zł na milionie tokenów. 1000 zł zwraca się po 51 mln tokenów, czyli po około 140 godzinach generowania.
• Zamiast Claude Opus 5.5: 1000 zł zwraca się po 12 mln tokenów (34 godziny), ale to nie jest uczciwe porównanie, bo Opus jest o ponad 20 pkt lepszy.

To moja opinia: jeśli kartę już masz, lokalny model do rutynowych zadań (streszczenia, szkice, klasyfikacja maili, tłumaczenia robocze) jest praktycznie darmowy. Kupowanie karty tylko po to, żeby oszczędzić na API, ma sens dopiero przy bardzo dużej skali albo gdy dane nie mogą opuścić firmy.

Obrazy i wideo: tu lokalnie wychodzi taniej

W teście Z-Image Turbo karta pobierała średnio 350 W przez 4,2 sekundy na obraz 1344×768. To 0,0004 kWh, czyli 0,04 grosza za obraz, a z resztą komputera około 0,05 grosza. Tysiąc obrazów kosztuje w prądzie około 50 groszy. Generatory w chmurze biorą za jeden obraz zwykle od kilku do kilkudziesięciu groszy. Przy dużych seriach, np. wariantach zdjęć produktów, różnica robi się realna.

Wideo z Wan 2.2 5B to około 4 minut pracy karty na 5 sekund filmu 720p, przy średnio 315 W. To około 0,02 kWh, czyli 2 grosze za klip. Jakość jest jednak daleko za płatnymi generatorami, więc ta oszczędność ma sens tylko przy szkicach i materiałach roboczych.

Czego nie widać w rachunku

• Prywatność. Lokalny model nie wysyła niczego do internetu. Dla umów, danych klientów czy dokumentacji medycznej to często jedyny powód, który się liczy.
• Czas. Instalacja, dobór modelu i ustawień zajęły mi kilka godzin. Najwięcej trwało pobieranie ponad 100 GB plików. W API zaczynasz w minutę.
• Pułapki. Zła wersja silnika potrafi spowolnić model 2-2,6 raza, a domyślny tryb myślenia zwiększyć zużycie tokenów 11 razy. Oba przypadki opisałem w poradniku llama.cpp.
• Hałas i ciepło. Karta pod obciążeniem pobiera 190-450 W. Przy ciągłej pracy to odczuwalne w małym pokoju.

Zmierz to u siebie: gotowy skrypt

Liczby z tego tekstu są z mojej karty. Twoje będą inne, więc przygotowałem skrypt, który mierzy to samo na dowolnym komputerze. Wysyła 5 polskich poleceń do lokalnego serwera (llama.cpp, LM Studio albo Ollama), odczytuje szybkość, szczyt pamięci karty i pobór mocy z nvidia-smi, a na końcu liczy koszt prądu za milion tokenów. Na Gemmie 4 12B z RTX 4090 i doliczonymi 100 W za resztę komputera pokazał 91,4 tokena na sekundę, 8,6 GB pamięci modelu i 1,14 zł za milion tokenów. To zgadza się z tabelą wyżej.

• Pobierz: zmierz-model.py (6 KB) albo wszystkie 5 skryptów w jednym pliku ZIP (15 KB).
• llama.cpp: python zmierz-model.py --reszta-w 100
• LM Studio: python zmierz-model.py --url http://127.0.0.1:1234 --model nazwa-modelu, Ollama: --url http://127.0.0.1:11434 --model gemma4:12b
• Własna cena prądu: --cena 0.98 (zł za kWh z rachunku).

Zanim uruchomisz jakikolwiek skrypt z internetu, przeczytaj go. Działa z twoimi uprawnieniami. Dlatego poniżej jest pełny kod, bez skracania, z komentarzami po polsku. Skrypty są na licencji MIT: możesz je zmieniać i używać także w firmie.

"""
zmierz-model.py - szybkość, pamięć karty i koszt prądu lokalnego modelu (promptowy.com/lokalny-model-czy-api/)
Autor: Piotr Olszewski, promptowy.com. Licencja skryptu: MIT. Sprawdzone 26.09.2026: llama.cpp b11200, RTX 4090.

Działa z każdym serwerem zgodnym z API OpenAI: llama-server (port 8080), LM Studio (1234), Ollama (11434).
Wysyła 5 polskich poleceń, mierzy tokeny na sekundę, szczyt pamięci karty i średni pobór mocy (nvidia-smi),
a na końcu liczy koszt prądu za milion tokenów. Tylko biblioteka standardowa Pythona 3.9+.

Przykłady:
  python zmierz-model.py                                   (llama-server na 127.0.0.1:8080)
  python zmierz-model.py --url http://127.0.0.1:1234 --model gemma-4-12b      (LM Studio)
  python zmierz-model.py --url http://127.0.0.1:11434 --model gemma4:12b      (Ollama)
  python zmierz-model.py --cena 1.05 --reszta-w 100        (cena prądu zł/kWh, dopłata za resztę komputera)
"""
import argparse, json, statistics, subprocess, sys, threading, time, urllib.error, urllib.request

POLECENIA = [
    "Napisz uprzejmą odpowiedź na reklamację klienta, którego paczka spóźnia się 5 dni. Do 120 słów.",
    "Wyjaśnij dwunastolatkowi, czym jest inflacja. 100-130 słów, jeden przykład.",
    "Streść w 5 punktach: zarząd postanowił przesunąć premierę aplikacji o miesiąc, zwiększyć budżet testów o 20% i zatrudnić dwóch testerów.",
    "Zaproponuj 10 tytułów artykułu o oszczędzaniu prądu w bloku, każdy do 60 znaków.",
    "Przetłumacz na polski, bez kalk: 'We're over the moon to announce our new release - it's been a long time coming.'",
]


class Czujnik(threading.Thread):
    def __init__(self):
        super().__init__(daemon=True); self.stop = False; self.vram = []; self.moc = []
    def run(self):
        while not self.stop:
            try:
                o = subprocess.check_output(["nvidia-smi", "--query-gpu=memory.used,power.draw", "--format=csv,noheader,nounits"], text=True, timeout=5)
                v, w = [float(x) for x in o.strip().splitlines()[0].split(",")]
                self.vram.append(v); self.moc.append(w)
            except Exception:
                return
            time.sleep(0.5)


def main():
    a = argparse.ArgumentParser(description="Pomiar lokalnego modelu: tok/s, VRAM, koszt prądu")
    a.add_argument("--url", default="http://127.0.0.1:8080", help="adres serwera zgodnego z API OpenAI")
    a.add_argument("--model", default="lokalny", help="nazwa modelu (LM Studio i Ollama jej wymagają)")
    a.add_argument("--cena", type=float, default=1.05, help="cena prądu w zł za kWh (domyślnie 1,05 - G11 z dystrybucją, 2026)")
    a.add_argument("--reszta-w", type=float, default=0, help="dolicz tyle watów za resztę komputera (np. 100)")
    a.add_argument("--max-tokens", type=int, default=800)
    x = a.parse_args()
    try:
        o = subprocess.check_output(["nvidia-smi", "--query-gpu=name,memory.used", "--format=csv,noheader,nounits"], text=True, timeout=5)
        karta, tlo = o.strip().splitlines()[0].rsplit(",", 1); tlo = float(tlo)
        print(f"Karta: {karta.strip()}, zajęte przed testem: {tlo:.0f} MB")
    except Exception:
        karta, tlo = None, 0
        print("Brak nvidia-smi - mierzę tylko szybkość, bez pamięci i prądu.")
    # llama-server odpowiada 503, dopóki wczytuje model - czekamy do 5 minut
    for proba in range(150):
        try:
            urllib.request.urlopen(x.url.rstrip("/") + "/v1/models", timeout=5); break
        except urllib.error.HTTPError as e:
            if e.code != 503: break
        except Exception:
            pass
        if proba == 0: print("Czekam, aż serwer wczyta model...")
        time.sleep(2)
    wyniki = []
    for i, p in enumerate(POLECENIA, 1):
        body = {"model": x.model, "messages": [{"role": "user", "content": p}], "max_tokens": x.max_tokens, "temperature": 0.7}
        cz = Czujnik(); cz.start(); t0 = time.time()
        try:
            req = urllib.request.Request(x.url.rstrip("/") + "/v1/chat/completions", data=json.dumps(body).encode(), headers={"Content-Type": "application/json"})
            j = json.load(urllib.request.urlopen(req, timeout=900))
        except Exception as e:
            sys.exit(f"Serwer {x.url} nie odpowiada ({e}). Czy model jest uruchomiony?")
        czas = time.time() - t0; cz.stop = True; cz.join()
        tok = j.get("usage", {}).get("completion_tokens") or 0
        tps = j.get("timings", {}).get("predicted_per_second") or (tok / czas if czas else 0)
        moc = statistics.mean(cz.moc) if cz.moc else 0
        wyniki.append({"tok": tok, "czas": czas, "tps": tps, "vram": max(cz.vram or [0]), "moc": moc})
        tekst = (j["choices"][0]["message"].get("content") or "").strip().replace("\n", " ")
        print(f"[{i}/5] {tok} tokenów w {czas:.1f} s, {tps:.1f} tok/s, {moc:.0f} W | {tekst[:70]}...")
    tok = sum(w["tok"] for w in wyniki); czas = sum(w["czas"] for w in wyniki)
    print("\n=== Podsumowanie ===")
    print(f"Szybkość generowania: {statistics.mean(w['tps'] for w in wyniki):.1f} tok/s")
    if karta:
        wh = sum(w["czas"] * (w["moc"] + x.reszta_w) for w in wyniki) / 3600
        print(f"Pamięć karty: szczyt {max(w['vram'] for w in wyniki):.0f} MB, z czego model ok. {max(w['vram'] for w in wyniki) - tlo:.0f} MB")
        print(f"Energia: {wh:.2f} Wh na {tok} tokenów")
        if tok:
            print(f"Koszt prądu: {wh / 1000 * x.cena * 100:.3f} gr za test, {wh / 1000 * x.cena / tok * 1e6:.2f} zł za milion tokenów "
                  f"(cena {x.cena} zł/kWh{', +%.0f W reszta komputera' % x.reszta_w if x.reszta_w else ', sama karta'})")


if __name__ == "__main__":
    main()

Najczęstsze pytania

Czy lokalny model AI jest darmowy?

Model tak, bo Gemma 4, Qwen 3.8, Bielik v3 i GPT-OSS są na licencji Apache 2.0. Płacisz za prąd: w moim teście 13 zadań na Gemmie 4 12B kosztowało 0,4 grosza, plus za sprzęt, który już masz albo musisz kupić.

Co jest tańsze: lokalny model czy ChatGPT API?

Prąd za lokalną Gemmę 4 12B to około 1,22 zł za milion tokenów z całym komputerem, a GPT-6 Luna w API na tych samych zadaniach kosztowała około 2,16 zł za milion. Luna pisała jednak lepiej, a karta zwraca się dopiero po tysiącach godzin pracy.

Ile prądu zużywa karta przy AI?

RTX 4090 pobierała przy generowaniu tekstu średnio 190-360 W zależnie od modelu, a przy obrazach i wideo 300-450 W. Godzina ciągłej pracy to około 0,3-0,45 kWh, czyli 30-47 groszy.