Upload INT4-G128 quant for facebook/sapiens2-normal-1b

README.md

@@ -0,0 +1,63 @@
+---
+license: other
+license_name: sapiens2-license
+license_link: https://github.com/facebookresearch/sapiens2/blob/main/LICENSE.md
+base_model: facebook/sapiens2-normal-1b
+base_model_relation: quantized
+library_name: sapiens
+tags:
+- sapiens
+- sapiens2
+- int4
+- quantized
+- safetensors
+---
+
+# sapiens2-normal-1b INT4-G128
+
+Packed 4-bit derivative of [facebook/sapiens2-normal-1b](https://huggingface.co/facebook/sapiens2-normal-1b).
+
+This artifact uses symmetric per-group INT4 packing with group size 128 for large floating-point weight tensors. Norms, biases, positional/rope tensors, and small tensors are kept in their source dtype. It is a storage/runtime-loader quant for the current official Sapiens2 code path, not an AWQ/GGUF/NVFP4 LLM artifact.
+
+## Files
+
+- `facebook__sapiens2-normal-1b-int4-g128.safetensors`: packed INT4 safetensors artifact.
+- `load_sapiens2_int4.py`: loader that reconstructs a PyTorch state dict for the official Sapiens2 model code.
+- `config.json` and `preprocessor_config.json`: copied from the source repo.
+- `quantization_report.json`: build report.
+
+## Quantization Report
+
+- Source revision: `c4c2641bd89c585a3973e88ea5cca5d1aa2498ed`
+- Group size: `128`
+- Source bytes: `6157337292`
+- Artifact bytes: `797079156`
+- Compression ratio: `7.7249x`
+- Tensors: `704`
+- Quantized tensors: `250`
+- Max tensor MAE during dequant smoke: `0.00477664`
+
+
+## Fidelity Validation
+
+The packed INT4 artifact was dequantized back to floating-point tensors and compared against the source checkpoint.
+
+- Validation gate: global floating-tensor similarity >= `90.00%`
+- Result: `PASS`
+- Global floating-tensor similarity: `99.340750%`
+- Minimum large-tensor cosine: `0.987384617`
+
+
+## Loading
+
+```python
+from load_sapiens2_int4 import load_state_dict
+
+state_dict = load_state_dict("facebook__sapiens2-normal-1b-int4-g128.safetensors", device="cpu")
+# Then instantiate the matching official Sapiens2 architecture and load:
+# model.load_state_dict(state_dict, strict=True)
+```
+
+## Limitations
+
+This is a verified packed-weight artifact with a dequantizing loader. It does not claim native INT4 CUDA kernels for Sapiens2 yet. Runtime speedups require a Sapiens2-specific kernel/export path and should be benchmarked separately.

config.json

@@ -0,0 +1,194 @@
+{
+  "architectures": [
+    "Sapiens2ForNormalEstimation"
+  ],
+  "attention_dropout": 0.0,
+  "drop_path_rate": 0.0,
+  "flip_pairs": null,
+  "head_config": {
+    "_name_or_path": "",
+    "architectures": null,
+    "chunk_size_feed_forward": 0,
+    "conv_kernel_size": 1,
+    "conv_kernel_sizes": [
+      3,
+      3,
+      3
+    ],
+    "conv_out_channels": [
+      64,
+      32,
+      16
+    ],
+    "dtype": null,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "model_type": "sapiens2_head",
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "problem_type": null,
+    "return_dict": true,
+    "scale_conv_kernel_size": 1,
+    "scale_conv_kernel_sizes": null,
+    "scale_conv_out_channels": null,
+    "scale_final_hidden_sizes": null,
+    "scale_final_input_size": null,
+    "upsample_kernel_size": 4,
+    "upsample_kernel_sizes": [
+      3,
+      3,
+      3,
+      3
+    ],
+    "upsample_out_channels": [
+      768,
+      512,
+      256,
+      128
+    ],
+    "use_pixel_shuffle": true
+  },
+  "hidden_act": "silu",
+  "hidden_size": 1536,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2"
+  },
+  "image_size": [
+    1024,
+    768
+  ],
+  "initializer_range": 0.02,
+  "intermediate_size": 6144,
+  "key_bias": true,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_2": 2
+  },
+  "layerscale_value": 1.0,
+  "mlp_bias": true,
+  "model_type": "sapiens2",
+  "normalize_backbone_outputs": true,
+  "num_attention_heads": 24,
+  "num_channels": 3,
+  "num_first_full_attention_layers": 8,
+  "num_hidden_layers": 40,
+  "num_key_value_attention_heads": 12,
+  "num_key_value_heads_per_layer": [
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    12,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24
+  ],
+  "num_last_full_attention_layers": 8,
+  "num_register_tokens": 8,
+  "out_features": [
+    "stage40"
+  ],
+  "out_indices": [
+    40
+  ],
+  "patch_size": 16,
+  "pos_embed_jitter": null,
+  "pos_embed_rescale": 2.0,
+  "pos_embed_shift": null,
+  "proj_bias": true,
+  "query_bias": true,
+  "reshape_hidden_states": true,
+  "rms_norm_eps": 1e-06,
+  "rope_theta": 100.0,
+  "semantic_loss_ignore_index": 255,
+  "stage_names": [
+    "stem",
+    "stage1",
+    "stage2",
+    "stage3",
+    "stage4",
+    "stage5",
+    "stage6",
+    "stage7",
+    "stage8",
+    "stage9",
+    "stage10",
+    "stage11",
+    "stage12",
+    "stage13",
+    "stage14",
+    "stage15",
+    "stage16",
+    "stage17",
+    "stage18",
+    "stage19",
+    "stage20",
+    "stage21",
+    "stage22",
+    "stage23",
+    "stage24",
+    "stage25",
+    "stage26",
+    "stage27",
+    "stage28",
+    "stage29",
+    "stage30",
+    "stage31",
+    "stage32",
+    "stage33",
+    "stage34",
+    "stage35",
+    "stage36",
+    "stage37",
+    "stage38",
+    "stage39",
+    "stage40"
+  ],
+  "transformers_version": "5.10.0.dev0",
+  "use_gated_mlp": true,
+  "use_mask_token": false,
+  "use_qk_norm": true,
+  "value_bias": true
+}

