Jak ChatGPT naprawdę pisze odpowiedź? Token po tokenie

annotated-doc==0.0.5
annotated-types==0.8.0
anthropic==1.14.0
anyio==4.15.1
certifi==2026.7.22
charset-normalizer==3.5.2
click==8.5.0
docstring_parser==0.18.0
filelock==4.2.0
fsspec==2026.9.0
h11==0.16.0
hf-xet==1.7.0
httpcore2==2.13.1
httpx2==2.13.1
huggingface_hub==2.2.0
idna==3.20
Jinja2==3.1.6
jiter==0.17.0
markdown-it-py==4.2.0
MarkupSafe==3.0.4
mdurl==0.1.2
mpmath==1.3.0
networkx==3.6.1
numpy==2.4.6
opentelemetry-api==1.45.1
packaging==26.3
pydantic==2.14.1
pydantic_core==2.50.1
Pygments==2.21.0
PyYAML==6.0.3
regex==2026.9.29
requests==2.34.2
rich==15.0.0
safetensors==0.8.0
shellingham==1.5.4
sniffio==1.3.1
sympy==1.14.0
tiktoken==0.14.0
tokenizers==0.23.3
torch==2.14.1
tqdm==4.70.1
transformers==5.19.0
truststore==0.10.5
typer==0.27.3
typing-inspection==0.4.4
typing_extensions==4.16.0
urllib3==2.8.0

"""Wspólne stałe i funkcje skryptów pomiarowych odcinka 1.

Każdy skrypt zapisuje wynik obok siebie (niezależnie od katalogu, z którego go uruchomiono)
i dokłada klucz "meta": wersje bibliotek, rewizję modelu, platformę i datę przebiegu.
Rewizje modeli są przypięte, żeby ponowny przebieg używał dokładnie tych samych wag.
"""
import datetime, importlib, json, platform
from pathlib import Path

KATALOG = Path(__file__).resolve().parent

MODEL_BAZOWY = "Qwen/Qwen3-0.6B-Base"
REWIZJA_BAZOWY = "da87bfb608c14b7cf20ba1ce41287e8de496c0cd"  # main na Hugging Face od 2025-07-26, użyta w pomiarach 2026-10-09
MODEL_CZAT = "Qwen/Qwen3-0.6B"
REWIZJA_CZAT = "c1899de289a04d12100db370d81485cdf75e47ca"

# Pięć par zdań PL/EN do liczenia tokenów (tok.py, claude_tokeny.py).
PARY_TOK = [
    ("Dlaczego niebo jest niebieskie?", "Why is the sky blue?"),
    ("Wpisujesz pytanie i naciskasz Enter.", "You type a question and press Enter."),
    ("Model zgaduje następny token i dokleja go do odpowiedzi.", "The model guesses the next token and appends it to the answer."),
    ("Prawdopodobieństwo każdego kawałka słownika jest różne.", "The probability of each piece of the vocabulary is different."),
    ("Szybki brązowy lis przeskakuje nad leniwym psem.", "The quick brown fox jumps over the lazy dog."),
]


def meta(**dodatkowe):
    wersje = {}
    for nazwa in ["torch", "transformers", "tokenizers", "tiktoken", "numpy", "huggingface_hub", "safetensors"]:
        try:
            wersje[nazwa] = importlib.import_module(nazwa).__version__
        except ImportError:
            pass
    m = {"data": datetime.datetime.now().astimezone().isoformat(timespec="seconds"),
         "python": platform.python_version(), "platforma": platform.platform(), "procesor": platform.machine(),
         "wersje": wersje}
    if "torch" in wersje:
        import torch
        m["watki_torch"] = torch.get_num_threads()
    m.update(dodatkowe)
    return m


def zapisz_json(sciezka, dane, **opcje):
    """Zapis w UTF-8; względna ścieżka liczy się od katalogu pomiarów."""
    sciezka = Path(sciezka)
    if not sciezka.is_absolute():
        sciezka = KATALOG / sciezka
    opcje.setdefault("indent", 1)
    with open(sciezka, "w", encoding="utf-8") as f:
        json.dump(dane, f, ensure_ascii=False, **opcje)
    print(f"zapisano {sciezka.name}")


def wczytaj_json(sciezka):
    sciezka = Path(sciezka)
    if not sciezka.is_absolute():
        sciezka = KATALOG / sciezka
    with open(sciezka, encoding="utf-8") as f:
        return json.load(f)

#!/usr/bin/env bash
# Uruchamia wszystkie pomiary odcinka 1 po kolei i zapisuje wynik każdego kroku do logi/<skrypt>.log.
#   bash uruchom_wszystko.sh              # wszystko, łącznie z Claude (potrzebny klucz, patrz README)
#   bash uruchom_wszystko.sh --bez-claude # bez claude_tokeny.py
# Python: zmienna PYTHON (domyślnie python3 z aktywnego środowiska). Paski postępu ładowania wag są pomijane w logach.
set -euo pipefail
cd "$(dirname "$0")"
PY="${PYTHON:-python3}"
mkdir -p logi
KROKI=(tok spacja slowniki pairs losowanie probki_lab filtruj_probki rozklad parametry koniec claude_tokeny sprawdz)
for k in "${KROKI[@]}"; do
  if [ "$k" = "claude_tokeny" ] && [ "${1:-}" = "--bez-claude" ]; then continue; fi
  echo "== $k ($(date +%H:%M:%S))"
  echo "\$ python $k.py" > "logi/$k.log"
  set +e
  "$PY" "$k.py" 2>&1 | tr '\r' '\n' | grep -v -E "Loading weights|it/s\]|s/it\]|^\s*$|unauthenticated requests to the HF Hub" >> "logi/$k.log"
  kod=${PIPESTATUS[0]}
  set -e
  tail -n 3 "logi/$k.log"
  if [ "$kod" -ne 0 ]; then echo "BŁĄD: $k.py zakończył się kodem $kod (pełny wynik: logi/$k.log)"; exit "$kod"; fi
