Routed Open Weights 10.8.0: router + matting / BiRefNet, no refiner

LICENSE

@@ -0,0 +1,28 @@
+withoutBG Open Weights License
+
+Copyright 2026 withoutBG
+
+The withoutBG Open Weights model in this repository (the ONNX graphs
+withoutbg-open-weights-backbone.onnx, withoutbg-open-weights.onnx and
+birefnet-general.onnx, and the sidecar withoutbg-open-weights.onnx.json) is
+distributed under the withoutBG Open Weights license:
+
+    https://withoutbg.com/open-model/license
+
+The model is built from third-party components that remain under their own
+licenses, and your use must also comply with them:
+
+  - DINOv3 (Meta Platforms, Inc.): DINOv3 License
+    https://ai.meta.com/resources/models-and-libraries/dinov3-license/
+    Built with DINOv3.
+  - Depth Anything V2 (small): Apache License 2.0
+    https://www.apache.org/licenses/LICENSE-2.0
+  - BiRefNet (ZhengPeng7): MIT License
+
+Full notices and license texts are in THIRD_PARTY_NOTICES.md.
+
+THE MODEL IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+Commercial licensing: contact@withoutbg.com

README.md

@@ -1,5 +1,7 @@
 ---
-license: apache-2.0
+license: other
+license_name: withoutbg-open-weights
+license_link: LICENSE
 library_name: onnxruntime
 tags:
   - background-removal
@@ -13,11 +15,18 @@ pipeline_tag: image-segmentation
 
 # withoutBG Open Weights (ONNX)
 
-Open-source background removal and alpha matting from RGB images. This repository
-hosts the **OSS variant** exported as a self-contained ONNX graph for ONNX Runtime.
+Open-source background removal and alpha matting from RGB images, exported as an
+ONNX bundle for ONNX Runtime. No PyTorch checkpoints are needed at inference time.
 
