Add files using upload-large-folder tool

.gitattributes

@@ -33,3 +33,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Pixal3D/torch_hub/hub/valeoai_NAF_main/evaluation/dataset/kitti360/train_split.json filter=lfs diff=lfs merge=lfs -text
+Pixal3D/torch_hub/hub/valeoai_NAF_main/asset/attention.gif filter=lfs diff=lfs merge=lfs -text
+Pixal3D/torch_hub/hub/valeoai_NAF_main/asset/dinov3.png filter=lfs diff=lfs merge=lfs -text
+Pixal3D/torch_hub/hub/valeoai_NAF_main/asset/dog0.jpg filter=lfs diff=lfs merge=lfs -text
+Pixal3D/torch_hub/hub/valeoai_NAF_main/asset/inference.png filter=lfs diff=lfs merge=lfs -text
+Pixal3D/torch_hub/hub/valeoai_NAF_main/asset/resolution.png filter=lfs diff=lfs merge=lfs -text
+Pixal3D/torch_hub/hub/valeoai_NAF_main/asset/results.png filter=lfs diff=lfs merge=lfs -text
+Pixal3D/torch_hub/hub/valeoai_NAF_main/asset/teaser.gif filter=lfs diff=lfs merge=lfs -text

Pixal3D/TencentARC_Pixal3D/ckpts/shape_dec_next_dc_f16c32_fp16.safetensors

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

Pixal3D/TencentARC_Pixal3D/ckpts/slat_flow_img2shape_dit_1_3B_1024_bf16.safetensors

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

Pixal3D/TencentARC_Pixal3D/ckpts/slat_flow_img2shape_dit_1_3B_512_bf16.safetensors

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

Pixal3D/TencentARC_Pixal3D/ckpts/slat_flow_imgshape2tex_dit_1_3B_1024_bf16.safetensors

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

Pixal3D/TencentARC_Pixal3D/ckpts/ss_dec_conv3d_16l8_fp16.safetensors

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

Pixal3D/TencentARC_Pixal3D/ckpts/ss_flow_img_dit_1_3B_64_bf16.safetensors

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

Pixal3D/TencentARC_Pixal3D/ckpts/tex_dec_next_dc_f16c32_fp16.safetensors

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

Pixal3D/briaai_RMBG-2.0/model.safetensors

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

Pixal3D/briaai_RMBG-2.0/onnx/model.onnx

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

Pixal3D/briaai_RMBG-2.0/onnx/model_bnb4.onnx

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

Pixal3D/briaai_RMBG-2.0/onnx/model_fp16.onnx

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

Pixal3D/briaai_RMBG-2.0/onnx/model_int8.onnx

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

Pixal3D/briaai_RMBG-2.0/onnx/model_q4.onnx

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

Pixal3D/briaai_RMBG-2.0/onnx/model_q4f16.onnx

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

Pixal3D/briaai_RMBG-2.0/onnx/model_quantized.onnx

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

Pixal3D/briaai_RMBG-2.0/pytorch_model.bin

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

Pixal3D/camenduru_dinov3-vitl16-pretrain-lvd1689m/facebookdinov3-vits16-pretrain-lvd1689m-transformers-default-v1.tar.gz

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

Pixal3D/camenduru_dinov3-vitl16-pretrain-lvd1689m/model.safetensors

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

Pixal3D/torch_hub/hub/checkpoints/naf_release.pth

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

Pixal3D/torch_hub/hub/valeoai_NAF_main/evaluation/dataset/kitti360/train_split.json

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

Pixal3D/torch_hub/hub/valeoai_NAF_main/test/forward_speed.py

