add gradio app and dependencies

app.py

@@ -0,0 +1,102 @@
+from __future__ import absolute_import, division, print_function
+
+import os, sys
+import cv2
+import yaml
+import torch
+import numpy as np
+import torch.nn as nn
+import gradio as gr
+from huggingface_hub import hf_hub_download
+
+# ========== 让 Space 能 import 你的工程 ==========
+PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))  # app.py 在仓库根目录
+sys.path.append(PROJECT_ROOT)
+
+from networks.models import make
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# ====== HF 权重仓库配置（你已经上传成功）======
+WEIGHTS_REPO = "Insta360-Research/DAP-weights"
+WEIGHTS_FILE = "model.pth"
+
+# ========== 可视化 ==========
+def colorize_depth(depth, colormap=cv2.COLORMAP_JET):
+    depth = depth.astype(np.float32)
+    depth_norm = (depth - depth.min()) / (depth.max() - depth.min() + 1e-6)
+    depth_u8 = (depth_norm * 255).astype(np.uint8)
+    return cv2.applyColorMap(depth_u8, colormap)  # BGR
+
+# ========== 加载模型（只加载一次） ==========
+def load_model(config_path: str):
+    with open(config_path, "r") as f:
+        config = yaml.load(f, Loader=yaml.FullLoader)
+
+    print(f"Downloading weights from HF: {WEIGHTS_REPO}/{WEIGHTS_FILE}")
+    model_path = hf_hub_download(repo_id=WEIGHTS_REPO, filename=WEIGHTS_FILE)
+    print(f"✅ Weights downloaded to: {model_path}")
+
+    state = torch.load(model_path, map_location=device)
+
+    model = make(config["model"])
+    if any(k.startswith("module") for k in state.keys()):
+        model = nn.DataParallel(model)
+
+    model = model.to(device)
+
+    model_state = model.state_dict()
+    model.load_state_dict({k: v for k, v in state.items() if k in model_state}, strict=False)
+    model.eval()
+    print("✅ Model loaded.")
+    return model
+
+# 这里改成你仓库里的 config 路径
+CONFIG_PATH = "config/infer.yaml"
+model = load_model(CONFIG_PATH)
+
+# ========== 单张图推理 ==========
+@torch.no_grad()
+def predict(img_rgb: np.ndarray):
+    """
+    img_rgb: H x W x 3 (RGB), uint8
+    return: depth_color_rgb, depth_gray
+    """
+    if img_rgb is None:
+        return None, None
+
+    img = img_rgb.astype(np.float32) / 255.0
+    tensor = torch.from_numpy(img.transpose(2, 0, 1)).unsqueeze(0).to(device)
+
+    outputs = model(tensor)
+
+    if isinstance(outputs, dict) and "pred_depth" in outputs:
+        # 你原来的 mask 逻辑
+        if "pred_mask" in outputs:
+            outputs["pred_mask"] = 1 - outputs["pred_mask"]
+            outputs["pred_mask"] = (outputs["pred_mask"] > 0.5)
+            outputs["pred_depth"][~outputs["pred_mask"]] = 1
+        pred = outputs["pred_depth"][0].detach().cpu().squeeze().numpy()
+    else:
+        pred = outputs[0].detach().cpu().squeeze().numpy()
+
+    pred_clip = np.clip(pred, 0.001, 1.0)
+    depth_gray = (pred_clip * 255).astype(np.uint8)
+
+    depth_color_bgr = colorize_depth(pred_clip, cv2.COLORMAP_JET)
+    depth_color_rgb = cv2.cvtColor(depth_color_bgr, cv2.COLOR_BGR2RGB)
+
+    return depth_color_rgb, depth_gray
+
+demo = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="numpy", label="Input Image"),
+    outputs=[
+        gr.Image(type="numpy", label="Depth (Color)"),
+        gr.Image(type="numpy", label="Depth (Gray)"),
+    ],
+    title="DAP Depth Prediction Demo",
+    description="Upload an image and get depth prediction."
+)
+
+demo.launch()

config/infer.yaml

@@ -0,0 +1,19 @@
+model:
+  name: dap
+  args:
+    midas_model_type: vitl         
+    fine_tune_type: hypersim       
+    min_depth: 0.01
+    max_depth: 1.0
+    train_decoder: True
+
+median_align: False
+load_weights_dir: checkpoints
+input:
+  height: 512
+  width: 1024
+inference:
+  batch_size: 1
+  num_workers: 1
+  save_colormap: True       
+  colormap_type: jet        

depth_anything_utils.py