-The graph includes DepthAnythingV2 and a ConvNeXt-fused matting head — no
-PyTorch checkpoints are needed at inference time.
+A trained **router** looks at each image and picks the branch suited to it:
+
+- **Fine strands, soft detail, transparency** → the **withoutBG matting** model
+  (Depth Anything V2 small depth + ConvNeXt-fused matting), trained and maintained by withoutBG.
+- **Hard opaque objects, flat scenes, vehicles** → **BiRefNet** segmentation.
+
+Only the selected branch runs, and its alpha is upsampled to the image's native
+resolution. The open-weights release ships no edge refiner; refined edges are part of the
+[Cloud API](https://withoutbg.com/pro-model?utm_source=github&utm_medium=withoutbg-hf-readme&utm_campaign=main-readme).
 
 - **Try it live:** [withoutBG on Hugging Face Spaces](https://huggingface.co/spaces/withoutbg/withoutbg)
 - **Website:** [withoutbg.com/open-model](https://withoutbg.com/open-model?utm_source=github&utm_medium=withoutbg-hf-readme&utm_campaign=main-readme)
@@ -36,133 +45,181 @@ PyTorch checkpoints are needed at inference time.
 | Field | Value |
 |-------|-------|
 | Variant | `oss` |
-| Version | `10.0.0` |
-| Format | ONNX (opset 18) |
+| Version | `10.8.0` |
+| Pipeline | `routed` (sidecar schema 3) |
+| Format | ONNX (opset 18), 3 graphs |
 | Precision | fp32 |
-| Max resolution | 448 |
-| ONNX input tensor | 448 × 448 (fixed letterbox) |
-| ONNX output tensor | 448 × 448 |
-| Depth | DepthAnythingV2 `vits` (`dav2s`) |
-| Matting | ConvNeXtFusedMattingUNet (DINOv3 ConvNeXt `base`) |
-| Transformer opt | disabled |
-| ORT offline opt | extended |
-| Size | ~455 MB |
-| SHA256 | `29930e48e9d5ecc56d6486c53c35a4c1470566c2a3359fa180b08c8d3c34ef0f` |
+| Max inference size | 4096 × 4096 (larger images are downscaled first) |
+| Router | DINOv3 ConvNeXt `base` @ 448², 6 categories |
+| Matting branch | DepthAnythingV2 `vits` (`dav2s`) @ 518² + ConvNeXtFusedMattingUNet @ 448² |
+| BiRefNet branch | BiRefNet (general) @ 1024² |
+| Size | ~1.5 GB total |
 
 ## Files
 
-Always distribute the ONNX file and its sidecar JSON together:
-
-- `withoutbg-open-weights.onnx` — inference graph (depth → ConvNeXt matting)
-- `withoutbg-open-weights.onnx.json` — sidecar metadata (I/O names, shapes, SHA256, canvas size)
-
-Read the sidecar first. It is the authoritative source for `canvas_size` (448),
-input/output names, precision, model version, `depth_variant`, `convnext_size`,
-and SHA256.
-
-## Architecture
+Always distribute all four files together:
 
-v10 pipeline:
+| File | Contents | Size |
+|------|----------|------|
+| `withoutbg-open-weights-backbone.onnx` | Shared ConvNeXt backbone → router logits + features for matting | ~350 MB |
+| `withoutbg-open-weights.onnx` | Matting branch: depth + ConvNeXt-fused matting (reuses backbone features) | ~104 MB |
+| `birefnet-general.onnx` | BiRefNet branch | ~1.04 GB |
+| `withoutbg-open-weights.onnx.json` | Sidecar: files, SHA256, input sizes and resize modes, router categories | — |
 
-- **Depth:** DepthAnythingV2 `vits` (`dav2s`)
-- **Matting:** ConvNeXtFusedMattingUNet — frozen DINOv3 **ConvNeXt** backbone
-  fused into a U-Net on 4-channel RGB+depth at **448²**
+Read the sidecar first. It is the authoritative source for every graph's file name,
+SHA256, input/output names, input size and interpolation, the router `categories`, and
+which of them route to BiRefNet (`birefnet_categories`).
 
-Consumers letterbox RGB to the fixed ONNX input tensor (`canvas_size` in the
-sidecar) and run a single inference session. Depth is computed inside the graph.
+## Pipeline
 
-## Input / output contract
+All graph inputs are float32 RGB in `[0, 1]`, NCHW, and a **square stretch** of the
+whole working image (no letterbox, no padding).
 
-> **Max resolution is 448px.** Input letterboxing and output alpha both use
-> `canvas_size` (448).
+| Graph | Inputs | Output |
+|-------|--------|--------|
+| backbone (`router`) | `rgb_matting` `[1, 3, 448, 448]` (bilinear, no antialias) | `route_logits` `[1, 6]`, `f0`–`f3` |
+| matting (`coarse`) | `rgb_depth` `[1, 3, 518, 518]` (bicubic, antialias), `rgb_matting` (same as backbone), `f0`–`f3` | `coarse_alpha` `[1, 1, 448, 448]` |
+| BiRefNet (`birefnet`) | `rgb` `[1, 3, 1024, 1024]` (bilinear, no antialias) | `alpha` `[1, 1, 1024, 1024]` |
 
-The graph expects a **letterboxed** RGB tensor sized to `canvas_size` from the sidecar:
+1. Convert to RGB. If the image exceeds `max_inference_size`, downscale it to fit
+   (keeping aspect ratio). This is the working image.
+2. Run the backbone. The category is the argmax of `route_logits` over `categories`.
+3. If the category is in `birefnet_categories` (`hard_opaque`, `flat_scene`, `vehicle`),
+   run BiRefNet. Otherwise run the matting graph with the backbone's `f0`–`f3`.
+4. Upsample the branch alpha bilinearly (`align_corners=False`) to the working size and
+   clamp to `[0, 1]`. Resize to the original size if step 1 downscaled.
 
-| | Name | Shape | Dtype | Range |
-|---|------|-------|-------|-------|
-| Input | `rgb` | `[1, 3, 448, 448]` | float32 | `[0, 1]`, NCHW |
-| Output | `alpha` | `[1, 1, 448, 448]` | float32 | `[0, 1]` |
+Bilinear resizes match PyTorch `F.interpolate(mode="bilinear", align_corners=False)`
+without antialiasing. The bicubic depth input matches PyTorch with `antialias=True`, which
+PIL reproduces on float (`"F"` mode) channels.
 
-Preprocessing (required):
-
-1. Convert image to RGB.
-2. Read `canvas_size` from the sidecar (448 for this export).
-3. Resize longest side to `canvas_size`, preserve aspect ratio.
-4. Paste at top-left on a black `canvas_size` × `canvas_size` canvas.
-5. Normalize to float32 `[0, 1]`, transpose HWC → CHW, add batch dim.
-
-Postprocessing (required):
+## Download
 
-1. Crop alpha to the resized image region (top-left, before padding).
-2. Resize alpha back to the original image dimensions.
-3. Attach as PNG alpha channel for cutout output.
+```bash
+hf download withoutbg/withoutbg-openweights-onnx --local-dir withoutbg-open-weights
+```
 
-## Download
+Or in Python:
 
 ```python
-from huggingface_hub import hf_hub_download
+from huggingface_hub import snapshot_download
 
-model_path = hf_hub_download(
-    repo_id="withoutbg/withoutbg-openweights-onnx",
-    filename="withoutbg-open-weights.onnx",
-)
-sidecar_path = hf_hub_download(
+bundle = snapshot_download(
     repo_id="withoutbg/withoutbg-openweights-onnx",
-    filename="withoutbg-open-weights.onnx.json",
+    allow_patterns=["*.onnx", "*.onnx.json"],
 )
 ```
 
-Or with the CLI:
+## Usage
 
-```bash
-hf download withoutbg/withoutbg-openweights-onnx \
-  withoutbg-open-weights.onnx \
-  withoutbg-open-weights.onnx.json
+The reference host is `RoutedPipeline` in
+[withoutbg-inference](https://github.com/withoutbg/withoutbg-inference). It verifies
+every file's SHA256 and runs the pipeline above:
+
+```python
+import json
+from pathlib import Path
+from PIL import Image
+from withoutbg_openweights.edge_pipeline import RoutedPipeline
+
+bundle = Path("withoutbg-open-weights")
+sidecar = json.loads((bundle / "withoutbg-open-weights.onnx.json").read_text())
+pipeline = RoutedPipeline(sidecar, bundle, providers=["CPUExecutionProvider"])
+
+image = Image.open("input.jpg").convert("RGB")
+matte, route = pipeline.estimate_alpha_with_route(image)  # route: {"category", "pipeline"}
+image.putalpha(matte)
+image.save("output.png")
 ```
 
-## Usage
+Standalone, with only `numpy`, `pillow` and `onnxruntime` (run from the bundle folder):
 
 ```python
-from pathlib import Path
 import json
+from pathlib import Path
+
 import numpy as np
 import onnxruntime as ort
 from PIL import Image
 
-model_path = Path("withoutbg-open-weights.onnx")
-sidecar = json.loads(model_path.with_suffix(model_path.suffix + ".json").read_text())
-canvas = sidecar.get("canvas_size", 448)
-input_name = sidecar.get("input_name", "rgb")
+bundle = Path(".")  # folder holding the four files
+sidecar = json.loads((bundle / "withoutbg-open-weights.onnx.json").read_text())
+providers = ["CPUExecutionProvider"]
+sessions = {
+    name: ort.InferenceSession(str(bundle / sidecar[name]["file"]), providers=providers)
+    for name in ("router", "coarse", "birefnet")
+}
+
+
+def bilinear(x, height, width):
+    """(C, H, W) -> (C, height, width); torch bilinear, align_corners=False, no antialias."""
+    def axis(src, dst):
+        pos = np.maximum((np.arange(dst) + 0.5) * (src / dst) - 0.5, 0.0)
+        i0 = pos.astype(np.int64)
+        return i0, np.minimum(i0 + 1, src - 1), (pos - i0).astype(np.float32)
+
+    _, h, w = x.shape
+    r0, r1, rl = axis(h, height)
+    c0, c1, cl = axis(w, width)
+    rows = x[:, r0] * (1 - rl)[:, None] + x[:, r1] * rl[:, None]
+    return rows[:, :, c0] * (1 - cl) + rows[:, :, c1] * cl
+
+
+def feed(rgb, spec):
+    """Square-stretch native (H, W, 3) float RGB as each graph input's spec says."""
+    feeds = {}
+    for name, s in spec["inputs"].items():
+        if s["interpolation"] == "bicubic":  # antialiased; PIL "F" mode matches torch
+            x = np.stack([np.asarray(Image.fromarray(np.ascontiguousarray(rgb[..., c]))
+                                     .resize((s["size"],) * 2, Image.Resampling.BICUBIC))
+                          for c in range(3)])
+        else:
+            x = bilinear(np.ascontiguousarray(rgb.transpose(2, 0, 1)), s["size"], s["size"])
+        feeds[name] = np.ascontiguousarray(x[None], dtype=np.float32)
+    return feeds
 
-session = ort.InferenceSession(str(model_path), providers=["CPUExecutionProvider"])
 
 image = Image.open("input.jpg").convert("RGB")
-orig_w, orig_h = image.size
-scale = canvas / max(orig_w, orig_h)
-new_w = max(1, round(orig_w * scale))
-new_h = max(1, round(orig_h * scale))
-
-resized = image.resize((new_w, new_h), Image.Resampling.BILINEAR)
-padded = Image.new("RGB", (canvas, canvas), (0, 0, 0))
-padded.paste(resized, (0, 0))
-
-rgb = np.asarray(padded, dtype=np.float32) / 255.0
-rgb = np.transpose(rgb, (2, 0, 1))[None, ...]
-
-alpha_canvas = session.run(None, {input_name: rgb})[0][0, 0]
-alpha_crop = alpha_canvas[:new_h, :new_w]
-alpha_u8 = np.clip(alpha_crop * 255.0, 0, 255).astype(np.uint8)
-alpha = Image.fromarray(alpha_u8, "L").resize((orig_w, orig_h), Image.Resampling.BILINEAR)
+w, h = image.size
+max_w, max_h = sidecar["max_inference_size"]
+if w > max_w:
+    w, h = max_w, int(max_w / (image.width / image.height))
+if h > max_h:
+    w, h = int(max_h * (image.width / image.height)), max_h
+work = image.resize((w, h)) if (w, h) != image.size else image
+rgb = np.asarray(work, dtype=np.float32) / 255.0
+
+# 1. Route: shared ConvNeXt backbone -> category logits + features.
+router = sidecar["router"]
+router_feeds = feed(rgb, router)
+logits, *feats = sessions["router"].run([router["logits_name"], *router["feature_names"]], router_feeds)
+category = router["categories"][int(np.argmax(logits[0]))]
+
+# 2. Run only the selected branch.
+if category in router["birefnet_categories"]:
+    spec = sidecar["birefnet"]
+    alpha = sessions["birefnet"].run([spec["output_name"]], feed(rgb, spec))[0][0]
+else:
+    spec = sidecar["coarse"]
+    feeds = {**router_feeds, **feed(rgb, {"inputs": {"rgb_depth": spec["inputs"]["rgb_depth"]}})}
+    feeds.update(zip(spec["feature_names"], feats))
+    alpha = sessions["coarse"].run([spec["output_name"]], feeds)[0][0]
+
+# 3. Upsample to the working size, then to the original size.
+alpha = np.clip(bilinear(alpha, h, w), 0.0, 1.0)[0]
+matte = Image.fromarray(np.clip(alpha * 255.0 + 0.5, 0, 255).astype(np.uint8))
+matte = matte.resize(image.size, Image.Resampling.BILINEAR)
 
 out = image.copy()
-out.putalpha(alpha)
+out.putalpha(matte)
 out.save("output.png")
+print(category, "->", "birefnet" if category in router["birefnet_categories"] else "matting")
 ```
 
 ## Runtime dependencies
 
 ```text
-python >=3.11
+python >=3.10
 numpy
 pillow
 onnxruntime
@@ -185,23 +242,22 @@ This repo hosts the **ONNX weights**. Same open-weights technology powers ready-
 
 ## License
 
-Apache-2.0 — see [withoutbg.com/open-model/license](https://withoutbg.com/open-model/license?utm_source=github&utm_medium=withoutbg-hf-readme&utm_campaign=main-readme).
+The withoutBG Open Weights model is distributed under the withoutBG Open Weights license.
+See [LICENSE](LICENSE) and
+[withoutbg.com/open-model/license](https://withoutbg.com/open-model/license?utm_source=github&utm_medium=withoutbg-hf-readme&utm_campaign=main-readme).
 
 Built with DINOv3.
 
 ## Third-party terms
 
-This distribution includes upstream components under their respective licenses.
+This bundle includes upstream components under their respective licenses.
 See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
 
-### DINOv3
-
-License: [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/)
-
-### Depth Anything V2
-
-License: [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0) —
-[Depth Anything V2](https://github.com/DepthAnything/Depth-Anything-V2)
+| Component | Used in | License |
+|-----------|---------|---------|
+| [DINOv3](https://github.com/facebookresearch/dinov3) | Router backbone, matting | [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/) |
+| [Depth Anything V2](https://github.com/DepthAnything/Depth-Anything-V2) (small) | Matting branch depth | [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0) |
+| [BiRefNet](https://github.com/ZhengPeng7/BiRefNet) (ZhengPeng7) | `birefnet-general.onnx` | MIT |
 
 ## Links
 

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,50 @@
+# Third-Party Notices
+
+## withoutBG Open Weights Model (10.8.0, routed)
+
+License: withoutBG Open Weights license — https://withoutbg.com/open-model/license
+
+This bundle contains three ONNX graphs built from the following upstream components: DINOv3 (router backbone and matting), Depth Anything V2 small (matting depth) and BiRefNet (`birefnet-general.onnx`).
+
+**Built with DINOv3**
+
+## DINOv3
+
+License: DINOv3 License
+
+- https://ai.meta.com/resources/models-and-libraries/dinov3-license/
+- https://github.com/facebookresearch/dinov3/blob/main/LICENSE.md
+
+## Depth Anything V2
+
+License: Apache-2.0
+
+- https://github.com/DepthAnything/Depth-Anything-V2
+- https://www.apache.org/licenses/LICENSE-2.0
+
+## BiRefNet
+
+The `birefnet-general.onnx` graph in this bundle is BiRefNet by ZhengPeng7, exported to ONNX.
+Source: https://github.com/ZhengPeng7/BiRefNet
+
+MIT License
+
+Copyright (c) 2024 ZhengPeng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

birefnet-general.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28c988df0383b7c9925139b7aa012c33ce750e8552bd75a628346096acb4c0bb
+size 1038495470

withoutbg-onnx.md

@@ -1,259 +0,0 @@
-# withoutBG ONNX Open Model Distribution Brief
-
-This file gives AI agents enough context to package, serve, and distribute the
-withoutBG ONNX open model from another project, such as a Docker image or model
-registry release.
-
-Primary source files in the training repo (`model-pro`):
-
-- `scripts/export_wbgnet_onnx.py` - exports the optimized ONNX artifact and
-  writes the sidecar metadata JSON.
-- `scripts/serve_wbgnet.py` - reference ONNX Runtime CLI that handles image
-  preprocessing, inference, postprocessing, output composition, and benchmarking.
-- `src/depth_variants.py` / `src/model_matting.py` - depth + ConvNeXt checkpoint
-  naming.
-
-## What To Distribute
-
-Distribute the final ONNX file and its sidecar JSON together:
-
-```text
-withoutbg-open-weights.onnx
-withoutbg-open-weights.onnx.json
-```
-
-The ONNX graph is self-contained for inference. It includes DepthAnythingV2 and
-the ConvNeXt-fused matting head. The serving container does not need PyTorch
-checkpoints at runtime.
-
-Do not distribute local training checkpoints unless the release explicitly calls
-for source-weight distribution.
-
-## Model Identity
-
-- Product: `withoutBG`
-- Variant: `oss`
-- Version: `10.0.0`
-- Target: ONNX / Hugging Face / Docker
-- License: Apache-2.0 via `https://withoutbg.com/open-model/license`
-- Third-party upstream: DINOv3 terms at
-  `https://ai.meta.com/resources/models-and-libraries/dinov3-license/`
-- Main use: background removal / alpha matting from RGB images
-
-v10 pipeline:
-
-- Depth: DepthAnythingV2 `vits` (`dav2s`)
-- Matting: ConvNeXtFusedMattingUNet — DINOv3 **ConvNeXt** `base` fused into a
-  U-Net on 4-channel RGB+depth at **448²**
-
-## ONNX Contract
-
-The exported graph has a fixed shape contract:
-
-```text
-input_name: rgb
-input_shape: [1, 3, 448, 448]
-input_dtype: float32 by default, float16 only when exported with --io-fp16
-input_layout: NCHW
-input_range: [0, 1]
-
-output_name: alpha
-output_shape: [1, 1, 448, 448]
-output_dtype: float32
-output_range: [0, 1]
-```
-
-The graph does not accept arbitrary image sizes. The consumer must letterbox each
-image to the fixed canvas before inference, then remove the padded region and
-resize the alpha matte back to the original image size.
-
-Read the sidecar JSON first when present. It records the authoritative
-`canvas_size` (448), `matting_input_size`, `depth_variant`, `convnext_size`,
-input and output names, precision, model version, SHA256, and optional
-benchmark/parity values.
-
-## Export Command
-
-Run Python through `uv` in the training repo:
-
-```bash
-uv sync
-uv run python scripts/export_wbgnet_onnx.py \
-  --variant oss \
-  --convnext base \
-  --precision fp32 \
-  --no-transformer-opt \
-  --ort-opt-level extended \
-  --output compiled_models/withoutbg-open-weights.onnx
-```
-
-Typical knobs:
-
-- `--precision fp32|fp16|int8|int4`
-- `--canvas-size 448` (default)
-- `--convnext {small,base}` (default `base`)
-- `--opset-version 18`
-- `--validate` defaults on and compares ONNX output against patched PyTorch
-- `--bench` runs a small CPU benchmark and writes stats into the sidecar
-- `--ort-offline-opt` defaults on
-- `--ort-opt-level extended` is portable; `all` can be faster but may bake in
-  host CPU-specific layout choices
-- `--transformer-opt` can improve DepthAnything ViT latency but is off by
-  default because it may produce provider-specific ops
-
-Required export-time checkpoints under `--checkpoint-dir`:
-
-```text
-depth_anything_v2_vits.pth
-matting-dav2s-base_*_best.pth
-dinov3_convnext_base_pretrain_lvd1689m-801f2ba9.pth
-```
-
-Runtime distribution only needs the `.onnx` and `.onnx.json`.
-
-## Reference Serving Behavior
-
-Preprocessing:
-
-1. Convert input image to RGB.
-2. Preserve aspect ratio by resizing the longest side to `canvas_size`.
-3. Paste the resized image at top-left of a black `canvas_size x canvas_size`
-   RGB canvas.
-4. Convert to `float32`, divide by `255.0`, transpose HWC to CHW, add batch
-   dimension.
-5. Run ONNX Runtime with `{input_name: tensor}`.
-
-Postprocessing:
-
-1. Read `alpha` from `[1, 1, canvas, canvas]`.
-2. Crop to the resized image area before padding (`alpha[:new_h, :new_w]`).
-3. Resize cropped alpha back to the original image width and height.
-4. For cutout output, attach alpha as the PNG alpha channel.
-5. For matte output, save alpha as grayscale PNG.
-6. For composite output, blend RGB over a solid background:
-   `out = rgb * alpha + bg * (1 - alpha)`.
-
-Supported reference providers:
-
-```text
-cpu    -> CPUExecutionProvider
-cuda   -> CUDAExecutionProvider
-coreml -> CoreMLExecutionProvider
-```
-
-Provider order matters. For a CPU Docker image, use only `CPUExecutionProvider`
-unless the image explicitly installs GPU ONNX Runtime.
-
-## Minimal Runtime Dependencies
-
-For a CPU Docker image, runtime code needs:
-
-```text
-python >=3.11
-numpy
-pillow
-onnxruntime
-```
-
-The full exporter also needs PyTorch, ONNX tooling, `onnxsim`,
-`onnxconverter-common`, and repo source modules. Keep exporter dependencies out
-of the runtime image unless the image is meant to export models too.
-
-## Suggested Docker Layout
-
-Use a small runtime image and copy only the serving code and model artifacts:
-
-```dockerfile
-FROM python:3.11-slim
-
-WORKDIR /app
-
-RUN pip install --no-cache-dir numpy pillow onnxruntime
-
-COPY withoutbg-open-weights.onnx /app/model.onnx
-COPY withoutbg-open-weights.onnx.json /app/model.onnx.json
-COPY space/inference.py /app/inference.py
-
-ENTRYPOINT ["python", "-c", "print('wire your serve entrypoint here')"]
-```
-
-For an API server image, keep the same preprocessing and postprocessing contract.
-Load one `onnxruntime.InferenceSession` at process startup, warm it with a zero
-tensor, and reuse it across requests.
-
-## Validation Checklist
-
-Before publishing a Docker image or model release:
-
-- Confirm both files exist: `.onnx` and `.onnx.json`.
-- Confirm sidecar `sha256` matches the ONNX artifact.
-- Run a smoke inference on at least one real image.
-- Inspect a cutout PNG and a matte PNG visually.
-- Check that output alpha has original image resolution, not `448 x 448`.
-- Verify the selected ORT provider is the expected one.
-- Include license and DINOv3 third-party terms in release metadata.
-- Avoid `--ort-opt-level all` for broadly distributed CPU images unless the
-  artifact is intentionally tied to the build host architecture.
-
-## Known Export Approximations
-
-The exporter applies ONNX-only patches:
-
-- Antialiased resize is disabled where this PyTorch/ONNX stack cannot lower it.
-- Some fixed-shape arithmetic is folded for the 448 canvas.
-
-These approximations are expected. The exporter validates parity against the
-patched PyTorch model.
-
-## Failure Modes Agents Should Watch For
-
-- Missing sidecar: service still works with defaults, but distribution should
-  include the sidecar because it records precision, names, SHA256, and version.
-- Wrong tensor layout: input must be NCHW, not NHWC.
-- Wrong normalization: input must be float in `[0, 1]`, not uint8 or `[-1, 1]`.
-- Forgetting unletterbox: padded canvas alpha will produce wrong output sizes
-  and black-padding artifacts.
-- `fp16` IO mismatch: only feed float16 when sidecar says `io_fp16: true`.
-- Provider fallback: ONNX Runtime may silently choose CPU if CUDA/CoreML is
-  unavailable; log `session.get_providers()[0]`.
-- CPU-specific offline optimization: `--ort-opt-level all` can make a model less
-  portable across CPU architectures.
-
-## Minimal Python Inference Skeleton
-
-```python
-from pathlib import Path
-import json
-import numpy as np
-import onnxruntime as ort
-from PIL import Image
-
-model_path = Path("model.onnx")
-sidecar = json.loads(model_path.with_suffix(model_path.suffix + ".json").read_text())
-canvas = sidecar.get("canvas_size", 448)
-input_name = sidecar.get("input_name", "rgb")
-
-session = ort.InferenceSession(str(model_path), providers=["CPUExecutionProvider"])
-
-image = Image.open("input.jpg").convert("RGB")
-orig_w, orig_h = image.size
-scale = canvas / max(orig_w, orig_h)
-new_w = max(1, round(orig_w * scale))
-new_h = max(1, round(orig_h * scale))
-
-resized = image.resize((new_w, new_h), Image.Resampling.BILINEAR)
-padded = Image.new("RGB", (canvas, canvas), (0, 0, 0))
-padded.paste(resized, (0, 0))
-
-rgb = np.asarray(padded, dtype=np.float32) / 255.0
-rgb = np.transpose(rgb, (2, 0, 1))[None, ...]
-
-alpha_canvas = session.run(None, {input_name: rgb})[0][0, 0]
-alpha_crop = alpha_canvas[:new_h, :new_w]
-alpha_u8 = np.clip(alpha_crop * 255.0, 0, 255).astype(np.uint8)
-alpha = Image.fromarray(alpha_u8, "L").resize((orig_w, orig_h), Image.Resampling.BILINEAR)
-
-out = image.copy()
-out.putalpha(alpha)
-out.save("output.png")
-```

withoutbg-open-weights-backbone.onnx

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

withoutbg-open-weights.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:29930e48e9d5ecc56d6486c53c35a4c1470566c2a3359fa180b08c8d3c34ef0f
-size 454497726
+oid sha256:a22bc936a7be65f500f44955129bdde09a16d1ab3745a43224128638981cff32
+size 104110104

withoutbg-open-weights.onnx.json

@@ -1,35 +1,97 @@
 {
-  "canvas_size": 448,
-  "matting_input_size": 448,
+  "schema_version": 3,
+  "pipeline": "routed",
+  "variant": "oss",
+  "model_version": "10.8.0",
+  "components": {
+    "depth": "depth_anything_v2_vits.pth",
+    "convnext": "dinov3_convnext_base_pretrain_lvd1689m-801f2ba9.pth",
+    "matting": "matting-dav2s-base_10.0.0_best_trunk.pth",
+    "router": "router_10.1.0_best.pth",
+    "birefnet": "BiRefNet"
+  },
   "opset_version": 18,
   "precision": "fp32",
-  "requested_precision": "fp32",
-  "io_fp16": false,
-  "transformer_opt": false,
-  "ort_offline_opt": true,
-  "ort_opt_level": "extended",
-  "variant": "oss",
-  "depth_variant": "dav2s",
-  "convnext_size": "base",
-  "refiner": false,
-  "model_version": "10.0.0",
-  "input_name": "rgb",
-  "output_name": "alpha",
-  "input_dtype": "float32",
-  "input_shape": [
-    1,
-    3,
-    448,
-    448
-  ],
-  "output_shape": [
-    1,
-    1,
-    448,
-    448
+  "max_inference_size": [
+    4096,
+    4096
   ],
-  "size_mb": 454.5,
-  "sha256": "29930e48e9d5ecc56d6486c53c35a4c1470566c2a3359fa180b08c8d3c34ef0f",
-  "mae": 3.6705664285818784e-08,
-  "max_abs": 3.0040740966796875e-05
+  "router": {
+    "file": "withoutbg-open-weights-backbone.onnx",
+    "sha256": "a64ba43cc25557f568ad6f35ed1139049dd43f5568385fa4f9848e0b4c7123ff",
+    "inputs": {
+      "rgb_matting": {
+        "size": 448,
+        "resize": "stretch",
+        "interpolation": "bilinear",
+        "antialias": false
+      }
+    },
+    "logits_name": "route_logits",
+    "feature_names": [
+      "f0",
+      "f1",
+      "f2",
+      "f3"
+    ],
+    "categories": [
+      "fine_strand",
+      "soft_detail",
+      "transparency",
+      "hard_opaque",
+      "flat_scene",
+      "vehicle"
+    ],
+    "birefnet_categories": [
+      "hard_opaque",
+      "flat_scene",
+      "vehicle"
+    ],
+    "mae": 1.819754515963723e-06,
+    "max_abs": 0.00189208984375
+  },
+  "coarse": {
+    "file": "withoutbg-open-weights.onnx",
+    "sha256": "a22bc936a7be65f500f44955129bdde09a16d1ab3745a43224128638981cff32",
+    "inputs": {
+      "rgb_depth": {
+        "size": 518,
+        "resize": "stretch",
+        "interpolation": "bicubic",
+        "antialias": true
+      },
+      "rgb_matting": {
+        "size": 448,
+        "resize": "stretch",
+        "interpolation": "bilinear",
+        "antialias": false
+      }
+    },
+    "feature_names": [
+      "f0",
+      "f1",
+      "f2",
+      "f3"
+    ],
+    "output_name": "coarse_alpha",
+    "output_size": 448,
+    "mae": 5.89670491990546e-07,
+    "max_abs": 1.683831214904785e-05
+  },
+  "birefnet": {
+    "file": "birefnet-general.onnx",
+    "sha256": "28c988df0383b7c9925139b7aa012c33ce750e8552bd75a628346096acb4c0bb",
+    "inputs": {
+      "rgb": {
+        "size": 1024,
+        "resize": "stretch",
+        "interpolation": "bilinear",
+        "antialias": false
+      }
+    },
+    "output_name": "alpha",
+    "output_size": 1024,
+    "mae": 2.580805968932509e-08,
+    "max_abs": 1.3899352779844776e-07
+  }
 }