@@ -0,0 +1,64 @@
+import pytest
+import torch
+from test_utils import create_tensors, get_active_factor, print_test_info, setup_parametrization
+
+from utils.wrapper import ModelWrapper
+
+NUM_RUNS = 10
+
+
+@pytest.fixture(params=["FeatUp", "AnyUp", "JAFAR", "NAF"])
+def model_name(request):
+    return request.param
+
+
+# Main test - optimized parametrization
+def pytest_generate_tests(metafunc):
+    setup_parametrization(metafunc)
+
+
+def test_forward_speed(model_name, img_size, embed_dim, ratio, lr_size, request):
+    # Determine which factor is being swept
+    factor = get_active_factor(request)
+
+    # Create model
+    model = ModelWrapper(name=model_name, embed_dim=embed_dim, ratio=ratio).cuda()
+
+    # Create input tensors
+    img, lr_feats, output_size = create_tensors(img_size, embed_dim, ratio, lr_size)
+
+    # Warmup runs
+    for _ in range(5):
+        with torch.no_grad():
+            torch.cuda.empty_cache()
+            _ = model(img, lr_feats, output_size)
+
+    total_time = 0
+
+    # CUDA events for precise timing
+    start_event = torch.cuda.Event(enable_timing=True)
+    end_event = torch.cuda.Event(enable_timing=True)
+
+    for _ in range(NUM_RUNS):
+        torch.cuda.empty_cache()
+        torch.cuda.synchronize()  # Ensure all previous operations are complete
+        start_event.record()
+        with torch.no_grad():
+            _ = model(img, lr_feats, output_size)
+        end_event.record()
+        torch.cuda.synchronize()  # Wait for the events to complete
+        total_time += start_event.elapsed_time(end_event)  # Time in milliseconds
+
+    avg_time = total_time / NUM_RUNS
+
+    # Print results using shared utility
+    print_test_info(
+        model_name,
+        factor,
+        embed_dim,
+        img_size,
+        lr_size,
+        ratio,
+        save=True,
+        **{"Average forward pass time": f"{avg_time:.6f} ms"},
+    )

Pixal3D/torch_hub/hub/valeoai_NAF_main/test/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+addopts = -q --tb=short --disable-warnings -s -v

Pixal3D/torch_hub/hub/valeoai_NAF_main/test/test_results.json