done
rm -rf __pycache__

"""Liczba tokenów w 5 parach zdań PL/EN (scena 3) i numery tokenów pokazywane w filmie.

Słowniki: o200k_base (GPT-4o) i cl100k_base (GPT-4, GPT-3.5-turbo), biblioteka tiktoken.
Uruchomienie: python tok.py   (tiktoken 0.14.0). Wynik: tok.json
"""
import tiktoken
from _wspolne import PARY_TOK, meta, zapisz_json

# Pojedyncze słowa z filmu: truskawka (ujęcie 18), kot i czajnik (ujęcie 19). Spacja przed słowem zmienia numer.
SLOWA = ["truskawka", "strawberry", "kot", " kot", "Kot", "czajnik", " czajnik"]
MODELE = ["gpt-4o", "gpt-4", "gpt-3.5-turbo"]

out = {"meta": meta(), "kodowania": {}, "encoding_for_model": {}}
for name in ["cl100k_base", "o200k_base"]:
    enc = tiktoken.get_encoding(name)
    print(f"== {name}: n_vocab={enc.n_vocab}")
    k = {"n_vocab": enc.n_vocab, "pary": [], "slowa": {}}
    totpl = toten = 0
    for pl, en in PARY_TOK:
        a, b = enc.encode(pl), enc.encode(en)
        totpl += len(a); toten += len(b)
        k["pary"].append({"pl": {"tekst": pl, "n": len(a), "id": a, "tokeny": [enc.decode([t]) for t in a]},
                          "en": {"tekst": en, "n": len(b), "id": b, "tokeny": [enc.decode([t]) for t in b]}})
        print(f"PL {len(a):2d} tok | {len(pl):2d} zn | {[enc.decode([t]) for t in a]}")
        print(f"EN {len(b):2d} tok | {len(en):2d} zn | {[enc.decode([t]) for t in b]}")
    k.update({"suma_pl": totpl, "suma_en": toten, "stosunek": round(totpl / toten, 2)})
    print(f"SUMA PL={totpl} EN={toten} stosunek={totpl/toten:.2f}")
    print("IDs:", enc.encode(PARY_TOK[0][0]))
    for s in SLOWA:
        ids = enc.encode(s)
        k["slowa"][s] = {"id": ids, "tokeny": [enc.decode([i]) for i in ids]}
    out["kodowania"][name] = k
for m in MODELE:
    out["encoding_for_model"][m] = tiktoken.encoding_for_model(m).name
print("slowa o200k_base:", {s: v["id"] for s, v in out["kodowania"]["o200k_base"]["slowa"].items()})
print("encoding_for_model:", out["encoding_for_model"])
zapisz_json("tok.json", out)

"""Czy spacja należy do tokenu? Odcinek 1, ujęcie 12b.

W słowniku o200k_base (GPT-4o) " nie" (ze spacją przed słowem) i "nie" (bez spacji) to dwa różne tokeny,
więc mają różne numery. Skrypt zapisuje wynik w spacja.json (tiktoken 0.14.0).
Uruchomienie: python spacja.py
"""
import tiktoken
from _wspolne import meta, zapisz_json

enc = tiktoken.get_encoding("o200k_base")
res = {"meta": meta(), "tiktoken": tiktoken.__version__, "encoding": "o200k_base", "n_vocab": enc.n_vocab, "teksty": {}}
for s in [" nie", "nie", "Nie", "Dlaczego niebo jest niebieskie?"]:
    ids = enc.encode(s)
    res["teksty"][s] = {"id": ids, "tokeny": [enc.decode([i]) for i in ids]}
    print(f"{s!r}: {ids} -> {[enc.decode([i]) for i in ids]}")
res["decode_4725"] = enc.decode([4725])
zapisz_json("spacja.json", res)

"""Ile tokenów zużywa Claude Opus 5.5 na te same 5 par zdań PL/EN co tok.py? (ujęcie 17)

Dwie drogi, ten sam tokenizer Claude:
1. Klucz Anthropic (ANTHROPIC_API_KEY albo CLAUDE_API_KEY): oficjalny licznik messages.count_tokens.
   Liczenie jest według dokumentacji darmowe, ale konto w Claude Console musi mieć dodatnie saldo.
2. Klucz OpenRouter (OPENROUTER_API_KEY): krótkie wywołanie modelu przez endpoint w formacie Anthropic
   (https://openrouter.ai/api/v1/messages). OpenRouter podaje input_tokens liczone natywnym tokenizerem modelu.
   Płatne: ok. 26 wywołań po kilkanaście tokenów, razem poniżej kilku centów.
Licznik obejmuje zdanie i stałą otoczkę wiadomości (znaczniki roli). Otoczkę K wyznaczamy z kalibracji
na pojedynczych znakach ".", "a", "?": każdy z nich to jeden token (tokenizer bajtowy ma każdy znak ASCII
w słowniku), więc wszystkie trzy muszą dać ten sam wynik, a K = licznik(".") - 1.
Wynik zdania to licznik(zdanie) - K. Każdy tekst liczymy dwa razy.
Uwaga: "hello" nie nadaje się do kalibracji. W nowym tokenizerze Claude (od Opus 4.7) " hello" to 2 tokeny,
co pokazała pierwsza próba (zapisana w polu "hello").

Klucze: zmienne środowiskowe albo wpisy w najbliższym pliku .env w górę od tego katalogu.
Nie eksportuj klucza Anthropic w powłoce na stałe: Claude Code użyłby go zamiast subskrypcji.
Uruchomienie: python claude_tokeny.py   (anthropic 1.14.0). Wynik: claude_tokeny.json
"""
import os
import anthropic
from _wspolne import KATALOG, PARY_TOK, meta, zapisz_json

