tiny-d1-2B-for-testing / slice_d1.py
ngxson's picture
ngxson HF Staff
upload tiny test model
0c573c1 verified
Raw History Blame Contribute Delete
6.87 kB
#!/usr/bin/env python3
"""
Build a tiny slice of LiquidAI/d1-2B (lfm3-d1 decision model) 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. The stock script only drops layers, which cannot go below the 128000 x 2048 token embedding, so this one also narrows the hidden sizes (text hidden 64 keeps the Q4_0 GGUF under 10 MB).
Adapted from slice_d1omni.py of ggml-org-dev/tiny-d1-Omni-2B-for-testing. d1-2B has the LFM3-VL weights (no audio encoder, no depthformer).
usage: slice_d1.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-2B'
AUX = ['tokenizer.json', 'tokenizer_config.json', 'chat_template.jinja', 'processor_config.json', 'calibration.json', 'LICENSE']
E, H, KV, FF = 64, 2, 1, 256 # text: hidden, heads, kv heads, ffn. head_dim stays 128
V, VH, VKV, VFF, VP = 128, 2, 1, 256, 256 # vision, head_dim stays 64, VP is the projector hidden size
TEXT_LAYERS = [0, 2, 3, 4] # conv, full attn, conv, sliding attn
VISION_LAYERS = [0, 2] # conv, full attn
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 lfm_block(t, key, n_embd, n_ff, n_q, n_kv):
"""Narrow one tensor of a text or vision block."""
if key.endswith(('conv.conv.weight', 'conv.spatial_conv.weight')):
return t[:n_embd]
if key.endswith('conv.in_proj.weight'):
return t.reshape(3, -1, t.shape[-1])[:, :n_embd, :n_embd].reshape(3 * n_embd, n_embd) # B, C and x are stacked
if key.endswith('conv.out_proj.weight'):
return t[:n_embd, :n_embd]
if key.endswith(('feed_forward.w1.weight', 'feed_forward.w3.weight')):
return t[:n_ff, :n_embd]
if key.endswith('feed_forward.w2.weight'):
return t[:n_embd, :n_ff]
if key.endswith(('ffn_norm.weight', 'operator_norm.weight', 'post_ffn_norm.weight', 'post_operator_norm.weight')):
return t[:n_embd]
if key.endswith(('q_norm.weight', 'k_norm.weight', 'q_layernorm.weight', 'k_layernorm.weight')):
return t
if key.endswith('self_attn.q_proj.weight'):
return t[:n_q, :n_embd]
if key.endswith(('self_attn.k_proj.weight', 'self_attn.v_proj.weight')):
return t[:n_kv, :n_embd]
if key.endswith(('self_attn.o_proj.weight', 'self_attn.out_proj.weight')):
return t[:n_embd, :n_q]
if key.endswith('self_attn.gate_proj.weight'):
return None # needs the head count, see the callers
raise SystemExit(f'unhandled tensor {key}')
def narrow(name, t):
if name.startswith('model.language_model.layers.'):
if name.endswith('gate_proj.weight'):
return t[:H, :E]
return lfm_block(t, name, E, FF, H * 128, KV * 128)
if name.startswith('model.vision_tower.layers.'):
return lfm_block(t, name, V, VFF, VH * 64, VKV * 64)
table = {
'model.language_model.embed_tokens.weight': lambda: t[:, :E],
'model.language_model.embedding_norm.weight': lambda: t[:E],
'model.vision_tower.embedding_norm.weight': lambda: t[:V],
'model.vision_tower.patchifier.weight': lambda: t[:V, :],
'model.multi_modal_projector.layer_norm.weight': lambda: t[:V],
'model.multi_modal_projector.layer_norm.bias': lambda: t[:V],
'model.multi_modal_projector.linear_1.weight': lambda: t[:VP, :V * 4], # 2 x 2 patches are merged
'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 slice_file(filename, out_path, rename, transform):
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, transform(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 rename_main(n):
for prefix, keep in (('model.language_model.layers', TEXT_LAYERS), ('model.vision_tower.layers', VISION_LAYERS)):
if n.startswith(prefix + '.'):
return renumber(n, prefix, keep)
return n
def patch_config(c):
t = c['text_config']
t.update(hidden_size=E, intermediate_size=FF, num_attention_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_key_value_heads=VKV, num_hidden_layers=len(VISION_LAYERS), layer_types=[v['layer_types'][i] for i in 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', rename_main, narrow)
for f in AUX:
r = requests.get(hf_hub_url(REPO, f), timeout=120)
r.raise_for_status()
(out / f).parent.mkdir(parents=True, exist_ok=True)
(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()