# Level 8 Standalone Decoder — Procedural Seeded Projections # Watermark: ip zymatica.space | astronautshe.com import os import sys import struct import zlib import json import shutil import numpy as np import torch from safetensors.torch import save_file from safetensors import safe_open from transformers import AutoTokenizer, AutoModelForCausalLM sys.stdout.reconfigure(encoding='utf-8', errors='backslashreplace') SEED_FILE = "j:/Language-U/ProceduralSeed.LLM" OUTPUT_DIR = "j:/Language-U/qwen-3.5-0.8b-procedural-reconstruction" CONFIG_SOURCE = "j:/Language-U/Language-U-V2/qwen-3.5-0.8b-local" GENESIS_MAGIC = 0x47454E45 PERFECT_MAGIC = 0x50455246 WATERMARK_LEN = 32 MASTER_SEED = 42 DICT_SIZE = 256 def get_dictionary(dim, dictionary_size, seed): """Procedurally generate a normalized dictionary matrix.""" rng = np.random.RandomState(seed) dict_mat = rng.standard_normal((dim, dictionary_size)).astype(np.float32) norms = np.linalg.norm(dict_mat, axis=0, keepdims=True) + 1e-9 return dict_mat / norms def main(): print("=" * 80) print(" PROCEDURAL DECODER -- DYNAMIC SEED PROJECTIONS RECONSTRUCTION") print(" Watermark: ip zymatica.space | astronautshe.com") print("=" * 80) if not os.path.exists(SEED_FILE): print(f"Error: Seed file '{SEED_FILE}' not found.") return print(f"\n[1] Decompressing {os.path.basename(SEED_FILE)}...") with open(SEED_FILE, "rb") as f_in: raw_genesis_data = zlib.decompress(f_in.read()) print(f" Decompressed to {len(raw_genesis_data):,} bytes.") # Read base safetensors structure (shapes/dtypes only, NOT weights) print(f"\n[2] Reading base safetensors STRUCTURE (shapes only)...") base_st = os.path.join(CONFIG_SOURCE, "model.safetensors-00001-of-00001.safetensors") tensor_meta = {} meta_state = {} with safe_open(base_st, framework="pt", device="cpu") as f: for k in f.keys(): t = f.get_tensor(k) tensor_meta[k] = (t.shape, t.dtype) meta_state[k] = t print(f"\n[3] Reconstructing absolute layers from seeds...") layer_map = {} pos = 0 # Parse header magic = struct.unpack_from('>I', raw_genesis_data, pos)[0]; pos += 4 assert magic == GENESIS_MAGIC version = struct.unpack_from('>H', raw_genesis_data, pos)[0]; pos += 2 assert version == 12, f"Expected v12, got {version}" watermark = raw_genesis_data[pos : pos + WATERMARK_LEN].decode('utf-8', errors='ignore').strip(); pos += WATERMARK_LEN perf_magic = struct.unpack_from('>I', raw_genesis_data, pos)[0]; pos += 4 assert perf_magic == PERFECT_MAGIC hidden, heads, kv_heads, ffn_dim, blocks, vocab = struct.unpack_from('>IIIIII', raw_genesis_data, pos); pos += 24 pos += 16 # skip energy targets num_layers = struct.unpack_from('>I', raw_genesis_data, pos)[0]; pos += 4 print(f" Watermark: {watermark}") print(f" v{version} | {num_layers} layers | hidden={hidden} ffn={ffn_dim} blocks={blocks} vocab={vocab}") for idx in range(num_layers): name_len = struct.unpack_from('>H', raw_genesis_data, pos)[0]; pos += 2 name = raw_genesis_data[pos : pos + name_len].decode('utf-8'); pos += name_len m, n, r = struct.unpack_from('>III', raw_genesis_data, pos); pos += 12 # Layer-specific seeds seed_u = MASTER_SEED + idx * 1000 seed_v = MASTER_SEED + idx * 1000 + 500 U_dict = get_dictionary(m, DICT_SIZE, seed_u) V_dict = get_dictionary(n, DICT_SIZE, seed_v) W_rec = np.zeros((m, n), dtype=np.float32) for rank in range(r): idx_u = raw_genesis_data[pos]; pos += 1 idx_v = raw_genesis_data[pos]; pos += 1 c = struct.unpack_from('>e', raw_genesis_data, pos)[0]; pos += 2 W_rec += c * np.outer(U_dict[:, idx_u], V_dict[:, idx_v]) dtype = tensor_meta.get(name, (None, torch.float16))[1] layer_map[name] = torch.from_numpy(W_rec).to(dtype) if (idx + 1) % 40 == 0 or (idx + 1) == num_layers: print(f" [{idx+1:3d}/{num_layers}] Reconstructed {name[-40:]}") # EOF Check print(f" EOF Check: {pos:,} vs {len(raw_genesis_data):,} bytes {'PASS' if pos == len(raw_genesis_data) else 'FAIL'}") # Step 4: Assemble final model tensors print(f"\n[4] Assembling complete safetensors...") os.makedirs(OUTPUT_DIR, exist_ok=True) reconstructed_tensors = {} for k, (shape, dtype) in tensor_meta.items(): if k in layer_map: t = layer_map[k] if t.shape == shape: reconstructed_tensors[k] = t.clone() elif t.T.shape == shape: reconstructed_tensors[k] = t.T.clone() else: reconstructed_tensors[k] = meta_state[k].to(dtype).clone() else: # Keep embeddings / norm layers from base model for SFT baseline reconstructed_tensors[k] = meta_state[k].to(dtype).clone() out_st = os.path.join(OUTPUT_DIR, "model.safetensors") print(f" Saving to {out_st}...") save_file(reconstructed_tensors, out_st) # Copy metadata files (config / tokenizer) print(f"\n[5] Copying configuration and tokenizer metadata...") skip_ext = {'.safetensors', '.bin', '.pt', '.ckpt'} for fname in os.listdir(CONFIG_SOURCE): if os.path.splitext(fname)[1].lower() in skip_ext or fname == '.cache': continue src = os.path.join(CONFIG_SOURCE, fname) dst = os.path.join(OUTPUT_DIR, fname) if os.path.isdir(src): shutil.copytree(src, dst, dirs_exist_ok=True) else: shutil.copy2(src, dst) print(f"\n[6] Re-loading and verifying model structure...") tokenizer = AutoTokenizer.from_pretrained(OUTPUT_DIR, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( OUTPUT_DIR, torch_dtype=torch.float16, trust_remote_code=True ) print("Success! Model successfully loaded and verified.") print("=" * 80) if __name__ == "__main__": main()