MODEL = "claude-opus-5-5"
MODEL_OPENROUTER = "anthropic/claude-opus-5.5"
KALIBRACJA = [".", "a", "?"]
HELLO = ["hello", "hello hello", "hello hello hello hello"]


def klucz(*nazwy):
    for nazwa in nazwy:
        if os.environ.get(nazwa):
            return os.environ[nazwa]
    for kat in [KATALOG, *KATALOG.parents]:
        plik = kat / ".env"
        if plik.is_file():
            for linia in plik.read_text(encoding="utf-8").splitlines():
                nazwa, _, wartosc = linia.partition("=")
                if nazwa.strip() in nazwy and wartosc.strip():
                    return wartosc.strip().strip("'\"")
    return None


if k := klucz("ANTHROPIC_API_KEY", "CLAUDE_API_KEY"):
    droga = "Anthropic messages.count_tokens"
    client = anthropic.Anthropic(api_key=k)

    def jeden(tekst):
        return client.messages.count_tokens(model=MODEL, messages=[{"role": "user", "content": tekst}]).input_tokens
elif k := klucz("OPENROUTER_API_KEY"):
    droga = "OpenRouter /api/v1/messages, usage.input_tokens"
    client = anthropic.Anthropic(base_url="https://openrouter.ai/api", api_key=None, auth_token=k)

    def jeden(tekst):
        odp = client.messages.create(model=MODEL_OPENROUTER, max_tokens=16, messages=[{"role": "user", "content": tekst}])
        return odp.usage.input_tokens
else:
    raise SystemExit("Brak klucza: ustaw ANTHROPIC_API_KEY (albo CLAUDE_API_KEY) lub OPENROUTER_API_KEY")
print("droga:", droga)


def licz(tekst):
    wyniki = [jeden(tekst) for _ in range(2)]
    if wyniki[0] != wyniki[1]:
        raise SystemExit(f"różne wyniki dla {tekst!r}: {wyniki}")
    return wyniki[0]


kal = {t: licz(t) for t in KALIBRACJA}
if len(set(kal.values())) != 1:
    raise SystemExit(f"kalibracja: pojedyncze znaki dały różne wyniki {kal}")
K = kal["."] - 1
hello = {t: licz(t) - K for t in HELLO}
print(f"kalibracja {kal}, otoczka K = {K}, hello: {hello}")

pary, spl, sen = [], 0, 0
for pl, en in PARY_TOK:
    a, b = licz(pl) - K, licz(en) - K
    spl += a; sen += b
    pary.append({"pl": {"tekst": pl, "n": a}, "en": {"tekst": en, "n": b}})
    print(f"PL {a:3d} | EN {b:3d} | {pl!r}")
print(f"SUMA PL={spl} EN={sen} stosunek={spl / sen:.2f}")

res = {"meta": meta(model=MODEL, droga=droga, metoda="licznik tokenów wejścia minus otoczka K z kalibracji"),
       "kalibracja": kal, "otoczka_K": K, "hello": hello, "pary": pary, "suma_pl": spl, "suma_en": sen, "stosunek": round(spl / sen, 2)}
zapisz_json("claude_tokeny.json", res)

"""Ile parametrów ma Qwen3-0.6B-Base i ile z nich to współrzędne kartek słownika (ujęcia 32 i 32a).

Liczy parametry modelu (wspólna tabela wejścia i wyjścia liczona raz, bo tie_word_embeddings = true),
odczytuje budowę z config.json i sprawdza, co leży na pozycjach słownika ponad len(tokenizer).
Uruchomienie: python parametry.py   (torch 2.14.1, transformers 5.19.0). Wynik: parametry.json
"""
import torch, warnings
warnings.filterwarnings("ignore")
from transformers import AutoTokenizer, AutoModelForCausalLM
from _wspolne import MODEL_BAZOWY, REWIZJA_BAZOWY, meta, zapisz_json

tok = AutoTokenizer.from_pretrained(MODEL_BAZOWY, revision=REWIZJA_BAZOWY)
model = AutoModelForCausalLM.from_pretrained(MODEL_BAZOWY, revision=REWIZJA_BAZOWY, dtype=torch.float32).eval()
cfg = model.config

razem = sum(p.numel() for p in model.parameters())  # parameters() nie powtarza wspólnej tabeli
emb = model.get_input_embeddings().weight
wspolna = emb.data_ptr() == model.get_output_embeddings().weight.data_ptr()
slownik = emb.numel()

# Pozycje tabeli bez kawałka tekstu w tokenizerze (tabela jest większa niż słownik).
dlugosc = len(tok)
nadmiar = list(range(dlugosc, cfg.vocab_size))
bez_tekstu = [i for i in nadmiar if tok.convert_ids_to_tokens(i) is None]

res = {"meta": meta(model=MODEL_BAZOWY, rewizja=REWIZJA_BAZOWY),
       "config": {k: getattr(cfg, k) for k in ["num_hidden_layers", "hidden_size", "num_attention_heads", "num_key_value_heads",
                                               "intermediate_size", "vocab_size", "tie_word_embeddings", "max_position_embeddings"]},
       "parametry_razem": razem, "tabela_slownika": slownik, "tabela_slownika_wymiary": list(emb.shape),
       "tabela_wspolna_wejscie_wyjscie": wspolna, "bez_tabeli_slownika": razem - slownik,
       "udzial_tabeli_slownika_%": round(100 * slownik / razem, 2),
       "len_tokenizer": dlugosc, "pozycje_ponad_tokenizer": len(nadmiar), "z_nich_bez_tekstu": len(bez_tekstu),
       "przyklady_ponad_tokenizer": {i: tok.convert_ids_to_tokens(i) for i in nadmiar[:3] + nadmiar[-2:]}}
for k, v in res.items():
    if k != "meta":
        print(f"{k}: {v}")
zapisz_json("parametry.json", res)

