Download slice_d1_3b.py from ggml-org-dev/tiny-d1-3B-for-testing: direct link, hf CLI and curl.
- Browser
- Download file 6.99 kB
-
https://huggingface.co/ggml-org-dev/tiny-d1-3B-for-testing/resolve/main/slice_d1_3b.py
- Command line
-
hf download hf://ggml-org-dev/tiny-d1-3B-for-testing/slice_d1_3b.py
-
curl -L -o slice_d1_3b.py https://huggingface.co/ggml-org-dev/tiny-d1-3B-for-testing/resolve/main/slice_d1_3b.py
6.99 kB
| #!/usr/bin/env python3 | |
| """ | |
| Build a tiny slice of LiquidAI/d1-3B (lfm2-d1 decision model, LFM2-VL based) for testing. Output is gibberish, only the shapes and code paths are real. | |
| Adapted from the slice-model skill of llama.cpp (skills/slice-model): tensors are fetched with HTTP range requests and config.json is patched to match, then convert_hf_to_gguf.py does the conversion. It keeps a few layers and also narrows the widths: the 128000 x 2048 token embedding alone would be far too big, text hidden 64 keeps the Q4_0 GGUF under 10 MB. | |
| usage: slice_d1_3b.py <output dir> | |
| """ | |
| import json, re, struct, sys | |
| from concurrent.futures import ThreadPoolExecutor | |
| from pathlib import Path | |
| import requests | |
| import torch | |
| from huggingface_hub import hf_hub_url | |
| from safetensors.torch import save_file | |
| REPO = 'LiquidAI/d1-3B' | |
| AUX = ['tokenizer.json', 'tokenizer_config.json', 'chat_template.jinja', 'processor_config.json', 'LICENSE'] | |
| E, H, KV, FF = 64, 1, 1, 256 # text: hidden, heads, kv heads, ffn. head_dim stays 64 (hidden / heads) | |
| V, VH, VFF, VP = 144, 2, 288, 256 # vision: hidden, heads (head_dim stays 72), ffn, projector hidden size | |
| TEXT_LAYERS = [0, 2, 3, 5] # conv, full attn, conv, full attn | |
| VISION_LAYERS = [0, 1, 2] # 3 layers: the converter maps multi_modal_projector.linear_{bid} by block id, linear_2 needs a block count > 2 | |
| DTYPES = {'BF16': torch.bfloat16, 'F32': torch.float32, 'F16': torch.float16} | |
| def read_header(url): | |
| def rng(a, b): | |
| r = requests.get(url, headers={'Range': f'bytes={a}-{b}'}, timeout=120) | |
| r.raise_for_status() | |
| return r.content | |
| n = struct.unpack('<Q', rng(0, 7))[0] | |
| h = json.loads(rng(8, 8 + n - 1)) | |
| h.pop('__metadata__', None) | |
| return h, 8 + n | |
| def fetch(url, meta, base): | |
| a, b = meta['data_offsets'] | |
| r = requests.get(url, headers={'Range': f'bytes={base + a}-{base + b - 1}'}, timeout=600) | |
| r.raise_for_status() | |
| assert len(r.content) == b - a | |
| return torch.frombuffer(bytearray(r.content), dtype=DTYPES[meta['dtype']]).reshape(meta['shape']) | |
| def renumber(name, prefix, keep): | |
| m = re.match(re.escape(prefix) + r'\.(\d+)\.(.*)', name) | |
| if not m: | |
| return name | |
| i = int(m[1]) | |
| return f'{prefix}.{keep.index(i)}.{m[2]}' if i in keep else None | |
| def text_block(t, key): | |
| if key.endswith('conv.conv.weight'): | |
| return t[:E] | |
| if key.endswith('conv.in_proj.weight'): | |
| return t.reshape(3, -1, t.shape[-1])[:, :E, :E].reshape(3 * E, E) # B, C and x are stacked | |
| if key.endswith('conv.out_proj.weight'): | |
| return t[:E, :E] | |
| if key.endswith(('feed_forward.w1.weight', 'feed_forward.w3.weight')): | |
| return t[:FF, :E] | |
| if key.endswith('feed_forward.w2.weight'): | |
| return t[:E, :FF] | |
| if key.endswith(('ffn_norm.weight', 'operator_norm.weight')): | |
| return t[:E] | |
| if key.endswith(('q_layernorm.weight', 'k_layernorm.weight')): | |
| return t | |
| if key.endswith('self_attn.q_proj.weight'): | |
| return t[:H * 64, :E] | |
| if key.endswith(('self_attn.k_proj.weight', 'self_attn.v_proj.weight')): | |
| return t[:KV * 64, :E] | |
| if key.endswith('self_attn.out_proj.weight'): | |
| return t[:E, :H * 64] | |
| raise SystemExit(f'unhandled tensor {key}') | |
| def vision_block(t, key): | |
| if key.endswith(('layer_norm1.weight', 'layer_norm1.bias', 'layer_norm2.weight', 'layer_norm2.bias', 'mlp.fc2.bias', | |
| 'q_proj.bias', 'k_proj.bias', 'v_proj.bias', 'out_proj.bias')): | |
| return t[:V] | |
| if key.endswith(('q_proj.weight', 'k_proj.weight', 'v_proj.weight', 'out_proj.weight')): | |
| return t[:V, :V] | |
| if key.endswith('mlp.fc1.weight'): | |
| return t[:VFF, :V] | |
| if key.endswith('mlp.fc1.bias'): | |
| return t[:VFF] | |
| if key.endswith('mlp.fc2.weight'): | |
| return t[:V, :VFF] | |
| raise SystemExit(f'unhandled tensor {key}') | |
| def narrow(name, t): | |
| if name.startswith('model.language_model.layers.'): | |
| return text_block(t, name) | |
| if name.startswith('model.vision_tower.vision_model.encoder.layers.'): | |
| return vision_block(t, name) | |
| p = 'model.vision_tower.vision_model.' | |
| table = { | |
| 'model.language_model.embed_tokens.weight': lambda: t[:, :E], | |
| 'model.language_model.embedding_norm.weight': lambda: t[:E], | |
| p + 'embeddings.patch_embedding.weight': lambda: t[:V], | |
| p + 'embeddings.patch_embedding.bias': lambda: t[:V], | |
| p + 'embeddings.position_embedding.weight': lambda: t[:, :V], | |
| p + 'post_layernorm.weight': lambda: t[:V], | |
| p + 'post_layernorm.bias': lambda: t[:V], | |
| # the 2x2 pixel unshuffle puts the 4 patches one after the other, each with its V channels | |
| 'model.multi_modal_projector.linear_1.weight': lambda: t.reshape(t.shape[0], 4, -1)[:VP, :, :V].reshape(VP, 4 * V), | |
| 'model.multi_modal_projector.linear_1.bias': lambda: t[:VP], | |
| 'model.multi_modal_projector.linear_2.weight': lambda: t[:E, :VP], | |
| 'model.multi_modal_projector.linear_2.bias': lambda: t[:E], | |
| } | |
| if name in table: | |
| return table[name]() | |
| raise SystemExit(f'unhandled tensor {name}') | |
| def rename(n): | |
| for prefix, keep in (('model.language_model.layers', TEXT_LAYERS), ('model.vision_tower.vision_model.encoder.layers', VISION_LAYERS)): | |
| if n.startswith(prefix + '.'): | |
| return renumber(n, prefix, keep) | |
| return n | |
| def slice_file(filename, out_path): | |
| url = hf_hub_url(REPO, filename) | |
| header, base = read_header(url) | |
| jobs = [(n, m, rename(n)) for n, m in header.items()] | |
| jobs = [j for j in jobs if j[2] is not None] | |
| def one(job): | |
| src, meta, dst = job | |
| return dst, narrow(src, fetch(url, meta, base)).contiguous().clone() | |
| with ThreadPoolExecutor(8) as ex: | |
| tensors = dict(ex.map(one, jobs)) | |
| out_path.parent.mkdir(parents=True, exist_ok=True) | |
| save_file(tensors, out_path, metadata={'format': 'pt'}) | |
| print(f'{filename}: {len(tensors)}/{len(header)} tensors, {out_path.stat().st_size / 1e6:.1f} MB') | |
| def patch_config(c): | |
| t = c['text_config'] | |
| t.update(hidden_size=E, block_dim=E, conv_dim=E, intermediate_size=FF, num_attention_heads=H, num_heads=H, num_key_value_heads=KV, | |
| num_hidden_layers=len(TEXT_LAYERS), layer_types=[t['layer_types'][i] for i in TEXT_LAYERS]) | |
| v = c['vision_config'] | |
| v.update(hidden_size=V, intermediate_size=VFF, num_attention_heads=VH, num_hidden_layers=len(VISION_LAYERS)) | |
| c['projector_hidden_size'] = VP | |
| return c | |
| def main(): | |
| out = Path(sys.argv[1]) | |
| out.mkdir(parents=True, exist_ok=True) | |
| slice_file('model.safetensors', out / 'model.safetensors') | |
| for f in AUX: | |
| r = requests.get(hf_hub_url(REPO, f), timeout=120) | |
| r.raise_for_status() | |
| (out / f).write_bytes(r.content) | |
| r = requests.get(hf_hub_url(REPO, 'config.json'), timeout=120) | |
| r.raise_for_status() | |
| (out / 'config.json').write_text(json.dumps(patch_config(r.json()), indent=2) + '\n') | |
| main() | |