tensorfs 0.9.1__tar.gz → 0.9.2__tar.gz

{tensorfs-0.9.1 → tensorfs-0.9.2}/Cargo.lock

@@ -559,7 +559,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.9.1"
+version = "0.9.2"
 dependencies = [
  "base64",
  "fs2",
@@ -580,7 +580,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-plane"
-version = "0.9.1"
+version = "0.9.2"
 dependencies = [
  "libc",
  "libloading",
@@ -590,7 +590,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.9.1"
+version = "0.9.2"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.9.1 → tensorfs-0.9.2}/Cargo.toml

@@ -3,5 +3,5 @@ resolver = "2"
 members = ["crates/tensorfs-core", "crates/tensorfs-plane", "crates/tensorfs-py"]
 
 [workspace.package]
-version = "0.9.1"
+version = "0.9.2"
 edition = "2021"

{tensorfs-0.9.1 → tensorfs-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfs
-Version: 0.9.1
+Version: 0.9.2
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Rust

{tensorfs-0.9.1 → tensorfs-0.9.2}/crates/tensorfs-core/src/registry.rs

@@ -120,6 +120,7 @@ fn mined(name: &str) -> EncodingVectors {
         }
         "nvfp4-w4a4" => include_bytes!("../../../vectors/mined/nvfp4-w4a4.json"),
         "mxfp8" => include_bytes!("../../../vectors/mined/mxfp8.json"),
+        "int8-convrot256" => include_bytes!("../../../vectors/mined/int8-convrot256.json"),
         other => panic!("no mined vector set {other:?}"),
     };
     EncodingVectors::parse_fixture(bytes).expect("mined vectors are frozen canonical data")
@@ -266,6 +267,23 @@ pub fn seeds() -> Vec<Seed> {
             ],
             Some(mined("mxfp8")),
         ),
+        // int8 W8A8 with ComfyUI's ConvRot: each row is rotated by the orthonormal regular
+        // Hadamard H4(x)H4(x)H4(x)H4 per 256 input channels, then quantized per output row.
+        // value[i,j] = scale[i] * (data[i] . H)[j] / 16, the integer Hadamard sum times the
+        // f32 scale in f32, then the logical cast. Mined from cozy-runtime's own producer.
+        seed(
+            "int8-convrot256/1",
+            float.clone(),
+            Some(2),
+            vec![
+                ("data", role(set(&[Dtype::I8]), Relation::Same)),
+                (
+                    "scale",
+                    role(set(&[Dtype::F32]), dims(vec![Dim::Axis { axis: 0 }])),
+                ),
+            ],
+            Some(mined("int8-convrot256")),
+        ),
         Seed {
             alias: "svdq-microscale/1",
             vectors: None,

{tensorfs-0.9.1 → tensorfs-0.9.2}/crates/tensorfs-core/tests/conform.rs

@@ -311,6 +311,51 @@ fn nvfp4_inner(c: &Case, swap: bool, skip_global: bool) -> Option<Vec<u8>> {
     Some(out)
 }
 
+/// int8-convrot256: value[i,j] = f32(sum_k data[i,k] * H[k,j]) * scale[i] / 16 over each
+/// 256-group, H = H4(x)H4(x)H4(x)H4 with H4's -1 where the two base-4 digits sum to 3.
+fn int8_convrot256(c: &Case) -> Option<Vec<u8>> {
+    int8_convrot_inner(c, false, false)
+}
+fn int8_convrot_unrotated(c: &Case) -> Option<Vec<u8>> {
+    int8_convrot_inner(c, true, false)
+}
+fn int8_convrot_scale_by_column(c: &Case) -> Option<Vec<u8>> {
+    int8_convrot_inner(c, false, true)
+}
+
+fn hadamard_sign(k: usize, j: usize) -> i32 {
+    let mut sign = 1;
+    for digit in 0..4 {
+        if (k >> (2 * digit)) % 4 + (j >> (2 * digit)) % 4 == 3 {
+            sign = -sign;
+        }
+    }
+    sign
+}
+
+fn int8_convrot_inner(c: &Case, unrotated: bool, wrong_axis: bool) -> Option<Vec<u8>> {
+    let d = role(c, "data")?;
+    let s = role(c, "scale")?;
+    let rows = *c.logical_shape.first()? as usize;
+    let cols = *c.logical_shape.get(1)? as usize;
+    let mut out = Vec::new();
+    for i in 0..rows {
+        for j in 0..cols {
+            let group = j - j % 256;
+            let q = |k: usize| d.bits[i * cols + group + k] as i8 as i32;
+            let sum = if unrotated {
+                q(j % 256) * 16
+            } else {
+                (0..256).map(|k| q(k) * hadamard_sign(k, j % 256)).sum()
+            };
+            let o = if wrong_axis { (j % rows) * 4 } else { i * 4 };
+            let sc = f32::from_le_bytes(s.bits[o..o + 4].try_into().ok()?);
+            put_logical(c.logical_dtype, sum as f32 * sc * 0.0625, &mut out);
+        }
+    }
+    Some(out)
+}
+
 fn candidates(alias: &str) -> Vec<Candidate> {
     let mk = |name, wrong, decode| Candidate {
         name,
@@ -342,6 +387,11 @@ fn candidates(alias: &str) -> Vec<Candidate> {
             mk("fp8-scaled-scalar:scale-ignored", true, fp8_scaled_no_scale),
             mk("fp8-scaled-scalar:f32-math", true, fp8_scaled_f32_math),
         ],
+        "int8-convrot256/1" => vec![
+            mk("int8-convrot256", false, int8_convrot256),
+            mk("int8-convrot256:unrotated", true, int8_convrot_unrotated),
+            mk("int8-convrot256:scale-by-column", true, int8_convrot_scale_by_column),
+        ],
         "mxfp8/1" => vec![
             mk("mxfp8", false, mxfp8),
             mk("mxfp8:block-16", true, mxfp8_wrong_block),

{tensorfs-0.9.1 → tensorfs-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "tensorfs"
-version = "0.9.1"
+version = "0.9.2"
 description = "TensorFS — canonical tensor artifact substrate"
 requires-python = ">=3.12"
 classifiers = [