"""Porównanie cięcia tego samego tekstu przez dwa tokenizery: o200k_base (tiktoken, scena 3) i Qwen3 (scena 6).
Uruchomienie: python slowniki.py   (tiktoken 0.14.0, transformers 5.19.0). Wynik: slowniki.json
"""
import tiktoken
from transformers import AutoTokenizer
from _wspolne import MODEL_BAZOWY, REWIZJA_BAZOWY, meta, zapisz_json

enc = tiktoken.get_encoding("o200k_base")
qwen = AutoTokenizer.from_pretrained(MODEL_BAZOWY, revision=REWIZJA_BAZOWY)
texts = ["Niebo jest", "Dlaczego niebo jest niebieskie?", "The sky is", "Why is the sky blue?"]
out = {"meta": meta(model=MODEL_BAZOWY, rewizja=REWIZJA_BAZOWY),
       "o200k_base": {"n_vocab": enc.n_vocab}, "qwen3": {"len_tokenizer": len(qwen)}, "texty": {}}
for t in texts:
    a = enc.encode(t); b = qwen(t)["input_ids"]
    out["texty"][t] = {
        "o200k_base": {"n": len(a), "tokeny": [enc.decode([i]) for i in a], "id": a},
        "qwen3": {"n": len(b), "tokeny": [qwen.decode([i]) for i in b], "id": b},
    }
    print(repr(t)); print("  o200k:", len(a), [enc.decode([i]) for i in a], a); print("  qwen3:", len(b), [qwen.decode([i]) for i in b], b)
zapisz_json("slowniki.json", out)

"""Rozkład następnego tokenu w Qwen3-0.6B-Base dla 5 par promptów PL/EN (scena 6) przy T = 1,0 / 0,2 / 1,5.

Wyniki modelu (logity) w float32, softmax w float64. Pierwsza para ("Niebo jest" / "The sky is") jest w filmie.
Uruchomienie: python pairs.py   (torch 2.14.1, transformers 5.19.0, CPU, float32). Wynik: dist2.json
"""
import torch, warnings
warnings.filterwarnings("ignore")
from transformers import AutoTokenizer, AutoModelForCausalLM
from _wspolne import MODEL_BAZOWY, REWIZJA_BAZOWY, meta, zapisz_json

name = MODEL_BAZOWY
tok = AutoTokenizer.from_pretrained(name, revision=REWIZJA_BAZOWY)
model = AutoModelForCausalLM.from_pretrained(name, revision=REWIZJA_BAZOWY, dtype=torch.float32).eval()
pairs = [
 ("Niebo jest", "The sky is"),
 ("Stolicą Francji jest", "The capital of France is"),
 ("Pies szczeka, a kot", "The dog barks and the cat"),
 ("Dwa plus dwa równa się", "Two plus two equals"),
 ("Woda zamarza w temperaturze zero stopni", "Water freezes at zero degrees"),
]
res = {"meta": meta(model=name, rewizja=REWIZJA_BAZOWY), "model": name, "layers": model.config.num_hidden_layers,
       "logits_dim": model.config.vocab_size, "len_tokenizer": len(tok), "pairs": []}
def run(prompt):
    ids = tok(prompt, return_tensors="pt")
    with torch.no_grad():
        lg = model(**ids).logits[0, -1].float()
    out = {"prompt": prompt, "tokens": [tok.decode([t]) for t in ids["input_ids"][0]], "T": {}}
    for T in [1.0, 0.2, 1.5]:
        p = torch.softmax(lg.double() / T, dim=-1)
        top = torch.topk(p, 8)
        out["T"][str(T)] = {"top": [(tok.decode([i]), round(v.item()*100, 2)) for v, i in zip(top.values, top.indices)],
                            "top8_sum": round(top.values.sum().item()*100, 2),
                            "n_over_1e-6": int((p > 1e-6).sum().item())}
    return out
for pl, en in pairs:
    a, b = run(pl), run(en)
    res["pairs"].append({"pl": a, "en": b})
    for r in (a, b):
        t = r["T"]["1.0"]
        print(f"{r['prompt']!r} {r['tokens']}\n   T=1: " + ", ".join(f"{x!r} {y}%" for x, y in t["top"]) + f" | top8={t['top8_sum']}% n>1e-6={t['n_over_1e-6']}")
zapisz_json("dist2.json", res)
print("layers", res["layers"], "logits_dim", res["logits_dim"], "len_tokenizer", res["len_tokenizer"])

"""Prawdziwe losowanie z Qwen3-0.6B-Base dla sceny 7 (rozsypujący się tekst przy wysokiej temperaturze)
oraz sprawdzenie, czy softmax daje któremukolwiek tokenowi dokładnie zero.

Czyste próbkowanie z rozkładu softmax(z / T): bez Top-K i bez Top-P (wyłączone jawnie, bo domyślne
ustawienia generation_config mogłyby je włączyć). Seedy 1..N, wynik w losowanie.json.
Uruchomienie: python losowanie.py   (torch 2.14.1, transformers 5.19.0, CPU, float32)
"""
import json, warnings
import torch
warnings.filterwarnings("ignore")
from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed
from _wspolne import MODEL_BAZOWY, REWIZJA_BAZOWY, meta, zapisz_json

NAME = MODEL_BAZOWY
PROMPTS = ["Niebo jest", "The sky is"]
TEMPS = [1.0, 1.5, 2.0]
SEEDS = range(1, 11)
NEW = 24

tok = AutoTokenizer.from_pretrained(NAME, revision=REWIZJA_BAZOWY)
model = AutoModelForCausalLM.from_pretrained(NAME, revision=REWIZJA_BAZOWY, dtype=torch.float32).eval()
res = {"meta": meta(model=NAME, rewizja=REWIZJA_BAZOWY), "model": NAME, "torch": torch.__version__, "new_tokens": NEW,
       "sampling": "temperature only, top_k=0, top_p=1.0", "samples": [], "zero_check": {}}

