qualia_core_db/gguf_bridge/qwen35/ftw/
weights.rs1use 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#[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 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}