Datasets:
File size: 7,755 Bytes
2656dc7 | 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 158 159 160 161 | #!/usr/bin/env python3
"""Intelligenz- und Mathetests: Original Qwen2.5-7B-Instruct gegen geheiltes Modell gegen Hardcore-Modell.
Gleiche Aufgaben, gleiche Einstellungen (bf16, GPU 0, Greedy, repetition_penalty 1.0, Standard-Chat-Template):
GSM8K (100, Rechenaufgaben, Antwort per Text) | MMLU (100, Multiple Choice, Logits ueber A-D)
ARC-Challenge (100, Multiple Choice) | Arithmetik (40, selbst erzeugt).
"""
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
PLATTE = "/home/david/Schreibtisch/Platte"
os.environ.setdefault("HF_HOME", f"{PLATTE}/cache/huggingface")
os.environ.setdefault("HF_HUB_CACHE", f"{PLATTE}/cache/huggingface/hub")
os.environ["HF_HUB_OFFLINE"] = "1"
import gc
import json
import random
import re
import time
import torch
from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
MODELS = [
("v4", f"{PLATTE}/models/graf_zahl/qwen_graf_zahl_v4_merged"),
]
RESULTS = f"{PLATTE}/models/graf_zahl/compare_intelligence_v4_results.json"
N_GSM, N_MMLU, N_ARC = 100, 100, 100
SEED = 3407
BATCH = 16
def build_tasks():
rng = random.Random(SEED)
g = load_dataset("openai/gsm8k", "main", split="test")
gsm = [{"q": g[i]["question"], "a": float(g[i]["answer"].split("####")[-1].strip().replace(",", ""))}
for i in rng.sample(range(len(g)), N_GSM)]
m = load_dataset("cais/mmlu", "all", split="test")
mmlu = []
for i in rng.sample(range(len(m)), N_MMLU):
r = m[i]
opts = "\n".join(f"{l}. {c}" for l, c in zip("ABCD", r["choices"]))
mmlu.append({"q": f"The following is a multiple choice question about {r['subject'].replace('_', ' ')}.\n\n"
f"{r['question']}\n{opts}\n\nAnswer with only the letter of the correct option.",
"a": "ABCD"[r["answer"]], "labels": "ABCD", "subject": r["subject"]})
a = load_dataset("allenai/ai2_arc", "ARC-Challenge", split="test")
arc = []
for i in rng.sample(range(len(a)), N_ARC):
r = a[i]
labels = r["choices"]["label"]
opts = "\n".join(f"{l}. {t}" for l, t in zip(labels, r["choices"]["text"]))
arc.append({"q": f"The following is a multiple choice science question.\n\n{r['question']}\n{opts}\n\n"
"Answer with only the letter of the correct option.", "a": r["answerKey"], "labels": "".join(labels)})
ar = []
for _ in range(10): x, y = rng.randint(10000, 99999), rng.randint(10000, 99999); ar.append((f"{x} + {y}", x + y, "add"))
for _ in range(10): x, y = rng.randint(50000, 99999), rng.randint(10000, 49999); ar.append((f"{x} - {y}", x - y, "sub"))
for _ in range(10): x, y = rng.randint(100, 999), rng.randint(11, 99); ar.append((f"{x} * {y}", x * y, "mul 3x2"))
for _ in range(5): x, y = rng.randint(100, 999), rng.randint(100, 999); ar.append((f"{x} * {y}", x * y, "mul 3x3"))
for _ in range(5): y, q = rng.randint(12, 99), rng.randint(100, 999); ar.append((f"{y * q} / {y}", q, "div"))
arith = [{"q": f"Berechne: {e} = ?\nAntworte nur mit der Zahl.", "a": float(v), "typ": t} for e, v, t in ar]
return {"GSM8K": gsm, "MMLU": mmlu, "ARC-Challenge": arc, "Arithmetik": arith}
def to_prompt(tok, text):
return tok.apply_chat_template([{"role": "user", "content": text}], tokenize=False, add_generation_prompt=True)
def last_number(s):
nums = re.findall(r"-?\d[\d,]*\.?\d*", s.replace("$", ""))
return float(nums[-1].replace(",", "").rstrip(".")) if nums else None
def gsm_number(s):
m = re.findall(r"Answer:\s*\$?\s*(-?\d[\d,]*\.?\d*)", s)
return float(m[-1].replace(",", "").rstrip(".")) if m else last_number(s)
@torch.no_grad()
def generate_batch(model, tok, prompts, max_new):
outs = []
order = sorted(range(len(prompts)), key=lambda i: len(prompts[i]))
res = [None] * len(prompts)
for s in range(0, len(order), BATCH):
idx = order[s:s + BATCH]
enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True, add_special_tokens=False).to("cuda")
out = model.generate(**enc, max_new_tokens=max_new, do_sample=False, repetition_penalty=1.0,
eos_token_id=tok.eos_token_id, pad_token_id=tok.pad_token_id)
for j, i in enumerate(idx):
res[i] = tok.decode(out[j][enc["input_ids"].shape[1]:], skip_special_tokens=True)
return res
@torch.no_grad()
def choose_letters(model, tok, prompts, labels_list):
letter_ids = {}
for l in set("".join(labels_list)):
ids = tok.encode(l, add_special_tokens=False)
assert len(ids) == 1, (l, ids)
letter_ids[l] = ids[0]
res = [None] * len(prompts)
order = sorted(range(len(prompts)), key=lambda i: len(prompts[i]))
for s in range(0, len(order), BATCH):
idx = order[s:s + BATCH]
enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True, add_special_tokens=False).to("cuda")
logits = model(**enc).logits[:, -1, :].float()
for j, i in enumerate(idx):
res[i] = max(labels_list[i], key=lambda l: logits[j, letter_ids[l]].item())
return res
def main():
tasks = build_tasks()
print({k: len(v) for k, v in tasks.items()}, flush=True)
results = {}
for name, path in MODELS:
t0 = time.time()
tok = AutoTokenizer.from_pretrained(path)
tok.padding_side = "left"
model = AutoModelForCausalLM.from_pretrained(path, dtype=torch.bfloat16, device_map={"": 0}).eval()
print(f"\n===== {name} geladen ({len(tok)} Tokens im Vokabular, {time.time() - t0:.0f}s) =====", flush=True)
r = {}
outs = generate_batch(model, tok, [to_prompt(tok, t["q"] + "\nSolve the problem step by step. End your reply with 'Answer: <number>'.")
for t in tasks["GSM8K"]], 512)
ok = [gsm_number(o) is not None and abs(gsm_number(o) - t["a"]) < 1e-6 for o, t in zip(outs, tasks["GSM8K"])]
r["GSM8K"] = {"richtig": sum(ok), "n": len(ok), "beispiel_antwort": outs[0][-300:]}
print(f" GSM8K: {sum(ok)}/{len(ok)} ({time.time() - t0:.0f}s)", flush=True)
for key in ("MMLU", "ARC-Challenge"):
pick = choose_letters(model, tok, [to_prompt(tok, t["q"]) for t in tasks[key]], [t["labels"] for t in tasks[key]])
ok = [p == t["a"] for p, t in zip(pick, tasks[key])]
r[key] = {"richtig": sum(ok), "n": len(ok)}
print(f" {key}: {sum(ok)}/{len(ok)} ({time.time() - t0:.0f}s)", flush=True)
outs = generate_batch(model, tok, [to_prompt(tok, t["q"]) for t in tasks["Arithmetik"]], 40)
ok = [last_number(o) is not None and abs(last_number(o) - t["a"]) < 1e-6 for o, t in zip(outs, tasks["Arithmetik"])]
by = {}
for t, k in zip(tasks["Arithmetik"], ok):
by.setdefault(t["typ"], []).append(k)
r["Arithmetik"] = {"richtig": sum(ok), "n": len(ok), "je_typ": {k: f"{sum(v)}/{len(v)}" for k, v in by.items()}}
print(f" Arithmetik: {sum(ok)}/{len(ok)} {r['Arithmetik']['je_typ']} ({time.time() - t0:.0f}s)", flush=True)
results[name] = r
json.dump(results, open(RESULTS, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
del model
gc.collect()
torch.cuda.empty_cache()
print("\n===== AUSWERTUNG =====")
names = list(results)
print(f"{'Test':16} " + " ".join(f"{n[:28]:>30}" for n in names))
for key in ("GSM8K", "MMLU", "ARC-Challenge", "Arithmetik"):
print(f"{key:16} " + " ".join(f"{results[n][key]['richtig']:>4}/{results[n][key]['n']:<3} = {results[n][key]['richtig'] / results[n][key]['n'] * 100:5.1f} %".rjust(30) for n in names))
print(f"\nErgebnisse: {RESULTS}")
if __name__ == "__main__":
main()
|