for prompt in PROMPTS:
    ids = tok(prompt, return_tensors="pt")
    # Czy któryś z 151 936 wyników ma prawdopodobieństwo dokładnie 0?
    with torch.no_grad():
        lg = model(**ids).logits[0, -1]
    for T in (1.0, 1.5):
        p32 = torch.softmax(lg.float() / T, dim=-1)
        p64 = torch.softmax(lg.double() / T, dim=-1)
        res["zero_check"][f"{prompt}|T={T}"] = {
            "n": int(p64.numel()),
            "zeros_float32": int((p32 == 0).sum()),
            "zeros_float64": int((p64 == 0).sum()),
            "min_float64": float(p64.min()),
        }
    for T in TEMPS:
        for seed in SEEDS:
            set_seed(seed)
            out = model.generate(**ids, do_sample=True, temperature=T, top_k=0, top_p=1.0,
                                 max_new_tokens=NEW, pad_token_id=tok.eos_token_id)
            text = tok.decode(out[0], skip_special_tokens=True)
            res["samples"].append({"prompt": prompt, "T": T, "seed": seed, "text": text})
            print(f"[{prompt!r} T={T} seed={seed}] {text!r}")

zapisz_json("losowanie.json", res)
print(json.dumps(res["zero_check"], indent=1))

"""Kiedy rośnie szansa kartki końca? (ujęcia 47 i 47b)

Czatowy Qwen3-0.6B (ta sama rodzina i ten sam słownik co Qwen3-0.6B-Base) odpowiada na pytanie z filmu.
Odpowiedź jest zachłanna (zawsze najwyższy słupek), więc za każdym razem ta sama. Potem jeden przebieg
po całej odpowiedzi: przed każdą kolejną kartką odczytujemy szansę kartki końca <|im_end|> (151645).
Tryb myślenia wyłączony (enable_thinking=False), żeby odpowiedź nie zaczynała się od <think>.
Uruchomienie: python koniec.py   (torch 2.14.1, transformers 5.19.0, CPU, float32). Wynik: koniec.json
"""
import torch, warnings
warnings.filterwarnings("ignore")
from transformers import AutoTokenizer, AutoModelForCausalLM
from _wspolne import MODEL_CZAT, REWIZJA_CZAT, meta, zapisz_json

PYTANIA = ["Dlaczego niebo jest niebieskie? Odpowiedz jednym zdaniem.",  # pytanie z filmu
           "Jaka jest stolica Francji? Odpowiedz jednym zdaniem."]       # zapas: krótka, poprawna odpowiedź
MAKS = 80

tok = AutoTokenizer.from_pretrained(MODEL_CZAT, revision=REWIZJA_CZAT)
model = AutoModelForCausalLM.from_pretrained(MODEL_CZAT, revision=REWIZJA_CZAT, dtype=torch.float32).eval()
KONIEC = tok.convert_tokens_to_ids("<|im_end|>")
KONIEC_TEKSTU = tok.convert_tokens_to_ids("<|endoftext|>")


def odpowiedz(pytanie):
    prompt = tok.apply_chat_template([{"role": "user", "content": pytanie}], tokenize=False,
                                     add_generation_prompt=True, enable_thinking=False)
    ids = tok(prompt, return_tensors="pt")["input_ids"]
    plen = ids.shape[1]
    print(f"# pytanie: {pytanie}")
    with torch.no_grad():
        pelne = model.generate(ids, do_sample=False, max_new_tokens=MAKS, pad_token_id=KONIEC_TEKSTU)[0]
        p = torch.softmax(model(pelne.unsqueeze(0)).logits[0].double(), dim=-1)
    kroki = []
    for j in range(plen, len(pelne)):  # kartka na pozycji j; rozkład przed nią to wiersz j-1
        t = int(pelne[j])
        kroki.append({"kartka": tok.decode([t]), "id": t,
                      "p_wybranej_%": round(100 * p[j - 1, t].item(), 4),
                      "p_koniec_%": round(100 * p[j - 1, KONIEC].item(), 6),
                      "p_koniec_tekstu_%": round(100 * p[j - 1, KONIEC_TEKSTU].item(), 6)})
        print(f"{tok.decode([t])!r:>14}  p(koniec) przed nią = {kroki[-1]['p_koniec_%']:.6f}%")
    tekst = tok.decode(pelne[plen:], skip_special_tokens=True)
    print(f"# odpowiedź modelu: {tekst}")
    return {"pytanie": pytanie, "prompt": prompt, "odpowiedz": tekst,
            "zakonczona_kartka_konca": int(pelne[-1]) == KONIEC, "kroki": kroki}


res = {"meta": meta(model=MODEL_CZAT, rewizja=REWIZJA_CZAT),
       "kartka_konca": {"tekst": "<|im_end|>", "id": KONIEC}, "kartka_konca_tekstu": {"tekst": "<|endoftext|>", "id": KONIEC_TEKSTU},
       "eos_token_id_generation_config": model.generation_config.eos_token_id,
       "odpowiedzi": [odpowiedz(q) for q in PYTANIA]}
zapisz_json("koniec.json", res)

"""Czy Twój przebieg pomiarów zgadza się z naszym? Porównuje świeże wyniki z wzorcowe-2026-10-09/.

Zasady porównania:
- numery tokenów i liczby tokenów: muszą być identyczne;
- procenty (zaokrąglone do 2 miejsc): różnica najwyżej 0,01;
- liczba kandydatów z szansą > 1e-6: różnica najwyżej 1;
- zera w softmaksie: identyczne, najmniejsze p: względna różnica najwyżej 1e-6;
- teksty losowań: przy tych samych wersjach bibliotek na CPU w float32 powinny być identyczne,
  ale mogą się różnić na innym procesorze lub systemie. Różnice są wtedy wypisane jako ZALEŻNE OD PLATFORMY,
  a błąd zgłaszamy tylko z opcją --scisle.
- wzorce losowań (losowanie.json, probki-lab.json) mogą mieć zamiast tekstów ich skróty SHA-256 (tak jest w paczce do
  pobrania, żeby nie publikować surowych losowań małego modelu); wtedy porównujemy skróty Twoich tekstów.
tok.json nie ma pliku wzorcowego, więc jego liczby porównujemy z wartościami podanymi w filmie.
Uruchomienie: python sprawdz.py [--scisle] [--wzorcowe KATALOG]   Kod wyjścia 0 = zgodność.
"""
import argparse, hashlib, json
from pathlib import Path
from _wspolne import KATALOG, wczytaj_json

