π Geometric Computer Vision Library for Spatial AI
Python artificial-intelligencecomputer-visiondeep-learninghacktoberfestimage-processingmachine-learningneural-networkpythonpytorchroboticsspatial-ai
# LICENSE HEADER MANAGED BY add-license-header
#
# Copyright 2018 Kornia Team
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""ONNX export survey β area `models` (kornia.models, kornia.contrib, kornia.tracking, kornia.sensors, kornia.image)."""
from __future__ import annotations
import sys
import traceback
import torch
from harness import case, run_cases
import kornia as K
torch.manual_seed(0)
# ----------------------------------------------------------------------------- helpers
def ev(m):
"""Return module in eval mode (lambda targets are not put in eval() by the harness)."""
return m.eval()
def build(ctor):
"""Build lazily-failing objects: if the constructor raises, return a callable that re-raises (-> eager-fail)."""
try:
return ctor(), None
except Exception as e:
tb = traceback.format_exc()
return None, (e, tb)
def raiser(exc):
def _f(*a, **k):
raise exc[0]
return _f
def reuse(obj, err):
"""Constructor returning an already-built object, re-raising its build error if any."""
def _c():
if err is not None:
raise err[0]
return obj
return _c
def mcase(name, group, ctor, call, inputs, kwargs=None, **kw):
"""Case whose target is `call(obj)` where obj = ctor(); constructor errors surface as eager-fail."""
obj, err = build(ctor)
if err is not None:
kw["note"] = (kw.get("note", "") + f" | CONSTRUCTOR FAILED: {type(err[0]).__name__}: {err[0]}").strip(" |")
return case(name, group, raiser(err), inputs, kwargs, **kw)
return case(name, group, call(obj), inputs, kwargs, **kw)
IMG = torch.rand(1, 3, 64, 96)
IMG2 = torch.rand(2, 3, 48, 64)
IMG32 = torch.rand(1, 3, 224, 224)
CASES: list[dict] = []
A = CASES.append
# ============================================================================= kornia.models.rt_detr
from kornia.models.rt_detr import RTDETR, DETRPostProcessor, RTDETRConfig, RTDETRModelType # noqa: E402
rtdetr_pre, _e = build(lambda: ev(RTDETR.from_pretrained("rtdetr_r18vd")))
A(
mcase(
"models.rt_detr.RTDETR[r18vd,pretrained]",
"models.rt_detr",
reuse(rtdetr_pre, _e),
lambda m: m,
[torch.rand(1, 3, 256, 320)],
note="weights rtdetr_r18vd (HF kornia/rt_detr); outputs (logits (1,300,80), boxes (1,300,4)); 256x320 input",
tags=("model", "pretrained"),
)
)
A(
mcase(
"models.rt_detr.RTDETR[r18vd,random,160x192]",
"models.rt_detr",
lambda: ev(RTDETR.from_name("rtdetr_r18vd", num_classes=80)),
lambda m: m,
[torch.rand(1, 3, 160, 192)],
note="random init via RTDETR.from_name; 160x192 input. NOTE: 64x96 fails eagerly ('selected "
"index k out of range'): "
"the decoder topk selects 300 queries so the input must yield >=300 encoder tokens (>= ~128x160)",
tags=("model",),
)
)
A(
mcase(
"models.rt_detr.RTDETR.from_config[r18vd,num_classes=3]",
"models.rt_detr",
lambda: ev(RTDETR.from_config(RTDETRConfig(RTDETRModelType.resnet18d, 3))),
lambda m: m,
[torch.rand(1, 3, 160, 192)],
note="RTDETRConfig(RTDETRModelType.resnet18d, num_classes=3); random init (str model_type "
"'rtdetr_r18vd' is rejected: AttributeError)",
tags=("model",),
)
)
A(case("models.rt_detr.RTDETRConfig", "models.rt_detr", None, [], skip="config dataclass, not a callable graph"))
A(case("models.rt_detr.RTDETRModelType", "models.rt_detr", None, [], skip="enum"))
_logits = torch.randn(1, 300, 80)
_boxes = torch.rand(1, 300, 4) * 0.5 + 0.25
_sizes = torch.tensor([[64.0, 96.0]])
A(
case(
"models.rt_detr.DETRPostProcessor[confidence_filtering=False]",
"models.rt_detr",
DETRPostProcessor(num_classes=80, num_top_queries=300, confidence_filtering=False),
[_logits, _boxes, _sizes],
note="num_top_queries=300 baked; returns (1,300,6) tensor; uses topk + gather + mod",
)
)
A(
case(
"models.rt_detr.DETRPostProcessor[threshold=0.3,filter_as_zero]",
"models.rt_detr",
DETRPostProcessor(confidence_threshold=0.3, num_classes=80, num_top_queries=300, filter_as_zero=True),
[_logits, _boxes, _sizes],
note="threshold baked as buffer; filtered rows zeroed -> fixed shape",
)
)
A(
case(
"models.rt_detr.DETRPostProcessor[threshold=0.3,list output]",
"models.rt_detr",
DETRPostProcessor(confidence_threshold=0.3, num_classes=80, num_top_queries=300),
[_logits, _boxes, _sizes],
note="default: BoxFiltering returns Python list of (Di,6) tensors, data-dependent shapes",
)
)
# ============================================================================= kornia.models.sam
from kornia.models.sam import Sam, SamConfig # noqa: E402
from kornia.models.structures import SegmentationResults # noqa: E402
A(
case(
"models.sam.Sam.forward",
"models.sam",
None,
[],
skip="forward(images, batched_prompts: list[dict], multimask_output: bool) -> list[SegmentationResults]; "
"list/dict/bool inputs are not exportable β sub-modules exported as separate cases",
)
)
A(case("models.sam.SamConfig", "models.sam", None, [], skip="config dataclass"))
A(case("models.sam.SamModelType", "models.sam", None, [], skip="enum"))
A(case("models.structures.Prompts", "models.sam", None, [], skip="plain dataclass holding tensors, no computation"))
A(
case(
"models.structures.SegmentationResults",
"models.sam",
SegmentationResults,
[torch.randn(1, 3, 64, 96), torch.rand(1, 3)],
note="dataclass container; `binary_masks` property = logits > 0",
)
)
A(
case(
"models.structures.SegmentationResults.binary_masks",
"models.sam",
lambda lg, sc: SegmentationResults(lg, sc).binary_masks,
[torch.randn(1, 3, 64, 96), torch.rand(1, 3)],
note="mask_threshold=0.0 baked",
)
)
sam_mobile, _e_sm = build(lambda: ev(Sam.from_config(SamConfig("mobile_sam", pretrained=True))))
sam_b, _e_sb = build(lambda: ev(Sam.from_config(SamConfig("vit_b", pretrained=False))))
A(
case(
"models.sam.Sam.image_encoder[vit_b,pretrained]",
"models.sam",
None,
[],
skip="weights 375 MB but ViT-B on a mandatory 1024x1024 input: random-init vit_b encoder exported instead "
"(same graph); mobile_sam covers the pretrained path",
)
)
A(case("models.sam.Sam.image_encoder[vit_l]", "models.sam", None, [], skip="weights > 500 MB (1.25 GB)"))
A(case("models.sam.Sam.image_encoder[vit_h]", "models.sam", None, [], skip="weights > 500 MB (2.56 GB)"))
def _sam_sub(model, err, attr, name, inputs, kwargs=None, **kw):
if err is not None:
kw["note"] = (kw.get("note", "") + f" | CONSTRUCTOR FAILED: {err[0]}").strip(" |")
return case(name, "models.sam", raiser(err), inputs, kwargs, **kw)
return case(name, "models.sam", getattr(model, attr), inputs, kwargs, **kw)
_img_emb = torch.randn(1, 256, 64, 64)
_sparse = torch.randn(1, 3, 256)
_dense = torch.randn(1, 256, 64, 64)
for tagname, mdl, err in (("mobile_sam", sam_mobile, _e_sm), ("vit_b,random", sam_b, _e_sb)):
pe = None if err else mdl.prompt_encoder
A(
case(
f"models.sam.Sam.prompt_encoder[points,{tagname}]",
"models.sam",
(raiser(err) if err else (lambda c, l, _pe=pe: _pe(points=(c, l), boxes=None, masks=None))),
[torch.tensor([[[300.0, 400.0], [512.0, 512.0]]]), torch.tensor([[1, 0]])],
note="points=(coords (1,2,2), labels (1,2) int64); pads with a -1 label point; "
"boolean-mask indexed assignment "
"`point_embedding[labels == -1] = 0.0`",
tags=("model",) + (("pretrained",) if "mobile" in tagname else ()),
)
)
A(
case(
f"models.sam.Sam.prompt_encoder[boxes,{tagname}]",
"models.sam",
(raiser(err) if err else (lambda b, _pe=pe: _pe(points=None, boxes=b, masks=None))),
[torch.tensor([[100.0, 120.0, 600.0, 700.0]])],
note="boxes (1,4) in 1024x1024 pixel coords",
tags=("model",),
)
)
A(
case(
f"models.sam.Sam.prompt_encoder[masks,{tagname}]",
"models.sam",
(raiser(err) if err else (lambda m, _pe=pe: _pe(points=None, boxes=None, masks=m))),
[torch.randn(1, 1, 256, 256)],
note="mask prompt (1,1,256,256) -> dense (1,256,64,64) via conv downscale",
tags=("model",),
)
)
A(
case(
f"models.sam.Sam.prompt_encoder.get_dense_pe[{tagname}]",
"models.sam",
(raiser(err) if err else (lambda d, _pe=pe: _pe.get_dense_pe())),
[torch.zeros(1)],
note="no tensor input: graph is a constant positional encoding (1,256,64,64)",
tags=("model",),
)
)
A(
_sam_sub(
mdl,
err,
"mask_decoder",
f"models.sam.Sam.mask_decoder[multimask,{tagname}]",
[_img_emb, _img_emb.clone(), _sparse, _dense],
{"multimask_output": True},
note="multimask_output=True baked; inputs image_embeddings/image_pe (1,256,64,64), sparse (1,3,256), "
"dense (1,256,64,64); TwoWayTransformer",
tags=("model",),
)
)
A(
_sam_sub(
mdl,
err,
"mask_decoder",
f"models.sam.Sam.mask_decoder[single,{tagname}]",
[_img_emb, _img_emb.clone(), _sparse, _dense],
{"multimask_output": False},
note="multimask_output=False baked",
tags=("model",),
)
)
# ============================================================================= kornia.models.yunet
from kornia.models.yunet import YuNet # noqa: E402
from kornia.models.yunet.processors import PriorBox, decode # noqa: E402
A(
mcase(
"models.yunet.YuNet[test,pretrained]",
"models.yunet",
lambda: ev(YuNet("test", pretrained=True)),
lambda m: m,
[IMG],
note="weights yunet_final.pth; dict outputs loc/conf/iou; H,W must be multiples of 32",
tags=("model", "pretrained"),
)
)
A(
mcase(
"models.yunet.YuNet[test,batch2]",
"models.yunet",
lambda: ev(YuNet("test", pretrained=True)),
lambda m: m,
[torch.rand(2, 3, 64, 128)],
tags=("model", "pretrained", "batch>1"),
)
)
A(
case(
"models.yunet.processors.PriorBox",
"models.yunet",
lambda d: PriorBox([[10, 16, 24], [32, 48], [64, 96], [128, 192, 256]], [8, 16, 32, 64], False, (64, 96))(),
[torch.zeros(1)],
note="no tensor input: fully constant graph (priors for 64x96)",
)
)
_pri = PriorBox([[10, 16, 24], [32, 48], [64, 96], [128, 192, 256]], [8, 16, 32, 64], False, (64, 96))()
A(
case(
"models.yunet.processors.decode",
"models.yunet",
decode,
[torch.randn(_pri.shape[0], 14) * 0.1, _pri],
{"variances": [0.1, 0.2]},
note="variances baked",
)
)
# ============================================================================= kornia.models.dexined
from kornia.models.dexined import DexiNed # noqa: E402
dexi, _e_dx = build(lambda: ev(DexiNed(pretrained=True)))
A(
mcase(
"models.dexined.DexiNed[pretrained]",
"models.dexined",
reuse(dexi, _e_dx),
lambda m: m,
[IMG],
note="weights DexiNed_BIPED_10.pth; output (1,1,H,W)",
tags=("model", "pretrained"),
)
)
A(
mcase(
"models.dexined.DexiNed.get_features",
"models.dexined",
reuse(dexi, _e_dx),
lambda m: m,
[IMG],
method="get_features",
note="returns list of 6 side outputs",
tags=("model", "pretrained"),
)
)
A(
mcase(
"models.dexined.DexiNed[batch2,48x64]",
"models.dexined",
reuse(dexi, _e_dx),
lambda m: m,
[IMG2],
tags=("model", "pretrained", "batch>1"),
)
)
# ============================================================================= depth / segmentation / base
A(
case(
"models.depth_estimation.DepthEstimation",
"models.depth_estimation",
None,
[],
skip="HFONNXComunnityModel: loads a pre-built ONNX graph from HF onnx-community and runs it with onnxruntime; "
"not a torch module",
)
)
A(
case(
"models.depth_estimation.DepthAnythingONNXBuilder",
"models.depth_estimation",
None,
[],
skip="builder returns the onnx-community ONNX model wrapped in ONNXSequential; nothing to export",
)
)
from kornia.models.segmentation import SegmentationModelsBuilder, SemanticSegmentation # noqa: E402
A(
case(
"models.segmentation.SegmentationModelsBuilder.build",
"models.segmentation",
SegmentationModelsBuilder.build(
torch.nn.Sequential(torch.nn.Conv2d(3, 2, 1), torch.nn.Softmax(dim=1)),
{
"input_space": "BGR",
"input_range": [0, 255],
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
),
[IMG],
note="builder wraps a user-built network (a 1x1 conv + softmax stand-in here; kornia does not import "
"segmentation_models_pytorch) behind the BgrToRgb/rescale/Normalize preprocessing an smp encoder declares",
)
)
A(
case(
"models.segmentation.SemanticSegmentation",
"models.segmentation",
SemanticSegmentation(
model=torch.nn.Identity(), pre_processor=torch.nn.Identity(), post_processor=torch.nn.Identity(), name="x"
),
[IMG],
note="container with identity model/pre/post: the graph is the input",
)
)
A(case("models.base.ModelBase", "models.base", None, [], skip="abstract base class (from_config abstract)"))
A(
case(
"models.base.ModelBase.save/load/resize",
"models.base",
None,
[],
skip="file-IO / PIL helpers on ModelBase, not tensor graphs",
)
)
A(
case(
"models._hf_models.HFONNXComunnityModel",
"models.base",
None,
[],
skip="ORT wrapper around downloaded onnx-community graphs; not a torch module",
)
)
# ============================================================================= efficient_vit
from kornia.models.efficient_vit import EfficientViT, EfficientViTConfig # noqa: E402
from kornia.models.efficient_vit.backbone import ( # noqa: E402
efficientvit_backbone_b0,
efficientvit_backbone_b1,
efficientvit_backbone_l0,
)
A(
mcase(
"models.efficient_vit.EfficientViT[b1-r224,pretrained]",
"models.efficient_vit",
lambda: ev(EfficientViT.from_config(EfficientViTConfig.from_pretrained("b1", 224))),
lambda m: m,
[IMG],
note="weights HF kornia/efficientvit_imagenet_b1_r224 (b1-r224.pt); dict of stage features; 64x96 input",
tags=("model", "pretrained"),
)
)
A(
mcase(
"models.efficient_vit.backbone.efficientvit_backbone_b0",
"models.efficient_vit",
lambda: ev(efficientvit_backbone_b0()),
lambda m: m,
[IMG],
note="random init; dict output",
tags=("model",),
)
)
A(
mcase(
"models.efficient_vit.backbone.efficientvit_backbone_b1",
"models.efficient_vit",
lambda: ev(efficientvit_backbone_b1()),
lambda m: m,
[IMG],
note="random init",
tags=("model",),
)
)
A(
mcase(
"models.efficient_vit.backbone.efficientvit_backbone_l0",
"models.efficient_vit",
lambda: ev(efficientvit_backbone_l0()),
lambda m: m,
[IMG],
note="random init (large family)",
tags=("model",),
)
)
for _n in ("b2", "b3", "l1", "l2", "l3"):
A(
case(
f"models.efficient_vit.backbone.efficientvit_backbone_{_n}",
"models.efficient_vit",
None,
[],
skip=f"same architecture family as b0/b1/l0 with more channels/blocks; {_n} not exported separately",
)
)
A(
case(
"models.efficient_vit.EfficientViTBackbone",
"models.efficient_vit",
None,
[],
skip="class instantiated by efficientvit_backbone_b* factories (covered)",
)
)
A(
case(
"models.efficient_vit.EfficientViTLargeBackbone",
"models.efficient_vit",
None,
[],
skip="class instantiated by efficientvit_backbone_l* factories (covered)",
)
)
# ============================================================================= tiny_vit / vit / vit_mobile
from kornia.models.tiny_vit import TinyViT # noqa: E402
from kornia.models.vit import VisionTransformer # noqa: E402
from kornia.models.vit_mobile import MobileViT # noqa: E402
A(
mcase(
"models.tiny_vit.TinyViT[5m,in1k]",
"models.tiny_vit",
lambda: ev(TinyViT.from_config("5m", pretrained="in1k")),
lambda m: m,
[IMG32],
note="weights tiny_vit_5m_224 in1k (HF kornia/tiny_vit); img_size=224 baked (window attention)",
tags=("model", "pretrained"),
)
)
A(
mcase(
"models.tiny_vit.TinyViT[5m,mobile_sam,random,img_size=64]",
"models.tiny_vit",
lambda: ev(TinyViT.from_config("5m", img_size=64, mobile_sam=True)),
lambda m: m,
[torch.rand(1, 3, 64, 64)],
note="mobile_sam=True head: unflatten + neck -> (1,256,4,4)",
tags=("model",),
)
)
A(
case(
"models.tiny_vit.TinyViT[non-square input]",
"models.tiny_vit",
None,
[],
skip="eager ValueError (a 64x48 input gives an 8x6 token grid; the stages are built for the 8x8 grid) β "
"TinyViT requires H=W=img_size",
)
)
A(case("contrib.TinyViT", "contrib", None, [], skip="alias of kornia.models.tiny_vit.TinyViT (covered)"))
A(
mcase(
"models.vit.VisionTransformer[small,random]",
"models.vit",
lambda: ev(VisionTransformer(image_size=32, patch_size=8, embed_dim=64, depth=2, num_heads=2)),
lambda m: m,
[torch.rand(1, 3, 32, 32)],
note="random init; image_size=32 patch=8; output (1,17,64)",
tags=("model",),
)
)
A(
case(
"models.vit.VisionTransformer[non-square input]",
"models.vit",
None,
[],
skip="eager ValueError (input image shape must be Bx3x32x32) β VisionTransformer requires "
"H=W=image_size (fixed pos_embed)",
)
)
A(
case(
"models.vit.VisionTransformer.from_config[vit_b/16]",
"models.vit",
None,
[],
skip="86M-param random init (no pretrained weights shipped); small config covers the graph",
)
)
A(
mcase(
"models.vit_mobile.MobileViT[xxs,random,64x128]",
"models.vit_mobile",
lambda: ev(MobileViT(mode="xxs")),
lambda m: m,
[torch.rand(1, 3, 64, 128)],
note="random init; H,W must be multiples of 64 (64x96 fails eagerly: view '[96,2,1,2]' "
"invalid β stride-32 grid "
"must be divisible by patch_size 2)",
tags=("model",),
)
)
A(
mcase(
"models.vit_mobile.MobileViT[xxs,random,256]",
"models.vit_mobile",
lambda: ev(MobileViT(mode="xxs")),
lambda m: m,
[torch.rand(1, 3, 256, 256)],
note="documented input size 256x256",
tags=("model",),
)
)
# ============================================================================= small_sr
from kornia.models.small_sr import SmallSRNet, SmallSRNetWrapper # noqa: E402
A(
mcase(
"models.small_sr.SmallSRNet[x3,pretrained]",
"models.small_sr",
lambda: ev(SmallSRNet(3, pretrained=True)),
lambda m: m,
[torch.rand(1, 1, 16, 24)],
note="weights small_sr.pth; Y channel (1,1,H,W) -> (1,1,3H,3W) PixelShuffle",
tags=("model", "pretrained"),
)
)
A(
mcase(
"models.small_sr.SmallSRNetWrapper[x3,pretrained]",
"models.small_sr",
lambda: ev(SmallSRNetWrapper(3, pretrained=True)),
lambda m: m,
[torch.rand(1, 3, 16, 24)],
note="RGB->YCbCr, SR on Y, bicubic upsample CbCr, ->RGB",
tags=("model", "pretrained"),
)
)
A(
case(
"contrib.SuperResolution",
"contrib",
lambda x: K.contrib.SuperResolution(
model=torch.nn.Identity(), pre_processor=torch.nn.Identity(), post_processor=torch.nn.Identity(), name="x"
),
[IMG],
)
)
A(
case(
"contrib.SmallSRBuilder.build",
"contrib",
lambda x: K.contrib.SmallSRBuilder.build("small_sr", pretrained=False),
[IMG],
)
)
A(
case(
"contrib.RRDBNetBuilder.build",
"contrib",
None,
[],
skip="builds a 17M-parameter Real-ESRGAN generator; too heavy for the survey",
)
)
# ============================================================================= processors
from kornia.models.processors import OutputRangePostProcessor, ResizePostProcessor, ResizePreProcessor # noqa: E402
from kornia.models.processors.naflex import NaFlex # noqa: E402
A(
case(
"models.processors.ResizePreProcessor",
"models.processors",
ResizePreProcessor(32, 40),
[IMG],
note="size (32,40) baked; returns (resized, original_sizes); per-image Python loop",
)
)
A(
case(
"models.processors.ResizePreProcessor[batch2]",
"models.processors",
ResizePreProcessor(32, 40),
[IMG2],
tags=("batch>1",),
)
)
A(
case(
"models.processors.ResizePostProcessor",
"models.processors",
ResizePostProcessor(),
[torch.rand(1, 1, 32, 40), torch.tensor([[64, 96]])],
note="original_sizes via .cpu().numpy().tolist(); returns inputs unchanged when torch.onnx.is_in_onnx_export()",
)
)
A(
case(
"models.processors.OutputRangePostProcessor",
"models.processors",
OutputRangePostProcessor(0.0, 1.0),
[torch.randn(1, 3, 16, 24)],
note="clamp(0,1) baked",
)
)
_pe_conv = torch.nn.Conv2d(3, 8, 8, 8)
A(
case(
"models.processors.NaFlex[interpolated pos]",
"models.processors",
NaFlex(_pe_conv, torch.randn(16, 8)),
[torch.rand(1, 3, 32, 48)],
note="pos-embed 4x4 grid interpolated to 4x6 with F.interpolate (bilinear); patch fn is a Conv2d",
)
)
A(
case(
"models.processors.NaFlex[matching pos]",
"models.processors",
NaFlex(_pe_conv, torch.randn(16, 8)),
[torch.rand(1, 3, 32, 32)],
note="4x4 patch grid == the 4x4 pos-embed grid -> plain add, no resize",
)
)
# ============================================================================= VLM re-implementations (pure PyTorch)
from kornia.models.kimi_vl import KimiVLConfig, KimiVLModel, KimiVLProjectorConfig, MoonViT, MoonViTConfig # noqa: E402
from kornia.models.paligemma import PaliGemma, PaliGemmaConfig # noqa: E402
from kornia.models.qwen25 import Qwen25VisionConfig, Qwen25VisionTransformer # noqa: E402
from kornia.models.siglip2 import SigLip2Config, SigLip2ImagePreprocessor, SigLip2Model # noqa: E402
from kornia.models.siglip2.config import SigLip2TextConfig, SigLip2VisionConfig # noqa: E402
from kornia.models.smolvlm2 import SmolVLM2 # noqa: E402
_vcfg = SigLip2VisionConfig(
image_size=32, patch_size=16, hidden_size=32, num_hidden_layers=1, num_attention_heads=2, intermediate_size=64
)
_tcfg = SigLip2TextConfig(
vocab_size=100,
hidden_size=32,
num_hidden_layers=1,
num_attention_heads=2,
intermediate_size=64,
max_position_embeddings=16,
)
_sig, _e_sig = build(lambda: ev(SigLip2Model(SigLip2Config(_vcfg, _tcfg, projection_dim=32))))
A(
case(
"models.siglip2.SigLip2Model[image only,tiny,random]",
"models.vlm",
raiser(_e_sig) if _e_sig else (lambda px: _sig(pixel_values=px)),
[torch.rand(1, 3, 32, 32)],
note="pure-PyTorch SigLIP2 (no transformers); tiny random config; SigLip2Result dataclass, None fields dropped",
tags=("model",),
)
)
A(
case(
"models.siglip2.SigLip2Model[image+text,tiny,random]",
"models.vlm",
raiser(_e_sig) if _e_sig else (lambda px, ids: _sig(pixel_values=px, input_ids=ids)),
[torch.rand(2, 3, 32, 32), torch.randint(0, 100, (2, 8))],
note="image+text -> embeds + logits_per_image/text",
tags=("model", "batch>1"),
)
)
A(
case(
"models.siglip2.SigLip2Model.get_image_features[non-square]",
"models.vlm",
None,
[],
skip="eager ValueError (input images must be 32x32: the position embeddings cover that size only) β "
"vision tower requires H=W=image_size (no pos-embed interpolation)",
)
)
A(
case(
"models.siglip2.SigLip2ImagePreprocessor",
"models.vlm",
SigLip2ImagePreprocessor((32, 40)),
[torch.rand(1, 3, 48, 64) * 255],
note="Rescale(1/255) + Resize bilinear antialias (default; bicubic via interpolation=) + Normalize; size baked",
)
)
A(
case(
"models.siglip2.SigLip2Builder.from_pretrained_hf",
"models.vlm",
None,
[],
skip="downloads google/siglip2-base-patch16-224 safetensors (~1.5 GB) from HF; weights > 500 MB",
)
)
A(
case(
"models.siglip2.SigLip2Builder.from_name",
"models.vlm",
None,
[],
skip="random-init base config (~375M params); tiny random config covers the same graph",
)
)
A(case("models.siglip2.SigLip2Config/SigLip2Result", "models.vlm", None, [], skip="config / result dataclasses"))
_mcfg = MoonViTConfig(
image_size=28, patch_size=14, hidden_size=32, num_hidden_layers=1, num_attention_heads=2, intermediate_size=64
)
A(
mcase(
"models.kimi_vl.MoonViT[tiny,random]",
"models.vlm",
lambda: ev(MoonViT(_mcfg)),
lambda m: m,
[torch.rand(1, 3, 28, 42)],
note="pure-PyTorch MoonViT; 2x3 patches vs 2x2 pos-embed -> interpolation path; 2D RoPE",
tags=("model",),
)
)
A(
mcase(
"models.kimi_vl.KimiVLModel[tiny,random]",
"models.vlm",
lambda: ev(KimiVLModel(KimiVLConfig(_mcfg, KimiVLProjectorConfig(32, 64, 48)))),
lambda m: m,
[torch.rand(1, 3, 28, 28)],
note="MoonViT + pixel-unshuffle projector; h,w patch grid from input shape",
tags=("model",),
)
)
A(
case(
"models.kimi_vl.KimiVLBuilder",
"models.vlm",
None,
[],
skip="weights > 500 MB (Kimi-VL-A3B-Instruct vision tower + projector safetensors, multi-GB download)",
)
)
A(
case(
"models.kimi_vl.KimiVLProjector",
"models.vlm",
None,
[],
skip="covered inside KimiVLModel case (needs h,w ints)",
)
)
A(
mcase(
"models.qwen25.Qwen25VisionTransformer[tiny,random]",
"models.vlm",
lambda: ev(
Qwen25VisionTransformer(
Qwen25VisionConfig(
depth=2,
hidden_size=32,
intermediate_size=48,
num_heads=2,
out_hidden_size=16,
window_size=56,
fullatt_block_indexes=(1,),
)
)
),
lambda m: m,
[torch.rand(1, 3, 112, 84)],
note="pure-PyTorch Qwen2.5-VL tower; conv3d patch embed, 2D RoPE, windowed + full attention, 2x2 merger",
tags=("model",),
)
)
_pcfg = PaliGemmaConfig(
vision_config=_vcfg,
vocab_size=100,
hidden_size=32,
intermediate_size=64,
num_hidden_layers=1,
num_attention_heads=2,
num_key_value_heads=1,
head_dim=16,
max_position_embeddings=64,
)
A(
mcase(
"models.paligemma.PaliGemma[tiny,random]",
"models.vlm",
lambda: ev(PaliGemma(_pcfg)),
lambda m: m,
[torch.randint(0, 100, (1, 4)), torch.rand(1, 3, 32, 32)],
note="pure-PyTorch SigLIP2 tower + Gemma decoder (RMSNorm, RoPE, GQA); inputs (input_ids, pixel_values)",
tags=("model",),
)
)
A(
mcase(
"models.smolvlm2.SmolVLM2",
"models.vlm",
lambda: ev(SmolVLM2(16, 16)),
lambda m: m,
[torch.rand(1, 5, 16), torch.rand(1, 5, 16)],
note="placeholder scaffold: sum of two Linear projections; image/text sequences must have equal length",
tags=("model",),
)
)
# ============================================================================= kornia.contrib β patches
_x = torch.rand(1, 2, 32, 48)
A(
case(
"contrib.extract_tensor_patches",
"contrib.patches",
K.contrib.extract_tensor_patches,
[_x],
{"window_size": 8, "stride": 8},
note="window 8, stride 8 baked -> (1,24,2,8,8)",
)
)
A(
case(
"contrib.extract_tensor_patches[rect window,stride,padding]",
"contrib.patches",
K.contrib.extract_tensor_patches,
[_x],
{"window_size": (8, 12), "stride": (4, 6), "padding": (2, 3)},
note="non-square window/stride, padding (2,3)",
)
)
A(
case(
"contrib.extract_tensor_patches[allow_auto_padding]",
"contrib.patches",
K.contrib.extract_tensor_patches,
[_x],
{"window_size": 10, "stride": 7, "allow_auto_padding": True},
note="auto padding computed from static shape",
)
)
A(
case(
"contrib.extract_tensor_patches[batch2]",
"contrib.patches",
K.contrib.extract_tensor_patches,
[IMG2],
{"window_size": 16, "stride": 16},
tags=("batch>1",),
)
)
A(case("contrib.ExtractTensorPatches", "contrib.patches", K.contrib.ExtractTensorPatches(8, stride=4, padding=2), [_x]))
_patches = K.contrib.extract_tensor_patches(_x, window_size=8, stride=8)
A(
case(
"contrib.combine_tensor_patches",
"contrib.patches",
K.contrib.combine_tensor_patches,
[_patches],
{"original_size": (32, 48), "window_size": 8, "stride": 8},
note="original_size/window/stride baked; fold + overlap norm",
)
)
_patches_o = K.contrib.extract_tensor_patches(_x, window_size=(8, 12), stride=(4, 6), padding=(2, 3))
A(
case(
"contrib.combine_tensor_patches[overlap,unpadding]",
"contrib.patches",
K.contrib.combine_tensor_patches,
[_patches_o],
{"original_size": (32, 48), "window_size": (8, 12), "stride": (4, 6), "unpadding": (2, 3)},
note="overlapping windows: divides by the exact ones-fold overlap count",
)
)
_patches_a = K.contrib.extract_tensor_patches(_x, window_size=10, stride=7, allow_auto_padding=True)
A(
case(
"contrib.combine_tensor_patches[allow_auto_unpadding]",
"contrib.patches",
K.contrib.combine_tensor_patches,
[_patches_a],
{"original_size": (32, 48), "window_size": 10, "stride": 7, "allow_auto_unpadding": True},
)
)
A(
case(
"contrib.CombineTensorPatches",
"contrib.patches",
K.contrib.CombineTensorPatches((32, 48), 8, stride=8),
[_patches],
)
)
A(
case(
"contrib.compute_padding",
"contrib.patches",
lambda d: K.contrib.compute_padding((32, 48), 10, 7),
[torch.zeros(1)],
note="returns tuple of Python ints -> expected no-tensor-output",
)
)
# ============================================================================= kornia.contrib β tensor ops
_bin = (torch.rand(1, 1, 16, 24) > 0.6).float()
A(
case(
"contrib.connected_components",
"contrib",
K.contrib.connected_components,
[_bin],
{"num_iterations": 50},
note="num_iterations=50 baked (Python for-loop unrolled into 50 max_pool2d stages); input 0/1 float mask",
)
)
A(
case(
"contrib.connected_components[batch2,default 100 it]",
"contrib",
K.contrib.connected_components,
[(torch.rand(2, 1, 12, 20) > 0.6).float()],
note="100 unrolled iterations",
tags=("batch>1",),
)
)
A(
case(
"contrib.distance_transform",
"contrib",
K.contrib.distance_transform,
[_bin],
note="kernel_size=3, h=0.35 baked; Python loop over max(H,W)//2 iterations unrolled",
)
)
A(
case(
"contrib.distance_transform[kernel_size=5]", "contrib", K.contrib.distance_transform, [_bin], {"kernel_size": 5}
)
)
A(
case(
"contrib.distance_transform[3d]",
"contrib",
K.contrib.distance_transform,
[(torch.rand(1, 1, 6, 10, 12) > 0.7).float()],
note="3D input path",
tags=("3d",),
)
)
A(case("contrib.DistanceTransform", "contrib", K.contrib.DistanceTransform(kernel_size=3, h=0.35), [_bin]))
A(
case(
"contrib.diamond_square",
"contrib",
lambda d: K.contrib.diamond_square((1, 1, 16, 24), roughness=0.5, random_scale=1.0),
[torch.zeros(1)],
check=False,
note="no tensor input; torch.rand inside graph (RandomUniformLike); output_size baked",
)
)
A(
case(
"contrib.diamond_square[normalize_range]",
"contrib",
lambda d: K.contrib.diamond_square((2, 3, 16, 24), roughness=0.7, normalize_range=(0.0, 1.0)),
[torch.zeros(1)],
check=False,
note="normalize_range applied",
tags=("batch>1",),
)
)
A(
case(
"contrib.histogram_matching",
"contrib",
K.contrib.histogram_matching,
[torch.rand(1, 1, 16, 24), torch.rand(1, 1, 20, 30)],
note="unique(return_inverse, return_counts) + cumsum + interp",
)
)
A(
case(
"contrib.interp",
"contrib",
K.contrib.interp,
[torch.rand(20) * 10, torch.linspace(0, 10, 6), torch.rand(6)],
note="1-D linear interp via searchsorted/bucketize",
)
)
_km_centers = torch.tensor([[0.0, 0.0], [5.0, 5.0], [0.0, 5.0]])
_km = K.contrib.KMeans(3, _km_centers, tolerance=None, max_iterations=5, seed=0)
A(
case(
"contrib.KMeans.predict",
"contrib",
_km.predict,
[torch.randn(20, 2) * 0.5 + torch.tensor([2.5, 2.5])],
note="cluster centers fixed (3,2); argmin of pairwise distances",
)
)
def _kmeans_fit(x):
km = K.contrib.KMeans(3, _km_centers.clone(), tolerance=None, max_iterations=5, seed=0)
km.fit(x)
return km.cluster_centers
A(
case(
"contrib.KMeans.fit",
"contrib",
_kmeans_fit,
[torch.randn(20, 2) * 0.5 + torch.tensor([2.5, 2.5])],
note="max_iterations=5, tolerance=None (fixed iteration count); the centroid update has no "
"data-dependent control flow, so torch.export and the ONNX export now succeed; the one remaining "
"graph break is torch.manual_seed in __init__",
)
)
A(case("contrib.Lambda", "contrib", K.contrib.Lambda(K.color.rgb_to_grayscale), [IMG], note="wraps rgb_to_grayscale"))
# ============================================================================= kornia.contrib β model wrappers
from kornia.contrib.face_detection import FaceDetector, FaceDetectorResult # noqa: E402
fd, _e_fd = build(lambda: ev(FaceDetector()))
A(
mcase(
"contrib.FaceDetector",
"contrib.wrappers",
reuse(fd, _e_fd),
lambda m: m,
[torch.rand(1, 3, 64, 96) * 255],
note="YuNet + PriorBox + decode + confidence mask + NMS; returns list of (N,15); data-dependent shapes",
tags=("model", "pretrained"),
)
)
A(
mcase(
"contrib.FaceDetector.model",
"contrib.wrappers",
reuse(fd, _e_fd),
lambda m: m.model,
[torch.rand(1, 3, 64, 96) * 255],
note="the underlying YuNet only (as FaceDetector.model)",
tags=("model", "pretrained"),
)
)
A(
case(
"contrib.FaceDetectorResult",
"contrib.wrappers",
lambda d: torch.stack(
[
FaceDetectorResult(d).xmin,
FaceDetectorResult(d).ymin,
FaceDetectorResult(d).xmax,
FaceDetectorResult(d).ymax,
FaceDetectorResult(d).score,
FaceDetectorResult(d).top_left[..., 0],
FaceDetectorResult(d).bottom_right[..., 1],
],
-1,
),
[torch.rand(15) * 60],
note="property accessors on a (15,) detection vector; __init__ requires a last dimension of at least 15",
)
)
A(case("contrib.FaceKeypoint", "contrib.wrappers", None, [], skip="enum"))
edge, _e_ed = build(lambda: ev(K.contrib.EdgeDetectorBuilder.build("dexined", pretrained=True, image_size=64)))
A(
mcase(
"contrib.EdgeDetectorBuilder.build[dexined,image_size=64]",
"contrib.wrappers",
reuse(edge, _e_ed),
lambda m: m,
[torch.rand(1, 3, 48, 80) * 255],
note="RgbToBgr + Normalize -> DexiNed -> Sigmoid with ResizePreProcessor(64,64) and ResizePostProcessor "
"(numpy tolist); image_size=64 baked",
tags=("model", "pretrained"),
)
)
A(
mcase(
"contrib.EdgeDetector.model",
"contrib.wrappers",
reuse(edge, _e_ed),
lambda m: m.model,
[torch.rand(1, 3, 64, 64)],
note="core nn.Sequential(nn.Sequential(RgbToBgr, Normalize), DexiNed, Sigmoid) without pre/post processors",
tags=("model", "pretrained"),
)
)
od, _e_od = build(
lambda: ev(
K.contrib.RTDETRDetectorBuilder.build("rtdetr_r18vd", pretrained=True, image_size=256, confidence_threshold=0.0)
)
)
A(
mcase(
"contrib.RTDETRDetectorBuilder.build[r18vd,image_size=256,threshold=0]",
"contrib.wrappers",
reuse(od, _e_od),
lambda m: m,
[torch.rand(1, 3, 200, 320)],
note="ObjectDetector = ResizePreProcessor(640,640) + RTDETR + DETRPostProcessor (image_size=256 is ignored "
"with a model_name); threshold 0 -> all 300 boxes (1,300,6). forward is @torch.inference_mode()",
tags=("model", "pretrained"),
)
)
od_f, _e_odf = build(
lambda: ev(
K.contrib.RTDETRDetectorBuilder.build("rtdetr_r18vd", pretrained=True, image_size=256, confidence_threshold=0.3)
)
)
A(
mcase(
"contrib.RTDETRDetectorBuilder.build[r18vd,threshold=0.3,list output]",
"contrib.wrappers",
reuse(od_f, _e_odf),
lambda m: m,
[torch.rand(1, 3, 200, 320)],
note="default confidence_filtering=True; list of (Di,6) tensors",
tags=("model", "pretrained"),
)
)
A(case("contrib.ObjectDetector", "contrib.wrappers", None, [], skip="constructed by RTDETRDetectorBuilder (covered)"))
A(
case(
"contrib.ObjectDetectorResult/BoundingBox/BoundingBoxDataFormat",
"contrib.wrappers",
None,
[],
skip="dataclasses / enum",
)
)
A(
case(
"contrib.object_detection.results_from_detections",
"contrib.wrappers",
None,
[],
skip="returns a Python list of ObjectDetectorResult dataclasses",
)
)
A(
case(
"contrib.object_detection.ResizePreProcessor",
"contrib.wrappers",
None,
[],
skip="re-export of kornia.models.processors.ResizePreProcessor (covered)",
)
)
_det = torch.cat([torch.randint(0, 80, (1, 300, 1)).float(), torch.rand(1, 300, 1), torch.rand(1, 300, 4) * 100], -1)
A(
case(
"contrib.object_detection.BoxFiltering[filter_as_zero]",
"contrib.wrappers",
K.contrib.object_detection.BoxFiltering(filter_as_zero=True),
[_det, torch.tensor(0.5)],
note="threshold passed as 0-d tensor input; `confidence_threshold or "
"self.confidence_threshold` -> bool() on tensor",
)
)
A(
case(
"contrib.object_detection.BoxFiltering[filter_as_zero,classes_to_keep]",
"contrib.wrappers",
K.contrib.object_detection.BoxFiltering(torch.tensor(0.5), torch.tensor([1, 2, 3]), filter_as_zero=True),
[_det],
note="threshold + classes baked as buffers",
)
)
A(
case(
"contrib.object_detection.BoxFiltering[list output]",
"contrib.wrappers",
K.contrib.object_detection.BoxFiltering(torch.tensor(0.5)),
[_det],
note="returns list of variable-size tensors",
)
)
A(
case(
"contrib.ImageStitcher",
"contrib.wrappers",
None,
[],
skip="LoFTR matcher + RANSAC (Python loop over data-dependent inlier counts) + `.item()` in postprocess; "
"variable-arity forward(*imgs) β blocker recorded, not exportable",
)
)
A(
case(
"contrib.VisualPrompter",
"contrib.wrappers",
None,
[],
skip="stateful plain-Python API (set_image/predict) over SAM with Keypoints/Boxes prompts; "
"sub-modules covered by "
"models.sam cases; default config is vit_h (>500 MB)",
)
)
# ============================================================================= kornia.tracking
A(
case(
"tracking.HomographyTracker",
"tracking",
None,
[],
skip="stateful tracker (GFTTAffNetHardNet + LoFTR + RANSAC) returning (H, bool); RANSAC and LoFTR coarse "
"matching are data-dependent β blocker recorded",
)
)
# ============================================================================= kornia.sensors.camera
from kornia.geometry.vector import Vector2, Vector3 # noqa: E402
from kornia.image import ImageSize # noqa: E402
from kornia.sensors.camera import ( # noqa: E402
BrownConradyModel,
CameraModel,
CameraModelType,
KannalaBrandtK3,
Orthographic,
PinholeModel,
)
_pin = PinholeModel(ImageSize(480, 640), torch.tensor([[328.0, 328.0, 320.0, 240.0]]))
_bc = BrownConradyModel(
ImageSize(480, 640),
torch.tensor([328.0, 328.0, 320.0, 240.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
)
_kb = KannalaBrandtK3(
ImageSize(480, 640),
torch.tensor([328.0, 328.0, 320.0, 240.0, 0.0, 0.0, 0.0, 0.0]),
)
_orth = Orthographic(ImageSize(480, 640), torch.tensor([328.0, 328.0, 320.0, 240.0]))
_pts3 = torch.tensor([[1.0, 2.0, 5.0], [-0.5, 0.3, 2.0]])
A(
case(
"sensors.camera.PinholeModel.project",
"sensors.camera",
lambda p: _pin.project(Vector3(p)).data,
[_pts3],
note="params (fx,fy,cx,cy) baked; Vector3 in -> Vector2 out (.data)",
)
)
A(
case(
"sensors.camera.PinholeModel.unproject",
"sensors.camera",
lambda p, d: _pin.unproject(Vector2(p), d).data,
[torch.tensor([[320.0, 240.0], [100.0, 50.0]]), torch.tensor([2.0, 3.0])],
note="depth as live tensor",
)
)
A(
case(
"sensors.camera.PinholeModel.matrix",
"sensors.camera",
lambda d: _pin.matrix(),
[torch.zeros(1)],
note="no tensor input: constant 3x3 K",
)
)
A(
case(
"sensors.camera.PinholeModel.scale",
"sensors.camera",
lambda s: _pin.scale(s).params,
[torch.tensor(0.5)],
note="scale factor live tensor; returns new model params",
)
)
A(
case(
"sensors.camera.CameraModel[pinhole].project",
"sensors.camera",
lambda p: (
CameraModel(ImageSize(480, 640), CameraModelType.PINHOLE, torch.tensor([[328.0, 328.0, 320.0, 240.0]]))
.project(Vector3(p))
.data
),
[_pts3],
note="generic wrapper delegating via __getattr__",
)
)
A(
case(
"sensors.camera.BrownConradyModel.project",
"sensors.camera",
lambda p: _bc.project(Vector3(p)).data,
[_pts3],
note="zero Brown-Conrady coefficients; params baked",
)
)
A(
case(
"sensors.camera.KannalaBrandtK3.project",
"sensors.camera",
lambda p: _kb.project(Vector3(p)).data,
[_pts3],
note="zero Kannala-Brandt coefficients; params baked",
)
)
A(
case(
"sensors.camera.Orthographic.project",
"sensors.camera",
lambda p: _orth.project(Vector3(p)).data,
[_pts3],
note="orthographic projection with affine intrinsics baked",
)
)
A(case("sensors.camera.CameraModelBase/CameraModelType", "sensors.camera", None, [], skip="base class / enum"))
# ============================================================================= heavy SAM encoders last
A(
case(
"models.sam.Sam.image_encoder[mobile_sam,pretrained]",
"models.sam",
raiser(_e_sm) if _e_sm else sam_mobile.image_encoder,
[torch.rand(1, 3, 1024, 1024)],
note="weights mobile_sam.pt (HF kornia/mobile_sam); TinyViT-5m img_size=1024 mobile_sam head -> (1,256,64,64); "
"1024x1024 input mandatory",
tags=("model", "pretrained"),
)
)
A(
case(
"models.sam.Sam.image_encoder[vit_b,random]",
"models.sam",
raiser(_e_sb) if _e_sb else sam_b.image_encoder,
[torch.rand(1, 3, 1024, 1024)],
note="ImageEncoderViT ViT-B, window attention 14, random init; 1024x1024 mandatory (abs pos_embed 64x64)",
tags=("model",),
)
)
if __name__ == "__main__":
run_cases(CASES, sys.argv[1], only=sys.argv[2:] or None)