facebook__sapiens2-normal-1b-int4-g128.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d484690015ac19d478e240946383061d70b7373687f59e41e0c2f542fbec2f7
+size 797282804

load_sapiens2_int4.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Load a sapiens2-int4-safetensors artifact back into a PyTorch state dict."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import torch
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+
+def unpack_int4(packed: torch.Tensor, elements: int) -> torch.Tensor:
+    packed = packed.cpu().to(torch.uint8)
+    lo = (packed & 0x0F).to(torch.int16)
+    hi = ((packed >> 4) & 0x0F).to(torch.int16)
+    vals = torch.empty(packed.numel() * 2, dtype=torch.int16)
+    vals[0::2] = lo
+    vals[1::2] = hi
+    vals = vals[:elements]
+    vals = torch.where(vals >= 8, vals - 16, vals)
+    return vals.to(torch.float32)
+
+
+def dequantize_tensor(packed: torch.Tensor, scales: torch.Tensor, shape: list[int], group_size: int, dtype: str) -> torch.Tensor:
+    elements = 1
+    for dim in shape:
+        elements *= dim
+    pad = (-elements) % group_size
+    q = unpack_int4(packed, elements + pad).view(-1, group_size)
+    out = (q * scales.to(torch.float32)[:, None]).flatten()[:elements].view(*shape)
+    target_dtype = getattr(torch, dtype, torch.float16)
+    return out.to(target_dtype if target_dtype.is_floating_point else torch.float32)
+
+
+def load_state_dict(path: str | Path, device: str = "cpu") -> dict[str, torch.Tensor]:
+    with safe_open(str(path), framework="pt", device="cpu") as f:
+        metadata = f.metadata() or {}
+        manifest = json.loads(metadata["manifest_json"])
+        state = {}
+        for name, info in manifest.items():
+            if info.get("quantized"):
+                state[name] = dequantize_tensor(
+                    f.get_tensor(info["qweight"]),
+                    f.get_tensor(info["scales"]),
+                    info["shape"],
+                    int(info["group_size"]),
+                    info.get("dtype", "float16"),
+                ).to(device)
+            else:
+                state[name] = f.get_tensor(name).to(device)
+    return state
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("artifact")
+    parser.add_argument("--save-dequantized", help="Optional safetensors path for the dequantized state dict")
+    args = parser.parse_args()
+
+    state = load_state_dict(args.artifact)
+    print(f"loaded {len(state)} tensors")
+    if args.save_dequantized:
+        save_file(state, args.save_dequantized)
+        print(f"saved {args.save_dequantized}")
+
+
+if __name__ == "__main__":
+    main()

preprocessor_config.json

@@ -0,0 +1,29 @@
+{
+  "crop_size": {
+    "height": 224,
+    "width": 224
+  },
+  "do_center_crop": false,
+  "do_normalize": true,
+  "do_pad": true,
+  "do_reduce_labels": false,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.485,
+    0.456,
+    0.406
+  ],
+  "image_processor_type": "Sapiens2ImageProcessor",
+  "image_std": [
+    0.229,
+    0.224,
+    0.225
+  ],
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 1024,
+    "width": 768
+  }
+}

quantization_report.json

@@ -0,0 +1,17 @@
+{
+  "input": "/home/rezo/sapiens2_quant/run/downloads/facebook__sapiens2-normal-1b/sapiens2_1b_normal.safetensors",
+  "output": "/home/rezo/sapiens2_quant/run/artifacts/facebook__sapiens2-normal-1b-int4-g128.safetensors",
+  "group_size": 128,
+  "tensor_count": 704,
+  "quantized_tensor_count": 250,
+  "source_bytes": 6157337292,
+  "artifact_bytes": 797079156,
+  "compression_ratio": 7.724875560539687,
+  "max_tensor_mae": 0.004776639398187399,
+  "repo": "facebook/sapiens2-normal-1b",
+  "fidelity": {
+    "global_floating_similarity_percent": 99.34075001308999,
+    "min_large_tensor_cosine": 0.9873846173286438,
+    "threshold": 0.9
+  }
+}