| """Bounded CPU tensor slices and arithmetic probes; not an inference benchmark. |
| |
| Uses safetensors' slice contract; never loads a complete checkpoint or engine. |
| """ |
| from __future__ import annotations |
| import argparse |
| import gc |
| import json |
| import math |
| from pathlib import Path |
| import time |
|
|
| import mlx.core as mx |
| import numpy as np |
| import torch |
| from safetensors import safe_open |
|
|
| ROOT = Path(__file__).resolve().parent |
| mx.set_default_device(mx.cpu) |
| torch.set_num_threads(2) |
|
|
|
|
| def rows(root, name, start, end, *, max_bytes=32 * 1024 * 1024): |
| if mx.default_device() != mx.cpu: |
| raise ValueError('Bounded checkpoint probes require CPU device') |
| root = Path(root).resolve() |
| mapping = json.loads((root / 'model.safetensors.index.json').read_text())['weight_map'] |
| if name not in mapping: |
| raise ValueError('Missing checkpoint tensor: ' + name) |
| filename = mapping[name] |
| if Path(filename).name != filename: |
| raise ValueError('Unsafe checkpoint shard path') |
| path = (root / filename).resolve() |
| if path.parent != root: |
| raise ValueError('Checkpoint shard path escapes root') |
| with safe_open(path, framework='pt', device='cpu') as handle: |
| if name not in handle.keys(): |
| raise ValueError('Index points at missing tensor: ' + name) |
| tensor = handle.get_slice(name) |
| shape = tensor.get_shape() |
| if not shape or not (0 <= start < end <= shape[0]): |
| raise ValueError('Invalid checkpoint row bounds') |
| |
| if (end - start) * math.prod(shape[1:]) * 8 > max_bytes: |
| raise ValueError('Checkpoint slice exceeds memory bound') |
| value = tensor[start:end] |
| if value.dtype == torch.bfloat16: |
| return mx.array(value.view(torch.uint16).numpy()).view(mx.bfloat16) |
| return mx.array(value.numpy()) |
|
|
|
|
| def all_small(root, name): |
| mapping = json.loads((Path(root) / 'model.safetensors.index.json').read_text())['weight_map'] |
| with safe_open(Path(root) / mapping[name], framework='pt', device='cpu') as handle: |
| count = handle.get_slice(name).get_shape()[0] |
| return rows(root, name, 0, count) |
|
|
|
|
| def probes(output): |
| started = time.monotonic() |
| target, source = ROOT / 'target-affine4-g64', ROOT / 'source/BF16' |
| from mlx_vlm.models.qwen3_vl.vision import PatchEmbed |
| records = [] |
| |
| |
| for name, count in [ |
| ('language_model.model.layers.0.linear_attn.in_proj_a.weight', 48), |
| ('language_model.model.layers.0.mlp.up_proj.weight', 8), |
| ('language_model.model.layers.31.self_attn.q_proj.weight', 8), |
| ('language_model.lm_head.weight', 8), |
| ]: |
| prefix = name.removesuffix('.weight') |
| q = rows(target, name, 0, count) |
| scale = rows(target, prefix + '.scales', 0, count) |
| bias = rows(target, prefix + '.biases', 0, count) |
| width = q.shape[1] * 8 |
| x = (mx.arange(2 * width).reshape(2, width).astype(mx.float32) % 19 - 9) / 32 |
| x = x.astype(mx.bfloat16) |
| |
| |
| |
| bf16_result = mx.quantized_matmul(x, q, scale, bias, transpose=True, group_size=64, bits=4) |
| xf, sf, bf = x.astype(mx.float32), scale.astype(mx.float32), bias.astype(mx.float32) |
| actual = mx.quantized_matmul(xf, q, sf, bf, transpose=True, group_size=64, bits=4) |
| dense = mx.dequantize(q, sf, bf, group_size=64, bits=4) |
| mx.eval(actual, dense, xf, bf16_result) |
| ref = torch.from_numpy(np.asarray(xf)) @ torch.from_numpy(np.asarray(dense)).T |
| want = mx.array(ref.numpy()) |
| error = float(mx.max(mx.abs(actual - want))) |
| denominator = max(float(mx.max(mx.abs(want))), 1e-6) |
| bf16_error = float(mx.max(mx.abs(bf16_result.astype(mx.float32) - want))) |
| finite = bool(mx.all(mx.isfinite(actual))) |
| if not finite or error > 1e-4 * max(1., denominator): |
| raise ValueError('CPU float32 packed projection parity failed: ' + name) |
| records.append({'probe': 'quantized_projection', 'tensor': name, 'rows': count, |
| 'output_shape': list(actual.shape), 'finite': finite, |
| 'layout_parity_arithmetic_dtype': 'float32', |
| 'max_abs_error': error, 'max_abs_error_over_peak': error / denominator, |
| 'cpu_bf16_vs_float32_max_abs_error': bf16_error, |
| 'cpu_bf16_vs_float32_error_over_peak': bf16_error / denominator, |
| 'bf16_cpu_inference_parity_claimed': False}) |
| del q, scale, bias, x, actual, dense, ref, want, xf, sf, bf, bf16_result |
| gc.collect() |
|
|
| |
| config = json.loads((target / 'config.json').read_text())['vision_config'] |
| original = rows(source, 'model.visual.patch_embed.proj.weight', 0, 8).astype(mx.float32) |
| converted = rows(target, 'vision_tower.patch_embed.proj.weight', 0, 8).astype(mx.float32) |
| bias = rows(target, 'vision_tower.patch_embed.proj.bias', 0, 8).astype(mx.float32) |
| patch = PatchEmbed(patch_size=config['patch_size'], temporal_patch_size=config['temporal_patch_size'], |
| in_channels=config['in_channels'], hidden_size=8) |
| patch.load_weights([('proj.weight', converted), ('proj.bias', bias)], strict=True) |
| pixels = mx.arange(3 * 2 * 16 * 16).astype(mx.float32).reshape(1, -1) / 4096 |
| actual = patch(pixels) |
| ref = torch.nn.functional.conv3d(torch.from_numpy(np.asarray(pixels).reshape(1, 3, 2, 16, 16)), |
| torch.from_numpy(np.asarray(original)), torch.from_numpy(np.asarray(bias)), |
| stride=(2, 16, 16)).reshape(1, 8) |
| mx.eval(actual) |
| error = float(mx.max(mx.abs(actual - mx.array(ref.numpy())))) |
| if error > .001 or not bool(mx.all(mx.isfinite(actual))): |
| raise ValueError('Source/native vision patch arithmetic mismatch') |
| records.append({'probe': 'vision_patch_embed', 'output_channels': 8, |
| 'native_module': 'mlx_vlm.models.qwen3_vl.vision.PatchEmbed', |
| 'comparison': 'original-source torch Conv3d CPU', 'max_abs_error': error}) |
|
|
| norm = all_small(target, 'language_model.model.layers.0.input_layernorm.weight').astype(mx.float32) |
| x = (mx.arange(norm.size).astype(mx.float32) % 17 - 8).reshape(1, -1) / 16 |
| actual = mx.fast.rms_norm(x, norm, 1e-6) |
| refx = torch.from_numpy(np.asarray(x)) |
| ref = refx * torch.rsqrt(refx.square().mean(dim=-1, keepdim=True) + 1e-6) * torch.from_numpy(np.asarray(norm)) |
| mx.eval(actual) |
| error = float(mx.max(mx.abs(actual - mx.array(ref.numpy())))) |
| if error > .0001: |
| raise ValueError('CPU norm arithmetic mismatch') |
| records.append({'probe': 'rmsnorm', 'max_abs_error': error}) |
|
|
| result = {'device': 'cpu', 'scope': 'bounded projection, vision patch and norm arithmetic only', |
| 'full_model_loaded': False, 'model_forward_or_answer': False, |
| 'inference_speed_measured': False, 'all_passed': True, |
| 'elapsed_s': time.monotonic() - started, 'probes': records} |
| output.write_text(json.dumps(result, indent=2) + '\n') |
| return result |
|
|
|
|
| if __name__ == '__main__': |
| parser = argparse.ArgumentParser() |
| parser.add_argument('--output', type=Path, required=True) |
| args = parser.parse_args() |
| print(json.dumps(probes(args.output), indent=2)) |
|
|
