File size: 5,373 Bytes
198fb2a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | import argparse
from pathlib import Path
from typing import Iterable, List, Tuple
import numpy as np
from export_weights import SCALE, load_state_dict, quantize_q12
from karpathy_exact_reference import (
BLOCK_SIZE,
N_LAYER,
consume_training_rng_state,
gpt,
load_docs,
sample_names,
softmax,
)
def load_float_state(weights_path: Path) -> dict[str, np.ndarray]:
state = load_state_dict(weights_path)
return {key: np.asarray(value, dtype=np.float64) for key, value in state.items()}
def load_q12_dequant_state(weights_path: Path) -> dict[str, np.ndarray]:
state = load_float_state(weights_path)
return {
key: quantize_q12(value).astype(np.float64) / float(SCALE)
for key, value in state.items()
}
def build_vocab(names_path: Path) -> tuple[dict[int, str], int, list[str]]:
docs = load_docs(names_path)
uchars = sorted(set("".join(docs)))
bos_token = len(uchars)
itos = {idx: ch for idx, ch in enumerate(uchars)}
return itos, bos_token, docs
def count_params(state: dict[str, np.ndarray]) -> int:
return sum(int(np.prod(value.shape)) for value in state.values())
def xorshift32(state: int) -> int:
state &= 0xFFFFFFFF
state ^= (state << 13) & 0xFFFFFFFF
state ^= (state >> 17) & 0xFFFFFFFF
state ^= (state << 5) & 0xFFFFFFFF
return state & 0xFFFFFFFF
def sample_names_xorshift(
state: dict[str, np.ndarray],
itos: dict[int, str],
bos_token: int,
count: int,
temperature: float,
seed: int,
) -> Iterable[Tuple[int, str, List[int], int]]:
rng_state = seed & 0xFFFFFFFF
for sample_idx in range(count):
keys = [[] for _ in range(N_LAYER)]
values = [[] for _ in range(N_LAYER)]
token_id = bos_token
sample = []
tokens = []
for pos_id in range(BLOCK_SIZE):
logits = gpt(state, token_id, pos_id, keys, values, bos_token)
probs = softmax([logit / temperature for logit in logits])
rng_state = xorshift32(rng_state)
threshold = (rng_state & 0xFFFFFF) / float(1 << 24)
cdf = 0.0
token_id = len(probs) - 1
for idx, prob in enumerate(probs):
cdf += prob
if threshold < cdf:
token_id = idx
break
tokens.append(token_id)
if token_id == bos_token:
break
sample.append(itos[token_id])
yield sample_idx + 1, "".join(sample), tokens, rng_state
def collect_python_reference(
state: dict[str, np.ndarray],
names_path: Path,
count: int,
temperature: float,
) -> list[tuple[int, str, list[int]]]:
itos, bos_token, docs = build_vocab(names_path)
consume_training_rng_state(docs, bos_token + 1)
return list(sample_names(state, itos, bos_token, count, temperature))
def collect_xorshift_reference(
state: dict[str, np.ndarray],
names_path: Path,
count: int,
temperature: float,
seed: int,
) -> list[tuple[int, str, list[int], int]]:
itos, bos_token, _ = build_vocab(names_path)
return list(sample_names_xorshift(state, itos, bos_token, count, temperature, seed))
def main() -> None:
parser = argparse.ArgumentParser(
description="Compare exact Python microGPT outputs against the exported RTL Q4.12 weights."
)
parser.add_argument("--weights", default="rtl/microgpt/weights_only.npy")
parser.add_argument("--names", default="rtl/microgpt/names.txt")
parser.add_argument("--count", type=int, default=5)
parser.add_argument("--temperature", type=float, default=0.5)
parser.add_argument("--xorshift-seed", type=int, default=2)
args = parser.parse_args()
root = Path(__file__).resolve().parents[2]
weights_path = Path(args.weights)
names_path = Path(args.names)
if not weights_path.is_absolute():
weights_path = root / weights_path
if not names_path.is_absolute():
names_path = root / names_path
float_state = load_float_state(weights_path)
q12_state = load_q12_dequant_state(weights_path)
print(f"param_count={count_params(float_state)}")
float_python = collect_python_reference(float_state, names_path, args.count, args.temperature)
q12_python = collect_python_reference(q12_state, names_path, args.count, args.temperature)
print("python_rng_float:")
for idx, text, tokens in float_python:
print(f" sample {idx:2d}: {text:<16s} tokens={tokens}")
print("python_rng_q12_dequant:")
for idx, text, tokens in q12_python:
print(f" sample {idx:2d}: {text:<16s} tokens={tokens}")
float_xorshift = collect_xorshift_reference(
float_state, names_path, args.count, args.temperature, args.xorshift_seed
)
q12_xorshift = collect_xorshift_reference(
q12_state, names_path, args.count, args.temperature, args.xorshift_seed
)
print(f"xorshift_float_seed={args.xorshift_seed}:")
for idx, text, tokens, seed_after in float_xorshift:
print(f" sample {idx:2d}: {text:<16s} tokens={tokens} rng=0x{seed_after:08X}")
print(f"xorshift_q12_dequant_seed={args.xorshift_seed}:")
for idx, text, tokens, seed_after in q12_xorshift:
print(f" sample {idx:2d}: {text:<16s} tokens={tokens} rng=0x{seed_after:08X}")
if __name__ == "__main__":
main()
|