@@ -0,0 +1,580 @@
+[
+  {
+    "model": "FeatUp",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 2,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "74.09 MB",
+      "Average backward pass time": "14.882304 ms",
+      "Average forward pass time": "8.870912 ms",
+      "Peak GPU memory usage (forward)": "52.38 MB",
+      "GFLOPS": "0.98",
+      "# Params": "173540"
+    }
+  },
+  {
+    "model": "AnyUp",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 2,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "719.75 MB",
+      "Average backward pass time": "38.561280 ms",
+      "Average forward pass time": "11.235226 ms",
+      "Peak GPU memory usage (forward)": "315.98 MB",
+      "GFLOPS": "7.74",
+      "# Params": "878080"
+    }
+  },
+  {
+    "model": "JAFAR",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 2,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "5923.12 MB",
+      "Average backward pass time": "106.851736 ms",
+      "Average forward pass time": "57.254605 ms",
+      "Peak GPU memory usage (forward)": "604.26 MB",
+      "GFLOPS": "6.05",
+      "# Params": "628480"
+    }
+  },
+  {
+    "model": "NAF",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 2,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "3670.42 MB",
+      "Average backward pass time": "88.292659 ms",
+      "Average forward pass time": "39.513908 ms",
+      "Peak GPU memory usage (forward)": "604.98 MB",
+      "GFLOPS": "4.14",
+      "# Params": "662528"
+    }
+  },
+  {
+    "model": "FeatUp",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 4,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "284.56 MB",
+      "Average backward pass time": "22.538547 ms",
+      "Average forward pass time": "10.212659 ms",
+      "Peak GPU memory usage (forward)": "180.35 MB",
+      "GFLOPS": "4.88",
+      "# Params": "173540"
+    }
+  },
+  {
+    "model": "AnyUp",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 4,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "1347.67 MB",
+      "Average backward pass time": "50.124697 ms",
+      "Average forward pass time": "18.281574 ms",
+      "Peak GPU memory usage (forward)": "400.47 MB",
+      "GFLOPS": "23.01",
+      "# Params": "878080"
+    }
+  },
+  {
+    "model": "JAFAR",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 4,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "6525.77 MB",
+      "Average backward pass time": "124.415592 ms",
+      "Average forward pass time": "58.664141 ms",
+      "Peak GPU memory usage (forward)": "604.26 MB",
+      "GFLOPS": "23.22",
+      "# Params": "628480"
+    }
+  },
+  {
+    "model": "NAF",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 4,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "3684.27 MB",
+      "Average backward pass time": "102.527796 ms",
+      "Average forward pass time": "40.170496 ms",
+      "Peak GPU memory usage (forward)": "604.98 MB",
+      "GFLOPS": "16.57",
+      "# Params": "662528"
+    }
+  },
+  {
+    "model": "FeatUp",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 8,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "1099.72 MB",
+      "Average backward pass time": "45.861990 ms",
+      "Average forward pass time": "18.657178 ms",
+      "Peak GPU memory usage (forward)": "677.52 MB",
+      "GFLOPS": "20.50",
+      "# Params": "173540"
+    }
+  },
+  {
+    "model": "AnyUp",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 8,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "4812.09 MB",
+      "Average backward pass time": "133.391360 ms",
+      "Average forward pass time": "51.705651 ms",
+      "Peak GPU memory usage (forward)": "1552.49 MB",
+      "GFLOPS": "84.11",
+      "# Params": "878080"
+    }
+  },
+  {
+    "model": "JAFAR",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 8,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "8943.22 MB",
+      "Average backward pass time": "220.743989 ms",
+      "Average forward pass time": "64.862413 ms",
+      "Peak GPU memory usage (forward)": "1439.94 MB",
+      "GFLOPS": "91.87",
+      "# Params": "628480"
+    }
+  },
+  {
+    "model": "NAF",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 8,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "4028.77 MB",
+      "Average backward pass time": "112.663655 ms",
+      "Average forward pass time": "42.510439 ms",
+      "Peak GPU memory usage (forward)": "604.98 MB",
+      "GFLOPS": "66.28",
+      "# Params": "662528"
+    }
+  },
+  {
+    "model": "FeatUp",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "4929.11 MB",
+      "Average backward pass time": "171.858228 ms",
+      "Average forward pass time": "57.109504 ms",
+      "Peak GPU memory usage (forward)": "2673.83 MB",
+      "GFLOPS": "82.97",
+      "# Params": "173540"
+    }
+  },
+  {
+    "model": "AnyUp",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "18675.29 MB",
+      "Average backward pass time": "502.506192 ms",
+      "Average forward pass time": "181.956609 ms",
+      "Peak GPU memory usage (forward)": "6162.59 MB",
+      "GFLOPS": "328.50",
+      "# Params": "878080"
+    }
+  },
+  {
+    "model": "JAFAR",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "18613.05 MB",
+      "Average backward pass time": "489.506000 ms",
+      "Average forward pass time": "108.141977 ms",
+      "Peak GPU memory usage (forward)": "5410.94 MB",
+      "GFLOPS": "366.47",
+      "# Params": "628480"
+    }
+  },
+  {
+    "model": "NAF",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "6016.48 MB",
+      "Average backward pass time": "163.075171 ms",
+      "Average forward pass time": "56.241766 ms",
+      "Peak GPU memory usage (forward)": "1786.52 MB",
+      "GFLOPS": "265.12",
+      "# Params": "662528"
+    }
+  },
+  {
+    "model": "FeatUp",
+    "factor_swept": "embed_dim",
+    "embed_dim": 128,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "3292.90 MB",
+      "Average backward pass time": "117.686886 ms",
+      "Average forward pass time": "44.057805 ms",
+      "Peak GPU memory usage (forward)": "2558.69 MB",
+      "GFLOPS": "12.96",
+      "# Params": "41700"
+    }
+  },
+  {
+    "model": "AnyUp",
+    "factor_swept": "embed_dim",
+    "embed_dim": 128,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "18375.39 MB",
+      "Average backward pass time": "492.871991 ms",
+      "Average forward pass time": "179.089816 ms",
+      "Peak GPU memory usage (forward)": "6161.83 MB",
+      "GFLOPS": "246.65",
+      "# Params": "878080"
+    }
+  },
+  {
+    "model": "JAFAR",
+    "factor_swept": "embed_dim",
+    "embed_dim": 128,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "18415.26 MB",
+      "Average backward pass time": "472.802716 ms",
+      "Average forward pass time": "103.970201 ms",
+      "Peak GPU memory usage (forward)": "5408.40 MB",
+      "GFLOPS": "285.80",
+      "# Params": "562688"
+    }
+  },
+  {
+    "model": "NAF",
+    "factor_swept": "embed_dim",
+    "embed_dim": 128,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "5139.84 MB",
+      "Average backward pass time": "132.395419 ms",
+      "Average forward pass time": "50.801562 ms",
+      "Peak GPU memory usage (forward)": "1197.75 MB",
+      "GFLOPS": "265.12",
+      "# Params": "662528"
+    }
+  },
+  {
+    "model": "FeatUp",
+    "factor_swept": "embed_dim",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "4926.61 MB",
+      "Average backward pass time": "168.519371 ms",
+      "Average forward pass time": "79.571660 ms",
+      "Peak GPU memory usage (forward)": "2673.83 MB",
+      "GFLOPS": "82.97",
+      "# Params": "173540"
+    }
+  },
+  {
+    "model": "AnyUp",
+    "factor_swept": "embed_dim",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "18675.31 MB",
+      "Average backward pass time": "493.956909 ms",
+      "Average forward pass time": "182.373581 ms",
+      "Peak GPU memory usage (forward)": "6162.62 MB",
+      "GFLOPS": "328.50",
+      "# Params": "878080"
+    }
+  },
+  {
+    "model": "JAFAR",
+    "factor_swept": "embed_dim",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "18613.05 MB",
+      "Average backward pass time": "495.504486 ms",
+      "Average forward pass time": "104.385638 ms",
+      "Peak GPU memory usage (forward)": "5410.18 MB",
+      "GFLOPS": "366.47",
+      "# Params": "628480"
+    }
+  },
+  {
+    "model": "NAF",
+    "factor_swept": "embed_dim",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "6016.48 MB",
+      "Average backward pass time": "151.195137 ms",
+      "Average forward pass time": "60.107775 ms",
+      "Peak GPU memory usage (forward)": "1786.52 MB",
+      "GFLOPS": "265.12",
+      "# Params": "662528"
+    }
+  },
+  {
+    "model": "FeatUp",
+    "factor_swept": "embed_dim",
+    "embed_dim": 768,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "6611.20 MB",
+      "Average backward pass time": "236.789557 ms",
+      "Average forward pass time": "91.205427 ms",
+      "Peak GPU memory usage (forward)": "2848.23 MB",
+      "GFLOPS": "319.01",
+      "# Params": "617060"
+    }
+  },
+  {
+    "model": "AnyUp",
+    "factor_swept": "embed_dim",
+    "embed_dim": 768,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "19123.01 MB",
+      "Average backward pass time": "495.348840 ms",
+      "Average forward pass time": "190.718669 ms",
+      "Peak GPU memory usage (forward)": "6163.74 MB",
+      "GFLOPS": "451.27",
+      "# Params": "878080"
+    }
+  },
+  {
+    "model": "JAFAR",
+    "factor_swept": "embed_dim",
+    "embed_dim": 768,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "18909.72 MB",
+      "Average backward pass time": "490.327139 ms",
+      "Average forward pass time": "130.610995 ms",
+      "Peak GPU memory usage (forward)": "5412.85 MB",
+      "GFLOPS": "487.47",
+      "# Params": "727168"
+    }
+  },
+  {
+    "model": "NAF",
+    "factor_swept": "embed_dim",
+    "embed_dim": 768,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "7487.63 MB",
+      "Average backward pass time": "201.987173 ms",
+      "Average forward pass time": "88.825344 ms",
+      "Peak GPU memory usage (forward)": "2669.67 MB",
+      "GFLOPS": "265.12",
+      "# Params": "662528"
+    }
+  },
+  {
+    "model": "FeatUp",
+    "factor_swept": "embed_dim",
+    "embed_dim": 1024,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "9704.04 MB",
+      "Average backward pass time": "288.535754 ms",
+      "Average forward pass time": "115.101184 ms",
+      "Peak GPU memory usage (forward)": "2965.61 MB",
+      "GFLOPS": "563.72",
+      "# Params": "1076580"
+    }
+  },
+  {
+    "model": "AnyUp",
+    "factor_swept": "embed_dim",
+    "embed_dim": 1024,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "19421.91 MB",
+      "Average backward pass time": "541.674496 ms",
+      "Average forward pass time": "197.642342 ms",
+      "Peak GPU memory usage (forward)": "6164.90 MB",
+      "GFLOPS": "533.12",
+      "# Params": "878080"
+    }
+  },
+  {
+    "model": "JAFAR",
+    "factor_swept": "embed_dim",
+    "embed_dim": 1024,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "19107.51 MB",
+      "Average backward pass time": "491.764941 ms",
+      "Average forward pass time": "140.854272 ms",
+      "Peak GPU memory usage (forward)": "5414.63 MB",
+      "GFLOPS": "568.14",
+      "# Params": "792960"
+    }
+  },
+  {
+    "model": "NAF",
+    "factor_swept": "embed_dim",
+    "embed_dim": 1024,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 16,
+    "metrics": {
+      "Peak GPU memory usage (backward)": "8468.40 MB",
+      "Average backward pass time": "222.735052 ms",
+      "Average forward pass time": "104.489368 ms",
+      "Peak GPU memory usage (forward)": "3258.43 MB",
+      "GFLOPS": "265.12",
+      "# Params": "662528"
+    }
+  },
+  {
+    "model": "AnyUp",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 32,
+    "metrics": {
+      "Average forward pass time": "744.272083 ms",
+      "Peak GPU memory usage (forward)": "24594.02 MB"
+    }
+  },
+  {
+    "model": "JAFAR",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 32,
+    "metrics": {
+      "Average forward pass time": "582.697070 ms",
+      "Peak GPU memory usage (forward)": "21285.80 MB"
+    }
+  },
+  {
+    "model": "NAF",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 448,
+    "lr_size": 28,
+    "ratio": 32,
+    "metrics": {
+      "Average forward pass time": "267.944962 ms",
+      "Peak GPU memory usage (forward)": "7101.49 MB",
+      "GFLOPS": "1060.49",
+      "# Params": "662528"
+    }
+  },
+  {
+    "model": "LargeImg",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 896,
+    "lr_size": 28,
+    "ratio": 2,
+    "metrics": {
+      "Average forward pass time": "110.051565 ms",
+      "Peak GPU memory usage (forward)": "0.00 MB",
+      "GFLOPS": "537.78",
+      "# Params": "85669632"
+    }
+  },
+  {
+    "model": "LargeImg",
+    "factor_swept": "ratio",
+    "embed_dim": 384,
+    "img_size": 1792,
+    "lr_size": 28,
+    "ratio": 4,
+    "metrics": {
+      "Average forward pass time": "1035.683667 ms",
+      "Peak GPU memory usage (forward)": "0.00 MB",
+      "GFLOPS": "2148.59",
+      "# Params": "85669632"
+    }
+  }
+]