ap = argparse.ArgumentParser()
ap.add_argument("--scisle", action="store_true", help="różne teksty losowań też są błędem")
ap.add_argument("--wzorcowe", default=str(KATALOG / "wzorcowe-2026-10-09"))
args = ap.parse_args()
W = Path(args.wzorcowe)
STRONA = KATALOG / "../../strona/src/data"
bledy, platforma = [], []


def blad(msg):
    bledy.append(msg); print("BŁĄD:", msg)


def sha(tekst):
    return hashlib.sha256(tekst.encode("utf-8")).hexdigest()


def tekst_zgodny(moj, wzor):
    """Wzorzec ma albo pełny tekst ("text"), albo jego skrót ("text_sha256")."""
    return moj == wzor["text"] if "text" in wzor else sha(moj) == wzor["text_sha256"]


def probka_zgodna(moja, wzor):
    """Próbka z probki-lab.json: pełna ({"t","p","r"}) albo skrót ({"sha256"}) jej postaci JSON."""
    if "sha256" in wzor and "t" not in wzor:
        return sha(json.dumps(moja, sort_keys=True, ensure_ascii=False)) == wzor["sha256"]
    return moja == wzor


def rowne(a, b, gdzie):
    if a != b:
        blad(f"{gdzie}: {a!r} != {b!r}")


def blisko(a, b, tol, gdzie):
    if abs(a - b) > tol:
        blad(f"{gdzie}: {a} vs {b} (tolerancja {tol})")


# Tokenizery
s, w = wczytaj_json("spacja.json"), wczytaj_json(W / "spacja.json")
for t in w["teksty"]:
    rowne(s["teksty"][t]["id"], w["teksty"][t]["id"], f"spacja.json {t!r}")
s, w = wczytaj_json("slowniki.json"), wczytaj_json(W / "slowniki.json")
for t in w["texty"]:
    for k in ("o200k_base", "qwen3"):
        rowne(s["texty"][t][k]["id"], w["texty"][t][k]["id"], f"slowniki.json {t!r} {k}")

# Liczby z filmu (scena 3, ujęcia 12, 18, 19)
t = wczytaj_json("tok.json")["kodowania"]
rowne((t["o200k_base"]["suma_pl"], t["o200k_base"]["suma_en"]), (72, 49), "tok.json o200k_base sumy")
rowne((t["cl100k_base"]["suma_pl"], t["cl100k_base"]["suma_en"]), (84, 49), "tok.json cl100k_base sumy")
rowne(t["o200k_base"]["pary"][0]["pl"]["id"], [136923, 182265, 4725, 1692, 12637, 4725, 73826, 51201, 30], "tok.json zdanie 1")
rowne(t["o200k_base"]["slowa"]["truskawka"]["id"], [371, 26604, 1134, 1854], "tok.json truskawka")
rowne(t["o200k_base"]["slowa"]["kot"]["id"], [74443], "tok.json kot")

# Rozkłady (scena 6)
s, w = wczytaj_json("dist2.json"), wczytaj_json(W / "dist2.json")
for i, (ps, pw) in enumerate(zip(s["pairs"], w["pairs"])):
    for lang in ("pl", "en"):
        for T, tw in pw[lang]["T"].items():
            ts, gdzie = ps[lang]["T"][T], f"dist2.json para {i} {lang} T={T}"
            rowne([x[0] for x in ts["top"]], [x[0] for x in tw["top"]], gdzie + " kandydaci")
            for (_, a), (_, b) in zip(ts["top"], tw["top"]):
                blisko(a, b, 0.01, gdzie + " %")
            blisko(ts["top8_sum"], tw["top8_sum"], 0.01, gdzie + " top8")
            blisko(ts["n_over_1e-6"], tw["n_over_1e-6"], 1, gdzie + " n>1e-6")

# Zera w softmaksie i losowania (scena 7)
s, w = wczytaj_json("losowanie.json"), wczytaj_json(W / "losowanie.json")
for k, zw in w["zero_check"].items():
    zs = s["zero_check"][k]
    rowne((zs["zeros_float32"], zs["zeros_float64"]), (zw["zeros_float32"], zw["zeros_float64"]), f"losowanie.json {k} zera")
    blisko(zs["min_float64"] / zw["min_float64"], 1.0, 1e-6, f"losowanie.json {k} min p")
inne = sum(not tekst_zgodny(a["text"], b) for a, b in zip(s["samples"], w["samples"]))
if inne:
    platforma.append(f"losowanie.json: {inne} z {len(w['samples'])} tekstów inne")

s, w = wczytaj_json("probki-lab.json"), wczytaj_json(W / "probki-lab.json")
inne = sum(not probka_zgodna(a, b) for k in w["samples"] for a, b in zip(s["samples"][k], w["samples"][k]))
if inne:
    platforma.append(f"probki-lab.json: {inne} z {sum(len(v) for v in w['samples'].values())} próbek inne")

