kernels: MXFP4 -> BF16 dequant kernel (verified vs numpy)

From-scratch CUDA kernel for gpt-oss expert weights: one thread per packed
byte decodes 2 FP4 (E2M1) codes, applies the per-32-block E8M0 scale
(2^(e-127)), and writes BF16 transposed into [IN, OUT] (IN = nblk*32) so it
drops straight into x @ W. dequant_mxfp4() wrapper takes raw GpuBuffers
(uint8 is not an xserv Tensor dtype). mxfp4-check bin dequants layer-0
expert-0 on GPU and matches tools/mxfp4_probe.py exactly:
  [0, 0, 0, -0.0625, 0, -0, -0.015625, -0.03125]

This lets experts stay MXFP4-resident on GPU (13GB, fits one 32GB card)
and be dequantized to a BF16 scratch right before each expert GEMM, instead
of holding 36GB of BF16 or uploading experts per token. Loader plumbing +
GPU MoE decode use it next.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

crates/xserv-model/src/bin/mxfp4-check.rs

@@ -0,0 +1,59 @@
+//! Verify the GPU MXFP4 dequant kernel against the numpy reference.
+//! Loads layer-0 expert-0 gate_up_proj from the raw MXFP4 model, dequantizes on
+//! GPU, and prints out[in_idx, out_row=0] for in_idx 0..8 — which should match
+//! tools/mxfp4_probe.py's "row0 first 8 vals".
+//!
+//! Usage: mxfp4-check <mxfp4-model-dir>
+use std::fs;
+use std::path::PathBuf;
+use safetensors::SafeTensors;
+use xserv_cuda::GpuBuffer;
+use xserv_tensor::Device;
+
+fn main() {
+    let dir = PathBuf::from(std::env::args().nth(1).expect("model dir"));
+    xserv_cuda::device::set_device(0).unwrap();
+
+    let blocks_name = "model.layers.0.mlp.experts.gate_up_proj_blocks";
+    let scales_name = "model.layers.0.mlp.experts.gate_up_proj_scales";
+
+    // Find the shard holding these tensors.
+    let index: serde_json::Value =
+        serde_json::from_str(&fs::read_to_string(dir.join("model.safetensors.index.json")).unwrap()).unwrap();
+    let wm = &index["weight_map"];
+    let shard = wm[blocks_name].as_str().expect("blocks in index");
+    assert_eq!(shard, wm[scales_name].as_str().unwrap(), "blocks/scales in same shard assumed");
+    eprintln!("[mxfp4-check] reading shard {shard}");
+    let data = fs::read(dir.join(shard)).unwrap();
+    let st = SafeTensors::deserialize(&data).unwrap();
+
+    let bv = st.tensor(blocks_name).unwrap();
+    let sv = st.tensor(scales_name).unwrap();
+    eprintln!("[mxfp4-check] blocks shape {:?} dtype {:?}", bv.shape(), bv.dtype());
+    eprintln!("[mxfp4-check] scales shape {:?} dtype {:?}", sv.shape(), sv.dtype());
+
+    // shapes: blocks [E, OUT, nblk, 16], scales [E, OUT, nblk]
+    let (out_dim, nblk) = (bv.shape()[1], bv.shape()[2]);
+    let bytes_per_expert_blocks = out_dim * nblk * 16;
+    let bytes_per_expert_scales = out_dim * nblk;
+
+    // Expert 0 = first slice of the contiguous [E, ...] buffer.
+    let blk0 = &bv.data()[..bytes_per_expert_blocks];
+    let scl0 = &sv.data()[..bytes_per_expert_scales];
+
+    let mut blk_buf = GpuBuffer::alloc(blk0.len()).unwrap();
+    let mut scl_buf = GpuBuffer::alloc(scl0.len()).unwrap();
+    blk_buf.copy_from_host(blk0).unwrap();
+    scl_buf.copy_from_host(scl0).unwrap();
+
+    let out = xserv_kernels::dequant_mxfp4(&blk_buf, &scl_buf, out_dim, nblk, 0); // BF16 [IN, OUT]
+    let in_dim = nblk * 32;
+    assert_eq!(out.shape(), &[in_dim, out_dim]);
+
+    let host = out.to_device(Device::Cpu);
+    let s = host.as_slice::<half::bf16>();
+    // out[in_idx, 0] = s[in_idx*out_dim + 0]
+    let vals: Vec<f32> = (0..8).map(|i| s[i * out_dim].to_f32()).collect();
+    println!("GPU out[0..8, row0] = {vals:?}");
+    println!("numpy ref row0 first8 = [0.0, 0.0, 0.0, -0.0625, 0.0, -0.0, -0.0156, -0.0312]");
+}