@@ -0,0 +1,249 @@
+import os
+import random
+from PIL import Image, ImageOps, ImageFilter
+import torch
+from torchvision import transforms
+import torch.nn.functional as F
+
+import numpy as np
+import cv2
+import math
+
+
+def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AREA):
+    """Rezise the sample to ensure the given size. Keeps aspect ratio.
+
+    Args:
+        sample (dict): sample
+        size (tuple): image size
+
+    Returns:
+        tuple: new size
+    """
+    shape = list(sample["disparity"].shape)
+
+    if shape[0] >= size[0] and shape[1] >= size[1]:
+        return sample
+
+    scale = [0, 0]
+    scale[0] = size[0] / shape[0]
+    scale[1] = size[1] / shape[1]
+
+    scale = max(scale)
+
+    shape[0] = math.ceil(scale * shape[0])
+    shape[1] = math.ceil(scale * shape[1])
+
+    # resize
+    sample["image"] = cv2.resize(
+        sample["image"], tuple(shape[::-1]), interpolation=image_interpolation_method
+    )
+
+    sample["disparity"] = cv2.resize(
+        sample["disparity"], tuple(shape[::-1]), interpolation=cv2.INTER_NEAREST
+    )
+    sample["mask"] = cv2.resize(
+        sample["mask"].astype(np.float32),
+        tuple(shape[::-1]),
+        interpolation=cv2.INTER_NEAREST,
+    )
+    sample["mask"] = sample["mask"].astype(bool)
+
+    return tuple(shape)
+
+
+class Resize(object):
+    """Resize sample to given size (width, height).
+    """
+
+    def __init__(
+        self,
+        width,
+        height,
+        resize_target=True,
+        keep_aspect_ratio=False,
+        ensure_multiple_of=1,
+        resize_method="lower_bound",
+        image_interpolation_method=cv2.INTER_AREA,
+    ):
+        """Init.
+
+        Args:
+            width (int): desired output width
+            height (int): desired output height
+            resize_target (bool, optional):
+                True: Resize the full sample (image, mask, target).
+                False: Resize image only.
+                Defaults to True.
+            keep_aspect_ratio (bool, optional):
+                True: Keep the aspect ratio of the input sample.
+                Output sample might not have the given width and height, and
+                resize behaviour depends on the parameter 'resize_method'.
+                Defaults to False.
+            ensure_multiple_of (int, optional):
+                Output width and height is constrained to be multiple of this parameter.
+                Defaults to 1.
+            resize_method (str, optional):
+                "lower_bound": Output will be at least as large as the given size.
+                "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
+                "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
+                Defaults to "lower_bound".
+        """
+        self.__width = width
+        self.__height = height
+
+        self.__resize_target = resize_target
+        self.__keep_aspect_ratio = keep_aspect_ratio
+        self.__multiple_of = ensure_multiple_of
+        self.__resize_method = resize_method
+        self.__image_interpolation_method = image_interpolation_method
+
+    def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
+        y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if max_val is not None and y > max_val:
+            y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if y < min_val:
+            y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        return y
+
+    def get_size(self, width, height):
+        # determine new height and width
+        scale_height = self.__height / height
+        scale_width = self.__width / width
+
+        if self.__keep_aspect_ratio:
+            if self.__resize_method == "lower_bound":
+                # scale such that output size is lower bound
+                if scale_width > scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "upper_bound":
+                # scale such that output size is upper bound
+                if scale_width < scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "minimal":
+                # scale as least as possbile
+                if abs(1 - scale_width) < abs(1 - scale_height):
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            else:
+                raise ValueError(
+                    f"resize_method {self.__resize_method} not implemented"
+                )
+
+        if self.__resize_method == "lower_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, min_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, min_val=self.__width
+            )
+        elif self.__resize_method == "upper_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, max_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, max_val=self.__width
+            )
+        elif self.__resize_method == "minimal":
+            new_height = self.constrain_to_multiple_of(scale_height * height)
+            new_width = self.constrain_to_multiple_of(scale_width * width)
+        else:
+            raise ValueError(f"resize_method {self.__resize_method} not implemented")
+
+        return (new_width, new_height)
+
+    def __call__(self, sample):
+        width, height = self.get_size(
+            sample["image"].shape[1], sample["image"].shape[0]
+        )
+
+        # resize sample
+        sample["image"] = cv2.resize(
+            sample["image"],
+            (width, height),
+            interpolation=self.__image_interpolation_method,
+        )
+
+        if self.__resize_target:
+            if "disparity" in sample:
+                sample["disparity"] = cv2.resize(
+                    sample["disparity"],
+                    (width, height),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+
+            if "depth" in sample:
+                sample["depth"] = cv2.resize(
+                    sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST
+                )
+
+            if "semseg_mask" in sample:
+                # sample["semseg_mask"] = cv2.resize(
+                #     sample["semseg_mask"], (width, height), interpolation=cv2.INTER_NEAREST
+                # )
+                sample["semseg_mask"] = F.interpolate(torch.from_numpy(sample["semseg_mask"]).float()[None, None, ...], (height, width), mode='nearest').numpy()[0, 0]
+                
+            if "mask" in sample:
+                sample["mask"] = cv2.resize(
+                    sample["mask"].astype(np.float32),
+                    (width, height),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+                # sample["mask"] = sample["mask"].astype(bool)
+
+        # print(sample['image'].shape, sample['depth'].shape)
+        return sample
+
+
+class NormalizeImage(object):
+    """Normlize image by given mean and std.
+    """
+
+    def __init__(self, mean, std):
+        self.__mean = mean
+        self.__std = std
+
+    def __call__(self, sample):
+        sample["image"] = (sample["image"] - self.__mean) / self.__std
+
+        return sample
+
+
+class PrepareForNet(object):
+    """Prepare sample for usage as network input.
+    """
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        image = np.transpose(sample["image"], (2, 0, 1))
+        sample["image"] = np.ascontiguousarray(image).astype(np.float32)
+
+        if "mask" in sample:
+            sample["mask"] = sample["mask"].astype(np.float32)
+            sample["mask"] = np.ascontiguousarray(sample["mask"])
+        
+        if "depth" in sample:
+            depth = sample["depth"].astype(np.float32)
+            sample["depth"] = np.ascontiguousarray(depth)
+            
+        if "semseg_mask" in sample:
+            sample["semseg_mask"] = sample["semseg_mask"].astype(np.float32)
+            sample["semseg_mask"] = np.ascontiguousarray(sample["semseg_mask"])
+
+        return sample

depth_anything_v2_metric/depth_anything_v2/dinov2.py

@@ -0,0 +1,415 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/main/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py
+
+from functools import partial
+import math
+import logging
+from typing import Sequence, Tuple, Union, Callable
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint
+from torch.nn.init import trunc_normal_
+
+from .dinov2_layers import Mlp, PatchEmbed, SwiGLUFFNFused, MemEffAttention, NestedTensorBlock as Block
+
+
+logger = logging.getLogger("dinov2")
+
+
+def named_apply(fn: Callable, module: nn.Module, name="", depth_first=True, include_root=False) -> nn.Module:
+    if not depth_first and include_root:
+        fn(module=module, name=name)
+    for child_name, child_module in module.named_children():
+        child_name = ".".join((name, child_name)) if name else child_name
+        named_apply(fn=fn, module=child_module, name=child_name, depth_first=depth_first, include_root=True)
+    if depth_first and include_root:
+        fn(module=module, name=name)
+    return module
+
+
+class BlockChunk(nn.ModuleList):
+    def forward(self, x):
+        for b in self:
+            x = b(x)
+        return x
+
+
+class DinoVisionTransformer(nn.Module):
+    def __init__(
+        self,
+        img_size=224,
+        patch_size=16,
+        in_chans=3,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4.0,
+        qkv_bias=True,
+        ffn_bias=True,
+        proj_bias=True,
+        drop_path_rate=0.0,
+        drop_path_uniform=False,
+        init_values=None,  # for layerscale: None or 0 => no layerscale
+        embed_layer=PatchEmbed,
+        act_layer=nn.GELU,
+        block_fn=Block,
+        ffn_layer="mlp",
+        block_chunks=1,
+        num_register_tokens=0,
+        interpolate_antialias=False,
+        interpolate_offset=0.1,
+    ):
+        """
+        Args:
+            img_size (int, tuple): input image size
+            patch_size (int, tuple): patch size
+            in_chans (int): number of input channels
+            embed_dim (int): embedding dimension
+            depth (int): depth of transformer
+            num_heads (int): number of attention heads
+            mlp_ratio (int): ratio of mlp hidden dim to embedding dim
+            qkv_bias (bool): enable bias for qkv if True
+            proj_bias (bool): enable bias for proj in attn if True
+            ffn_bias (bool): enable bias for ffn if True
+            drop_path_rate (float): stochastic depth rate
+            drop_path_uniform (bool): apply uniform drop rate across blocks
+            weight_init (str): weight init scheme
+            init_values (float): layer-scale init values
+            embed_layer (nn.Module): patch embedding layer
+            act_layer (nn.Module): MLP activation layer
+            block_fn (nn.Module): transformer block class
+            ffn_layer (str): "mlp", "swiglu", "swiglufused" or "identity"
+            block_chunks: (int) split block sequence into block_chunks units for FSDP wrap
+            num_register_tokens: (int) number of extra cls tokens (so-called "registers")
+            interpolate_antialias: (str) flag to apply anti-aliasing when interpolating positional embeddings
+            interpolate_offset: (float) work-around offset to apply when interpolating positional embeddings
+        """
+        super().__init__()
+        norm_layer = partial(nn.LayerNorm, eps=1e-6)
+
+        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
+        self.num_tokens = 1
+        self.n_blocks = depth
+        self.num_heads = num_heads
+        self.patch_size = patch_size
+        self.num_register_tokens = num_register_tokens
+        self.interpolate_antialias = interpolate_antialias
+        self.interpolate_offset = interpolate_offset
+
+        self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
+        num_patches = self.patch_embed.num_patches
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
+        assert num_register_tokens >= 0
+        self.register_tokens = (
+            nn.Parameter(torch.zeros(1, num_register_tokens, embed_dim)) if num_register_tokens else None
+        )
+
+        if drop_path_uniform is True:
+            dpr = [drop_path_rate] * depth
+        else:
+            dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
+
+        if ffn_layer == "mlp":
+            logger.info("using MLP layer as FFN")
+            ffn_layer = Mlp
+        elif ffn_layer == "swiglufused" or ffn_layer == "swiglu":
+            logger.info("using SwiGLU layer as FFN")
+            ffn_layer = SwiGLUFFNFused
+        elif ffn_layer == "identity":
+            logger.info("using Identity layer as FFN")
+
+            def f(*args, **kwargs):
+                return nn.Identity()
+
+            ffn_layer = f
+        else:
+            raise NotImplementedError
+
+        blocks_list = [
+            block_fn(
+                dim=embed_dim,
+                num_heads=num_heads,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                proj_bias=proj_bias,
+                ffn_bias=ffn_bias,
+                drop_path=dpr[i],
+                norm_layer=norm_layer,
+                act_layer=act_layer,
+                ffn_layer=ffn_layer,
+                init_values=init_values,
+            )
+            for i in range(depth)
+        ]
+        if block_chunks > 0:
+            self.chunked_blocks = True
+            chunked_blocks = []
+            chunksize = depth // block_chunks
+            for i in range(0, depth, chunksize):
+                # this is to keep the block index consistent if we chunk the block list
+                chunked_blocks.append([nn.Identity()] * i + blocks_list[i : i + chunksize])
+            self.blocks = nn.ModuleList([BlockChunk(p) for p in chunked_blocks])
+        else:
+            self.chunked_blocks = False
+            self.blocks = nn.ModuleList(blocks_list)
+
+        self.norm = norm_layer(embed_dim)
+        self.head = nn.Identity()
+
+        self.mask_token = nn.Parameter(torch.zeros(1, embed_dim))
+
+        self.init_weights()
+
+    def init_weights(self):
+        trunc_normal_(self.pos_embed, std=0.02)
+        nn.init.normal_(self.cls_token, std=1e-6)
+        if self.register_tokens is not None:
+            nn.init.normal_(self.register_tokens, std=1e-6)
+        named_apply(init_weights_vit_timm, self)
+
+    def interpolate_pos_encoding(self, x, w, h):
+        previous_dtype = x.dtype
+        npatch = x.shape[1] - 1
+        N = self.pos_embed.shape[1] - 1
+        if npatch == N and w == h:
+            return self.pos_embed
+        pos_embed = self.pos_embed.float()
+        class_pos_embed = pos_embed[:, 0]
+        patch_pos_embed = pos_embed[:, 1:]
+        dim = x.shape[-1]
+        w0 = w // self.patch_size
+        h0 = h // self.patch_size
+        # we add a small number to avoid floating point error in the interpolation
+        # see discussion at https://github.com/facebookresearch/dino/issues/8
+        # DINOv2 with register modify the interpolate_offset from 0.1 to 0.0
+        w0, h0 = w0 + self.interpolate_offset, h0 + self.interpolate_offset
+        # w0, h0 = w0 + 0.1, h0 + 0.1
+        
+        sqrt_N = math.sqrt(N)
+        sx, sy = float(w0) / sqrt_N, float(h0) / sqrt_N
+        patch_pos_embed = nn.functional.interpolate(
+            patch_pos_embed.reshape(1, int(sqrt_N), int(sqrt_N), dim).permute(0, 3, 1, 2),
+            scale_factor=(sx, sy),
+            # (int(w0), int(h0)), # to solve the upsampling shape issue
+            mode="bicubic",
+            antialias=self.interpolate_antialias
+        )
+        
+        assert int(w0) == patch_pos_embed.shape[-2]
+        assert int(h0) == patch_pos_embed.shape[-1]
+        patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+        return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1).to(previous_dtype)
+
+    def prepare_tokens_with_masks(self, x, masks=None):
+        B, nc, w, h = x.shape
+        x = self.patch_embed(x)
+        if masks is not None:
+            x = torch.where(masks.unsqueeze(-1), self.mask_token.to(x.dtype).unsqueeze(0), x)
+
+        x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1)
+        x = x + self.interpolate_pos_encoding(x, w, h)
+
+        if self.register_tokens is not None:
+            x = torch.cat(
+                (
+                    x[:, :1],
+                    self.register_tokens.expand(x.shape[0], -1, -1),
+                    x[:, 1:],
+                ),
+                dim=1,
+            )
+
+        return x
+
+    def forward_features_list(self, x_list, masks_list):
+        x = [self.prepare_tokens_with_masks(x, masks) for x, masks in zip(x_list, masks_list)]
+        for blk in self.blocks:
+            x = blk(x)
+
+        all_x = x
+        output = []
+        for x, masks in zip(all_x, masks_list):
+            x_norm = self.norm(x)
+            output.append(
+                {
+                    "x_norm_clstoken": x_norm[:, 0],
+                    "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1],
+                    "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :],
+                    "x_prenorm": x,
+                    "masks": masks,
+                }
+            )
+        return output
+
+    def forward_features(self, x, masks=None):
+        if isinstance(x, list):
+            return self.forward_features_list(x, masks)
+
+        x = self.prepare_tokens_with_masks(x, masks)
+
+        for blk in self.blocks:
+            x = blk(x)
+
+        x_norm = self.norm(x)
+        return {
+            "x_norm_clstoken": x_norm[:, 0],
+            "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1],
+            "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :],
+            "x_prenorm": x,
+            "masks": masks,
+        }
+
+    def _get_intermediate_layers_not_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        # If n is an int, take the n last blocks. If it's a list, take them
+        output, total_block_len = [], len(self.blocks)
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for i, blk in enumerate(self.blocks):
+            x = blk(x)
+            if i in blocks_to_take:
+                output.append(x)
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def _get_intermediate_layers_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        output, i, total_block_len = [], 0, len(self.blocks[-1])
+        # If n is an int, take the n last blocks. If it's a list, take them
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for block_chunk in self.blocks:
+            for blk in block_chunk[i:]:  # Passing the nn.Identity()
+                x = blk(x)
+                if i in blocks_to_take:
+                    output.append(x)
+                i += 1
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def get_intermediate_layers(
+        self,
+        x: torch.Tensor,
+        n: Union[int, Sequence] = 1,  # Layers or n last layers to take
+        reshape: bool = False,
+        return_class_token: bool = False,
+        norm=True
+    ) -> Tuple[Union[torch.Tensor, Tuple[torch.Tensor]]]:
+        if self.chunked_blocks:
+            outputs = self._get_intermediate_layers_chunked(x, n)
+        else:
+            outputs = self._get_intermediate_layers_not_chunked(x, n)
+        if norm:
+            outputs = [self.norm(out) for out in outputs]
+        class_tokens = [out[:, 0] for out in outputs]
+        outputs = [out[:, 1 + self.num_register_tokens:] for out in outputs]
+        if reshape:
+            B, _, w, h = x.shape
+            outputs = [
+                out.reshape(B, w // self.patch_size, h // self.patch_size, -1).permute(0, 3, 1, 2).contiguous()
+                for out in outputs
+            ]
+        if return_class_token:
+            return tuple(zip(outputs, class_tokens))
+        return tuple(outputs)
+
+    def forward(self, *args, is_training=False, **kwargs):
+        ret = self.forward_features(*args, **kwargs)
+        if is_training:
+            return ret
+        else:
+            return self.head(ret["x_norm_clstoken"])
+
+
+def init_weights_vit_timm(module: nn.Module, name: str = ""):
+    """ViT weight initialization, original timm impl (for reproducibility)"""
+    if isinstance(module, nn.Linear):
+        trunc_normal_(module.weight, std=0.02)
+        if module.bias is not None:
+            nn.init.zeros_(module.bias)
+
+
+def vit_small(patch_size=16, num_register_tokens=0, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+    return model
+
+
+def vit_base(patch_size=16, num_register_tokens=0, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+    return model
+
+
+def vit_large(patch_size=16, num_register_tokens=0, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=1024,
+        depth=24,
+        num_heads=16,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+    return model
+
+
+def vit_giant2(patch_size=16, num_register_tokens=0, **kwargs):
+    """
+    Close to ViT-giant, with embed-dim 1536 and 24 heads => embed-dim per head 64
+    """
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=1536,
+        depth=40,
+        num_heads=24,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+    return model
+
+
+def DINOv2(model_name):
+    model_zoo = {
+        "vits": vit_small, 
+        "vitb": vit_base, 
+        "vitl": vit_large, 
+        "vitg": vit_giant2
+    }
+    
+    return model_zoo[model_name](
+        img_size=518,
+        patch_size=14,
+        init_values=1.0,
+        ffn_layer="mlp" if model_name != "vitg" else "swiglufused",
+        block_chunks=0,
+        num_register_tokens=0,
+        interpolate_antialias=False,
+        interpolate_offset=0.1
+    )

depth_anything_v2_metric/depth_anything_v2/dinov2_layers/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from .mlp import Mlp
+from .patch_embed import PatchEmbed
+from .swiglu_ffn import SwiGLUFFN, SwiGLUFFNFused
+from .block import NestedTensorBlock
+from .attention import MemEffAttention

depth_anything_v2_metric/depth_anything_v2/dinov2_layers/attention.py

@@ -0,0 +1,83 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py
+
+import logging
+
+from torch import Tensor
+from torch import nn
+
+
+logger = logging.getLogger("dinov2")
+
+
+try:
+    from xformers.ops import memory_efficient_attention, unbind, fmha
+
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    logger.warning("xFormers not available")
+    XFORMERS_AVAILABLE = False
+
+
+class Attention(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int = 8,
+        qkv_bias: bool = False,
+        proj_bias: bool = True,
+        attn_drop: float = 0.0,
+        proj_drop: float = 0.0,
+    ) -> None:
+        super().__init__()
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.scale = head_dim**-0.5
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim, bias=proj_bias)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+    def forward(self, x: Tensor) -> Tensor:
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+
+        q, k, v = qkv[0] * self.scale, qkv[1], qkv[2]
+        attn = q @ k.transpose(-2, -1)
+
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class MemEffAttention(Attention):
+    def forward(self, x: Tensor, attn_bias=None) -> Tensor:
+        if not XFORMERS_AVAILABLE:
+            assert attn_bias is None, "xFormers is required for nested tensors usage"
+            return super().forward(x)
+
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads)
+
+        q, k, v = unbind(qkv, 2)
+
+        x = memory_efficient_attention(q, k, v, attn_bias=attn_bias)
+        x = x.reshape([B, N, C])
+
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+        

depth_anything_v2_metric/depth_anything_v2/dinov2_layers/block.py

@@ -0,0 +1,252 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py
+
+import logging
+from typing import Callable, List, Any, Tuple, Dict
+
+import torch
+from torch import nn, Tensor
+
+from .attention import Attention, MemEffAttention
+from .drop_path import DropPath
+from .layer_scale import LayerScale
+from .mlp import Mlp
+
+
+logger = logging.getLogger("dinov2")
+
+
+try:
+    from xformers.ops import fmha
+    from xformers.ops import scaled_index_add, index_select_cat
+
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    logger.warning("xFormers not available")
+    XFORMERS_AVAILABLE = False
+
+
+class Block(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int,
+        mlp_ratio: float = 4.0,
+        qkv_bias: bool = False,
+        proj_bias: bool = True,
+        ffn_bias: bool = True,
+        drop: float = 0.0,
+        attn_drop: float = 0.0,
+        init_values=None,
+        drop_path: float = 0.0,
+        act_layer: Callable[..., nn.Module] = nn.GELU,
+        norm_layer: Callable[..., nn.Module] = nn.LayerNorm,
+        attn_class: Callable[..., nn.Module] = Attention,
+        ffn_layer: Callable[..., nn.Module] = Mlp,
+    ) -> None:
+        super().__init__()
+        # print(f"biases: qkv: {qkv_bias}, proj: {proj_bias}, ffn: {ffn_bias}")
+        self.norm1 = norm_layer(dim)
+        self.attn = attn_class(
+            dim,
+            num_heads=num_heads,
+            qkv_bias=qkv_bias,
+            proj_bias=proj_bias,
+            attn_drop=attn_drop,
+            proj_drop=drop,
+        )
+        self.ls1 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = ffn_layer(
+            in_features=dim,
+            hidden_features=mlp_hidden_dim,
+            act_layer=act_layer,
+            drop=drop,
+            bias=ffn_bias,
+        )
+        self.ls2 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.sample_drop_ratio = drop_path
+
+    def forward(self, x: Tensor) -> Tensor:
+        def attn_residual_func(x: Tensor) -> Tensor:
+            return self.ls1(self.attn(self.norm1(x)))
+
+        def ffn_residual_func(x: Tensor) -> Tensor:
+            return self.ls2(self.mlp(self.norm2(x)))
+
+        if self.training and self.sample_drop_ratio > 0.1:
+            # the overhead is compensated only for a drop path rate larger than 0.1
+            x = drop_add_residual_stochastic_depth(
+                x,
+                residual_func=attn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+            )
+            x = drop_add_residual_stochastic_depth(
+                x,
+                residual_func=ffn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+            )
+        elif self.training and self.sample_drop_ratio > 0.0:
+            x = x + self.drop_path1(attn_residual_func(x))
+            x = x + self.drop_path1(ffn_residual_func(x))  # FIXME: drop_path2
+        else:
+            x = x + attn_residual_func(x)
+            x = x + ffn_residual_func(x)
+        return x
+
+
+def drop_add_residual_stochastic_depth(
+    x: Tensor,
+    residual_func: Callable[[Tensor], Tensor],
+    sample_drop_ratio: float = 0.0,
+) -> Tensor:
+    # 1) extract subset using permutation
+    b, n, d = x.shape
+    sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+    brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+    x_subset = x[brange]
+
+    # 2) apply residual_func to get residual
+    residual = residual_func(x_subset)
+
+    x_flat = x.flatten(1)
+    residual = residual.flatten(1)
+
+    residual_scale_factor = b / sample_subset_size
+
+    # 3) add the residual
+    x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+    return x_plus_residual.view_as(x)
+
+
+def get_branges_scales(x, sample_drop_ratio=0.0):
+    b, n, d = x.shape
+    sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+    brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+    residual_scale_factor = b / sample_subset_size
+    return brange, residual_scale_factor
+
+
+def add_residual(x, brange, residual, residual_scale_factor, scaling_vector=None):
+    if scaling_vector is None:
+        x_flat = x.flatten(1)
+        residual = residual.flatten(1)
+        x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+    else:
+        x_plus_residual = scaled_index_add(
+            x, brange, residual.to(dtype=x.dtype), scaling=scaling_vector, alpha=residual_scale_factor
+        )
+    return x_plus_residual
+
+
+attn_bias_cache: Dict[Tuple, Any] = {}
+
+
+def get_attn_bias_and_cat(x_list, branges=None):
+    """
+    this will perform the index select, cat the tensors, and provide the attn_bias from cache
+    """
+    batch_sizes = [b.shape[0] for b in branges] if branges is not None else [x.shape[0] for x in x_list]
+    all_shapes = tuple((b, x.shape[1]) for b, x in zip(batch_sizes, x_list))
+    if all_shapes not in attn_bias_cache.keys():
+        seqlens = []
+        for b, x in zip(batch_sizes, x_list):
+            for _ in range(b):
+                seqlens.append(x.shape[1])
+        attn_bias = fmha.BlockDiagonalMask.from_seqlens(seqlens)
+        attn_bias._batch_sizes = batch_sizes
+        attn_bias_cache[all_shapes] = attn_bias
+
+    if branges is not None:
+        cat_tensors = index_select_cat([x.flatten(1) for x in x_list], branges).view(1, -1, x_list[0].shape[-1])
+    else:
+        tensors_bs1 = tuple(x.reshape([1, -1, *x.shape[2:]]) for x in x_list)
+        cat_tensors = torch.cat(tensors_bs1, dim=1)
+
+    return attn_bias_cache[all_shapes], cat_tensors
+
+
+def drop_add_residual_stochastic_depth_list(
+    x_list: List[Tensor],
+    residual_func: Callable[[Tensor, Any], Tensor],
+    sample_drop_ratio: float = 0.0,
+    scaling_vector=None,
+) -> Tensor:
+    # 1) generate random set of indices for dropping samples in the batch
+    branges_scales = [get_branges_scales(x, sample_drop_ratio=sample_drop_ratio) for x in x_list]
+    branges = [s[0] for s in branges_scales]
+    residual_scale_factors = [s[1] for s in branges_scales]
+
+    # 2) get attention bias and index+concat the tensors
+    attn_bias, x_cat = get_attn_bias_and_cat(x_list, branges)
+
+    # 3) apply residual_func to get residual, and split the result
+    residual_list = attn_bias.split(residual_func(x_cat, attn_bias=attn_bias))  # type: ignore
+
+    outputs = []
+    for x, brange, residual, residual_scale_factor in zip(x_list, branges, residual_list, residual_scale_factors):
+        outputs.append(add_residual(x, brange, residual, residual_scale_factor, scaling_vector).view_as(x))
+    return outputs
+
+
+class NestedTensorBlock(Block):
+    def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]:
+        """
+        x_list contains a list of tensors to nest together and run
+        """
+        assert isinstance(self.attn, MemEffAttention)
+
+        if self.training and self.sample_drop_ratio > 0.0:
+
+            def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.attn(self.norm1(x), attn_bias=attn_bias)
+
+            def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.mlp(self.norm2(x))
+
+            x_list = drop_add_residual_stochastic_depth_list(
+                x_list,
+                residual_func=attn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                scaling_vector=self.ls1.gamma if isinstance(self.ls1, LayerScale) else None,
+            )
+            x_list = drop_add_residual_stochastic_depth_list(
+                x_list,
+                residual_func=ffn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                scaling_vector=self.ls2.gamma if isinstance(self.ls1, LayerScale) else None,
+            )
+            return x_list
+        else:
+
+            def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.ls1(self.attn(self.norm1(x), attn_bias=attn_bias))
+
+            def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.ls2(self.mlp(self.norm2(x)))
+
+            attn_bias, x = get_attn_bias_and_cat(x_list)
+            x = x + attn_residual_func(x, attn_bias=attn_bias)
+            x = x + ffn_residual_func(x)
+            return attn_bias.split(x)
+
+    def forward(self, x_or_x_list):
+        if isinstance(x_or_x_list, Tensor):
+            return super().forward(x_or_x_list)
+        elif isinstance(x_or_x_list, list):
+            assert XFORMERS_AVAILABLE, "Please install xFormers for nested tensors usage"
+            return self.forward_nested(x_or_x_list)
+        else:
+            raise AssertionError

depth_anything_v2_metric/depth_anything_v2/dinov2_layers/drop_path.py

@@ -0,0 +1,35 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/drop.py
+
+
+from torch import nn
+
+
+def drop_path(x, drop_prob: float = 0.0, training: bool = False):
+    if drop_prob == 0.0 or not training:
+        return x
+    keep_prob = 1 - drop_prob
+    shape = (x.shape[0],) + (1,) * (x.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
+    random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
+    if keep_prob > 0.0:
+        random_tensor.div_(keep_prob)
+    output = x * random_tensor
+    return output
+
+
+class DropPath(nn.Module):
+    """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""
+
+    def __init__(self, drop_prob=None):
+        super(DropPath, self).__init__()
+        self.drop_prob = drop_prob
+
+    def forward(self, x):
+        return drop_path(x, self.drop_prob, self.training)

depth_anything_v2_metric/depth_anything_v2/dinov2_layers/layer_scale.py

@@ -0,0 +1,28 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Modified from: https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/vision_transformer.py#L103-L110
+
+from typing import Union
+
+import torch
+from torch import Tensor
+from torch import nn
+
+
+class LayerScale(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        init_values: Union[float, Tensor] = 1e-5,
+        inplace: bool = False,
+    ) -> None:
+        super().__init__()
+        self.inplace = inplace
+        self.gamma = nn.Parameter(init_values * torch.ones(dim))
+
+    def forward(self, x: Tensor) -> Tensor:
+        return x.mul_(self.gamma) if self.inplace else x * self.gamma

depth_anything_v2_metric/depth_anything_v2/dinov2_layers/mlp.py

@@ -0,0 +1,41 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/mlp.py
+
+
+from typing import Callable, Optional
+
+from torch import Tensor, nn
+
+
+class Mlp(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = nn.GELU,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features, bias=bias)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features, bias=bias)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x

depth_anything_v2_metric/depth_anything_v2/dinov2_layers/patch_embed.py

@@ -0,0 +1,89 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py
+
+from typing import Callable, Optional, Tuple, Union
+
+from torch import Tensor
+import torch.nn as nn
+
+
+def make_2tuple(x):
+    if isinstance(x, tuple):
+        assert len(x) == 2
+        return x
+
+    assert isinstance(x, int)
+    return (x, x)
+
+
+class PatchEmbed(nn.Module):
+    """
+    2D image to patch embedding: (B,C,H,W) -> (B,N,D)
+
+    Args:
+        img_size: Image size.
+        patch_size: Patch token size.
+        in_chans: Number of input image channels.
+        embed_dim: Number of linear projection output channels.
+        norm_layer: Normalization layer.
+    """
+
+    def __init__(
+        self,
+        img_size: Union[int, Tuple[int, int]] = 224,
+        patch_size: Union[int, Tuple[int, int]] = 16,
+        in_chans: int = 3,
+        embed_dim: int = 768,
+        norm_layer: Optional[Callable] = None,
+        flatten_embedding: bool = True,
+    ) -> None:
+        super().__init__()
+
+        image_HW = make_2tuple(img_size)
+        patch_HW = make_2tuple(patch_size)
+        patch_grid_size = (
+            image_HW[0] // patch_HW[0],
+            image_HW[1] // patch_HW[1],
+        )
+
+        self.img_size = image_HW
+        self.patch_size = patch_HW
+        self.patches_resolution = patch_grid_size
+        self.num_patches = patch_grid_size[0] * patch_grid_size[1]
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+        self.flatten_embedding = flatten_embedding
+
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_HW, stride=patch_HW)
+        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+    def forward(self, x: Tensor) -> Tensor:
+        _, _, H, W = x.shape
+        patch_H, patch_W = self.patch_size
+
+        assert H % patch_H == 0, f"Input image height {H} is not a multiple of patch height {patch_H}"
+        assert W % patch_W == 0, f"Input image width {W} is not a multiple of patch width: {patch_W}"
+
+        x = self.proj(x)  # B C H W
+        H, W = x.size(2), x.size(3)
+        x = x.flatten(2).transpose(1, 2)  # B HW C
+        x = self.norm(x)
+        if not self.flatten_embedding:
+            x = x.reshape(-1, H, W, self.embed_dim)  # B H W C
+        return x
+
+    def flops(self) -> float:
+        Ho, Wo = self.patches_resolution
+        flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])
+        if self.norm is not None:
+            flops += Ho * Wo * self.embed_dim
+        return flops

depth_anything_v2_metric/depth_anything_v2/dinov2_layers/swiglu_ffn.py

@@ -0,0 +1,63 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Callable, Optional
+
+from torch import Tensor, nn
+import torch.nn.functional as F
+
+
+class SwiGLUFFN(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = None,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.w12 = nn.Linear(in_features, 2 * hidden_features, bias=bias)
+        self.w3 = nn.Linear(hidden_features, out_features, bias=bias)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x12 = self.w12(x)
+        x1, x2 = x12.chunk(2, dim=-1)
+        hidden = F.silu(x1) * x2
+        return self.w3(hidden)
+
+
+try:
+    from xformers.ops import SwiGLU
+
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    SwiGLU = SwiGLUFFN
+    XFORMERS_AVAILABLE = False
+
+
+class SwiGLUFFNFused(SwiGLU):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = None,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8
+        super().__init__(
+            in_features=in_features,
+            hidden_features=hidden_features,
+            out_features=out_features,
+            bias=bias,
+        )

depth_anything_v2_metric/depth_anything_v2/dinov3/.docstr.yaml

@@ -0,0 +1,6 @@
+paths:
+    - dinov3
+exclude: dinov3/tests
+skip_init: True
+skip_private: True
+fail_under: 0

depth_anything_v2_metric/depth_anything_v2/dinov3/.github/workflows/lint.yaml

@@ -0,0 +1,47 @@
+name: Lint
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  run-linters:
+    name: Run linters
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3.11
+          cache: 'pip'
+          cache-dependency-path: '**/requirements*.txt'
+      - name: Install Python (development) dependencies
+        run: |
+          pip install -r requirements-dev.txt
+      - name: Run ruff (linter)
+        run: |
+          ruff check dinov3
+      - name: Run ruff (formatter)
+        if: always()
+        run: |
+          ruff format --diff dinov3
+      - name: Report docstring coverage
+        if: always()
+        run: |
+          docstr-coverage dinov3
+      - name: Run mypy
+        if: always()
+        run: |
+          mypy --txt-report .
+          [ -f index.txt ] && cat index.txt
+      - name: Run pylint
+        if: always()
+        run: |
+          pylint --exit-zero dinov3

depth_anything_v2_metric/depth_anything_v2/dinov3/.gitignore

@@ -0,0 +1,18 @@
+build/
+dist/
+*.egg-info/
+**/__pycache__/
+
+**/.ipynb_checkpoints
+**/.ipynb_checkpoints/**
+
+**/notebooks
+
+# Ignore shell scripts
+*.sh
+
+# Ignore swap files
+*.swp
+
+# Ignore vscode directory
+.vscode/

depth_anything_v2_metric/depth_anything_v2/dinov3/CODE_OF_CONDUCT.md

@@ -0,0 +1,80 @@
+# Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+This Code of Conduct also applies outside the project spaces when there is a
+reasonable belief that an individual's behavior may have a negative impact on
+the project or its community.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at <[email protected]>. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

depth_anything_v2_metric/depth_anything_v2/dinov3/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+# Contributing to DINOv3
+We want to make contributing to this project as easy and transparent as
+possible.
+
+## Pull Requests
+We actively welcome your pull requests.
+
+1. Fork the repo and create your branch from `main`.
+2. If you've added code that should be tested, add tests.
+3. If you've changed APIs, update the documentation.
+4. Ensure the test suite passes.
+5. Make sure your code lints.
+6. If you haven't already, complete the Contributor License Agreement ("CLA").
+
+## Contributor License Agreement ("CLA")
+In order to accept your pull request, we need you to submit a CLA. You only need
+to do this once to work on any of Meta's open source projects.
+
+Complete your CLA here: <https://code.facebook.com/cla>
+
+## Issues
+We use GitHub issues to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+Meta has a [bounty program](https://www.facebook.com/whitehat/) for the safe
+disclosure of security bugs. In those cases, please go through the process
+outlined on that page and do not file a public issue.
+
+## License
+By contributing to DINOv3, you agree that your contributions will be licensed
+under the LICENSE.md file in the root directory of this source tree.

depth_anything_v2_metric/depth_anything_v2/dinov3/LICENSE.md

@@ -0,0 +1,66 @@
+# DINOv3 License
+
+*Last Updated: August 19, 2025*
+
+**“Agreement”** means the terms and conditions for use, reproduction, distribution and modification of the DINO Materials set forth herein.
+
+**“DINO Materials”** means, collectively, Documentation and the models, software and algorithms, including machine-learning model code, trained model weights, inference-enabling code, training-enabling code, fine-tuning enabling code, and other elements of the foregoing distributed by Meta and made available under this Agreement.
+
+**“Documentation”** means the specifications, manuals and documentation accompanying
+DINO Materials distributed by Meta.
+
+**“Licensee”** or **“you”** means you, or your employer or any other person or entity (if you are entering into this Agreement on such person or entity’s behalf), of the age required under applicable laws, rules or regulations to provide legal consent and that has legal authority to bind your employer or such other person or entity if you are entering in this Agreement on their behalf.
+
+**“Meta”** or **“we”** means Meta Platforms Ireland Limited (if you are located in or, if you are an entity, your principal place of business is in the EEA or Switzerland) or Meta Platforms, Inc. (if you are located outside of the EEA or Switzerland).
+
+**“Sanctions”** means any economic or trade sanctions or restrictions administered or enforced by the United States (including the Office of Foreign Assets Control of the U.S. Department of the Treasury (“OFAC”), the U.S. Department of State and the U.S. Department of Commerce), the United Nations, the European Union, or the United Kingdom.
+
+**“Trade Controls”** means any of the following: Sanctions and applicable export and import controls.
+
+By clicking “I Accept” below or by using or distributing any portion or element of the DINO Materials, you agree to be bound by this Agreement.
+
+## 1. License Rights and Redistribution.
+
+a. <ins>Grant of Rights</ins>. You are granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under Meta’s intellectual property or other rights owned by Meta embodied in the DINO Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the DINO Materials.
+
+b. <ins>Redistribution and Use</ins>.
+
+i. Distribution of DINO Materials, and any derivative works thereof, are subject to the terms of this Agreement. If you distribute or make the DINO Materials, or any derivative works thereof, available to a third party, you may only do so under the terms of this Agreement and you shall provide a copy of this Agreement with any such DINO Materials.
+
+ii.  If you submit for publication the results of research you perform on, using, or otherwise in connection with DINO Materials, you must acknowledge the use of DINO Materials in your publication.
+
+iii. Your use of the DINO Materials must comply with applicable laws and regulations, including Trade Control Laws and applicable privacy and data protection laws.
+
+iv. Your use of the DINO Materials will not involve or encourage others to reverse engineer, decompile or discover the underlying components of the DINO Materials.
+
+v. You are not the target of Trade Controls and your use of DINO Materials must comply with Trade Controls. You agree not to use, or permit others to use, DINO Materials for any activities subject to the International Traffic in Arms Regulations (ITAR) or end uses prohibited by Trade Controls, including those related to military or warfare purposes, nuclear industries or applications, espionage, or the development or use of guns or illegal weapons.
+
+## 2. User Support.
+
+Your use of the DINO Materials is done at your own discretion; Meta does not process any information nor provide any service in relation to such use.  Meta is under no obligation to provide any support services for the DINO Materials. Any support provided is “as is”, “with all faults”, and without warranty of any kind.
+
+## 3. Disclaimer of Warranty.
+
+UNLESS REQUIRED BY APPLICABLE LAW, THE DINO MATERIALS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OF ANY KIND, AND META DISCLAIMS ALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE DINO MATERIALS AND ASSUME ANY RISKS ASSOCIATED WITH YOUR USE OF THE DINO MATERIALS AND ANY OUTPUT AND RESULTS.
+
+## 4. Limitation of Liability.
+
+IN NO EVENT WILL META OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT, FOR ANY LOST PROFITS OR ANY DIRECT OR INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL, EXEMPLARY OR PUNITIVE DAMAGES, EVEN IF META OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING.
+
+## 5. Intellectual Property.
+
+a. Subject to Meta’s ownership of DINO Materials and derivatives made by or for Meta, with respect to any derivative works and modifications of the DINO Materials that are made by you, as between you and Meta, you are and will be the owner of such derivative works and modifications.
+
+b. If you institute litigation or other proceedings against Meta or any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the DINO Materials, outputs or results, or any portion of any of the foregoing, constitutes infringement of intellectual property or other rights owned or licensable by you, then any licenses granted to you under this Agreement shall terminate as of the date such litigation or claim is filed or instituted. You will indemnify and hold harmless Meta from and against any claim by any third party arising out of or related to your use or distribution of the DINO Materials.
+
+## 6. Term and Termination.
+
+The term of this Agreement will commence upon your acceptance of this Agreement or access to the DINO Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein. Meta may terminate this Agreement if you are in breach of any term or condition of this Agreement. Upon termination of this Agreement, you shall delete and cease use of the DINO Materials. Sections 3, 4 and 7 shall survive the termination of this Agreement.
+
+## 7. Governing Law and Jurisdiction.
+
+This Agreement will be governed and construed under the laws of the State of California without regard to choice of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The courts of California shall have exclusive jurisdiction of any dispute arising out of this Agreement.
+
+## 8. Modifications and Amendments.
+
+Meta may modify this Agreement from time to time; provided that they are similar in spirit to the current version of the Agreement, but may differ in detail to address new problems or concerns. All such changes will be effective immediately. Your continued use of the DINO Materials after any modification to this Agreement constitutes your agreement to such modification. Except as provided in this Agreement, no modification or addition to any provision of this Agreement will be binding unless it is in writing and signed by an authorized representative of both you and Meta.

depth_anything_v2_metric/depth_anything_v2/dinov3/MODEL_CARD.md

@@ -0,0 +1,432 @@
+# Model Card for DINOv3
+
+DINOv3 is a family of versatile vision foundation models that outperforms the specialized state of the art across a broad range of settings, without fine-tuning. DINOv3 produces high-quality dense features that achieve outstanding performance on various vision tasks, significantly surpassing previous self- and weakly-supervised foundation models.
+
+## Model Details
+
+These are Vision Transformer and ConvNeXt models trained following the method described in the DINOv3 paper. 12 models are provided:
+
+- 10 models pretrained on web data (LVD-1689M dataset)
+  - 1 ViT-7B trained from scratch,
+  - 5 ViT-S/S+/B/L/H+ models distilled from the ViT-7B,
+  - 4 ConvNeXt-{T/S/B/L} models distilled from the ViT-7B,
+- 2 models pretrained on satellite data (SAT-493M dataset)
+  - 1 ViT-7B trained from scratch
+  - 1 ViT-L distilled from the ViT-7B
+
+
+Each Transformer-based model takes an image as input and returns a class token, patch tokens (and register tokens). These models follow a ViT architecture, with a patch size of 16. For a 224x224 image, this results in 1 class token + 4 register tokens + 196 patch tokens = 201 tokens (for DINOv2 with registers this resulted in 1 + 4 + 256 = 261 tokens).
+
+The models can accept larger images provided the image shapes are multiples of the patch size (16). If this condition is not verified, the model will crop to the closest smaller multiple of the patch size.
+
+### Model Description
+
+- **Developed by:** Meta AI
+- **Model type:** Vision Transformer, ConvNeXt
+- **License:** [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/)
+
+### Model Sources
+
+- **Repository:** [https://github.com/facebookresearch/dinov3](https://github.com/facebookresearch/dinov3)
+- **Paper:** [https://arxiv.org/abs/2508.10104](https://arxiv.org/abs/2508.10104)
+
+## Uses
+
+The models are vision backbones providing multi-purpose features for downstream tasks.
+
+### Direct Use
+
+The models can be used without fine-tuning, with downstream classifiers as simple as linear layers, to obtain competitive results:
+
+- on image classification, using k-NN classifiers on the class token
+- on image classification, with logistic regression classifiers applied on the class token
+- on image classification, with a linear layer applied on the class token and the average of the patch tokens
+- on image retrieval using nearest neighbors
+- on geometric and semantic 3D keypoint correspondances
+- on depth estimation, semantic segmentation, using linear layers
+- on unsupervised object discovery
+- on video segmentation tracking
+- on video classification, using a small 4-layer attentive probe
+
+### Downstream Use
+
+While fine-tuning the models can yield some gains, it is recommended to keep this option as a last resort: the frozen features are expected to provide good performance out-of-the-box.
+
+## Bias, Risks, and Limitations
+
+Compared to DINOv2 and SEERv2, DINOv3 delivers somewhat consistent performance across income categories on geographical fairness and diversity, although with a notable performance drop in the low-income bucket compared to the highest-income bucket.
+
+DINOv3 also achieves relatively good scores across different regions, improving over its predecessor DINOv2. However, a relative difference is still observed between Europe and Africa.
+
+### Recommendations
+
+Fine-tuning is expected to increase the biases in the features produced by the model as they will be tuned to the fine-tuning labels.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+```python
+import torch
+
+model = torch.hub.load(
+    repo_or_dir='facebookresearch/dinov3',
+    model='<MODEL_NAME>',
+    weights='<PATH/OR/URL/TO/CHECKPOINT>',
+)
+
+# where MODEL_NAME can be one of:
+# - dinov3_vits16
+# - dinov3_vits16plus
+# - dinov3_vitb16
+# - dinov3_vitl16
+# - dinov3_vith16plus
+# - dinov3_vit7b16
+# - dinov3_convnext_tiny
+# - dinov3_convnext_small
+# - dinov3_convnext_base
+# - dinov3_convnext_large
+
+# For instance
+dinov3_vits16 = torch.hub.load(
+    repo_or_dir='facebookresearch/dinov3',
+    model='dinov3_vits16',
+    weights='<PATH/OR/URL/TO/DINOV3/VITS16/LVD1689M/CHECKPOINT>',
+)
+```
+
+## Training Details
+
+### Training Data
+
+- Web dataset (LVD-1689M): a curated dataset of 1,689 millions of images extracted from a large data
+pool of 17 billions web images collected from public posts on Instagram
+
+- Satellite dataset (SAT-493M): a dataset of 493 millions of 512x512 images sampled randomly from Maxar RGB ortho-rectified imagery at 0.6 meter resolution
+
+### Training Procedure
+
+**Training objective:**
+
+- DINO self-distillation loss with multi-crop
+- iBOT masked-image modeling loss
+- KoLeo regularization on [CLS] tokens
+- Gram anchoring
+
+- **Training regime:** PyTorch FSDP2 (with bf16 and fp8 matrix multiplications)
+
+**Distillation:**
+
+- Distillation follows the standard DINOv3 pretraining procedure, except the teacher is a frozen pretrained ViT-7B.
+
+## Evaluation
+
+**Results**
+
+The reader is referred to the associated paper for details on the evaluation protocols
+
+*Results for ViT backbones pretrained (or distilled) on web (LVD-1689M)*
+
+<table>
+  <tr>
+    <th></th>
+    <!-- <th></th> -->
+    <th colspan="4">Global Tasks</th>
+    <th colspan="5">Dense Tasks</th>
+  </tr>
+  <tr>
+    <th>Model</th>
+    <!-- <th>Dataset</th> -->
+    <th>IN-ReaL</th>
+    <th>IN-R</th>
+    <th>Obj.Net</th>
+    <th>Ox.-H</th>
+    <th>ADE20k</th>
+    <th>NYU↓</th>
+    <th>DAVIS</th>
+    <th>NAVI</th>
+    <th>SPair</th>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-S/16</td>
+    <!-- <td>LVD-1689M</td> -->
+    <td align="right">87.0</td>
+    <td align="right">60.4</td>
+    <td align="right">50.9</td>
+    <td align="right">49.5</td>
+    <td align="right">47.0</td>
+    <td align="right">0.403</td>
+    <td align="right">72.7</td>
+    <td align="right">56.3</td>
+    <td align="right">50.4</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-S+/16</td>
+    <!-- <td>LVD-1689M</td> -->
+    <td align="right">88.0</td>
+    <td align="right">68.8</td>
+    <td align="right">54.6</td>
+    <td align="right">50.0</td>
+    <td align="right">48.8</td>
+    <td align="right">0.399</td>
+    <td align="right">75.5</td>
+    <td align="right">57.1</td>
+    <td align="right">55.2</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-B/16</td>
+    <!-- <td>LVD-1689M</td> -->
+    <td align="right">89.3</td>
+    <td align="right">76.7</td>
+    <td align="right">64.1</td>
+    <td align="right">58.5</td>
+    <td align="right">51.8</td>
+    <td align="right">0.373</td>
+    <td align="right">77.2</td>
+    <td align="right">58.8</td>
+    <td align="right">57.2</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-L/16</td>
+    <!-- <td>LVD-1689M</td> -->
+    <td align="right">90.2</td>
+    <td align="right">88.1</td>
+    <td align="right">74.8</td>
+    <td align="right">63.1</td>
+    <td align="right">54.9</td>
+    <td align="right">0.352</td>
+    <td align="right">79.9</td>
+    <td align="right">62.3</td>
+    <td align="right">61.3</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-H+/16</td>
+    <!-- <td>LVD-1689M</td> -->
+    <td align="right">90.3</td>
+    <td align="right">90.0</td>
+    <td align="right">78.6</td>
+    <td align="right">64.5</td>
+    <td align="right">54.8</td>
+    <td align="right">0.352</td>
+    <td align="right">79.3</td>
+    <td align="right">63.3</td>
+    <td align="right">56.3</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-7B/16</td>
+    <!-- <td>LVD-1689M</td> -->
+    <td align="right">90.4</td>
+    <td align="right">91.1</td>
+    <td align="right">91.1</td>
+    <td align="right">72.8</td>
+    <td align="right">55.9</td>
+    <td align="right">0.309</td>
+    <td align="right">79.7</td>
+    <td align="right">64.4</td>
+    <td align="right">58.7</td>
+  </tr>
+</table>
+
+*Results for ConvNeXt backbones distilled on web (LVD-1689M)*
+
+<table>
+  <tr>
+    <th></th>
+    <th colspan="6">Global Tasks</th>
+    <th colspan="2">Dense Tasks</th>
+  </tr>
+  <tr>
+    <th>Model</th>
+    <th colspan="2">IN-ReaL</th>
+    <th colspan="2">IN-R</th>
+    <th colspan="2">Obj.Net</th>
+    <th>ADE20k</th>
+    <th>NYU↓</th>
+  </tr>
+  <tr>
+    <td></th>
+    <td>@256px</td>
+    <td>@512px</td>
+    <td>@256px</td>
+    <td>@512px</td>
+    <td>@256px</td>
+    <td>@512px</td>
+    <td colspan="2"></td>
+  </tr>
+  <tr>
+    <td>DINOv3 ConvNeXt Tiny</td>
+    <td align="right">86.6</td>
+    <td align="right">87.7</td>
+    <td align="right">73.7</td>
+    <td align="right">74.1</td>
+    <td align="right">52.6</td>
+    <td align="right">58.7</td>
+    <td align="right">42.7</td>
+    <td align="right">0.448</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ConvNeXt Small</td>
+    <td align="right">87.9</td>
+    <td align="right">88.7</td>
+    <td align="right">73.7</td>
+    <td align="right">74.1</td>
+    <td align="right">52.6</td>
+    <td align="right">58.7</td>
+    <td align="right">44.8</td>
+    <td align="right">0.432</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ConvNeXt Base</td>
+    <td align="right">88.5</td>
+    <td align="right">89.2</td>
+    <td align="right">77.2</td>
+    <td align="right">78.2</td>
+    <td align="right">56.2</td>
+    <td align="right">61.3</td>
+    <td align="right">46.3</td>
+    <td align="right">0.420</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ConvNeXt Large</td>
+    <td align="right">88.9</td>
+    <td align="right">89.4</td>
+    <td align="right">81.3</td>
+    <td align="right">82.4</td>
+    <td align="right">59.3</td>
+    <td align="right">65.2</td>
+    <td align="right">47.8</td>
+    <td align="right">0.403</td>
+  </tr>
+</table>
+
+*Results for ViT backbones pretrained (or distilled) on satellite (SAT-493M)*
+
+<table>
+  <tr>
+    <th></th>
+    <th colspan="7">(GEO-Bench) Classification</th>
+  </tr>
+  <tr>
+    <th>Model</ht>
+    <th>m-BEnet</th>
+    <th>m-brick-kiln
+    <th>m-eurosat</th>
+    <th>m-forestnet</th>
+    <th>m-pv4ger</th>
+    <th>m-so2sat</th>
+    <th>mean</th>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-L/16</td>
+    <td>73.0</td>
+    <td>96.5</td>
+    <td>94.1</td>
+    <td>60.6</td>
+    <td>96.0</td>
+    <td>57.4</td>
+    <td>79.6</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-7B/16</td>
+    <td>74.0</td>
+    <td>97.2</td>
+    <td>94.8</td>
+    <td>62.3</td>
+    <td>96.1</td>
+    <td>62.1</td>
+    <td>81.1</td>
+  </tr>
+  <tr>
+    <th></th>
+    <th colspan="7">(GEO-Bench) Segmentation</th>
+  </tr>
+  <tr>
+    <th>Model</th>
+    <th>m-cashew</th>
+    <th>m-chesapeake</th>
+    <th>m-NeonTree</th>
+    <th>m-nz-cattle</th>
+    <th>m-pv4ger-seg</th>
+    <th>m-SA-crop</th>
+    <th>mean</th>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-L/16</td>
+    <td>94.2</td>
+    <td>75.6</td>
+    <td>61.8</td>
+    <td>83.7</td>
+    <td>95.2</td>
+    <td>36.8</td>
+    <td>74.5</td>
+  </tr>
+  <tr>
+    <td>DINOv3 ViT-7B/16</td>
+    <td>94.1</td>
+    <td>76.6</td>
+    <td>62.6</td>
+    <td>83.4</td>
+    <td>95.5</td>
+    <td>37.6</td>
+    <td>75.0</td>
+  </tr>
+</table>
+
+
+## Environmental Impact
+
+- **Hardware Type:** Nvidia H100
+- **Hours used:** 61,440 hours for ViT-7B model training
+- **Cloud Provider:** Private infrastructure
+- **Compute Region:** USA
+- **Carbon Emitted:** 18t CO2eq
+
+## Technical Specifications
+
+### Model Architecture and Objective
+
+Vision Transformer models:
+
+- ViT-S (21M parameters): patch size 16, embedding dimension 384, 4 register tokens, 6 heads, MLP FFN, RoPE
+- ViT-S+ (29M parameters): patch size 16, embedding dimension 384, 4 register tokens, 6 heads, SwiGLU FFN, RoPE
+- ViT-B (86M parameters): patch size 16, embedding dimension 768, 4 register tokens, 12 heads, MLP FFN, RoPE
+- ViT-L (300M parameters): patch size 16, embedding dimension 1024, 4 register tokens, 16 heads, MLP FFN, RoPE
+- ViT-H+ (840M parameters): patch size 16, embedding dimension 1280, 4 register tokens, 20 heads, SwiGLU FFN, RoPE
+- ViT-7B (6716M parameters): patch size 16, embedding dimension 4096, 4 register tokens, 32 heads, SwiGLU FFN, RoPE
+
+ConvNeXt models:
+
+- ConvNeXt Tiny (29M parameters)
+- ConvNeXt Small (50M parameters)
+- ConvNeXt Base (89M parameters)
+- ConvNeXt Large (198M parameters)
+
+### Compute Infrastructure
+
+#### Hardware
+
+Nvidia H100 GPUs
+
+#### Software
+
+PyTorch 2.7
+
+## More Information
+
+See the [blog post](https://ai.meta.com/blog/dinov3-self-supervised-vision-model/) and the associated [website](https://ai.meta.com/dinov3/).
+
+## Citation
+
+**BibTeX**
+
+```
+@misc{simeoni2025dinov3,
+  title={{DINOv3}},
+  author={Sim{\'e}oni, Oriane and Vo, Huy V. and Seitzer, Maximilian and Baldassarre, Federico and Oquab, Maxime and Jose, Cijo and Khalidov, Vasil and Szafraniec, Marc and Yi, Seungeun and Ramamonjisoa, Micha{\"e}l and Massa, Francisco and Haziza, Daniel and Wehrstedt, Luca and Wang, Jianyuan and Darcet, Timoth{\'e}e and Moutakanni, Th{\'e}o and Sentana, Leonel and Roberts, Claire and Vedaldi, Andrea and Tolan, Jamie and Brandt, John and Couprie, Camille and Mairal, Julien and J{\'e}gou, Herv{\'e} and Labatut, Patrick and Bojanowski, Piotr},
+  year={2025},
+  eprint={2508.10104},
+  archivePrefix={arXiv},
+  primaryClass={cs.CV},
+  url={https://arxiv.org/abs/2508.10104},
+}
+```

depth_anything_v2_metric/depth_anything_v2/dinov3/README.md

@@ -0,0 +1,734 @@
+🆕 [2025-08-14] :fire: DINOv3 backbones are now available in [Hugging Face Hub](https://huggingface.co/collections/facebook/dinov3-68924841bd6b561778e31009) and [supported](https://huggingface.co/docs/transformers/model_doc/dinov3) by the Hugging Face [Transformers](https://huggingface.co/docs/transformers/index) library
+
+# DINOv3 🦖🦖🦖
+
+**[Meta AI Research, FAIR](https://ai.meta.com/research/)**
+
+Oriane Siméoni, Huy V. Vo, Maximilian Seitzer, Federico Baldassarre, Maxime Oquab, <br/>
+Cijo Jose, Vasil Khalidov, Marc Szafraniec, Seungeun Yi, Michaël Ramamonjisoa, <br/>
+Francisco Massa, Daniel Haziza, Luca Wehrstedt, Jianyuan Wang, <br/>
+Timothée Darcet, Théo Moutakanni, Leonel Sentana, Claire Roberts, <br/>
+Andrea Vedaldi, Jamie Tolan, John Brandt, Camille Couprie, <br/>
+Julien Mairal, Hervé Jégou, Patrick Labatut, Piotr Bojanowski
+
+[ :scroll: [`Paper`](https://arxiv.org/abs/2508.10104)] [ :newspaper: [`Blog`](https://ai.meta.com/blog/dinov3-self-supervised-vision-model/)] [ :globe_with_meridians: [`Website`](https://ai.meta.com/dinov3/)] [ :book: [`BibTeX`](#citing-dinov3)]
+
+Reference PyTorch implementation and models for DINOv3. For details, see the **[DINOv3](https://arxiv.org/abs/2508.10104)** paper.
+
+## Overview
+
+<div align="center">
+  <img width="1364" height="1024" alt="market" src="https://github.com/user-attachments/assets/1411f491-988e-49cb-95ae-d03fe6e3c268" />
+
+  <i></em><b>High-resolution dense features.</b><br/>We visualize the cosine similarity maps obtained with DINOv3 output features<br/> between the patches marked with a red cross and all other patches.</i>
+</div>
+
+<br/>
+
+An extended family of versatile vision foundation models producing high-quality dense features and achieving outstanding performance on various vision tasks including outperforming the specialized state of the art across a broad range of settings, without fine-tuning
+
+## Pretrained models
+
+:information_source: Please follow the link provided below to get access to all the model weights: once accepted, an e-mail will be sent with the complete list of URLs pointing to all the available model weights (both backbones and adapters). These URLs can then be used to either:
+- download the model or adapter weights to a local filesystem and point `torch.hub.load()` to these local weights via the `weights` or `backbone_weights` parameters, or
+- directly invoke `torch.hub.load()` to download and load a backbone or an adapter from its URL via also the `weights` or `backbone_weights` parameters.
+
+See the example code snippets below.
+
+:warning: Please use `wget` instead of a web browser to download the weights.
+
+ViT models pretrained on web dataset (LVD-1689M):
+<table style="margin: auto">
+  <thead>
+    <tr>
+      <th>Model</th>
+      <th>Parameters</th>
+      <th>Pretraining<br/>Dataset</th>
+      <th>Download</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>ViT-S/16 distilled </td>
+      <td align="right">21M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+    <tr>
+      <td>ViT-S+/16 distilled</td>
+      <td align="right">29M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+    <tr>
+      <td>ViT-B/16 distilled</td>
+      <td align="right">86M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+    <tr>
+      <td>ViT-L/16 distilled</td>
+      <td align="right">300M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+    <tr>
+      <td>ViT-H+/16 distilled</td>
+      <td align="right">840M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+    <tr>
+      <td>ViT-7B/16</td>
+      <td align="right">6,716M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+  </tbody>
+</table>
+
+ConvNeXt models pretrained on web dataset (LVD-1689M):
+<table style="margin: auto">
+  <thead>
+    <tr>
+      <th>Model</th>
+      <th>Parameters</th>
+      <th>Pretraining<br/>Dataset</th>
+      <th>Download</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>ConvNeXt Tiny</td>
+      <td align="right">29M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+    <tr>
+      <td>ConvNeXt Small</td>
+      <td align="right">50M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+    <tr>
+      <td>ConvNeXt Base</td>
+      <td align="right">89M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+    <tr>
+      <td>ConvNeXt Large</td>
+      <td align="right">198M</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+  </tbody>
+</table>
+
+ViT models pretrained on satellite dataset (SAT-493M):
+<table style="margin: auto">
+  <thead>
+    <tr>
+      <th>Model</th>
+      <th>Parameters</th>
+      <th>Pretraining<br/>Dataset</th>
+      <th>Download</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>ViT-L/16 distilled</td>
+      <td align="right">300M</td>
+      <td align="center">SAT-493M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+    <tr>
+      <td>ViT-7B/16</td>
+      <td align="right">6,716M</td>
+      <td align="center">SAT-493M</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+  </tbody>
+</table>
+
+
+### Pretrained backbones (via PyTorch [Hub](https://docs.pytorch.org/docs/stable/hub.html))
+
+Please follow the instructions [here](https://pytorch.org/get-started/locally/) to install PyTorch (the only required dependency for loading the model). Installing PyTorch with CUDA support is strongly recommended.
+
+```python
+import torch
+
+REPO_DIR = <PATH/TO/A/LOCAL/DIRECTORY/WHERE/THE/DINOV3/REPO/WAS/CLONED>
+
+# DINOv3 ViT models pretrained on web images
+dinov3_vits16 = torch.hub.load(REPO_DIR, 'dinov3_vits16', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+dinov3_vits16plus = torch.hub.load(REPO_DIR, 'dinov3_vits16plus', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+dinov3_vitb16 = torch.hub.load(REPO_DIR, 'dinov3_vitb16', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+dinov3_vitl16 = torch.hub.load(REPO_DIR, 'dinov3_vitl16', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+dinov3_vith16plus = torch.hub.load(REPO_DIR, 'dinov3_vith16plus', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+dinov3_vit7b16 = torch.hub.load(REPO_DIR, 'dinov3_vit7b16', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+
+# DINOv3 ConvNeXt models pretrained on web images
+dinov3_convnext_tiny = torch.hub.load(REPO_DIR, 'dinov3_convnext_tiny', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+dinov3_convnext_small = torch.hub.load(REPO_DIR, 'dinov3_convnext_small', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+dinov3_convnext_base = torch.hub.load(REPO_DIR, 'dinov3_convnext_base', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+dinov3_convnext_large = torch.hub.load(REPO_DIR, 'dinov3_convnext_large', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+
+# DINOv3 ViT models pretrained on satellite imagery
+dinov3_vitl16 = torch.hub.load(REPO_DIR, 'dinov3_vitl16', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+dinov3_vit7b16 = torch.hub.load(REPO_DIR, 'dinov3_vit7b16', source='local', weights=<CHECKPOINT/URL/OR/PATH>)
+```
+
+### Pretrained backbones (via Hugging Face [Transformers](https://huggingface.co/docs/transformers/))
+
+All the backbones are available in the the [DINOv3](https://huggingface.co/collections/facebook/dinov3-68924841bd6b561778e31009) collection on Hugging Face Hub and supported via the Hugging Face [Transformers](https://huggingface.co/docs/transformers/index) library. Please refer to the corresponding documentation for usage, but below is a short example that demonstrates how to obtain an image embedding with either [Pipeline] or the [AutoModel] class.
+
+```python
+from transformers import pipeline
+from transformers.image_utils import load_image
+
+url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
+image = load_image(url)
+
+feature_extractor = pipeline(
+    model="facebook/dinov3-convnext-tiny-pretrain-lvd1689m",
+    task="image-feature-extraction", 
+)
+features = feature_extractor(image)
+```
+
+```python
+import torch
+from transformers import AutoImageProcessor, AutoModel
+from transformers.image_utils import load_image
+
+url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+image = load_image(url)
+
+pretrained_model_name = "facebook/dinov3-convnext-tiny-pretrain-lvd1689m"
+processor = AutoImageProcessor.from_pretrained(pretrained_model_name)
+model = AutoModel.from_pretrained(
+    pretrained_model_name, 
+    device_map="auto", 
+)
+
+inputs = processor(images=image, return_tensors="pt").to(model.device)
+with torch.inference_mode():
+    outputs = model(**inputs)
+
+pooled_output = outputs.pooler_output
+print("Pooled output shape:", pooled_output.shape)
+```
+
+where `model` and `pretrained_model_name` above can be one of:
+- `facebook/dinov3-vits16-pretrain-lvd1689m`
+- `facebook/dinov3-vits16plus-pretrain-lvd1689m`
+- `facebook/dinov3-vitb16-pretrain-lvd1689m`
+- `facebook/dinov3-vitl16-pretrain-lvd1689m`
+- `facebook/dinov3-vith16plus-pretrain-lvd1689m`
+- `facebook/dinov3-vit7b16-pretrain-lvd1689m`
+- `facebook/dinov3-convnext-base-pretrain-lvd1689m`
+- `facebook/dinov3-convnext-large-pretrain-lvd1689m`
+- `facebook/dinov3-convnext-small-pretrain-lvd1689m`
+- `facebook/dinov3-convnext-tiny-pretrain-lvd1689m`
+- `facebook/dinov3-vitl16-pretrain-sat493m`
+- `facebook/dinov3-vit7b16-pretrain-sat493m`
+
+### Image transforms
+
+For models using the LVD-1689M weights (pretrained on web images), please use the following transform (standard ImageNet evaluation transform):
+
+```python
+import torchvision
+
+def make_transform(resize_size: int = 224):
+    to_tensor = transforms.ToTensor()
+    resize = transforms.Resize((resize_size, resize_size), antialias=True)
+    normalize = transforms.Normalize(
+        mean=(0.485, 0.456, 0.406),
+        std=(0.229, 0.224, 0.225),
+    )
+    return transforms.Compose([to_tensor, resize, normalize])
+```
+
+
+For models using the SAT-493M weights (pretrained on satellite imagery), please use the following transform:
+
+
+```python
+import torchvision
+
+def make_transform(resize_size: int = 224):
+    to_tensor = transforms.ToTensor()
+    resize = transforms.Resize((resize_size, resize_size), antialias=True)
+    normalize = transforms.Normalize(
+        mean=(0.430, 0.411, 0.296),
+        std=(0.213, 0.156, 0.143),
+    )
+    return transforms.Compose([to_tensor, resize, normalize])
+```
+
+### Pretrained heads - Image classification
+
+<table style="margin: auto">
+  <thead>
+    <tr>
+      <th>Backbone</th>
+      <th>Pretraining<br/>Dataset</th>
+      <th>Head<br/>Dataset</th>
+      <th>Download</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>ViT-7B/16</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center">ImageNet</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+  </tbody>
+</table>
+
+
+The (full) classifier models can be loaded via PyTorch Hub:
+
+```python
+import torch
+
+# DINOv3
+dinov3_vit7b16_lc = torch.hub.load(REPO_DIR, 'dinov3_vit7b16_lc', source="local", weights=<DEPTHER/CHECKPOINT/URL/OR/PATH>, backbone_weights=<BACKBONE/CHECKPOINT/URL/OR/PATH>)
+
+```
+
+### Pretrained heads - Depther trained on SYNTHMIX dataset
+
+<table style="margin: auto">
+  <thead>
+    <tr>
+      <th>Backbone</th>
+      <th>Pretraining<br/>Dataset</th>
+      <th>Head<br/>Dataset</th>
+      <th>Download</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>ViT-7B/16</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center">SYNTHMIX</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+  </tbody>
+</table>
+
+
+```python
+depther = torch.hub.load(REPO_DIR, 'dinov3_vit7b16_dd', source="local", weights=<DEPTHER/CHECKPOINT/URL/OR/PATH>, backbone_weights=<BACKBONE/CHECKPOINT/URL/OR/PATH>)
+```
+
+Full example code of depther on an image
+
+```python
+from PIL import Image
+import torch
+from torchvision import transforms
+import matplotlib.pyplot as plt
+from matplotlib import colormaps
+
+def get_img():
+    import requests
+    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
+    return image
+
+def make_transform(resize_size: int | list[int] = 768):
+    to_tensor = transforms.ToTensor()
+    resize = transforms.Resize((resize_size, resize_size), antialias=True)
+    normalize = transforms.Normalize(
+        mean=(0.485, 0.456, 0.406),
+        std=(0.229, 0.224, 0.225),
+    )
+    return transforms.Compose([to_tensor, resize, normalize])
+
+depther = torch.hub.load(REPO_DIR, 'dinov3_vit7b16_dd', source="local", weights=<DEPTHER/CHECKPOINT/URL/OR/PATH>, backbone_weights=<BACKBONE/CHECKPOINT/URL/OR/PATH>)
+
+img_size = 1024
+img = get_img()
+transform = make_transform(img_size)
+with torch.inference_mode():
+    with torch.autocast('cuda', dtype=torch.bfloat16):
+        batch_img = transform(img)[None]
+        batch_img = batch_img
+        depths = depther(batch_img)
+
+plt.figure(figsize=(12, 6))
+plt.subplot(121)
+plt.imshow(img)
+plt.axis("off")
+plt.subplot(122)
+plt.imshow(depths[0,0].cpu(), cmap=colormaps["Spectral"])
+plt.axis("off")
+
+```
+
+### Pretrained heads - Detector trained on COCO2017 dataset
+
+<table style="margin: auto">
+  <thead>
+    <tr>
+      <th>Backbone</th>
+      <th>Pretraining<br/>Dataset</th>
+      <th>Head<br/>Dataset</th>
+      <th>Download</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>ViT-7B/16</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center">COCO2017</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+  </tbody>
+</table>
+
+
+```python
+detector = torch.hub.load(REPO_DIR, 'dinov3_vit7b16_de', source="local", weights=<DETECTOR/CHECKPOINT/URL/OR/PATH>, backbone_weights=<BACKBONE/CHECKPOINT/URL/OR/PATH>)
+```
+
+### Pretrained heads - Segmentor trained on ADE20K dataset
+
+<table style="margin: auto">
+  <thead>
+    <tr>
+      <th>Backbone</th>
+      <th>Pretraining<br/>Dataset</th>
+      <th>Head<br/>Dataset</th>
+      <th>Download</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>ViT-7B/16</td>
+      <td align="center">LVD-1689M</td>
+      <td align="center">ADE20K</td>
+      <td align="center"><a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a></td>
+    </tr>
+  </tbody>
+</table>
+
+```python
+segmentor = torch.hub.load(REPO_DIR, 'dinov3_vit7b16_ms', source="local", weights=<SEGMENTOR/CHECKPOINT/URL/OR/PATH>, backbone_weights=<BACKBONE/CHECKPOINT/URL/OR/PATH>)
+```
+
+Full example code of segmentator on an image
+
+```python
+import sys
+sys.path.append(REPO_DIR)
+
+from PIL import Image
+import torch
+from torchvision import transforms
+import matplotlib.pyplot as plt
+from matplotlib import colormaps
+from functools import partial
+from dinov3.eval.segmentation.inference import make_inference
+
+
+def get_img():
+    import requests
+    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
+    return image
+
+def make_transform(resize_size: int | list[int] = 768):
+    to_tensor = transforms.ToTensor()
+    resize = transforms.Resize((resize_size, resize_size), antialias=True)
+    normalize = transforms.Normalize(
+        mean=(0.485, 0.456, 0.406),
+        std=(0.229, 0.224, 0.225),
+    )
+    return transforms.Compose([to_tensor, resize, normalize])
+
+segmentor = torch.hub.load(REPO_DIR, 'dinov3_vit7b16_ms', source="local", weights=<SEGMENTOR/CHECKPOINT/URL/OR/PATH>, backbone_weights=<BACKBONE/CHECKPOINT/URL/OR/PATH>)
+
+img_size = 896
+img  = get_img()
+transform = make_transform(img_size)
+with torch.inference_mode():
+    with torch.autocast('cuda', dtype=torch.bfloat16):
+        batch_img = transform(img)[None]
+        pred_vit7b = segmentor(batch_img)  # raw predictions  
+        # actual segmentation map
+        segmentation_map_vit7b = make_inference(
+            batch_img,
+            segmentor,
+            inference_mode="slide",
+            decoder_head_type="m2f",
+            rescale_to=(img.size[-1], img.size[-2]),
+            n_output_channels=150,
+            crop_size=(img_size, img_size),
+            stride=(img_size, img_size),
+            output_activation=partial(torch.nn.functional.softmax, dim=1),
+        ).argmax(dim=1, keepdim=True)
+plt.figure(figsize=(12, 6))
+plt.subplot(121)
+plt.imshow(img)
+plt.axis("off")
+plt.subplot(122)
+plt.imshow(segmentation_map_vit7b[0,0].cpu(), cmap=colormaps["Spectral"])
+plt.axis("off")
+```
+
+
+
+
+### Pretrained heads - Zero-shot tasks with `dino.txt`
+
+<table style="margin: auto">
+  <thead>
+    <tr>
+      <th rowspan="2">Backbone</th>
+      <th>Download</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>ViT-L/16 distilled</td>
+      <td align="center">
+        <a href="https://ai.meta.com/resources/models-and-libraries/dinov3-downloads/">[link]</a>,
+        <a href="https://dl.fbaipublicfiles.com/dinov3/thirdparty/bpe_simple_vocab_16e6.txt.gz">vocabulary</a>,
+        <a href="https://dl.fbaipublicfiles.com/dinov2/thirdparty/LICENSE">vocabulary license</a>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+The (full) dino.txt model can be loaded via PyTorch Hub:
+
+```python
+import torch
+# DINOv3
+dinov3_vitl16_dinotxt_tet1280d20h24l, tokenizer = torch.hub.load(REPO_DIR, 'dinov3_vitl16_dinotxt_tet1280d20h24l', weights=<SEGMENTOR/CHECKPOINT/URL/OR/PATH>, backbone_weights=<BACKBONE/CHECKPOINT/URL/OR/PATH>)
+```
+
+
+## Installation
+
+The training and evaluation code requires PyTorch version >= 2.7.1 as well as a few other 3rd party packages. Note that the code has only been tested with the specified versions and also expects a Linux environment. To setup all the required dependencies for training and evaluation, please follow the instructions below:
+
+*[micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html)* **(Recommended)** - Clone the repository and then create and activate a `dinov3` conda environment using the provided environment definition:
+
+```shell
+micromamba env create -f conda.yaml
+micromamba activate dinov3
+```
+
+## Getting started
+
+Several notebooks are provided to get started applying DINOv3:
+- [PCA of patch features](notebooks/pca.ipynb): display the PCA of DINOv3 patch features on a foreground object (rainbow visualizations from the paper) [[Run in Google Colab]](https://colab.research.google.com/github/facebookresearch/dinov3/blob/main/notebooks/pca.ipynb)
+- [Foreground segmentation](notebooks/foreground_segmentation.ipynb): train a linear foreground segmentation model based on DINOv3 features [[Run in Google Colab]](https://colab.research.google.com/github/facebookresearch/dinov3/blob/main/notebooks/foreground_segmentation.ipynb)
+- [Dense and sparse matching](notebooks/dense_sparse_matching.ipynb): match patches from objects on two different images based on DINOv3 features [[Run in Google Colab]](https://colab.research.google.com/github/facebookresearch/dinov3/blob/main/notebooks/dense_sparse_matching.ipynb)
+- [Segmentation tracking](notebooks/segmentation_tracking.ipynb): video segmentation tracking using a non-parametric method based on DINOv3 features [[Run in Google Colab]](https://colab.research.google.com/github/facebookresearch/dinov3/blob/main/notebooks/segmentation_tracking.ipynb)
+
+## Data preparation
+
+### ImageNet-1k
+
+The root directory of the dataset should hold the following contents:
+
+- `<ROOT>/test/ILSVRC2012_test_00000001.JPEG`
+- `<ROOT>/test/[..]`
+- `<ROOT>/test/ILSVRC2012_test_00100000.JPEG`
+- `<ROOT>/train/n01440764/n01440764_10026.JPEG`
+- `<ROOT>/train/[...]`
+- `<ROOT>/train/n15075141/n15075141_9993.JPEG`
+- `<ROOT>/val/n01440764/ILSVRC2012_val_00000293.JPEG`
+- `<ROOT>/val/[...]`
+- `<ROOT>/val/n15075141/ILSVRC2012_val_00049174.JPEG`
+- `<ROOT>/labels.txt`
+
+The provided dataset implementation expects a few additional metadata files to be present under the extra directory:
+
+- `<EXTRA>/class-ids-TRAIN.npy`
+- `<EXTRA>/class-ids-VAL.npy`
+- `<EXTRA>/class-names-TRAIN.npy`
+- `<EXTRA>/class-names-VAL.npy`
+- `<EXTRA>/entries-TEST.npy`
+- `<EXTRA>/entries-TRAIN.npy`
+- `<EXTRA>/entries-VAL.npy`
+
+These metadata files can be generated (once) with the following lines of Python code:
+
+```python
+from dinov3.data.datasets import ImageNet
+
+for split in ImageNet.Split:
+    dataset = ImageNet(split=split, root="<ROOT>", extra="<EXTRA>")
+    dataset.dump_extra()
+```
+
+Note that the root and extra directories do not have to be distinct directories.
+
+### ImageNet-22k
+
+Please adapt the [dataset class](dinov3/data/datasets/image_net_22k.py) to match your local setup.
+
+<br />
+
+:warning: To execute the commands provided in the next sections for training and evaluation, the `dinov3` package should be included in the Python module search path, i.e. simply prefix the command to run with `PYTHONPATH=.`.
+
+## Training
+
+### Fast setup: training DINOv3 ViT-L/16 on ImageNet-1k
+
+Run DINOv3 pre-training on 4 H100-80GB nodes (32 GPUs) in a SLURM cluster environment with submitit:
+
+```shell
+ PYTHONPATH=${PWD} python -m dinov3.run.submit dinov3/train/train.py \
+  --nodes 4 \
+  --config-file dinov3/configs/train/vitl_im1k_lin834.yaml \
+  --output-dir <PATH/TO/OUTPUT/DIR> \
+  train.dataset_path=ImageNet22k:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET>
+```
+Training time is approximately 14 hours and the resulting checkpoint should reach 82.0% on k-NN eval and 83.5% on linear eval.
+
+The training code saves the weights of the teacher in the eval folder every 12500 iterations for evaluation.
+
+### Exact DINOv3 setup: training DINOv3 ViT-7B/16
+
+DINOv3 ViT-7B/16 is trained on a private dataset. The training involves 3 stages:
+- Pretraining
+- Gram anchoring
+- High resolution adaptation
+
+#### Pretraining
+
+Launch DINOV3 ViT-7B/16 pretraining on 32 nodes (256 GPUs) in a SLURM cluster environment with submitit.
+
+```shell
+PYTHONPATH=${PWD} python -m dinov3.run.submit dinov3/train/train.py \
+  --nodes 32 \
+  --config-file dinov3/configs/train/dinov3_vit7b16_pretrain.yaml \
+  --output-dir <PATH/TO/OUTPUT/DIR> \
+  train.dataset_path=<DATASET>:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET>
+```
+
+#### Gram anchoring
+
+```shell
+PYTHONPATH=${PWD} python -m dinov3.run.submit dinov3/train/train.py \
+  --nodes 32 \
+  --config-file dinov3/configs/train/dinov3_vit7b16_gram_anchor.yaml \
+  --output-dir <PATH/TO/OUTPUT/DIR> \
+  train.dataset_path=<DATASET>:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET> \
+  gram.ckpt=<PATH/TO/GRAM_TEACHER_FROM_PREVIOUS_STEP>   
+```
+
+#### High-resolution adaptation
+
+
+```shell
+PYTHONPATH=${PWD} python -m dinov3.run.submit dinov3/train/train.py \
+  --nodes 32 \
+  --config-file dinov3/configs/train/dinov3_vit7b16_high_res_adapt.yaml \
+  --output-dir <PATH/TO/OUTPUT/DIR> \
+  train.dataset_path=<DATASET>:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET> \
+  gram.ckpt=<PATH/TO/TEACHER_FROM_GRAM> \
+  student.resume_from_teacher_chkpt=<PATH/TO/TEACHER_FROM_GRAM>
+```
+
+## Multi-distillation 
+
+### Test setup:
+
+```shell
+PYTHONPATH=${PWD} python -m dinov3.run.submit dinov3/train/train.py \
+  --nodes 1 \
+  --config-file dinov3/configs/train/multi_distillation_test.yaml \
+  --output-dir <PATH/TO/OUTPUT/DIR> \
+  --multi-distillation \
+  train.dataset_path=<DATASET>:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET>
+```
+
+## Evaluation
+
+The training code regularly saves the teacher weights. In order to evaluate the model, run the following evaluation on a single node:
+
+
+### Logistic regression classification on ImageNet-1k
+
+```shell
+PYTHONPATH=${PWD} python -m dinov3.run.submit dinov3/eval/log_regression.py \
+  model.config_file=<PATH/TO/OUTPUT/DIR>/config.yaml \
+  model.pretrained_weights=<PATH/TO/OUTPUT/DIR>/teacher_checkpoint.pth \
+  output_dir=<PATH/TO/OUTPUT/DIR> \
+  train.dataset=ImageNet:split=TRAIN:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET> \
+  eval.test_dataset=ImageNet:split=VAL:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET>
+```
+
+### k-NN classification on ImageNet-1k
+
+```shell
+PYTHONPATH=${PWD} python -m dinov3.run.submit dinov3/eval/knn.py \
+  model.config_file=<PATH/TO/OUTPUT/DIR>/config.yaml \
+  model.pretrained_weights=<PATH/TO/OUTPUT/DIR>/teacher_checkpoint.pth \
+  output_dir=<PATH/TO/OUTPUT/DIR> \
+  train.dataset=ImageNet:split=TRAIN:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET> \
+  eval.test_dataset=ImageNet:split=VAL:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET>
+```
+
+### Linear classification with data augmentation on ImageNet-1k
+
+```shell
+PYTHONPATH=${PWD} python -m dinov3.run.submit dinov3/eval/linear.py \
+  model.config_file=<PATH/TO/OUTPUT/DIR>/config.yaml \
+  model.pretrained_weights=<PATH/TO/OUTPUT/DIR>/teacher_checkpoint.pth \
+  output_dir=<PATH/TO/OUTPUT/DIR> \
+  train.dataset=ImageNet:split=TRAIN:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET> \
+  train.val_dataset=ImageNet:split=VAL:root=<PATH/TO/DATASET>:extra=<PATH/TO/DATASET>
+```
+
+
+### Text alignment on DINOv3 using dino.txt
+
+Text alignment can be done following the method from `dino.txt` aka [DINOv2 Meets Text](https://arxiv.org/abs/2412.16334).
+
+```shell
+PYTHONPATH=${PWD} python -m dinov3.run.submit dinov3/eval/text/train_dinotxt.py \
+   --nodes 4 \
+  # An example config for text alignment is here: dinov3/eval/text/configs/dinov3_vitl_text.yaml \ 
+  trainer_config_file="<PATH/TO/DINOv3/TEXT/CONFIG>" \
+  output-dir=<PATH/TO/OUTPUT/DIR>
+```
+Launching the above trains text alignment on 4 nodes with 8 gpus each (32 gpus in total).
+Please note that the text alignment model in the DINOv3 paper was trained on a private dataset and here we have given an example config in ```dinov3/eval/text/configs/dinov3_vitl_text.yaml``` using ```CocoCaptions``` dataset for illustration purposes.
+Please adapt the provided ```CocoCaptions``` dataset class, the dataset can be found [here](https://www.kaggle.com/datasets/nikhil7280/coco-image-caption)  
+
+## License
+
+DINOv3 code and model weights are released under the DINOv3 License. See [LICENSE.md](LICENSE.md) for additional details.
+
+## Contributing
+
+See [contributing](CONTRIBUTING.md) and the [code of conduct](CODE_OF_CONDUCT.md).
+
+## Citing DINOv3
+
+If you find this repository useful, please consider giving a star :star: and citation :t-rex::
+
+```
+@misc{simeoni2025dinov3,
+  title={{DINOv3}},
+  author={Sim{\'e}oni, Oriane and Vo, Huy V. and Seitzer, Maximilian and Baldassarre, Federico and Oquab, Maxime and Jose, Cijo and Khalidov, Vasil and Szafraniec, Marc and Yi, Seungeun and Ramamonjisoa, Micha{\"e}l and Massa, Francisco and Haziza, Daniel and Wehrstedt, Luca and Wang, Jianyuan and Darcet, Timoth{\'e}e and Moutakanni, Th{\'e}o and Sentana, Leonel and Roberts, Claire and Vedaldi, Andrea and Tolan, Jamie and Brandt, John and Couprie, Camille and Mairal, Julien and J{\'e}gou, Herv{\'e} and Labatut, Patrick and Bojanowski, Piotr},
+  year={2025},
+  eprint={2508.10104},
+  archivePrefix={arXiv},
+  primaryClass={cs.CV},
+  url={https://arxiv.org/abs/2508.10104},
+}
+```

depth_anything_v2_metric/depth_anything_v2/dinov3/conda.yaml

@@ -0,0 +1,23 @@
+name: dinov3
+channels:
+  - defaults
+  - conda-forge
+dependencies:
+  - python=3.11
+  - omegaconf
+  - pip
+  - pip:
+    - ftfy # needed for dino.txt
+    - iopath
+    - omegaconf
+    - pandas 
+    - regex # needed for dino.txt
+    - pandas
+    - scikit-learn
+    - scikit-learn-intelex
+    - submitit
+    - termcolor
+    - torch 
+    - torchvision 
+    - torchmetrics
+    

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This software may be used and distributed in accordance with
+# the terms of the DINOv3 License Agreement.
+
+__version__ = "0.0.1"

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/checkpointer/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This software may be used and distributed in accordance with
+# the terms of the DINOv3 License Agreement.
+
+from .checkpointer import (
+    CheckpointRetentionPolicy,
+    cleanup_checkpoint,
+    find_all_checkpoints,
+    find_latest_checkpoint,
+    init_fsdp_model_from_checkpoint,
+    init_model_from_checkpoint_for_evals,
+    keep_checkpoint_copy,
+    keep_last_n_checkpoints,
+    load_checkpoint,
+    register_dont_save_hooks,
+    save_checkpoint,
+)

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/checkpointer/checkpointer.py

@@ -0,0 +1,352 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This software may be used and distributed in accordance with
+# the terms of the DINOv3 License Agreement.
+
+"""
+Suggested file structure:
+
+output_dir/
+|-- ckpt/
+|   |-- 0/
+|   |-- 99/
+|   |-- 199/
+|   |-- 199_keep/
+|   |-- 299/
+|   `-- ...
+`-- eval/
+    `-- 0/
+    `-- 99/
+        `-- ckpt/
+
+Distributed checkpointer docs:
+- https://pytorch.org/tutorials/recipes/distributed_checkpoint_recipe.html
+- https://pytorch.org/docs/stable/distributed.checkpoint.html
+"""
+
+import logging
+import shutil
+import subprocess
+import tempfile
+from enum import Enum
+from pathlib import Path
+from typing import List, Sequence, Set
+
+import torch
+import torch.distributed as dist
+import torch.distributed.checkpoint as dcp
+import torch.distributed.checkpoint.filesystem as dcpfs
+import torch.distributed.checkpoint.state_dict as dcpsd
+from torch.distributed.checkpoint.stateful import Stateful
+
+logger = logging.getLogger("dinov3")
+
+
+class CheckpointRetentionPolicy(Enum):
+    ALL = "all"  # keep all checkpoints
+    BEST = "best"
+    LAST = "last"
+    LAST_AND_BEST = "last_and_best"
+    NONE = "none"  # do not keep any checkpoints
+
+    @property
+    def keep_filters(self) -> Set[str]:
+        """Files that match these patterns are not deleted by cleanup"""
+        if self == CheckpointRetentionPolicy.LAST:
+            return set(["final"])
+        if self == CheckpointRetentionPolicy.BEST:
+            return set(["best"])
+        if self == CheckpointRetentionPolicy.LAST_AND_BEST:
+            return set(["final", "best"])
+        if self == CheckpointRetentionPolicy.ALL:
+            return set()
+        return set()
+
+    @property
+    def max_to_keep(self) -> int | None:
+        """
+        maximum "periodic" checkpoints to keep concurrently, ie. saved with `step` and not `save`. `None` for keep all
+        """
+        if self == CheckpointRetentionPolicy.ALL:
+            return None
+        return 1
+
+
+def save_checkpoint(
+    ckpt_dir: str | Path,  # output_dir/ckpt/199
+    *,
+    iteration: int | str,
+    model: torch.nn.Module,
+    optimizer: torch.optim.Optimizer | None = None,
+    overwrite: bool = True,
+    process_group: dist.ProcessGroup = None,
+    **others: Stateful,
+):
+    """Save a plain/DDP/FSDP/FSDP2 model, its optimizer, an integer iteration and other stateful objects."""
+    rank = torch.distributed.get_rank(group=process_group)
+
+    # Rank 0 checks if the checkpoint directory exists, but all ranks need to know if if exists,
+    # so they can raise an error when overwrite is False. If overwrite is True, rank 0 will delete it
+    # and other ranks wait for the deletion to finish.
+    ckpt_dir = Path(ckpt_dir)
+    ckpt_dir_exists = [ckpt_dir.exists() if rank == 0 else None]
+    src_rank = 0
+    if process_group is not None:
+        src_rank = torch.distributed.get_global_rank(group=process_group, group_rank=0)
+    torch.distributed.broadcast_object_list(ckpt_dir_exists, src=src_rank, group=process_group)
+    ckpt_dir_exists = ckpt_dir_exists[0]
+    if ckpt_dir_exists:
+        if overwrite:
+            if rank == 0:
+                if ckpt_dir.is_dir():
+                    shutil.rmtree(ckpt_dir)
+                else:
+                    ckpt_dir.unlink()
+                logger.info(f"Deleted: {ckpt_dir}")
+            torch.distributed.barrier(group=process_group)
+        else:
+            raise RuntimeError(f"Checkpoint already exists: {ckpt_dir}")
+
+    # Rank 0 creates a temporary directory for the checkpoint and broadcasts the name to all ranks.
+    ckpt_dir.parent.mkdir(parents=True, exist_ok=True)
+    ckpt_dir_tmp = [tempfile.mkdtemp(dir=ckpt_dir.parent, prefix=ckpt_dir.name) if rank == 0 else None]
+    torch.distributed.broadcast_object_list(ckpt_dir_tmp, src=src_rank, group=process_group)
+    ckpt_dir_tmp = Path(ckpt_dir_tmp[0])
+
+    to_save = {"iteration": iteration}
+    to_save["model"] = dcpsd.get_model_state_dict(model)
+    if optimizer is not None:
+        to_save["optimizer"] = dcpsd.get_optimizer_state_dict(model, optimizer)
+    to_save.update(others)
+    dcp.save(
+        to_save,
+        storage_writer=dcpfs.FileSystemWriter(ckpt_dir_tmp),
+        process_group=process_group,
+    )
+
+    # Rank 0 renames the temporary directory to the final checkpoint directory. All ranks wait for the rename.
+    if rank == 0:
+        ckpt_dir_tmp.rename(ckpt_dir)
+    torch.distributed.barrier()
+
+    logger.info(f"Saved: {ckpt_dir}")
+
+
+def load_checkpoint(
+    ckpt_dir: str | Path,  # output_dir/ckpt/199
+    *,
+    model: torch.nn.Module,
+    optimizer: torch.optim.Optimizer | None = None,
+    strict_loading: bool = True,
+    process_group: dist.ProcessGroup = None,
+    **others: Stateful,
+) -> int | None:
+    """
+    Load a plain/DDP/FSDP/FSDP2 model, its optimizer, an integer iteration and other stateful objects.
+    Can you take a checkpoint saved on N ranks and load it on M ranks? Sure you can!
+    Activation checkpointing and torch-compile can also be different between save and load, no problem.
+    """
+    ckpt_dir = Path(ckpt_dir)
+    to_load = {"iteration": None}
+    to_load["model"] = dcpsd.get_model_state_dict(model)
+    if optimizer is not None:
+        to_load["optimizer"] = dcpsd.get_optimizer_state_dict(model, optimizer)
+    to_load.update(others)
+    dcp.load(
+        to_load,
+        storage_reader=dcpfs.FileSystemReader(ckpt_dir),
+        planner=dcp.default_planner.DefaultLoadPlanner(allow_partial_load=not strict_loading),
+        process_group=process_group,
+    )
+    iteration = to_load["iteration"]
+    dcpsd.set_model_state_dict(model, to_load["model"])
+    if optimizer is not None:
+        dcpsd.set_optimizer_state_dict(model, optimizer, to_load["optimizer"])
+    logger.info(f"Loaded: {ckpt_dir}")
+    return iteration
+
+
+def register_dont_save_hooks(module: torch.nn.Module, dont_save: Sequence[str]):
+    """
+    Registers save/load state dict hooks such that the weights in `dont_save` are not persisted in the checkpoint.
+
+    Typical use case: a classification model composed of a frozen backbone and a trainable head.
+    If the frozen backbone is loaded from torch hub, it does't make sense to save a copy of it in each checkpoint.
+    """
+
+    def state_dict_post_hook(module, state_dict, prefix, local_metadata):
+        # Remove frozen weights so they won't get saved.
+        # If this module is not the top-level module, its weights will have a prefix in the state dict.
+        nonlocal _dont_save
+        for k in _dont_save:
+            del state_dict[prefix + k]
+
+    def load_state_dict_pre_hook(
+        module,
+        state_dict,
+        prefix,
+        local_metadata,
+        strict,
+        missing_keys,
+        unexpected_keys,
+        error_msgs,
+    ):
+        # This pre hook exists only to pass the prefix to the post hook when loading the state dict.
+        nonlocal _prefix
+        assert _prefix is None
+        _prefix = prefix
+
+    def load_state_dict_post_hook(module, incompatible_keys):
+        # Remove the frozen weights from the missing keys so they don't raise an error.
+        nonlocal _prefix
+        assert _prefix is not None
+        to_remove = []
+        for missing_key in incompatible_keys.missing_keys:
+            k = missing_key.removeprefix(_prefix)
+            k = k.replace("_checkpoint_wrapped_module.", "")  # Added by activation checkpointing
+            if k in _dont_save:
+                to_remove.append(missing_key)
+        for r in to_remove:
+            incompatible_keys.missing_keys.remove(r)
+        _prefix = None
+
+    _dont_save = set(name.replace("_checkpoint_wrapped_module.", "") for name in dont_save)
+    _prefix = None
+    module.register_state_dict_post_hook(state_dict_post_hook)
+    module.register_load_state_dict_pre_hook(load_state_dict_pre_hook)
+    module.register_load_state_dict_post_hook(load_state_dict_post_hook)
+
+
+def find_all_checkpoints(ckpt_dir: Path | str) -> list[Path]:
+    """Find all checkpoints in a directory, i.e. subdirs with integer name. Sorted from first to last."""
+    ckpt_dir = Path(ckpt_dir)
+    if not ckpt_dir.is_dir():
+        return []
+    checkpoints = [p for p in ckpt_dir.iterdir() if p.is_dir() and _is_int(p.name)]
+    checkpoints.sort(key=lambda p: int(p.name))
+    return checkpoints
+
+
+def find_latest_checkpoint(ckpt_dir: Path | str) -> Path | None:
+    """Find the latest checkpoint in a directory, i.e. the subdir with the highest integer name."""
+    checkpoints = find_all_checkpoints(ckpt_dir)
+    if len(checkpoints) == 0:
+        return None
+    return checkpoints[-1]
+
+
+def keep_last_n_checkpoints(ckpt_dir: Path | str, n: int | None):
+    """In a directory with integer-named subdirs, keep only the n subdirs with the highest number."""
+    if n is None:
+        return
+    checkpoints = find_all_checkpoints(ckpt_dir)
+    for ckpt_dir in checkpoints[:-n]:
+        try:
+            shutil.rmtree(ckpt_dir)
+            logger.info(f"Deleted: {ckpt_dir}")
+        except Exception:
+            logger.exception(f"Failed to delete: {ckpt_dir}")
+
+
+def keep_checkpoint_copy(src: Path | str):
+    """Copy a file/directory next to itself with a _keep suffix. Files are hardlinked."""
+    src = Path(src)
+    dst = src.parent / f"{src.name}_keep"
+    subprocess.check_output(["cp", "--recursive", "--link", src, dst])
+    logger.info(f"Copied: {src} -> {dst}")
+
+
+def _is_int(s: str) -> bool:
+    try:
+        int(s)
+        return True
+    except ValueError:
+        return False
+
+
+# Initialize a FSDP2 model from DCP or PyTorch standard checkpoint
+def init_fsdp_model_from_checkpoint(
+    model: torch.nn.Module,
+    checkpoint_path: str,
+    skip_load_keys: List[str] | None = None,
+    keys_not_sharded: List[str] | None = None,
+    process_group: dist.ProcessGroup = None,
+):
+    if not Path(checkpoint_path).is_dir():  # PyTorch standard checkpoint
+        logger.info(f"Loading pretrained weights from {checkpoint_path}")
+        chkpt = torch.load(checkpoint_path, map_location="cpu")["teacher"]
+        from torch.distributed.device_mesh import DeviceMesh, init_device_mesh
+
+        if process_group is None:
+            world_mesh = init_device_mesh(
+                "cuda",
+                mesh_shape=(dist.get_world_size(),),
+                mesh_dim_names=("dp",),
+            )
+        else:
+            world_mesh = DeviceMesh.from_group(process_group, "cuda")
+        chkpt = {
+            key: (
+                torch.distributed.tensor.distribute_tensor(tensor, world_mesh, src_data_rank=None)
+                if not any(key_not_sharded in key for key_not_sharded in keys_not_sharded)
+                else tensor
+            )
+            for key, tensor in chkpt.items()
+        }
+        model.load_state_dict(
+            {
+                key: tensor
+                for key, tensor in chkpt.items()
+                if not any(skip_load_key in key for skip_load_key in skip_load_keys)
+            }
+        )
+    else:  # DCP checkpoint
+        load_checkpoint(ckpt_dir=checkpoint_path, model=model, process_group=process_group)
+
+
+# Initialize a standard non distributed PyTorch model from PyTorch standard checkpoint for evals
+def init_model_from_checkpoint_for_evals(
+    model: torch.nn.Module, pretrained_weights: str | Path, checkpoint_key: str = None
+):
+    state_dict = torch.load(pretrained_weights, map_location="cpu")
+    if checkpoint_key is not None and checkpoint_key in state_dict:
+        logger.info(f"Take key {checkpoint_key} in provided checkpoint dict")
+        state_dict = state_dict[checkpoint_key]
+    # remove `module.` prefix
+    state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()}
+    # remove `backbone.` prefix induced by multicrop wrapper
+    state_dict = {k.replace("backbone.", ""): v for k, v in state_dict.items()}
+    msg = model.load_state_dict(state_dict, strict=False)
+    logger.info("Pretrained weights found at {} and loaded with msg: {}".format(pretrained_weights, msg))
+
+
+def cleanup_checkpoint(ckpt_dir: str, checkpoint_retention_policy: CheckpointRetentionPolicy):
+    """
+    ckpt_dir is the directory containing each individual checkpoint directories (either at iteration, best (validation performance) or final)
+    |-- ckpt_dir/
+    |   |-- 0/
+    |       |--checkpoint.pth  or dcp_sharded_checkpoint_dir
+    |   |-- 99/
+            |--checkpoint.pth or dcp_sharded_checkpoint_dir
+    |   |-- 199/
+            |--checkpoint.pth or dcp_sharded_checkpoint_dir
+    |   |-- best/
+            |--checkpoint.pth or dcp_sharded_checkpoint_dir
+    |   |-- 299/
+            |--checkpoint.pth or dcp_sharded_checkpoint_dir
+    |   |-- final/
+            |--checkpoint.pth or dcp_sharded_checkpoint_dir
+    """
+    ckpt_dir = Path(ckpt_dir)
+    if not ckpt_dir.is_dir():
+        return []
+    checkpoint_filters = checkpoint_retention_policy.keep_filters
+    checkpoints = [p for p in ckpt_dir.iterdir() if p.is_dir()]
+    for checkpoint in checkpoints:
+        if checkpoint in checkpoint_filters:
+            continue
+        try:
+            shutil.rmtree(checkpoint)
+            logger.info(f"Deleted: {checkpoint}")
+        except Exception:
+            logger.exception(f"Failed to delete: {checkpoint}")

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This software may be used and distributed in accordance with
+# the terms of the DINOv3 License Agreement.
+
+from .config import (
+    DinoV3SetupArgs,
+    apply_scaling_rules_to_cfg,
+    exit_job,
+    get_cfg_from_args,
+    get_default_config,
+    setup_config,
+    setup_job,
+    setup_multidistillation,
+    write_config,
+)

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/config.py

@@ -0,0 +1,222 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This software may be used and distributed in accordance with
+# the terms of the DINOv3 License Agreement.
+
+import logging
+import math
+import os
+import pathlib
+import sys
+from dataclasses import dataclass, field
+from datetime import timedelta
+from typing import Any, List, Optional, Sequence, Tuple
+
+from omegaconf import DictConfig, OmegaConf
+
+import dinov3.distributed as distributed
+from dinov3.logging import cleanup_logging, setup_logging
+from dinov3.utils import fix_random_seeds, get_conda_env, get_sha
+
+logger = logging.getLogger("dinov3")
+
+
+@dataclass
+class DinoV3SetupArgs:
+    config_file: str
+    pretrained_weights: str | None = None
+    shard_unsharded_model: bool = False
+    output_dir: str = ""
+    opts: List[Any] = field(default_factory=lambda: [])
+
+    def __post_init__(self):
+        # When loaded from benchmark.yaml, self.opts is a frozen omegaconf.ListConfig,
+        # which works everywhere except when we want to modify it or when
+        # we try to json-serialize it. So we convert it to a regular list here.
+        if OmegaConf.is_config(self.opts):
+            self.opts = OmegaConf.to_object(self.opts)
+
+
+def apply_scaling_rules_to_cfg(cfg):  # to fix
+    assert distributed.is_enabled(), "Setup distributed to get global size !"
+    if "schedules" in cfg:
+        # For schedules v2, the scaling rules are applied when building the schedules, the config is not modified
+        return cfg
+
+    if cfg.optim.scaling_rule == "linear_wrt_256":
+        old_lr = cfg.optim.lr
+        cfg.optim.lr *= cfg.train.batch_size_per_gpu * distributed.get_world_size() / 256.0
+        logger.info(f"linear scaling learning rate; old: {old_lr}, new: {cfg.optim.lr}")
+    elif cfg.optim.scaling_rule == "sqrt_wrt_1024":
+        old_lr = cfg.optim.lr
+        cfg.optim.lr *= 4 * math.sqrt(cfg.train.batch_size_per_gpu * distributed.get_world_size() / 1024.0)
+        logger.info(f"sqrt scaling learning rate; old: {old_lr}, new: {cfg.optim.lr}")
+    return cfg
+
+
+def write_config(cfg, output_dir, name="config.yaml"):
+    logger.info(OmegaConf.to_yaml(cfg))
+    output_dir = os.path.abspath(output_dir)
+    saved_cfg_path = os.path.join(output_dir, name)
+    with open(saved_cfg_path, "w") as f:
+        OmegaConf.save(config=cfg, f=f)
+    return saved_cfg_path
+
+
+def get_default_config() -> DictConfig:
+    p = pathlib.Path(__file__).parent / "ssl_default_config.yaml"
+    return OmegaConf.load(p)
+
+
+def get_cfg_from_args(args: DinoV3SetupArgs, multidistillation=False, strict=True):
+    overrides = [*args.opts]
+    if args.output_dir is not None:
+        overrides.append(f"train.output_dir={os.path.realpath(args.output_dir)}")
+
+    # Config file
+    cfg = OmegaConf.load(args.config_file)
+
+    # Command line overrides
+    opts_cfg = OmegaConf.from_cli(overrides)
+
+    if multidistillation:
+        cfg = OmegaConf.merge(cfg, opts_cfg)
+    else:
+        # Default config
+        default_cfg = get_default_config()
+        if strict:
+            OmegaConf.set_struct(default_cfg, True)
+        cfg = OmegaConf.merge(default_cfg, cfg, opts_cfg)
+    return cfg
+
+
+def setup_config(args: DinoV3SetupArgs, strict_cfg=True):
+    """
+    Create configs and perform basic setups.
+    """
+    # Create the cfg with OmegaConf
+    cfg = get_cfg_from_args(args, strict=strict_cfg)
+    # setup distributed, logging, and random seeds
+    logger.info("\n".join("%s: %s" % (k, str(v)) for k, v in sorted(dict(vars(args)).items())))
+    # dump config before modifying so it can be reloaded
+    if args.output_dir is not None:
+        write_config(cfg, args.output_dir)
+    # modify the config inplace by applying scaling rules
+    apply_scaling_rules_to_cfg(cfg)
+    return cfg
+
+
+def _enumerate_all_subgroup_ranks(all_subgroup_rank_spans: Sequence[Tuple[int, int]]):
+    """Expands a specification of process subgroups from spans to enumerated ranks.
+
+    Args:
+       all_group_rank_spans: a sequence of rank spans (first rank, last rank),
+           one for each process group. Example: ((0, 1), (2, 3), (4, 7)).
+    """
+    for first, last in all_subgroup_rank_spans:
+        assert first <= last
+    return tuple(tuple(range(first, last + 1)) for first, last in all_subgroup_rank_spans)
+
+
+def setup_multidistillation(args: DinoV3SetupArgs):
+    base_output_dir = args.output_dir
+    os.makedirs(args.output_dir, exist_ok=True)
+    # get config file for this rank
+    base_cfg = OmegaConf.load(args.config_file)
+    assert base_cfg.multidistillation.enabled
+
+    global_batch_size = base_cfg.multidistillation.global_batch_size
+
+    distributed.enable(overwrite=True)
+    seed = getattr(args, "seed", 0)
+    rank = distributed.get_rank()
+
+    # build process subgroups
+    all_subgroup_rank_spans = tuple(
+        (student.ranks_range[0], student.ranks_range[1] - 1) for student in base_cfg.multidistillation.students
+    )
+    all_subgroup_ranks = _enumerate_all_subgroup_ranks(all_subgroup_rank_spans)
+    distributed.new_subgroups(all_subgroup_ranks)
+
+    found = False
+    for student in base_cfg.multidistillation.students:
+        if rank in range(*student.ranks_range):
+            found = True
+            break
+    assert found, "rank of worker not in defined range"
+
+    name = student.name
+    config_path = student.config_path
+    n_gpus = student.ranks_range[1] - student.ranks_range[0]
+    assert global_batch_size % n_gpus == 0
+    total_n_gpus = distributed.get_world_size()
+
+    args.output_dir = os.path.join(base_output_dir, name)
+    args.opts += [f"train.output_dir={args.output_dir}"]
+    args.opts += [f"train.batch_size_per_gpu={global_batch_size // total_n_gpus}"]
+    args.config_file = os.path.abspath(config_path)
+    default_cfg = get_default_config()
+    cfg = OmegaConf.load(args.config_file)
+    cfg = OmegaConf.merge(default_cfg, cfg, base_cfg, OmegaConf.from_cli(args.opts))
+
+    global logger
+    setup_logging(output=args.output_dir, level=logging.INFO)
+
+    fix_random_seeds(seed + rank)
+
+    write_config(cfg, args.output_dir)
+    apply_scaling_rules_to_cfg(cfg)
+
+    return cfg
+
+
+def setup_job(
+    output_dir: Optional[str] = None,
+    distributed_enabled: bool = True,
+    logging_enabled: bool = True,
+    seed: Optional[int] = 0,
+    restrict_print_to_main_process: bool = True,
+    distributed_timeout: timedelta | None = None,
+):
+    """
+    Setup methods that should be done in every fairvit job
+    Initializes logging, distributed, random seeds and other utilities.
+    """
+    if output_dir is not None:
+        output_dir = os.path.realpath(output_dir)
+        os.makedirs(output_dir, exist_ok=True)
+
+    if logging_enabled:
+        setup_logging(
+            output=output_dir,
+            level=logging.INFO,
+            log_to_stdout_only_in_main_process=restrict_print_to_main_process,
+        )
+
+    if distributed_enabled:
+        distributed.enable(
+            overwrite=True,
+            nccl_async_error_handling=True,
+            restrict_print_to_main_process=restrict_print_to_main_process,
+            timeout=distributed_timeout,
+        )
+
+    if seed is not None:
+        rank = distributed.get_rank()
+        fix_random_seeds(seed + rank)
+
+    logger = logging.getLogger("dinov3")
+    logger.info("git:\n  {}\n".format(get_sha()))
+
+    # Log some python info
+    conda_env_name, conda_env_path = get_conda_env()
+    logger.info(f"conda env name: {conda_env_name}")
+    logger.info(f"conda env path: {conda_env_path}")
+    logger.info(f"python path: {sys.path}")
+
+
+def exit_job(distributed_enabled: bool = True, logging_enabled: bool = True):
+    if distributed_enabled:
+        distributed.disable()
+    if logging_enabled:
+        cleanup_logging()

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/ssl_default_config.yaml

@@ -0,0 +1,205 @@
+MODEL:
+  META_ARCHITECTURE: SSLMetaArch
+  DEVICE: cuda
+  WEIGHTS: ''
+  DTYPE: float32
+compute_precision:
+  param_dtype: bf16
+  reduce_dtype: fp32
+  sharding_strategy: SHARD_GRAD_OP
+dino:
+  loss_weight: 1.0
+  global_ignore_diagonal: true  # Whether to ignore A-A and B-B global pairs, default as in DINOv2, ignored by SSLMetaArch
+  head_n_prototypes: 65536
+  head_bottleneck_dim: 256
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 2048
+  koleo_loss_weight: 0.1
+  koleo_loss_distributed: false
+  koleo_topk: 1
+  koleo_distributed_replicas: 0
+  koleo_distributed_loss_group_size: null  # Size of the nearest neighbor set for distributed Koleo. If None, uses global batch size.
+  koleo_distributed_loss_group_data: true # group data from adjacent ranks to make sure koleo is applied on the same data distribution
+  force_weight_norm: false
+  reweight_dino_local_loss: false # If true, reweighting of DINO loss
+  local_loss_weight_schedule:  # Schedule for local loss weight, enabled if reweight_dino_local_loss is true
+    start: 0.5
+    peak: 0.5
+    end: 0.5
+    warmup_epochs: 0
+ibot:
+  loss_weight: 1.0
+  mask_sample_probability: 0.5
+  mask_ratio_min_max:
+  - 0.1
+  - 0.5
+  mask_random_circular_shift: false
+  force_masking_even_with_zero_weight: False
+  separate_head: true
+  head_n_prototypes: 65536
+  head_bottleneck_dim: 256
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 2048
+gram:
+  use_loss: false # (bool) if true gram is used, else not
+  compute_stats: false # (bool): if true compute auxilliary stats
+  loss_weight: 1.0 # (float): weight of the loss
+  ema_teacher: false # (bool): using the EMA teacher as GRAM teacher
+  ckpt: null  #(str): Checkpoint to the teacher
+  it_load_ema_teacher: -1 # (int): iteration at which the ema teacher is loaded into the gram teacher
+  rep_update: true # (bool): if true GRAM teacher updated every gram.update_frequency after iter gram.it_first_update steps
+  update_frequency: 50000 # (int): update frequency
+  it_first_update: 0 # (int): iteration of the first update
+  max_updates: null # (int): maximum number of updates to gram teacher. If None, it is unlimited
+  normalized: true # (bool): normalization of the features
+  img_level: false # (bool): if true GRAM computation at the image else, otherwise at the local batch level
+  remove_neg: false # (bool): if true remove the negative similarities before applying the loss
+  remove_only_teacher_neg: false # (bool): remove negative similarities of the teacher
+  tokens_used: all # (str): In [all, masked, unmasked]
+  global_teacher_resize_method: bicubic  # Method for resizing the outputs of the gram teacher
+  global_teacher_resize_antialias: false  # Whether to use antialiasing when resizing the outputs of the gram teacher
+  loss_weight_schedule: null  # (dict): If not None, use a schedule for the loss weight instead of `loss_weight`
+train:
+  batch_size_per_gpu: 64
+  dataset_path: ImageNet:split=TRAIN
+  data_config: null
+  output_dir: .
+  saveckp_freq: 20
+  seed: 0
+  num_workers: 10
+  OFFICIAL_EPOCH_LENGTH: 1250
+  monitor_gradient_norm: false
+  chunk_schedule: []
+  use_teacher_head: true
+  learn_from_teacher_tokens: false
+  centering: "sinkhorn_knopp" # or "sinkhorn_knopp"
+  checkpointing: false
+  checkpointing_full: false  # aggressive checkpointing
+  compile: true
+  cudagraphs: false
+  sharded_eval_checkpoint: false
+  cache_dataset: false
+student:
+  arch: vit_large
+  patch_size: 16
+  drop_path_rate: 0.3
+  layerscale: 1.0e-05
+  pretrained_weights: ''
+  ffn_layer: "mlp"
+  ffn_ratio: 4.0
+  resume_from_teacher_chkpt: ""
+  qkv_bias: true
+  proj_bias: true
+  ffn_bias: true
+  norm_layer: "layernorm"
+  n_storage_tokens: 0
+  mask_k_bias: false
+  untie_cls_and_patch_norms: false  # If true, use separate norms for CLS/reg and patch/mask tokens
+  untie_global_and_local_cls_norm: false  # If true, use separate norms for local and global crop CLS token during training
+  in_chans: 3
+  pos_embed_type: rope
+  pos_embed_rope_base: 100.0
+  pos_embed_rope_min_period: null
+  pos_embed_rope_max_period: null
+  pos_embed_rope_normalize_coords: separate  # min, max, separate
+  pos_embed_rope_shift_coords: null
+  pos_embed_rope_jitter_coords: null
+  pos_embed_rope_rescale_coords: null
+  pos_embed_rope_dtype: bf16
+  fp8_enabled: False  # Convert Linear layers to operate in fp8 precision
+  fp8_filter: "blocks"  # Regex that must appear in module path; empty means everything
+teacher:
+  momentum_teacher: 0.992
+  final_momentum_teacher: 1
+  warmup_teacher_temp: 0.04
+  teacher_temp: 0.07
+  warmup_teacher_temp_epochs: 30
+  in_chans: 3
+distillation:  # teacher
+  enabled: false
+  full_cfg_path: ""
+  checkpoint_path: ""
+multidistillation:
+  enabled: false
+hrft:  # non-hrft'd student
+  enabled: false
+  checkpoint_path: ""  # teacher_checkpoint path
+optim:
+  epochs: 100
+  optimizer: adamw
+  weight_decay: 0.04
+  weight_decay_end: 0.4
+  lr: 0.001
+  warmup_epochs: 10
+  min_lr: 1.0e-06
+  schedule_trunc_extra: 0.0  # Compute the schedule for (1 + schedule_trunc_extra) steps and truncate, .25 is a good choice
+  clip_grad: 3.0
+  freeze_last_layer_epochs: 1
+  scaling_rule: sqrt_wrt_1024
+  patch_embed_lr_mult: 0.2
+  dino_head_wd_multiplier: 1.0
+  layerwise_decay: 0.9
+  multi_tensor_optim: true
+  dump_fsdp_weights_path: ""
+  adamw_beta1: 0.9
+  adamw_beta2: 0.999
+crops:
+  global_crops_scale:
+  - 0.32
+  - 1.0
+  local_crops_number: 8
+  local_crops_scale:
+  - 0.05
+  - 0.32
+  global_crops_size: 224
+  local_crops_size: 96
+  global_local_crop_pairs_ratios: 1.0
+  gram_teacher_crops_size: null  # If not None, return crops for gram teacher
+  localcrops_subset_of_globalcrops: false
+  share_color_jitter: false
+  horizontal_flips: true
+  gram_teacher_no_distortions: false  # If True, no distortions are applied to gram teacher crops
+  rgb_mean:
+  - 0.485
+  - 0.456
+  - 0.406
+  rgb_std:
+  - 0.229
+  - 0.224
+  - 0.225
+evaluation:
+  eval_period_iterations: 12500
+  low_freq_every: 5
+  config_files:  # Must be in fairvit/eval/configs
+    high_freq: benchmark_high_frequency.yaml  # More often
+    low_freq: benchmark_low_frequency.yaml  # Less often
+checkpointing:
+  period: 3750
+  max_to_keep: 3
+  keep_every: 99999999999999999  # Save a checkpoint every N iterations, regardless of max_to_keep and period
+
+# Example of constant schedules with schedules v2
+# # schedules:
+# #   lr:
+# #     start: 0.0
+# #     peak: 1e-3
+# #     end: 1e-6
+# #     warmup_epochs: 10
+# #     freeze_last_layer_epochs: 1
+# #   weight_decay:
+# #     start: 0.04
+# #     peak: 0.04
+# #     end: 0.04
+# #     warmup_epochs: 0
+# #   momentum:
+# #     start: 0.992
+# #     peak: 0.992
+# #     end: 0.992
+# #     warmup_epochs: 0
+# #   teacher_temp:
+# #     start: 0.04
+# #     peak: 0.07
+# #     end: 0.07
+# #     warmup_epochs: 30

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/train/dinov3_vit7b16_gram_anchor.yaml

@@ -0,0 +1,203 @@
+MODEL:
+  META_ARCHITECTURE: SSLMetaArch
+  DEVICE: cuda
+  WEIGHTS: ''
+  DTYPE: float32
+compute_precision:
+  param_dtype: bf16
+  reduce_dtype: fp32
+  sharding_strategy: SHARD_GRAD_OP
+dino:
+  loss_weight: 1.0
+  global_ignore_diagonal: true
+  head_n_prototypes: 262144
+  head_bottleneck_dim: 512
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 8192
+  koleo_loss_weight: 0.1
+  koleo_loss_distributed: false
+  koleo_topk: 1
+  koleo_distributed_replicas: 0
+  koleo_distributed_loss_group_size: null
+  koleo_distributed_loss_group_data: true
+  force_weight_norm: false
+  reweight_dino_local_loss: true
+  local_loss_weight_schedule:
+    start: 1
+    peak: 1
+    end: 0.5
+    warmup_epochs: 1000
+    cosine_epochs: 1
+ibot:
+  loss_weight: 1.0
+  mask_sample_probability: 0.5
+  mask_ratio_min_max:
+  - 0.1
+  - 0.5
+  mask_random_circular_shift: false
+  force_masking_even_with_zero_weight: false
+  separate_head: true
+  head_n_prototypes: 98304
+  head_bottleneck_dim: 384
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 4096
+gram:
+  use_loss: true
+  compute_stats: false
+  loss_weight: 1.0
+  ema_teacher: false
+  ckpt: ignore
+  it_load_ema_teacher: -1
+  rep_update: true
+  update_frequency: 10000
+  it_first_update: 1010000
+  max_updates: 3
+  normalized: true
+  img_level: true
+  remove_neg: false
+  remove_only_teacher_neg: false
+  tokens_used: all
+  global_teacher_resize_method: bicubic
+  global_teacher_resize_antialias: false
+  loss_weight_schedule:
+    start: 0
+    peak: 0
+    end: 2.0
+    warmup_epochs: 1000
+    cosine_epochs: 1
+train:
+  batch_size_per_gpu: 16
+  dataset_path: null
+  saveckp_freq: 20
+  seed: 0
+  num_workers: 10
+  OFFICIAL_EPOCH_LENGTH: 1000
+  monitor_gradient_norm: false
+  chunk_schedule: []
+  cache_dataset: true
+  use_teacher_head: true
+  learn_from_teacher_tokens: false
+  centering: sinkhorn_knopp
+  checkpointing: true
+  checkpointing_full: true
+  compile: true
+  cudagraphs: false
+  cell_augmentation: false
+  cell_augmentation_type: hpa
+  sharded_eval_checkpoint: true
+student:
+  arch: vit_7b
+  patch_size: 16
+  drop_path_rate: 0.4
+  layerscale: 1.0e-05
+  patch_drop: 0.0
+  pretrained_weights: ''
+  ffn_layer: swiglu64
+  ffn_ratio: 3
+  resume_from_teacher_chkpt: ''
+  qkv_bias: false
+  proj_bias: true
+  ffn_bias: true
+  norm_layer: layernormbf16
+  n_storage_tokens: 4
+  untie_cls_and_patch_norms: false
+  untie_global_and_local_cls_norm: true
+  mask_k_bias: true
+  in_chans: 3
+  pos_embed_type: rope
+  pos_embed_rope_base: 100
+  pos_embed_rope_min_period: null
+  pos_embed_rope_max_period: null
+  pos_embed_rope_normalize_coords: separate
+  pos_embed_rope_shift_coords: null
+  pos_embed_rope_jitter_coords: null
+  pos_embed_rope_rescale_coords: 2
+  pos_embed_rope_dtype: fp32
+  fp8_enabled: true
+  fp8_filter: blocks
+teacher:
+  momentum_teacher: null
+  final_momentum_teacher: null
+  warmup_teacher_temp: null
+  teacher_temp: null
+  warmup_teacher_temp_epochs: null
+  in_chans: 3
+distillation:
+  enabled: false
+  full_cfg_path: ''
+  checkpoint_path: ''
+multidistillation:
+  enabled: false
+hrft:
+  enabled: false
+  checkpoint_path: ''
+optim:
+  epochs: 1200
+  optimizer: adamw
+  weight_decay: null
+  weight_decay_end: null
+  lr: null
+  warmup_epochs: null
+  min_lr: null
+  schedule_trunc_extra: null
+  clip_grad: 30.0
+  freeze_last_layer_epochs: null
+  scaling_rule: sqrt_wrt_1024
+  patch_embed_lr_mult: 0.2
+  dino_head_wd_multiplier: 1.0
+  layerwise_decay: 0.98
+  multi_tensor_optim: true
+  dump_fsdp_weights_path: ''
+  adamw_beta1: 0.9
+  adamw_beta2: 0.99
+crops:
+  global_crops_scale:
+  - 0.32
+  - 1.0
+  local_crops_number: 8
+  local_crops_scale:
+  - 0.05
+  - 0.32
+  global_crops_size: 256
+  local_crops_size: 112
+  gram_teacher_crops_size: 512
+  localcrops_subset_of_globalcrops: false
+  share_color_jitter: false
+  horizontal_flips: false
+  gram_teacher_no_distortions: true
+  rgb_mean:
+  - 0.485
+  - 0.456
+  - 0.406
+  rgb_std:
+  - 0.229
+  - 0.224
+  - 0.225
+checkpointing:
+  period: 1000
+  max_to_keep: 3
+  keep_every: 50000
+schedules:
+  lr:
+    start: 0
+    peak: 3.0e-05
+    end: 3.0e-05
+    warmup_epochs: 100
+    freeze_last_layer_epochs: 5
+  weight_decay:
+    start: 0.04
+    peak: 0.04
+    end: 0.04
+    warmup_epochs: 0
+  teacher_temp:
+    start: 0.04
+    peak: 0.07
+    end: 0.07
+    warmup_epochs: 100
+  momentum:
+    start: 0.999
+    peak: 0.999
+    end: 0.999
+    warmup_epochs: 0

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/train/dinov3_vit7b16_high_res_adapt.yaml

@@ -0,0 +1,224 @@
+MODEL:
+  META_ARCHITECTURE: SSLMetaArch
+  DEVICE: cuda
+  WEIGHTS: ''
+  DTYPE: float32
+compute_precision:
+  param_dtype: bf16
+  reduce_dtype: fp32
+  sharding_strategy: SHARD_GRAD_OP
+dino:
+  loss_weight: 1.0
+  global_ignore_diagonal: true
+  head_n_prototypes: 262144
+  head_bottleneck_dim: 512
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 8192
+  koleo_loss_weight: 0.1
+  koleo_loss_distributed: true
+  koleo_topk: 1
+  koleo_distributed_replicas: 0
+  koleo_distributed_loss_group_size: 16
+  force_weight_norm: false
+  reweight_dino_local_loss: true
+  local_loss_weight_schedule:
+    start: 0.5
+    peak: 0.5
+    end: 0.5
+    warmup_epochs: 0
+    cosine_epochs: 0
+  koleo_distributed_loss_group_data: true
+ibot:
+  loss_weight: 1.0
+  mask_sample_probability: 0.5
+  mask_ratio_min_max:
+  - 0.1
+  - 0.5
+  mask_random_circular_shift: false
+  force_masking_even_with_zero_weight: false
+  separate_head: true
+  head_n_prototypes: 98304
+  head_bottleneck_dim: 384
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 4096
+gram:
+  use_loss: true
+  compute_stats: false
+  loss_weight: 1.0
+  ema_teacher: false
+  it_load_ema_teacher: -1
+  rep_update: false
+  update_frequency: 10000
+  it_first_update: 1010000
+  max_updates: 3
+  normalized: true
+  img_level: true
+  remove_neg: false
+  remove_only_teacher_neg: false
+  tokens_used: all
+  global_teacher_resize_method: bicubic
+  global_teacher_resize_antialias: false
+  loss_weight_schedule:
+    start: 1.5
+    peak: 1.5
+    end: 1.5
+    warmup_epochs: 0
+    cosine_epochs: 0
+train:
+  batch_size_per_gpu: 8
+  dataset_path: null
+  saveckp_freq: 20
+  seed: 0
+  num_workers: 2
+  OFFICIAL_EPOCH_LENGTH: 1000
+  monitor_gradient_norm: false
+  chunk_schedule: []
+  cache_dataset: true
+  use_teacher_head: true
+  learn_from_teacher_tokens: false
+  centering: sinkhorn_knopp
+  checkpointing: true
+  checkpointing_full: true
+  compile: true
+  cudagraphs: false
+  cell_augmentation: false
+  cell_augmentation_type: hpa
+  sharded_eval_checkpoint: true
+student:
+  arch: vit_7b
+  patch_size: 16
+  drop_path_rate: 0.4
+  layerscale: 1.0e-05
+  patch_drop: 0.0
+  pretrained_weights: ''
+  ffn_layer: swiglu64
+  ffn_ratio: 3
+  resume_from_teacher_chkpt: ''
+  qkv_bias: false
+  proj_bias: true
+  ffn_bias: true
+  norm_layer: layernormbf16
+  n_storage_tokens: 4
+  untie_cls_and_patch_norms: false
+  untie_global_and_local_cls_norm: true
+  mask_k_bias: true
+  in_chans: 3
+  pos_embed_type: rope
+  pos_embed_rope_base: 100
+  pos_embed_rope_min_period: null
+  pos_embed_rope_max_period: null
+  pos_embed_rope_normalize_coords: separate
+  pos_embed_rope_shift_coords: null
+  pos_embed_rope_jitter_coords: null
+  pos_embed_rope_rescale_coords: 2
+  pos_embed_rope_dtype: fp32
+  fp8_enabled: true
+  fp8_filter: blocks
+teacher:
+  momentum_teacher: null
+  final_momentum_teacher: null
+  warmup_teacher_temp: null
+  teacher_temp: null
+  warmup_teacher_temp_epochs: null
+  in_chans: 3
+distillation:
+  enabled: false
+  full_cfg_path: ''
+  checkpoint_path: ''
+multidistillation:
+  enabled: false
+hrft:
+  enabled: false
+  checkpoint_path: ''
+optim:
+  epochs: 30
+  optimizer: adamw
+  weight_decay: null
+  weight_decay_end: null
+  lr: null
+  warmup_epochs: null
+  min_lr: null
+  schedule_trunc_extra: null
+  clip_grad: 30.0
+  freeze_last_layer_epochs: null
+  scaling_rule: sqrt_wrt_1024
+  patch_embed_lr_mult: 0.2
+  dino_head_wd_multiplier: 1.0
+  layerwise_decay: 0.98
+  multi_tensor_optim: true
+  dump_fsdp_weights_path: ''
+  adamw_beta1: 0.9
+  adamw_beta2: 0.99
+crops:
+  global_crops_scale:
+  - 0.32
+  - 1.0
+  local_crops_number: 8
+  local_crops_scale:
+  - 0.05
+  - 0.32
+  global_crops_size:
+  - 512
+  - 768
+  - 768
+  - 768
+  - 768
+  local_crops_size:
+  - 112
+  - 112
+  - 168
+  - 224
+  - 336
+  global_local_crop_pairs_ratios:
+  - 0.3
+  - 0.3
+  - 0.3
+  - 0.05
+  - 0.05
+  gram_teacher_crops_size:
+  - 768
+  - 1152
+  - 1152
+  - 1152
+  - 1152
+  localcrops_subset_of_globalcrops: false
+  share_color_jitter: false
+  horizontal_flips: false
+  gram_teacher_no_distortions: true
+  rgb_mean:
+  - 0.485
+  - 0.456
+  - 0.406
+  rgb_std:
+  - 0.229
+  - 0.224
+  - 0.225
+checkpointing:
+  period: 250
+  max_to_keep: 3
+  keep_every: 50000
+schedules:
+  lr:
+    start: 0
+    peak: 0
+    end: 1.25e-05
+    warmup_epochs: 0
+    freeze_last_layer_epochs: 0
+    cosine_epochs: 10
+  weight_decay:
+    start: 0.04
+    peak: 0.04
+    end: 0.04
+    warmup_epochs: 0
+  teacher_temp:
+    start: 0.07
+    peak: 0.07
+    end: 0.07
+    warmup_epochs: 0
+  momentum:
+    start: 0.999
+    peak: 0.999
+    end: 0.999
+    warmup_epochs: 0

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/train/dinov3_vit7b16_pretrain.yaml

@@ -0,0 +1,172 @@
+MODEL:
+  META_ARCHITECTURE: SSLMetaArch
+  DEVICE: cuda
+  WEIGHTS: ''
+  DTYPE: float32
+compute_precision:
+  param_dtype: bf16
+  reduce_dtype: fp32
+  sharding_strategy: SHARD_GRAD_OP
+dino:
+  loss_weight: 1.0
+  global_ignore_diagonal: true
+  head_n_prototypes: 262144
+  head_bottleneck_dim: 512
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 8192
+  koleo_loss_weight: 0.1
+  koleo_loss_distributed: false
+  koleo_topk: 1
+  koleo_distributed_replicas: 0
+  koleo_distributed_loss_group_size: null
+  force_weight_norm: false
+ibot:
+  loss_weight: 1.0
+  mask_sample_probability: 0.5
+  mask_ratio_min_max:
+  - 0.1
+  - 0.5
+  mask_random_circular_shift: false
+  force_masking_even_with_zero_weight: false
+  separate_head: true
+  head_n_prototypes: 98304
+  head_bottleneck_dim: 384
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 4096
+gram:
+  use_loss: false
+  compute_stats: false
+train:
+  batch_size_per_gpu: 16
+  dataset_path: null
+  saveckp_freq: 20
+  seed: 0
+  num_workers: 10
+  OFFICIAL_EPOCH_LENGTH: 1000
+  monitor_gradient_norm: false
+  chunk_schedule: []
+  cache_dataset: true
+  use_teacher_head: true
+  learn_from_teacher_tokens: false
+  centering: sinkhorn_knopp
+  checkpointing: true
+  checkpointing_full: false
+  compile: true
+  cudagraphs: false
+  cell_augmentation: false
+  cell_augmentation_type: hpa
+  sharded_eval_checkpoint: true
+student:
+  arch: vit_7b
+  patch_size: 16
+  drop_path_rate: 0.4
+  layerscale: 1.0e-05
+  patch_drop: 0.0
+  pretrained_weights: ''
+  ffn_layer: swiglu64
+  ffn_ratio: 3
+  resume_from_teacher_chkpt: ''
+  qkv_bias: false
+  proj_bias: true
+  ffn_bias: true
+  norm_layer: layernormbf16
+  n_storage_tokens: 4
+  untie_cls_and_patch_norms: false
+  untie_global_and_local_cls_norm: true
+  mask_k_bias: true
+  in_chans: 3
+  pos_embed_type: rope
+  pos_embed_rope_base: 100
+  pos_embed_rope_min_period: null
+  pos_embed_rope_max_period: null
+  pos_embed_rope_normalize_coords: separate
+  pos_embed_rope_shift_coords: null
+  pos_embed_rope_jitter_coords: null
+  pos_embed_rope_rescale_coords: 2
+  pos_embed_rope_dtype: fp32
+  fp8_enabled: true
+  fp8_filter: blocks
+teacher:
+  momentum_teacher: null
+  final_momentum_teacher: null
+  warmup_teacher_temp: null
+  teacher_temp: null
+  warmup_teacher_temp_epochs: null
+  in_chans: 3
+distillation:
+  enabled: false
+  full_cfg_path: ''
+  checkpoint_path: ''
+multidistillation:
+  enabled: false
+hrft:
+  enabled: false
+  checkpoint_path: ''
+optim:
+  epochs: 1000
+  optimizer: adamw
+  weight_decay: null
+  weight_decay_end: null
+  lr: null
+  warmup_epochs: null
+  min_lr: null
+  schedule_trunc_extra: null
+  clip_grad: 30.0
+  freeze_last_layer_epochs: null
+  scaling_rule: sqrt_wrt_1024
+  patch_embed_lr_mult: 0.2
+  dino_head_wd_multiplier: 1.0
+  layerwise_decay: 0.98
+  multi_tensor_optim: true
+  dump_fsdp_weights_path: ''
+  adamw_beta1: 0.9
+  adamw_beta2: 0.99
+crops:
+  global_crops_scale:
+  - 0.32
+  - 1.0
+  local_crops_number: 8
+  local_crops_scale:
+  - 0.05
+  - 0.32
+  global_crops_size: 256
+  local_crops_size: 112
+  localcrops_subset_of_globalcrops: false
+  share_color_jitter: false
+  horizontal_flips: false
+  rgb_mean:
+  - 0.485
+  - 0.456
+  - 0.406
+  rgb_std:
+  - 0.229
+  - 0.224
+  - 0.225
+checkpointing:
+  period: 1000
+  max_to_keep: 3
+  keep_every: 50000
+schedules:
+  lr:
+    start: 0
+    peak: 5.0e-05
+    end: 5.0e-05
+    warmup_epochs: 100
+    freeze_last_layer_epochs: 5
+  weight_decay:
+    start: 0.04
+    peak: 0.04
+    end: 0.04
+    warmup_epochs: 0
+  teacher_temp:
+    start: 0.04
+    peak: 0.07
+    end: 0.07
+    warmup_epochs: 100
+  momentum:
+    start: 0.994
+    peak: 0.994
+    end: 0.994
+    warmup_epochs: 0

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/train/dinov3_vitl16_lvd1689m_distilled.yaml

@@ -0,0 +1,251 @@
+MODEL:
+  META_ARCHITECTURE: MultiDistillationMetaArch
+  DEVICE: cuda
+  WEIGHTS: ''
+  DTYPE: float32
+compute_precision:
+  param_dtype: bf16
+  reduce_dtype: fp32
+  sharding_strategy: SHARD_GRAD_OP
+dino:
+  loss_weight: 1.0
+  global_ignore_diagonal: true
+  head_n_prototypes: 262144
+  head_bottleneck_dim: 512
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 8192
+  koleo_loss_weight: 0.1
+  koleo_loss_distributed: false
+  koleo_topk: 1
+  koleo_distributed_replicas: 0
+  koleo_distributed_loss_group_size: null
+  koleo_distributed_loss_group_data: true
+  force_weight_norm: false
+  reweight_dino_local_loss: false
+  local_loss_weight_schedule:
+    start: 0.5
+    peak: 0.5
+    end: 0.5
+    warmup_epochs: 0
+ibot:
+  loss_weight: 1.0
+  mask_sample_probability: 0.5
+  mask_ratio_min_max:
+  - 0.1
+  - 0.5
+  mask_random_circular_shift: false
+  force_masking_even_with_zero_weight: false
+  separate_head: true
+  head_n_prototypes: 98304
+  head_bottleneck_dim: 384
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 4096
+coding_rate_loss:
+  use_cls_loss: false
+  cls_loss_weight: 0.2
+  use_masked_patches_loss: false
+  masked_patches_loss_weight: 0.1
+  epsilon: 8
+gram:
+  use_loss: false
+  compute_stats: false
+  loss_weight: 1.0
+  ema_teacher: false
+  ckpt: null
+  it_load_ema_teacher: -1
+  rep_update: true
+  update_frequency: 50000
+  it_first_update: 0
+  max_updates: null
+  normalized: true
+  img_level: false
+  remove_neg: false
+  remove_only_teacher_neg: false
+  tokens_used: all
+  global_teacher_resize_method: bicubic
+  global_teacher_resize_antialias: false
+  loss_weight_schedule: null
+train:
+  batch_size_per_gpu: 3
+  dataset_path: <TRAIN/DATASET>
+  output_dir: <OUTPUT/DIR>
+  saveckp_freq: 20
+  seed: 0
+  num_workers: 2
+  OFFICIAL_EPOCH_LENGTH: 1250
+  monitor_gradient_norm: false
+  chunk_schedule: []
+  cache_dataset: true
+  use_teacher_head: true
+  learn_from_teacher_tokens: false
+  centering: sinkhorn_knopp
+  checkpointing: true
+  checkpointing_full: true
+  compile: true
+  cudagraphs: false
+  cell_augmentation: false
+  cell_augmentation_type: hpa
+  sharded_eval_checkpoint: false
+student:
+  arch: vit_large
+  patch_size: 16
+  drop_path_rate: 0.0
+  layerscale: 1.0e-05
+  drop_path_uniform: true
+  drop_path_shape: uniform
+  patch_drop: 0.0
+  pretrained_weights: ''
+  sin_cos_embeddings: false
+  fourier_embeddings: false
+  fourier_encoding_dim: 64
+  multiple_pos_embeddings: false
+  cls_pos_embedding: false
+  reg_pos_embedding: false
+  ffn_layer: mlp
+  ffn_ratio: 4.0
+  resume_from_teacher_chkpt: <PATH/TO/HRFT/TEACHER>
+  block_chunks: 0
+  qkv_bias: true
+  proj_bias: true
+  ffn_bias: true
+  norm_layer: layernormbf16
+  n_storage_tokens: 4
+  mask_attention: false
+  mask_register_attention: false
+  untie_cls_and_patch_norms: false
+  untie_global_and_local_cls_norm: false
+  interpolate_offset: 0.0
+  interpolate_antialias: true
+  mask_k_bias: true
+  init_std_cls: 0.02
+  init_std_reg: 0.02
+  rescale_weights_by_layer_id: false
+  in_chans: 3
+  pos_embed_grid_size: 48
+  pos_embed_type: ropenew
+  pos_embed_rope_gamma: 1.0
+  pos_embed_rope_init_multi_frequencies: false
+  pos_embed_rope_base: 100
+  pos_embed_rope_min_period: null
+  pos_embed_rope_max_period: null
+  pos_embed_rope_normalize_coords: separate
+  pos_embed_rope_shift_coords: null
+  pos_embed_rope_jitter_coords: null
+  pos_embed_rope_rescale_coords: 2
+  pos_embed_rope_dtype: bf16
+  sparse24_ranges: []
+  sparse24_filter:
+  - mlp
+  sparse24_default: false
+  fp8_enabled: false
+  fp8_filter: blocks
+teacher:
+  momentum_teacher: 0.994
+  final_momentum_teacher: 1
+  warmup_teacher_temp: 0.04
+  teacher_temp: 0.07
+  warmup_teacher_temp_epochs: 120
+  in_chans: 3
+distillation:
+  enabled: true
+  full_cfg_path: <PATH/TO/TEACHER/CONFIG/config.yaml>
+  checkpoint_path: <PATH/TO/TEACHER/checkpoint.pth>
+multidistillation:
+  enabled: true
+  global_batch_size: 1920
+  students:
+  - name: vits_mlp4_4
+    config_path:  <PATH/TO/STUDENT/CONFIG/vits_mlp4_4.yaml>
+    ranks_range:
+    - 0
+    - 48
+  - name: vitsp_swiglu6_1
+    config_path: <PATH/TO/STUDENT/CONFIG/vitsp_swiglu6_1.yaml>
+    ranks_range:
+    - 48
+    - 96
+  - name: vitb_mlp4_3
+    config_path: <PATH/TO/STUDENT/CONFIG/vitb_mlp4_3.yaml>
+    ranks_range:
+    - 96
+    - 176
+  - name: vitl_mlp4_1
+    config_path:  <PATH/TO/STUDENT/CONFIG/vitl_mlp4_1.yaml>
+    ranks_range:
+    - 176
+    - 296
+hrft:
+  enabled: false
+  checkpoint_path: ''
+optim:
+  epochs: 20
+  optimizer: adamw
+  weight_decay: 0.04
+  weight_decay_end: 0.2
+  lr: 0.0002
+  warmup_epochs: 0
+  min_lr: 1.0e-06
+  schedule_trunc_extra: 0.0
+  clip_grad: 3.0
+  freeze_last_layer_epochs: 0
+  scaling_rule: sqrt_wrt_1024
+  patch_embed_lr_mult: 0.2
+  dino_head_wd_multiplier: 1.0
+  layerwise_decay: 0.99
+  multi_tensor_optim: true
+  dump_fsdp_weights_path: ''
+  adamw_beta1: 0.9
+  adamw_beta2: 0.999
+crops:
+  global_crops_scale:
+  - 0.32
+  - 1.0
+  local_crops_number: 8
+  local_crops_scale:
+  - 0.05
+  - 0.32
+  global_crops_size: 256
+  local_crops_size: 112
+  global_local_crop_pairs_ratios: 1.0
+  gram_teacher_crops_size: 256
+  localcrops_subset_of_globalcrops: false
+  share_color_jitter: false
+  horizontal_flips: false
+  gram_teacher_no_distortions: false
+  rgb_mean:
+  - 0.485
+  - 0.456
+  - 0.406
+  rgb_std:
+  - 0.229
+  - 0.224
+  - 0.225
+checkpointing:
+  period: 3750
+  max_to_keep: 3
+  keep_every: 99999999999999999
+schedules:
+  weight_decay:
+    start: 0.04
+    peak: 0.04
+    end: 0.04
+    warmup_epochs: 0
+  teacher_temp:
+    start: 0.04
+    peak: 0.07
+    end: 0.07
+    warmup_epochs: 0
+  lr:
+    start: 0
+    peak: 0
+    end: 5.0e-05
+    warmup_epochs: 0
+    freeze_last_layer_epochs: 0
+    cosine_epochs: 10
+  momentum:
+    start: 0.994
+    peak: 0.994
+    end: 1.0
+    warmup_epochs: 0

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/train/multi_distillation_test.yaml

@@ -0,0 +1,27 @@
+MODEL:
+  META_ARCHITECTURE: MultiDistillationMetaArch
+multidistillation:
+  enabled: true
+  global_batch_size: 256
+  students:
+  - name: vits
+    config_path: dinov3/configs/train/multidist_tests/vits_p16.yaml
+    ranks_range:
+    - 0
+    - 4
+  - name: vitb
+    config_path: dinov3/configs/train/multidist_tests/vitb_p16.yaml
+    ranks_range:
+    - 4
+    - 8
+distillation:  # teacher
+  enabled: true
+  full_cfg_path: dinov3/configs/train/vitl_im1k_lin834.yaml
+  checkpoint_path: ignore
+train:
+  dataset_path: ImageNet:split=TRAIN
+  cache_dataset: false
+  centering: "sinkhorn_knopp"
+  compile: true
+ibot:
+  separate_head: true

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/train/multidist_tests/vitb_p16.yaml

@@ -0,0 +1,7 @@
+# this corresponds to the default config
+train:
+  dataset_path: ImageNet:split=TRAIN
+  checkpointing: true
+student:
+  drop_path_rate: 0.1
+  arch: vit_base

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/train/multidist_tests/vits_p16.yaml

@@ -0,0 +1,6 @@
+# this corresponds to the default config
+train:
+  dataset_path: ImageNet:split=TRAIN
+student:
+  drop_path_rate: 0.1
+  arch: vit_small

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/configs/train/vitl_im1k_lin834.yaml

@@ -0,0 +1,143 @@
+# tested on RSC: /checkpoint/dino/qas/rope/vitl16_im1k/
+# gives 82.2 im1k-knn, 83.3 im1k-linear
+# runs with a total batch size of 2048 (64/gpu, 4 nodes here)
+# runs at 0.57s/iter
+MODEL:
+  META_ARCHITECTURE: SSLMetaArch
+  DEVICE: cuda
+  WEIGHTS: ''
+  DTYPE: float32
+compute_precision:
+  param_dtype: bf16
+  reduce_dtype: fp32
+  sharding_strategy: SHARD_GRAD_OP
+dino:
+  loss_weight: 1.0
+  global_ignore_diagonal: true
+  head_n_prototypes: 65536
+  head_bottleneck_dim: 256
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 2048
+  koleo_loss_weight: 0.1
+  koleo_loss_distributed: false
+  koleo_topk: 1
+  koleo_distributed_replicas: 0
+  force_weight_norm: false
+ibot:
+  loss_weight: 1.0
+  mask_sample_probability: 0.5
+  mask_ratio_min_max:
+  - 0.1
+  - 0.5
+  mask_random_circular_shift: false
+  force_masking_even_with_zero_weight: false
+  separate_head: true
+  head_n_prototypes: 65536
+  head_bottleneck_dim: 256
+  head_norm_last_layer: false
+  head_nlayers: 3
+  head_hidden_dim: 2048
+train:
+  batch_size_per_gpu: 64
+  dataset_path: ImageNet:split=TRAIN
+  output_dir: /checkpoint/dino/qas/rope/vitl16_im1k
+  saveckp_freq: 20
+  seed: 0
+  num_workers: 10
+  OFFICIAL_EPOCH_LENGTH: 1250
+  monitor_gradient_norm: false
+  chunk_schedule: []
+  cache_dataset: true
+  use_teacher_head: true
+  learn_from_teacher_tokens: false
+  centering: sinkhorn_knopp
+  checkpointing: false
+  compile: true
+  cudagraphs: false
+  cell_augmentation: false
+  cell_augmentation_type: hpa
+student:
+  arch: vit_large
+  patch_size: 16
+  drop_path_rate: 0.3
+  layerscale: 1.0e-05
+  patch_drop: 0.0
+  pretrained_weights: ''
+  ffn_layer: mlp
+  ffn_ratio: 4.0
+  resume_from_teacher_chkpt: ''
+  qkv_bias: true
+  proj_bias: true
+  ffn_bias: true
+  norm_layer: layernorm
+  n_storage_tokens: 0
+  mask_k_bias: false
+  in_chans: 3
+  pos_embed_type: rope
+  pos_embed_rope_base: 100.0
+  pos_embed_rope_min_period: null
+  pos_embed_rope_max_period: null
+  pos_embed_rope_normalize_coords: separate  # min, max, separate
+  pos_embed_rope_shift_coords: null
+  pos_embed_rope_jitter_coords: null
+  pos_embed_rope_rescale_coords: null
+  pos_embed_rope_dtype: bf16
+  fp8_enabled: False  # Convert Linear layers to operate in fp8 precision
+  fp8_filter: "blocks"  # Regex that must appear in module path; empty means everything
+teacher:
+  momentum_teacher: 0.992
+  final_momentum_teacher: 1
+  warmup_teacher_temp: 0.04
+  teacher_temp: 0.07
+  warmup_teacher_temp_epochs: 30
+  in_chans: 3
+distillation:
+  enabled: false
+  full_cfg_path: ''
+  checkpoint_path: ''
+multidistillation:
+  enabled: false
+hrft:
+  enabled: false
+  checkpoint_path: ''
+optim:
+  epochs: 100
+  optimizer: adamw
+  weight_decay: 0.04
+  weight_decay_end: 0.4
+  lr: 0.001
+  warmup_epochs: 10
+  min_lr: 1.0e-06
+  clip_grad: 3.0
+  freeze_last_layer_epochs: 1
+  scaling_rule: sqrt_wrt_1024
+  patch_embed_lr_mult: 0.2
+  dino_head_wd_multiplier: 1.0
+  layerwise_decay: 0.9
+  multi_tensor_optim: true
+  dump_fsdp_weights_path: ''
+  adamw_beta1: 0.9
+  adamw_beta2: 0.999
+crops:
+  global_crops_scale:
+  - 0.32
+  - 1.0
+  local_crops_number: 8
+  local_crops_scale:
+  - 0.05
+  - 0.32
+  global_crops_size: 224
+  local_crops_size: 96
+  localcrops_subset_of_globalcrops: false
+  share_color_jitter: false
+  horizontal_flips: true
+evaluation:
+  eval_period_iterations: 12500
+  low_freq_every: 5
+  config_files:
+    high_freq: benchmark_high_frequency.yaml
+    low_freq: benchmark_low_frequency.yaml
+checkpointing:
+  period: 3750
+  max_to_keep: 3

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/data/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This software may be used and distributed in accordance with
+# the terms of the DINOv3 License Agreement.
+
+from .adapters import DatasetWithEnumeratedTargets
+from .augmentations import DataAugmentationDINO
+from .collate import collate_data_and_cast
+from .loaders import SamplerType, make_data_loader, make_dataset
+from .meta_loaders import CombinedDataLoader
+from .masking import MaskingGenerator
+from .transforms import make_classification_eval_transform, make_classification_train_transform

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/data/adapters.py

@@ -0,0 +1,68 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This software may be used and distributed in accordance with
+# the terms of the DINOv3 License Agreement.
+
+from typing import Any, Optional, Tuple
+
+from torch.utils.data import Dataset
+
+
+def extend_samples_with_index(dataset_class):
+    class DatasetWithIndex(dataset_class):
+        def __init__(self, **kwargs) -> None:
+            root = dataset_class.get_root()
+            super().__init__(root=root, **kwargs)
+
+        def __getitem__(self, index: int):
+            image, target = super().__getitem__(index)
+            return image, target, index
+
+    return DatasetWithIndex
+
+
+class DatasetWithEnumeratedTargets(Dataset):
+    """
+    If pad_dataset is set, pads based on torch's DistributedSampler implementation, which
+    with drop_last=False pads the last batch to be a multiple of the world size.
+    https://github.com/pytorch/pytorch/blob/main/torch/utils/data/distributed.py#L91
+    """
+
+    def __init__(self, dataset: Dataset, pad_dataset: bool = False, num_replicas: Optional[int] = None):
+        self._dataset = dataset
+        self._size = len(self._dataset)
+        self._padded_size = self._size
+        self._pad_dataset = pad_dataset
+        if self._pad_dataset:
+            assert num_replicas is not None, "num_replicas should be set if pad_dataset is True"
+            self._padded_size = num_replicas * ((len(dataset) + num_replicas - 1) // num_replicas)
+
+    def get_image_relpath(self, index: int) -> str:
+        assert self._pad_dataset or index < self._size
+        return self._dataset.get_image_relpath(index % self._size)
+
+    def get_image_data(self, index: int) -> bytes:
+        assert self._pad_dataset or index < self._size
+        return self._dataset.get_image_data(index % self._size)
+
+    def get_target(self, index: int) -> Tuple[Any, int]:
+        target = self._dataset.get_target(index % self._size)
+        if index >= self._size:
+            assert self._pad_dataset
+            return (-1, target)
+        return (index, target)
+
+    def get_sample_decoder(self, index: int) -> Any:
+        assert self._pad_dataset or index < self._size
+        return self._dataset.get_sample_decoder(index % self._size)
+
+    def __getitem__(self, index: int) -> Tuple[Any, Tuple[Any, int]]:
+        image, target = self._dataset[index % self._size]
+        if index >= self._size:
+            assert self._pad_dataset
+            return image, (-1, target)
+        target = index if target is None else target
+        return image, (index, target)
+
+    def __len__(self) -> int:
+        return self._padded_size

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/data/augmentations.py

@@ -0,0 +1,227 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This software may be used and distributed in accordance with
+# the terms of the DINOv3 License Agreement.
+
+import logging
+
+import numpy as np
+import torch
+from torch import nn
+from torchvision.transforms import v2
+
+from dinov3.data.transforms import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, GaussianBlur, make_normalize_transform
+
+logger = logging.getLogger("dinov3")
+
+
+class DataAugmentationDINO(object):
+    def __init__(
+        self,
+        global_crops_scale,
+        local_crops_scale,
+        local_crops_number,
+        global_crops_size=224,
+        local_crops_size=96,
+        gram_teacher_crops_size=None,
+        gram_teacher_no_distortions=False,
+        teacher_no_color_jitter=False,
+        local_crops_subset_of_global_crops=False,
+        patch_size=16,
+        share_color_jitter=False,
+        horizontal_flips=True,
+        mean=IMAGENET_DEFAULT_MEAN,
+        std=IMAGENET_DEFAULT_STD,
+    ):
+        self.global_crops_scale = global_crops_scale
+        self.local_crops_scale = local_crops_scale
+        self.local_crops_number = local_crops_number
+        self.global_crops_size = global_crops_size
+        self.local_crops_size = local_crops_size
+        self.gram_teacher_crops_size = gram_teacher_crops_size
+        self.gram_teacher_no_distortions = gram_teacher_no_distortions
+        self.teacher_no_color_jitter = teacher_no_color_jitter
+        self.local_crops_subset_of_global_crops = local_crops_subset_of_global_crops
+        self.patch_size = patch_size
+        self.share_color_jitter = share_color_jitter
+        self.mean = mean
+        self.std = std
+
+        logger.info("###################################")
+        logger.info("Using data augmentation parameters:")
+        logger.info(f"global_crops_scale: {global_crops_scale}")
+        logger.info(f"local_crops_scale: {local_crops_scale}")
+        logger.info(f"local_crops_number: {local_crops_number}")
+        logger.info(f"global_crops_size: {global_crops_size}")
+        logger.info(f"local_crops_size: {local_crops_size}")
+        logger.info(f"gram_crops_size: {gram_teacher_crops_size}")
+        logger.info(f"gram_teacher_no_distortions: {gram_teacher_no_distortions}")
+        logger.info(f"teacher_no_color_jitter: {teacher_no_color_jitter}")
+        logger.info(f"local_crops_subset_of_global_crops: {local_crops_subset_of_global_crops}")
+        logger.info(f"patch_size if local_crops_subset_of_global_crops: {patch_size}")
+        logger.info(f"share_color_jitter: {share_color_jitter}")
+        logger.info(f"horizontal flips: {horizontal_flips}")
+        logger.info("###################################")
+
+        # Global crops and gram teacher crops can have different sizes. We first take a crop of the maximum size
+        # and then resize it to the desired size for global and gram teacher crops.
+        global_crop_max_size = max(global_crops_size, gram_teacher_crops_size if gram_teacher_crops_size else 0)
+
+        # random resized crop and flip
+        self.geometric_augmentation_global = v2.Compose(
+            [
+                v2.RandomResizedCrop(
+                    global_crop_max_size,
+                    scale=global_crops_scale,
+                    interpolation=v2.InterpolationMode.BICUBIC,
+                ),
+                v2.RandomHorizontalFlip(p=0.5 if horizontal_flips else 0.0),
+            ]
+        )
+
+        resize_global = nn.Identity()  # Resize transform applied to global crops after random crop
+        self.resize_global_post_transf = (
+            nn.Identity()
+        )  # Resize transform applied to global crops after all other transforms
+        self.resize_gram_teacher = None  # Resize transform applied to crops for gram teacher
+        if gram_teacher_crops_size is not None:
+            # All resize transforms will do nothing if the crop size is already the desired size.
+            if gram_teacher_no_distortions:
+                # When there a no distortions for the gram teacher crop, we can resize before the distortions.
+                # This is the preferred order, because it keeps the image size for the augmentations consistent,
+                # which matters e.g. for GaussianBlur.
+                resize_global = v2.Resize(
+                    global_crops_size,
+                    interpolation=v2.InterpolationMode.BICUBIC,
+                )
+            else:
+                # When there a no distortions for the gram teacher crop, we need to resize after the distortions,
+                # because the distortions are shared between global and gram teacher crops.
+                self.resize_global_post_transf = v2.Resize(
+                    global_crops_size,
+                    interpolation=v2.InterpolationMode.BICUBIC,
+                )
+
+            self.resize_gram_teacher = v2.Resize(
+                gram_teacher_crops_size,
+                interpolation=v2.InterpolationMode.BICUBIC,
+            )
+
+        self.geometric_augmentation_local = v2.Compose(
+            [
+                v2.RandomResizedCrop(
+                    local_crops_size,
+                    scale=local_crops_scale,
+                    interpolation=v2.InterpolationMode.BICUBIC,
+                ),
+                v2.RandomHorizontalFlip(p=0.5 if horizontal_flips else 0.0),
+            ]
+        )
+
+        # color distortions / blurring
+        color_jittering = v2.Compose(
+            [
+                v2.RandomApply(
+                    [v2.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1)],
+                    p=0.8,
+                ),
+                v2.RandomGrayscale(p=0.2),
+            ]
+        )
+
+        global_transfo1_extra = GaussianBlur(p=1.0)
+
+        global_transfo2_extra = v2.Compose(
+            [
+                GaussianBlur(p=0.1),
+                v2.RandomSolarize(threshold=128, p=0.2),
+            ]
+        )
+
+        local_transfo_extra = GaussianBlur(p=0.5)
+
+        # normalization
+        self.normalize = v2.Compose(
+            [
+                v2.ToImage(),
+                v2.ToDtype(torch.float32, scale=True),
+                make_normalize_transform(mean=mean, std=std),
+            ]
+        )
+
+        if self.share_color_jitter:
+            self.color_jittering = color_jittering
+            self.global_transfo1 = v2.Compose([resize_global, global_transfo1_extra, self.normalize])
+            self.global_transfo2 = v2.Compose([resize_global, global_transfo2_extra, self.normalize])
+            self.local_transfo = v2.Compose([local_transfo_extra, self.normalize])
+        else:
+            self.global_transfo1 = v2.Compose(
+                [resize_global, color_jittering, global_transfo1_extra, self.normalize]
+            )
+            self.global_transfo2 = v2.Compose(
+                [resize_global, color_jittering, global_transfo2_extra, self.normalize]
+            )
+            self.local_transfo = v2.Compose([color_jittering, local_transfo_extra, self.normalize])
+
+    def __call__(self, image):
+        output = {}
+        output["weak_flag"] = True  # some residual from mugs
+
+        if self.share_color_jitter:
+            image = self.color_jittering(image)
+
+        # global crops:
+        im1_base = self.geometric_augmentation_global(image)
+        global_crop_1_transf = self.global_transfo1(im1_base)
+        global_crop_1 = self.resize_global_post_transf(global_crop_1_transf)
+
+        im2_base = self.geometric_augmentation_global(image)
+        global_crop_2_transf = self.global_transfo2(im2_base)
+        global_crop_2 = self.resize_global_post_transf(global_crop_2_transf)
+
+        output["global_crops"] = [global_crop_1, global_crop_2]
+
+        # global crops for teacher:
+        if self.teacher_no_color_jitter:
+            output["global_crops_teacher"] = [
+                self.normalize(im1_base),
+                self.normalize(im2_base),
+            ]
+        else:
+            output["global_crops_teacher"] = [global_crop_1, global_crop_2]
+
+        if self.gram_teacher_crops_size is not None:
+            # crops for gram teacher:
+            if self.gram_teacher_no_distortions:
+                gram_crop_1 = self.normalize(self.resize_gram_teacher(im1_base))
+                gram_crop_2 = self.normalize(self.resize_gram_teacher(im2_base))
+            else:
+                gram_crop_1 = self.resize_gram_teacher(global_crop_1_transf)
+                gram_crop_2 = self.resize_gram_teacher(global_crop_2_transf)
+            output["gram_teacher_crops"] = [gram_crop_1, gram_crop_2]
+
+        # local crops:
+        if self.local_crops_subset_of_global_crops:
+            _local_crops = [self.local_transfo(im1_base) for _ in range(self.local_crops_number // 2)] + [
+                self.local_transfo(im2_base) for _ in range(self.local_crops_number // 2)
+            ]
+
+            local_crops = []
+            offsets = []
+            gs = self.global_crops_size
+            ls = self.local_crops_size
+            for img in _local_crops:
+                rx, ry = np.random.randint(0, (gs - ls) // self.patch_size, 2) * self.patch_size
+                local_crops.append(img[:, rx : rx + ls, ry : ry + ls])
+                offsets.append((rx, ry))
+
+            output["local_crops"] = local_crops
+            output["offsets"] = offsets
+        else:
+            local_crops = [
+                self.local_transfo(self.geometric_augmentation_local(image)) for _ in range(self.local_crops_number)
+            ]
+            output["local_crops"] = local_crops
+            output["offsets"] = ()
+
+        return output

depth_anything_v2_metric/depth_anything_v2/dinov3/dinov3/data/collate.py

@@ -0,0 +1,125 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This software may be used and distributed in accordance with
+# the terms of the DINOv3 License Agreement.
+
+import random
+
+import torch
+
+
+def collate_data_and_cast(
+    samples_list,
+    mask_ratio_tuple,
+    mask_probability,
+    dtype,
+    n_tokens=None,
+    mask_generator=None,
+    random_circular_shift=False,
+    local_batch_size=None,
+):
+    n_global_crops = len(samples_list[0][0]["global_crops"])
+    n_local_crops = len(samples_list[0][0]["local_crops"])
+
+    collated_global_crops = torch.stack(
+        [s[0]["global_crops"][i] for i in range(n_global_crops) for s in samples_list]
+    )  # [n_global_crops, B, ...]
+    collated_local_crops = torch.stack([s[0]["local_crops"][i] for i in range(n_local_crops) for s in samples_list])
+    if "gram_teacher_crops" in samples_list[0][0]:
+        collated_gram_teacher_crops = torch.stack(
+            [s[0]["gram_teacher_crops"][i] for i in range(n_global_crops) for s in samples_list]
+        )  # [n_global_crops, B, ...]
+    else:
+        collated_gram_teacher_crops = None
+
+    if local_batch_size is not None:
+        # multi-distillation case, number of masks is different because the number of samples masked
+        # is different of the number of samples passed into the teacher initially
+        B = n_global_crops * local_batch_size
+    else:
+        B = len(collated_global_crops)
+    N = n_tokens
+    n_samples_masked = int(B * mask_probability)
+    probs = torch.linspace(*mask_ratio_tuple, n_samples_masked + 1)
+    upperbound = 0
+    masks_list = []
+    for i in range(0, n_samples_masked):
+        prob_max = probs[i + 1]
+        mask = torch.BoolTensor(mask_generator(int(N * prob_max)))
+        if random_circular_shift:  # apply le random circular shift to
+            shift_x, shift_y = (
+                random.randint(0, mask.shape[0] - 1),
+                random.randint(0, mask.shape[1] - 1),
+            )
+            mask = torch.roll(mask, (shift_x, shift_y), (0, 1))
+        masks_list.append(mask)
+        upperbound += int(N * prob_max)
+    for _ in range(n_samples_masked, B):
+        masks_list.append(torch.BoolTensor(mask_generator(0)))
+
+    random.shuffle(masks_list)
+
+    collated_masks = torch.stack(masks_list).flatten(1)
+    mask_indices_list = collated_masks.flatten().nonzero().flatten()
+
+    masks_weight = (1 / collated_masks.sum(-1).clamp(min=1.0)).unsqueeze(-1).expand_as(collated_masks)[collated_masks]
+
+    out = {
+        "collated_global_crops": collated_global_crops.to(dtype),
+        "collated_local_crops": collated_local_crops.to(dtype),
+        "collated_masks": collated_masks,
+        "mask_indices_list": mask_indices_list,
+        "masks_weight": masks_weight,
+        "upperbound": upperbound,
+        "n_masked_patches": torch.full((1,), fill_value=mask_indices_list.shape[0], dtype=torch.long),
+    }
+    if collated_gram_teacher_crops is not None:
+        out["collated_gram_teacher_crops"] = collated_gram_teacher_crops.to(dtype)
+    return out
+
+
+# def get_batch_subset(collated_data_batch, target_bs):
+def get_batch_subset(collated_data_batch, divide_by):
+    old_bs = collated_data_batch["collated_global_crops"].shape[0] // 2
+    target_bs = (old_bs + divide_by - 1) // divide_by
+    collated_global_crops = (
+        collated_data_batch["collated_global_crops"].unflatten(0, (2, old_bs)).narrow(1, 0, target_bs).flatten(0, 1)
+    )
+    collated_local_crops = (
+        collated_data_batch["collated_local_crops"].unflatten(0, (-1, old_bs)).narrow(1, 0, target_bs).flatten(0, 1)
+    )
+
+    masks_old_bs = collated_data_batch["collated_masks"].shape[0] // 2
+    masks_target_bs = masks_old_bs // divide_by
+    collated_masks = (
+        collated_data_batch["collated_masks"]
+        .unflatten(0, (2, masks_old_bs))
+        .narrow(1, 0, masks_target_bs)
+        .flatten(0, 1)
+    )
+    mask_indices_list = collated_masks.flatten().nonzero().flatten()
+
+    while mask_indices_list.shape[0] == 0:
+        _unbind = list(collated_data_batch["collated_masks"].unbind(0))
+        random.shuffle(_unbind)
+        _bind = torch.stack(_unbind, dim=0)
+        collated_masks = _bind.unflatten(0, (2, masks_old_bs)).narrow(1, 0, masks_target_bs).flatten(0, 1)
+        mask_indices_list = collated_masks.flatten().nonzero().flatten()
+
+    masks_weight = (1 / collated_masks.sum(-1).clamp(min=1.0)).unsqueeze(-1).expand_as(collated_masks)[collated_masks]
+    upperbound = collated_data_batch["upperbound"]
+
+    new_batch = {
+        "collated_global_crops": collated_global_crops,
+        "collated_local_crops": collated_local_crops,
+        "collated_masks": collated_masks,
+        "mask_indices_list": mask_indices_list,
+        "masks_weight": masks_weight,
+        "upperbound": upperbound,
+        "n_masked_patches": torch.full((1,), fill_value=mask_indices_list.shape[0], dtype=torch.long),
+    }
+
+    if "global_batch_size" in collated_data_batch.keys():
+        new_batch["global_batch_size"] = collated_data_batch["global_batch_size"] // divide_by
+
+    return new_batch