Skip to main content

qualia_core_db/gguf_bridge/qwen35/ftw/
weights.rs

1//! Exact borrowed FTW projection views; all execution output is caller-owned.
2use crate::inference::moe::ftw_loader::{FtwModelPackage, FtwTensorEntry};
3use etalon_inference::ordinary::qwen35::{self, weights::TensorBytes};
4use etalon_model::inference::TensorInfo;
5
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7pub enum WeightError {
8    Missing,
9    Ambiguous,
10    Shape,
11    Encoding,
12    Bounds,
13    NonFinite,
14}
15
16pub struct DenseSource<'a>(pub &'a FtwModelPackage);
17impl TensorBytes for DenseSource<'_> {
18    fn tensor_bytes(&self, info: &TensorInfo) -> Result<&[u8], qwen35::Error> {
19        let len = crate::ggml_quants::tensor_byte_len(info).ok_or(qwen35::Error::Provider)?;
20        self.0
21            .fetch_by_global_offset(info.byte_offset, len)
22            .ok_or(qwen35::Error::Provider)
23    }
24}
25
26#[derive(Clone, Copy, Debug)]
27struct Bytes {
28    offset: u64,
29    len: usize,
30}
31impl Bytes {
32    fn from_entry(t: &FtwTensorEntry) -> Result<Self, WeightError> {
33        Ok(Self {
34            offset: t.global_off,
35            len: usize::try_from(t.nbytes).map_err(|_| WeightError::Bounds)?,
36        })
37    }
38    fn get(self, pkg: &FtwModelPackage) -> Result<&[u8], WeightError> {
39        pkg.fetch_by_global_offset(self.offset, self.len)
40            .ok_or(WeightError::Bounds)
41    }
42}
43
44pub fn entry<'a>(pkg: &'a FtwModelPackage, name: &str) -> Result<&'a FtwTensorEntry, WeightError> {
45    let mut found = pkg.manifest.tensors.iter().filter(|t| t.name == name);
46    let result = found.next().ok_or(WeightError::Missing)?;
47    if found.next().is_some() {
48        return Err(WeightError::Ambiguous);
49    }
50    Ok(result)
51}
52
53/// Dense NVFP4 W4A16 matrix: two E2M1 values per byte, one E4M3 scale
54/// per sixteen columns, and an independent F16 multiplier per row.
55#[derive(Clone, Copy, Debug)]
56pub struct Nvfp4Projection {
57    pub(crate) rows: usize,
58    pub(crate) cols: usize,
59    packed: Bytes,
60    scales: Bytes,
61    globals: Bytes,
62}
63#[cfg(test)]
64#[path = "weights_tests.rs"]
65mod tests;
66impl Nvfp4Projection {
67    pub fn admit(
68        pkg: &FtwModelPackage,
69        base: &str,
70        rows: usize,
71        cols: usize,
72    ) -> Result<Self, WeightError> {
73        if rows == 0 || cols == 0 || cols % 16 != 0 || cols > 16384 {
74            return Err(WeightError::Shape);
75        }
76        let p = entry(pkg, &format!("{base}.weight"))?;
77        let s = entry(pkg, &format!("{base}.weight_scale"))?;
78        let g = entry(pkg, &format!("{base}.weight_global"))?;
79        if p.dtype != "uint8" || s.dtype != "float8_e4m3fn" || g.dtype != "float16" {
80            return Err(WeightError::Encoding);
81        }
82        if p.shape != [rows as u64, (cols / 2) as u64]
83            || s.shape != [rows as u64, (cols / 16) as u64]
84            || g.shape != [rows as u64]
85        {
86            return Err(WeightError::Shape);
87        }
88        let value = Self {
89            rows,
90            cols,
91            packed: Bytes::from_entry(p)?,
92            scales: Bytes::from_entry(s)?,
93            globals: Bytes::from_entry(g)?,
94        };
95        let expected = rows.checked_mul(cols).ok_or(WeightError::Bounds)?;
96        if value.packed.len != expected / 2
97            || value.scales.len != expected / 16
98            || value.globals.len != rows.checked_mul(2).ok_or(WeightError::Bounds)?
99        {
100            return Err(WeightError::Bounds);
101        }
102        value.packed.get(pkg)?;
103        let scales = value.scales.get(pkg)?;
104        let globals = value.globals.get(pkg)?;
105        // E4M3FN has no infinity encoding; only these signed NaN codes
106        // are non-finite. Inspect the encoding without a numerical decode.
107        if scales.iter().any(|&x| x & 0x7f == 0x7f) {
108            return Err(WeightError::NonFinite);
109        }
110        for row in 0..rows {
111            let global =
112                half::f16::from_le_bytes([globals[2 * row], globals[2 * row + 1]]).to_f32();
113            if !global.is_finite() || global <= 0.0 {
114                return Err(WeightError::NonFinite);
115            }
116        }
117        Ok(value)
118    }
119    pub fn row(
120        &self,
121        pkg: &FtwModelPackage,
122        row: usize,
123        out: &mut [f32],
124    ) -> Result<(), WeightError> {
125        if row >= self.rows || out.len() != self.cols {
126            return Err(WeightError::Shape);
127        }
128        let p = self.packed.get(pkg)?;
129        let s = self.scales.get(pkg)?;
130        let g = self.globals.get(pkg)?;
131        let global = half::f16::from_le_bytes([g[2 * row], g[2 * row + 1]]).to_f32();
132        crate::inference::moe::nvfp4::dequantize_nvfp4_row(
133            &p[row * self.cols / 2..(row + 1) * self.cols / 2],
134            &s[row * self.cols / 16..(row + 1) * self.cols / 16],
135            global,
136            out,
137        )
138        .map_err(|_| WeightError::Bounds)?;
139        if out.iter().any(|x| !x.is_finite()) {
140            return Err(WeightError::NonFinite);
141        }
142        Ok(())
143    }
144    pub fn gemv(
145        &self,
146        pkg: &FtwModelPackage,
147        input: &[f32],
148        out: &mut [f32],
149    ) -> Result<(), WeightError> {
150        if input.len() != self.cols
151            || out.len() != self.rows
152            || input.iter().any(|x| !x.is_finite())
153        {
154            return Err(WeightError::Shape);
155        }
156        super::nvfp4_rows::gemv(
157            input,
158            self.packed.get(pkg)?,
159            self.scales.get(pkg)?,
160            self.globals.get(pkg)?,
161            out,
162        )
163        .map_err(row_error)
164    }
165    pub fn argmax(&self, pkg: &FtwModelPackage, input: &[f32]) -> Result<(u32, f32), WeightError> {
166        if input.len() != self.cols || input.iter().any(|x| !x.is_finite()) {
167            return Err(WeightError::Shape);
168        }
169        super::nvfp4_rows::argmax(
170            input,
171            self.packed.get(pkg)?,
172            self.scales.get(pkg)?,
173            self.globals.get(pkg)?,
174            self.rows,
175        )
176        .map_err(row_error)
177    }
178}
179fn row_error(error: super::nvfp4_rows::RowError) -> WeightError {
180    match error {
181        super::nvfp4_rows::RowError::Shape => WeightError::Shape,
182        super::nvfp4_rows::RowError::NonFinite => WeightError::NonFinite,
183    }
184}