Pixal3D/torch_hub/hub/valeoai_NAF_main/test/test_utils.py

@@ -0,0 +1,155 @@
+"""
+Shared utilities for test files to eliminate code duplication.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+import torch
+
+# Add the project root to path dynamically
+project_root = Path(__file__).parent.parent
+sys.path.append(str(project_root))
+
+# Default values
+DEFAULT_IMG_SIZE = 448
+DEFAULT_EMBED_DIM = 384
+DEFAULT_RATIO = 16
+DEFAULT_LR_SIZE = DEFAULT_IMG_SIZE // DEFAULT_RATIO
+
+# Test configuration constants
+IMG_SIZES = [112, 224, 448, 896]
+EMBED_DIMS = [128, 384, 768, 1024]
+RATIOS = [2, 4, 8, 16, 32]
+LR_SIZES = [32]
+
+
+def setup_parametrization(metafunc):
+    """
+    Optimized pytest parametrization setup that eliminates repetitive if statements.
+    """
+    # Detect selected factor set
+    sweep_options = {
+        "embed_dim": (metafunc.config.getoption("--embed-dim"), EMBED_DIMS),
+        "img_size": (metafunc.config.getoption("--img-size"), IMG_SIZES),
+        "ratio": (metafunc.config.getoption("--ratio"), RATIOS),
+        "lr_size": (metafunc.config.getoption("--lr-size"), LR_SIZES),
+    }
+
+    # Check only one sweep option is selected
+    active_sweeps = [name for name, (enabled, _) in sweep_options.items() if enabled]
+    if len(active_sweeps) > 1:
+        raise ValueError("Only one fixture can be swept at a time")
+
+    # Default parameter values
+    defaults = {
+        "embed_dim": DEFAULT_EMBED_DIM,
+        "img_size": DEFAULT_IMG_SIZE,
+        "ratio": DEFAULT_RATIO,
+        "lr_size": DEFAULT_LR_SIZE,
+    }
+
+    # Set up parametrization
+    if active_sweeps:
+        sweep_param = active_sweeps[0]
+        for param_name, default_value in defaults.items():
+            if param_name == sweep_param:
+                # Use the sweep values for the active parameter
+                metafunc.parametrize(param_name, sweep_options[param_name][1])
+            else:
+                # Use default value for other parameters
+                metafunc.parametrize(param_name, [default_value])
+    else:
+        # Use all default values when no sweep is active
+        for param_name, default_value in defaults.items():
+            metafunc.parametrize(param_name, [default_value])
+
+
+def get_active_factor(request):
+    """
+    Determine which factor is being swept based on request config.
+    """
+    sweep_options = ["embed_dim", "img_size", "ratio", "lr_size"]
+    active_sweeps = [opt for opt in sweep_options if request.config.getoption(f"--{opt.replace('_', '-')}")]
+    return active_sweeps[0] if active_sweeps else "none (all defaults)"
+
+
+def create_tensors(img_size, embed_dim, ratio, lr_size, device="cuda"):
+    lr_feats = torch.randn(1, embed_dim, lr_size, lr_size, device=device)
+    output_size = (ratio * lr_size, ratio * lr_size)
+    img = torch.randn(1, 3, img_size, img_size, device=device)
+    return img, lr_feats, output_size
+
+
+def print_test_info(model_name, factor, embed_dim, img_size, lr_size, ratio, save=True, **extra_info):
+    print("\n" + "=" * 60)
+    print(f"Model: {model_name}")
+    print(f"Factor being swept: {factor}")
+    print(f"Embed size: {embed_dim}")
+    print(f"Image size: {img_size}")
+    print(f"LR size: {lr_size}")
+    print(f"Upsampling factor (ratio): {ratio}")
+    print("-" * 60)
+
+    for key, value in extra_info.items():
+        print(f"{key}: {value}")
+
+    print("=" * 60 + "\n")
+
+    # Save results to JSON
+    if save:
+        save_test_results(model_name, factor, embed_dim, img_size, lr_size, ratio, **extra_info)
+
+
+def save_test_results(model_name, factor, embed_dim, img_size, lr_size, ratio, **extra_info):
+    """Save test results to a JSON file for later analysis."""
+    # Create results directory if it doesn't exist
+    results_dir = Path("./test")
+    results_dir.mkdir(exist_ok=True)
+
+    # Load existing results or create new list
+    results_file = results_dir / "test_results.json"
+    if results_file.exists():
+        with open(results_file, "r") as f:
+            results = json.load(f)
+    else:
+        results = []
+
+    # Check if entry with same configuration already exists
+    existing_entry = None
+    for entry in results:
+        if (
+            entry["model"] == model_name
+            and entry["factor_swept"] == factor
+            and entry["embed_dim"] == embed_dim
+            and entry["img_size"] == img_size
+            and entry["lr_size"] == lr_size
+            and entry["ratio"] == ratio
+        ):
+            existing_entry = entry
+            break
+
+    if existing_entry:
+        # Merge metrics into existing entry
+        existing_entry["metrics"].update(extra_info)
+        print(f"Merged metrics into existing entry for {model_name} (ratio={ratio})")
+    else:
+        # Create new entry
+        result_entry = {
+            "model": model_name,
+            "factor_swept": factor,
+            "embed_dim": embed_dim,
+            "img_size": img_size,
+            "lr_size": lr_size,
+            "ratio": ratio,
+            "metrics": extra_info,
+        }
+        results.append(result_entry)
+        print(f"Created new entry for {model_name} (ratio={ratio})")
+
+    # Save updated results
+    with open(results_file, "w") as f:
+        json.dump(results, f, indent=2)
+
+    print(f"Results saved to: {results_file}")

Pixal3D/torch_hub/hub/valeoai_NAF_main/utils/img.py

@@ -0,0 +1,28 @@
+# import cv2
+import random
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+import torchvision.transforms as T
+from einops import rearrange
+
+
+def create_coordinate(h, w, start=0, end=1, device="cuda", dtype=torch.float32):
+    # Create a grid of coordinates
+    x = torch.linspace(start, end, h, device=device, dtype=dtype)
+    y = torch.linspace(start, end, w, device=device, dtype=dtype)
+    # Create a 2D map using meshgrid
+    xx, yy = torch.meshgrid(x, y, indexing="ij")
+    # Stack the x and y coordinates to create the final map
+    coord_map = torch.stack([xx, yy], axis=-1)[None, ...]
+    coords = rearrange(coord_map, "b h w c -> b (h w) c", h=h, w=w)
+    return coords
+
+
+class PILToTensor:
+    """Convert PIL Image to Tensor"""
+
+    def __call__(self, image):
+        image = T.functional.pil_to_tensor(image)
+        return image

Pixal3D/torch_hub/hub/valeoai_NAF_main/utils/training.py

@@ -0,0 +1,231 @@
+import os
+import random
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+import torchvision.transforms as T
+from hydra.utils import instantiate
+from omegaconf import ListConfig
+from torch.utils.tensorboard import SummaryWriter
+from torchvision.transforms.functional import InterpolationMode
+
+from src.backbone.vit_wrapper import PretrainedViTWrapper
+from utils.img import PILToTensor
+
+
+def seed_worker():
+    worker_seed = torch.initial_seed() % 2**32
+    np.random.seed(worker_seed)
+    random.seed(worker_seed)
+
+
+def round_to_nearest_multiple(value, multiple=14):
+    return multiple * round(value / multiple)
+
+
+def compute_feats(cfg, backbone, image_batch, min_rescale=0.60, max_rescale=0.25):
+    _, _, H, W = image_batch.shape  # Get original height and width
+
+    with torch.no_grad():
+        hr_feats = backbone(image_batch)
+
+        if cfg.get("lr_img_size", None) is not None:
+            size = (cfg.lr_img_size, cfg.lr_img_size)
+        else:
+            # Downscale
+            if cfg.down_factor == "random":
+                downscale_factor = np.random.uniform(min_rescale, max_rescale)
+
+            elif cfg.down_factor == "fixed":
+                downscale_factor = 0.5
+
+            new_H = round_to_nearest_multiple(H * downscale_factor, backbone.patch_size)
+            new_W = round_to_nearest_multiple(W * downscale_factor, backbone.patch_size)
+            size = (new_H, new_W)
+        low_res_batch = F.interpolate(image_batch, size=size, mode="bilinear")
+        lr_feats = backbone(low_res_batch)
+
+        return hr_feats, lr_feats
+
+
+def logger(args, base_log_dir):
+    os.makedirs(base_log_dir, exist_ok=True)
+    existing_versions = [
+        int(d.split("_")[-1])
+        for d in os.listdir(base_log_dir)
+        if os.path.isdir(os.path.join(base_log_dir, d)) and d.startswith("version_")
+    ]
+    new_version = max(existing_versions, default=-1) + 1
+    new_log_dir = os.path.join(base_log_dir, f"version_{new_version}")
+
+    # Create the SummaryWriter with the new log directory
+    writer = SummaryWriter(log_dir=new_log_dir)
+    return writer, new_version, new_log_dir
+
+
+def get_dataloaders(cfg, shuffle=True):
+    """Get dataloaders for either training or evaluation.
+
+    Args:
+        cfg: Configuration object
+        backbone: Backbone model for normalization parameters
+    """
+    # Default ImageNet normalization values
+    transforms = {
+        "image": T.Compose(
+            [
+                T.Resize(cfg.img_size, interpolation=InterpolationMode.BILINEAR),
+                T.CenterCrop((cfg.img_size, cfg.img_size)),
+                T.ToTensor(),
+            ]
+        )
+    }
+
+    transforms["label"] = T.Compose(
+        [
+            # T.ToTensor(),
+            T.Resize(cfg.target_size, interpolation=InterpolationMode.NEAREST_EXACT),
+            T.CenterCrop((cfg.target_size, cfg.target_size)),
+            PILToTensor(),
+        ]
+    )
+    train_dataset = cfg.dataset
+    val_dataset = cfg.dataset.copy()
+    if hasattr(val_dataset, "split"):
+        val_dataset.split = "val"
+
+    train_dataset = instantiate(
+        train_dataset,
+        transform=transforms["image"],
+        target_transform=transforms["label"],
+    )
+    val_dataset = instantiate(
+        val_dataset,
+        transform=transforms["image"],
+        target_transform=transforms["label"],
+    )
+
+    # Create generator for reproducibility
+    if not shuffle:
+        g = torch.Generator()
+        g.manual_seed(0)
+    else:
+        g = None
+
+    # Prepare dataloader configs - set worker_init_fn to None when shuffling for randomness
+    train_dataloader_cfg = cfg.train_dataloader.copy()
+    val_dataloader_cfg = cfg.val_dataloader.copy()
+
+    if shuffle:
+        # Set worker_init_fn to None to allow true randomness when shuffling
+        if "worker_init_fn" in train_dataloader_cfg:
+            train_dataloader_cfg["worker_init_fn"] = None
+        if "worker_init_fn" in val_dataloader_cfg:
+            val_dataloader_cfg["worker_init_fn"] = None
+
+    return (
+        instantiate(train_dataloader_cfg, dataset=train_dataset, generator=g),
+        instantiate(val_dataloader_cfg, dataset=val_dataset, generator=g),
+    )
+
+
+def get_batch(batch, device):
+    """Process batch and return required tensors."""
+    batch["image"] = batch["image"].to(device)
+    return batch
+
+
+def setup_training_optimizations(model, cfg):
+    """
+    Setup training optimizations based on configuration
+
+    Args:
+        model: The model to apply optimizations to
+        cfg: Configuration object with use_bf16 and use_checkpointing flags
+
+    Returns:
+        tuple: (scaler, use_bf16, use_checkpointing) for use in training loop
+    """
+    # Get configuration values with defaults
+    use_bf16 = getattr(cfg, "use_bf16", False)
+    use_checkpointing = getattr(cfg, "use_checkpointing", False)
+
+    # Initialize gradient scaler for mixed precision
+    scaler = torch.amp.GradScaler("cuda", enabled=use_bf16)
+
+    # Enable gradient checkpointing if requested
+    if use_checkpointing:
+        if hasattr(model, "gradient_checkpointing_enable"):
+            model.gradient_checkpointing_enable()
+            print("   ✓ Using built-in gradient checkpointing")
+        else:
+            # For custom models, wrap forward methods
+            def checkpoint_wrapper(module):
+                if hasattr(module, "forward"):
+                    original_forward = module.forward
+
+                    def checkpointed_forward(*args, **kwargs):
+                        return checkpoint.checkpoint(original_forward, *args, **kwargs)
+
+                    module.forward = checkpointed_forward
+
+            # Apply to key modules (adjust based on your model structure)
+            checkpointed_modules = []
+            for name, module in model.named_modules():
+                if any(key in name for key in ["cross_decode", "encoder", "sft"]):
+                    checkpoint_wrapper(module)
+                    checkpointed_modules.append(name)
+
+            if checkpointed_modules:
+                print(f"   ✓ Applied custom gradient checkpointing to: {checkpointed_modules}")
+            else:
+                print("   ⚠ No modules found for gradient checkpointing")
+
+    print(f"Training optimizations:")
+    print(f"  Mixed precision (bfloat16): {use_bf16}")
+    print(f"  Gradient checkpointing: {use_checkpointing}")
+
+    return scaler, use_bf16, use_checkpointing
+
+
+def load_multiple_backbones(cfg, backbone_configs, device):
+    """
+    Load multiple backbone models based on configuration.
+
+    Args:
+        cfg: Hydra configuration object
+        device: PyTorch device to load models on
+
+    Returns:
+        tuple: (backbones, backbone_names, primary_backbone)
+            - backbones: List of loaded backbone models
+            - backbone_names: List of backbone names
+    """
+    backbones = []
+    backbone_names = []
+    backbone_img_sizes = []
+
+    if not isinstance(backbone_configs, list) and not isinstance(backbone_configs, ListConfig):
+        backbone_configs = [backbone_configs]
+    print(f"Loading {len(backbone_configs)} backbone(s)...")
+
+    for i, backbone_config in enumerate(backbone_configs):
+        name = backbone_config["name"]
+        if name == "rgb":
+            backbone = instantiate(cfg.backbone)
+        else:
+            backbone = PretrainedViTWrapper(name=name)
+        print(f"  [{i}] Loaded {backbone_config['name']}")
+
+        # Move to device and set to eval mode
+        backbone = backbone.to(device)
+        backbone.eval()  # Set to eval mode for feature extraction
+
+        # Store backbone and name
+        backbones.append(backbone)
+        backbone_names.append(backbone_config["name"])
+        backbone_img_sizes.append(backbone.config["input_size"][1:])
+
+    return backbones, backbone_names, backbone_img_sizes

Pixal3D/torch_hub/hub/valeoai_NAF_main/utils/wrapper.py

@@ -0,0 +1,52 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from src.model import *
+
+
+class ModelWrapper(nn.Module):
+    def __init__(self, name, embed_dim=384, ratio=16, ckpt_path: str = None):
+        super().__init__()
+
+        self.name = name
+        self.embed_dim = embed_dim
+        self.ratio = ratio
+
+        self.model = self._load_model()
+
+        if ckpt_path is not None:
+            state = torch.load(ckpt_path, map_location="cpu")
+            if name != "FeatUp":
+                self.model.load_state_dict(state, strict=False)
+            else:
+                new_ckpts = {
+                    k.replace("model.1.", "norm."): v
+                    for k, v in state["state_dict"].items()
+                    if "upsampler" in k or "model.1.norm" in k
+                }
+                self.model.model.load_state_dict(new_ckpts, strict=True)
+
+    def _load_model(self):
+        upsampler_map = {
+            "AnyUp": lambda: AnyUpsampler(),
+            "Bilinear": lambda: Bilinear(),
+            "FeatUp": lambda: FeatUp(feature_dim=self.embed_dim, ratio=self.ratio),
+            "IRCNN": lambda: IRCNN(),
+            "JAFAR": lambda: JAFAR(v_dim=self.embed_dim),
+            "JBF": lambda: JBF(),
+            "JBU": lambda: JBU(),
+            "NAF": lambda: NAF(),
+            "Nearest": lambda: Nearest(),
+            "REDNet": lambda: REDNet(),
+            "Restormer": lambda: Restormer(),
+        }
+
+        if self.name not in upsampler_map:
+            raise ValueError(f"Unknown upsampler: {self.name}")
+
+        return upsampler_map[self.name]()
+
+    def forward(self, image, features, output_size):
+        out = self.model(image, features, output_size)
+        return out

geometry_estimation/moge_1_vitl_fp16.safetensors

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

geometry_estimation/moge_2_vitl_normal_fp16.safetensors

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