# Pliki na stronę: w repozytorium leżą w strona/src/data, w paczce obok skryptów (opcja --wyjscie)
for nazwa in ("rozklad", "probki"):
    plik = next((p for p in (STRONA / f"{nazwa}.json", KATALOG / f"{nazwa}.json") if p.is_file()), None)
    if plik is None:
        print(f"pominięto {nazwa}.json (brak pliku)")
        continue
    wzorzec = W / f"strona-{nazwa}.json"
    if not wzorzec.is_file():
        print(f"pominięto {plik.name} (brak wzorca w {W.name})")
        continue
    if wczytaj_json(plik) != wczytaj_json(wzorzec):
        (blad if nazwa == "rozklad" else platforma.append)(f"{plik.name} różni się od wzorca")

# Pomiary z 15.10.2026 (ujęcia 17, 32a, 47b), jeśli są we wzorcach i u Ciebie
if (W / "parametry.json").is_file() and (KATALOG / "parametry.json").is_file():
    a, b = wczytaj_json("parametry.json"), wczytaj_json(W / "parametry.json")
    for k in ("parametry_razem", "tabela_slownika", "len_tokenizer", "pozycje_ponad_tokenizer", "config"):
        rowne(a[k], b[k], f"parametry.json {k}")
if (W / "koniec.json").is_file() and (KATALOG / "koniec.json").is_file():
    a, b = wczytaj_json("koniec.json"), wczytaj_json(W / "koniec.json")
    for oa, ob in zip(a["odpowiedzi"], b["odpowiedzi"]):
        if [k["id"] for k in oa["kroki"]] != [k["id"] for k in ob["kroki"]]:
            platforma.append(f"koniec.json: inna odpowiedź na {ob['pytanie']!r}")
            continue
        for ka, kb in zip(oa["kroki"], ob["kroki"]):
            blisko(ka["p_koniec_%"], kb["p_koniec_%"], 0.01, f"koniec.json {ka['kartka']!r} p_koniec")
if (W / "claude_tokeny.json").is_file() and (KATALOG / "claude_tokeny.json").is_file():
    a, b = wczytaj_json("claude_tokeny.json"), wczytaj_json(W / "claude_tokeny.json")
    rowne([(p["pl"]["n"], p["en"]["n"]) for p in a["pary"]], [(p["pl"]["n"], p["en"]["n"]) for p in b["pary"]], "claude_tokeny.json")

for p in platforma:
    print("ZALEŻNE OD PLATFORMY:", p)
if args.scisle:
    bledy += platforma
print("ZGODNE" if not bledy else f"NIEZGODNE: {len(bledy)} różnic")
raise SystemExit(1 if bledy else 0)

"""Prawdziwe próbki do laboratorium na stronie WWW (strona/src/data/probki.json).

Dla każdego zdania (PL "Niebo jest", EN "The sky is") i każdej z trzech temperatur (0,2 / 1,0 / 1,5)
generujemy N niezależnych próbek z Qwen3-0.6B-Base: pierwszy kawałek (token) i dalszy ciąg do 12 tokenów.
Czyste próbkowanie z softmax(z / T): bez Top-K i bez Top-P (wyłączone jawnie).

Ponieważ próbki są niezależne, pierwsze tokeny mają dokładnie ten rozkład, który pokazują słupki (dist2.json),
z szumem losowym rzędu 1/sqrt(N). Skrypt sam to sprawdza i zapisuje w polu "check".

Uruchomienie: python probki_lab.py   (torch 2.14.1, transformers 5.19.0, CPU, float32), wynik: probki-lab.json
"""
import time, warnings
import torch
warnings.filterwarnings("ignore")
from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed
from _wspolne import MODEL_BAZOWY, REWIZJA_BAZOWY, meta, wczytaj_json, zapisz_json

NAME = MODEL_BAZOWY
PROMPTS = {"pl": "Niebo jest", "en": "The sky is"}
TEMPS = [0.2, 1.0, 1.5]
N = 300
NEW = 12
SEED = 2026

tok = AutoTokenizer.from_pretrained(NAME, revision=REWIZJA_BAZOWY)
model = AutoModelForCausalLM.from_pretrained(NAME, revision=REWIZJA_BAZOWY, dtype=torch.float32).eval()
dist = wczytaj_json("dist2.json")["pairs"][0]  # najpierw pairs.py
res = {"meta": meta(model=NAME, rewizja=REWIZJA_BAZOWY), "model": NAME, "torch": torch.__version__, "n_per_state": N,
       "new_tokens": NEW, "seed": SEED, "sampling": "temperature only, top_k=0, top_p=1.0", "samples": {}, "check": {}}

for lang, prompt in PROMPTS.items():
    ids = tok(prompt, return_tensors="pt")
    plen = ids["input_ids"].shape[1]
    for T in TEMPS:
        set_seed(SEED)
        t0 = time.time()
        with torch.no_grad():
            out = model.generate(**ids, do_sample=True, temperature=T, top_k=0, top_p=1.0, max_new_tokens=NEW,
                                 num_return_sequences=N, pad_token_id=tok.eos_token_id)
        items = []
        for row in out:
            gen = row[plen:].tolist()
            if tok.eos_token_id in gen:
                gen = gen[:gen.index(tok.eos_token_id)]
            if not gen:
                continue
            first = tok.decode(gen[:1])
            # kawałek do wyświetlenia: pierwszy token, a gdy to sama spacja albo urwany znak, razem z kolejnymi
            k, piece = 1, first
            while ("�" in piece or not piece.strip()) and k < min(4, len(gen)):
                k += 1
                piece = tok.decode(gen[:k])
            whole = tok.decode(gen)
            rest = whole[len(piece):] if whole.startswith(piece) else ""
            items.append({"t": first, "p": piece, "r": rest})
        key = f"{lang}|{T}"
        res["samples"][key] = items
        # kontrola: odsetek próbek, których pierwszy token to lider z pomiaru, kontra zmierzone prawdopodobieństwo
        top = dist[lang]["T"][str(T)]["top"]
        lead_tok, lead_p = top[0]
        frac = sum(1 for x in items if x["t"] == lead_tok) / len(items)
        res["check"][key] = {"n": len(items), "lider": lead_tok, "zmierzone_%": lead_p, "w_probkach_%": round(frac * 100, 2),
                             "szum_1sigma_%": round(100 * (lead_p / 100 * (1 - lead_p / 100) / len(items)) ** 0.5, 2)}
        print(f"[{key}] {len(items)} próbek, {time.time() - t0:.0f} s, lider {lead_tok!r}: zmierzone {lead_p}%, w próbkach {frac * 100:.1f}%", flush=True)
        for x in items[:3]:
            print("    ", repr(prompt + x["p"] + x["r"]), flush=True)

