Datasets:
File size: 7,562 Bytes
089042b | 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 162 163 164 165 166 167 168 169 170 171 172 173 174 | #!/usr/bin/env python3
"""Gehirnamputation Qwen2.5-7B-Instruct: Tokens mit Doppelzeichen entfernen.
Tokenizer (JSON-Roundtrip, tokenizers 0.22.2) + Tensor-Chirurgie (embed/lm_head).
keep_ids = Filter (auf dekodiertem Text) + WHITELIST (added_tokens + special ids).
"""
import os
import json
import shutil
from collections import Counter
from pathlib import Path
os.environ.setdefault("HF_HOME", "/home/david/Schreibtisch/Platte/cache/huggingface")
os.environ.setdefault("HF_HUB_CACHE", "/home/david/Schreibtisch/Platte/cache/huggingface/hub")
import torch
from tokenizers import Tokenizer
from transformers import AutoTokenizer, AutoModelForCausalLM
MODEL_NAME = "unsloth/Qwen2.5-7B-Instruct"
TARGET_DIR = Path("/mnt/models/graf_zahl/qwen_amputated_base")
EXPECTED_KEEP = 106915
def hat_doppelzeichen(text: str) -> bool:
counts = Counter(c.lower() for c in text if c.isalnum())
return any(n > 1 for n in counts.values())
def map_id(value, old_to_new):
if value is None:
return None
if isinstance(value, (list, tuple)):
return [old_to_new[v] for v in value]
return old_to_new[value]
def main():
print("=== [1/7] keep_ids bestimmen (Filter + Whitelist) ===", flush=True)
tok = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
vocab_size = len(tok)
d = json.loads(tok._tokenizer.to_str())
base_vocab = d["model"]["vocab"]
merges = d["model"]["merges"]
added_tokens = d["added_tokens"]
added_ids = {t["id"] for t in added_tokens}
special_ids = set(tok.all_special_ids)
decoded = {}
CHUNK = 20000
for i in range(0, vocab_size, CHUNK):
chunk = list(range(i, min(i + CHUNK, vocab_size)))
for tid, txt in zip(chunk, tok.batch_decode([[t] for t in chunk], skip_special_tokens=False)):
decoded[tid] = txt
keep_ids = [
oid for oid in range(vocab_size)
if (oid in added_ids) or (oid in special_ids) or not hat_doppelzeichen(decoded[oid])
]
n_keep = len(keep_ids)
print(f" Vokabular {vocab_size} -> {n_keep} (Verlust {(vocab_size - n_keep) / vocab_size * 100:.2f}%)")
assert n_keep == EXPECTED_KEEP, f"ERWARTET {EXPECTED_KEEP}, IST {n_keep}"
print("=== [2/7] Mapping old_to_new_id ===", flush=True)
old_to_new = {old: new for new, old in enumerate(keep_ids)}
keep_set = set(keep_ids)
assert all(old_to_new[k] == i for i, k in enumerate(keep_ids))
print("=== [3/7] Tokenizer-JSON umbauen ===", flush=True)
new_vocab = {raw: old_to_new[oid] for raw, oid in base_vocab.items() if oid in keep_set}
new_added = []
for t in added_tokens:
nt = dict(t)
nt["id"] = old_to_new[t["id"]]
new_added.append(nt)
new_merges = [
(a, b) for a, b in merges
if (a + b) in new_vocab and a in new_vocab and b in new_vocab
]
n_merge_result_only = sum(1 for a, b in merges if (a + b) in new_vocab)
print(f" Basis-Vokabular: {len(base_vocab)} -> {len(new_vocab)}")
print(f" Added Tokens: {len(added_tokens)} -> {len(new_added)}")
print(f" Merges: {len(merges)} -> {len(new_merges)} "
f"(nur Ergebnis-Regel haette {n_merge_result_only} behalten)")
d["model"]["vocab"] = new_vocab
d["model"]["merges"] = new_merges
d["added_tokens"] = new_added
new_raw = Tokenizer.from_str(json.dumps(d))
assert new_raw.get_vocab_size() == n_keep, f"{new_raw.get_vocab_size()} != {n_keep}"
print("=== [4/7] Tokenizer + Config-IDs speichern ===", flush=True)
TARGET_DIR.mkdir(parents=True, exist_ok=True)
tok.save_pretrained(TARGET_DIR)
new_raw.save(str(TARGET_DIR / "tokenizer.json"))
tc_path = TARGET_DIR / "tokenizer_config.json"
tc = json.loads(tc_path.read_text(encoding="utf-8"))
if "added_tokens_decoder" in tc:
tc["added_tokens_decoder"] = {
str(old_to_new[int(k)]): v for k, v in tc["added_tokens_decoder"].items()
}
tc_path.write_text(json.dumps(tc, ensure_ascii=False, indent=2), encoding="utf-8")
print(f" tokenizer_config.json: added_tokens_decoder auf neue IDs gemappt")
print("=== [5/7] Modell laden (CPU, bf16) ===", flush=True)
model = AutoModelForCausalLM.from_pretrained(
MODEL_NAME, device_map="cpu", dtype=torch.bfloat16, trust_remote_code=True,
)
print(f" embed_tokens {tuple(model.model.embed_tokens.weight.shape)}, "
f"lm_head {tuple(model.lm_head.weight.shape)}, "
f"tie_word_embeddings={model.config.tie_word_embeddings}")
assert not model.config.tie_word_embeddings, "Tied embeddings: Slicing muesste anders laufen"
print("=== [6/7] Tensor-Chirurgie + Config ===", flush=True)
keep_tensor = torch.tensor(keep_ids, dtype=torch.long)
with torch.no_grad():
model.model.embed_tokens.weight.data = model.model.embed_tokens.weight.data[keep_tensor].contiguous()
model.lm_head.weight.data = model.lm_head.weight.data[keep_tensor].contiguous()
model.model.embed_tokens.num_embeddings = n_keep
model.lm_head.out_features = n_keep
model.config.vocab_size = n_keep
for name in ("eos_token_id", "bos_token_id", "pad_token_id"):
for cfg in (model.config, model.generation_config):
old = getattr(cfg, name, None)
if old is not None:
new = map_id(old, old_to_new)
setattr(cfg, name, new)
print(f" {type(cfg).__name__}.{name}: {old} -> {new}")
assert model.model.embed_tokens.weight.shape[0] == n_keep
assert model.lm_head.weight.shape[0] == n_keep
print("=== [7/7] Modell speichern ===", flush=True)
model.save_pretrained(TARGET_DIR, safe_serialization=True)
print(f" Gespeichert in {TARGET_DIR}")
print("\n=== VERIFIKATION (frisch von Platte) ===", flush=True)
new_tok = AutoTokenizer.from_pretrained(TARGET_DIR, trust_remote_code=True)
assert len(new_tok) == n_keep, f"len(new_tok)={len(new_tok)} != {n_keep}"
for old_id, name in ((151643, "<|endoftext|>"), (151644, "<|im_start|>"), (151645, "<|im_end|>")):
new_id = old_to_new[old_id]
got = new_tok.convert_ids_to_tokens(new_id)
assert got == name, f"{name}: neue ID {new_id} liefert {got!r}"
print(f" {name}: {old_id} -> {new_id} OK")
for s in ["Hallo Welt", "Zaehl bitte: YYYYYYYYYY. Wie viele Y sind das?", "Ah ah ah! 1 2 3 4 5"]:
ids = new_tok.encode(s, add_special_tokens=False)
assert max(ids) < n_keep
back = new_tok.decode(ids)
print(f" {s!r} -> {len(ids)} Tokens -> {back!r} {'OK' if back == s else 'ABWEICHUNG'}")
assert back == s
msgs = [{"role": "user", "content": "Hi"}]
chat_text = new_tok.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
chat_ids = new_tok.encode(chat_text, add_special_tokens=False)
assert max(chat_ids) < n_keep
print(f" Chat-Template: {len(chat_ids)} Tokens, max ID {max(chat_ids)} < {n_keep}")
check = AutoModelForCausalLM.from_pretrained(TARGET_DIR, device_map="cpu", dtype=torch.bfloat16)
assert check.model.embed_tokens.weight.shape[0] == n_keep
assert check.lm_head.weight.shape[0] == n_keep
assert check.config.vocab_size == n_keep
ref = model.model.embed_tokens.weight[:5]
assert torch.equal(check.model.embed_tokens.weight[:5], ref)
print(f" Modell neu geladen: embed/lm_head {n_keep} x {check.config.hidden_size}, Gewichte identisch")
print("\nERFOLG: amputiertes Modell liegt unter", TARGET_DIR)
if __name__ == "__main__":
main()
|