zapisz_json("probki-lab.json", res)

"""Filtr próbek do publikacji na stronie: probki-lab.json -> ../../strona/src/data/probki.json.

Model bazowy w "ogonie" rozkładu potrafi wyprodukować adresy internetowe, urwane znaki i słowa wymagające ostrożności.
Takich próbek nie publikujemy. Filtr jest celowo ostrożny, więc odrzuca też kilka niewinnych (np. "killoan").
Liczba odrzuconych jest zapisana w pliku i podana na stronie, bo filtr minimalnie zmienia częstości.
Odrzucamy próbkę, gdy zawiera: znak zastępczy (urwany bajt), @, http, www., .com, .pl albo słowo z listy poniżej.
Uruchomienie: python filtruj_probki.py [--wyjscie ŚCIEŻKA]
Domyślnie: strona/src/data/probki.json, a gdy nie ma takiego katalogu (np. po pobraniu samych skryptów), probki.json obok skryptu.
"""
import argparse, re, collections
from pathlib import Path
from _wspolne import KATALOG, wczytaj_json, zapisz_json

ap = argparse.ArgumentParser()
ap.add_argument("--wyjscie")
args = ap.parse_args()
STRONA = (KATALOG / "../../strona/src/data").resolve()
WYJSCIE = Path(args.wyjscie) if args.wyjscie else (STRONA if STRONA.is_dir() else KATALOG) / "probki.json"

BAD = re.compile(r"kurw|chuj|huj|pierdol|jeb[aeiouy]|pizd|szmat|dziwk|skurw|sex|porn|fuck|shit|bitch|cunt|dick|pussy|nigg|fag|rape|nazi|hitler|suicid|whore|cock|slut|kill|murder|terror|bomb|isis|jihad|xxx|nude|naked|escort", re.I)
NET = re.compile(r"https?://|www\.|@|\.com|\.pl\b")

src = wczytaj_json("probki-lab.json")
dist = wczytaj_json("dist2.json")["pairs"][0]
out = {"model": src["model"], "new_tokens": src["new_tokens"], "sampling": src["sampling"], "seed": src["seed"], "samples": {}, "odrzucone": {}, "check": {}}
removed = collections.Counter()
for key, items in src["samples"].items():
    kept = []
    for s in items:
        txt = s["p"] + s["r"]
        if "�" in txt or NET.search(txt) or BAD.search(txt):
            removed[key] += 1
        else:
            kept.append(s)
    out["samples"][key] = kept
    lang, T = key.split("|")
    lead_tok, lead_p = dist[lang]["T"][str(float(T))]["top"][0]
    frac = 100 * sum(1 for s in kept if s["t"] == lead_tok) / len(kept)
    out["odrzucone"][key] = removed[key]
    out["check"][key] = {"n": len(kept), "lider": lead_tok, "zmierzone_%": lead_p, "w_probkach_%": round(frac, 2)}
    print(f"{key}: zostało {len(kept)}, odrzucono {removed[key]}, lider {lead_tok!r}: zmierzone {lead_p}% vs w próbkach {frac:.1f}%")
total_removed = sum(removed.values()); total = sum(len(v) for v in src["samples"].values())
out["n_per_state"] = min(len(v) for v in out["samples"].values())
print(f"razem odrzucono {total_removed} z {total} ({100 * total_removed / total:.1f}%)")
zapisz_json(WYJSCIE.resolve(), out, indent=None, separators=(",", ":"))

"""Dane słupków na stronę WWW: dist2.json -> strona/src/data/rozklad.json.

Bierze pierwszą parę z dist2.json ("Niebo jest" / "The sky is"), temperatury w kolejności 0,2 / 1,0 / 1,5,
osiem pierwszych kandydatów i liczbę kandydatów z szansą > 1e-6 (pole "n").
Uruchomienie: python rozklad.py [--wyjscie ŚCIEŻKA] [--data RRRR-MM-DD]   (najpierw pairs.py)
Domyślnie: strona/src/data/rozklad.json, a gdy nie ma takiego katalogu (np. po pobraniu samych skryptów), rozklad.json obok skryptu.
"""
import argparse
from pathlib import Path
from _wspolne import KATALOG, wczytaj_json, zapisz_json

ap = argparse.ArgumentParser()
ap.add_argument("--wyjscie")
ap.add_argument("--data", default="2026-10-09", help="data pomiaru pokazywana na stronie")
args = ap.parse_args()

dist = wczytaj_json("dist2.json")
para = dist["pairs"][0]
out = {"model": dist["model"], "vocab": dist["logits_dim"], "date": args.data, "prompts": {}}
for lang in ("pl", "en"):
    r = para[lang]
    out["prompts"][lang] = {
        "prompt": r["prompt"], "tokens": r["tokens"],
        "T": {T: {"top": r["T"][T]["top"], "top8_sum": r["T"][T]["top8_sum"], "n": r["T"][T]["n_over_1e-6"]}
              for T in sorted(r["T"], key=float)},
    }
STRONA = (KATALOG / "../../strona/src/data").resolve()
WYJSCIE = Path(args.wyjscie) if args.wyjscie else (STRONA if STRONA.is_dir() else KATALOG) / "rozklad.json"
zapisz_json(WYJSCIE.resolve(), out)