SYMBOL INDEX (374 symbols across 36 files)

FILE: engine_storm.py
  function visualize (line 21) | def visualize(args, model, dset_train, step, train_vis_id, device, dset_...
  function evaluate (line 50) | def evaluate(dataloader, model, args, name_str=None):
  function evaluate_flow (line 307) | def evaluate_flow(dataloader, model, args, name_str=None):

FILE: extract_sky.py
  class ListDataset (line 15) | class ListDataset:
    method __init__ (line 18) | def __init__(
    method _load_samples (line 37) | def _load_samples(self, data_list: str) -> list:
    method __getitem__ (line 46) | def __getitem__(self, index: int) -> Tuple[torch.Tensor, str]:
    method __len__ (line 63) | def __len__(self) -> int:
  function get_args_parser (line 66) | def get_args_parser() -> argparse.ArgumentParser:
  function setup_model (line 77) | def setup_model(device: torch.device, depth_ckpt: str) -> DepthAnythingV2:
  function get_sky_mask (line 87) | def get_sky_mask(dataloader: torch.utils.data.DataLoader,  depthv2: Dept...
  function main (line 121) | def main(args: argparse.Namespace) -> None:

FILE: inference.py
  function get_args_parser (line 27) | def get_args_parser():
  function main (line 80) | def main(args):

FILE: main_storm.py
  function get_args_parser (line 37) | def get_args_parser():
  function main (line 132) | def main(args):

FILE: preproc/utils.py
  class ProgressBar (line 12) | class ProgressBar:
    method __init__ (line 15) | def __init__(self, task_num=0, bar_width=50, start=True, file=sys.stdo...
    method terminal_width (line 24) | def terminal_width(self):
    method start (line 28) | def start(self):
    method update (line 36) | def update(self, num_tasks=1):
  function init_pool (line 70) | def init_pool(process_num, initializer=None, initargs=None):
  function track_parallel_progress (line 81) | def track_parallel_progress(

FILE: preproc/waymo_download.py
  function download_file (line 8) | def download_file(filename, target_dir, source):
  function download_files (line 25) | def download_files(

FILE: preproc/waymo_preprocess.py
  function project_vehicle_to_image (line 49) | def project_vehicle_to_image(vehicle_pose, calibration, points):
  function get_ground_np (line 91) | def get_ground_np(pts):
  function compute_range_image_cartesian (line 132) | def compute_range_image_cartesian(
  function extract_point_cloud_from_range_image (line 234) | def extract_point_cloud_from_range_image(
  function parse_range_image_flow_and_camera_projection (line 283) | def parse_range_image_flow_and_camera_projection(frame):
  function convert_range_image_to_point_cloud_flow (line 332) | def convert_range_image_to_point_cloud_flow(
  class WaymoProcessor (line 467) | class WaymoProcessor:
    method __init__ (line 468) | def __init__(
    method convert (line 495) | def convert(self):
    method convert_one (line 501) | def convert_one(self, file_id):
    method make_json (line 601) | def make_json(self, file_id):
    method __len__ (line 677) | def __len__(self):
    method save_image (line 681) | def save_image(self, frame, file_id, frame_id):
    method save_calib (line 713) | def save_calib(self, frame, file_id, frame_id):
    method save_lidar (line 745) | def save_lidar(self, frame, file_id, frame_id):
    method save_ground (line 884) | def save_ground(self, frame, file_id, frame_id):
    method save_pose (line 958) | def save_pose(self, frame, file_id, frame_id):
    method save_dynamic_mask (line 991) | def save_dynamic_mask(self, frame, file_id, frame_id):
    method create_folder (line 1084) | def create_folder(self):

FILE: storm/dataset/data_utils.py
  function forward_pose (line 11) | def forward_pose(pose: torch.tensor, transform: torch.tensor, inv=False)...
  function get_path_front_left_lift_then_spiral_forward (line 20) | def get_path_front_left_lift_then_spiral_forward(
  function to_tensor (line 142) | def to_tensor(x: Union[np.ndarray, List, Tuple]) -> torch.Tensor:
  function to_float_tensor (line 150) | def to_float_tensor(d):
  function to_batch_tensor (line 163) | def to_batch_tensor(d):
  function resize_depth (line 174) | def resize_depth(depth, target_size):
  function resize_flow (line 195) | def resize_flow(flow, target_size):
  function prepare_inputs_and_targets (line 222) | def prepare_inputs_and_targets(data_dict, device=torch.device("cuda"), v...
  function prepare_inputs_and_targets_novel_view (line 300) | def prepare_inputs_and_targets_novel_view(data_dict, device=torch.device...

FILE: storm/dataset/samplers.py
  function _get_torch_dtype (line 10) | def _get_torch_dtype(size: int) -> Any:
  function _generate_randperm_indices (line 15) | def _generate_randperm_indices(*, size: int, generator: torch.Generator):
  class InfiniteSampler (line 33) | class InfiniteSampler(Sampler):
    method __init__ (line 34) | def __init__(
    method __iter__ (line 61) | def __iter__(self):
    method _iterator (line 66) | def _iterator(self):
    method _shuffled_iterator (line 73) | def _shuffled_iterator(self):
  class NoPaddingDistributedSampler (line 82) | class NoPaddingDistributedSampler(Sampler):
    method __init__ (line 83) | def __init__(self, dataset, num_replicas=None, rank=None, shuffle=False):
    method __iter__ (line 108) | def __iter__(self):
    method __len__ (line 118) | def __len__(self):

FILE: storm/dataset/storm_dataset.py
  class STORMDataset (line 20) | class STORMDataset(Dataset):
    method __init__ (line 21) | def __init__(
    method __len__ (line 79) | def __len__(self) -> int:
    method get_frame (line 82) | def get_frame(
    method __getitem__ (line 249) | def __getitem__(
  class STORMDatasetEval (line 364) | class STORMDatasetEval(STORMDataset):
    method __init__ (line 365) | def __init__(
    method __len__ (line 413) | def __len__(self) -> int:
    method __getitem__ (line 416) | def __getitem__(self, index: int):
  class SingleSequenceDataset (line 424) | class SingleSequenceDataset(Dataset):
    method __init__ (line 425) | def __init__(
    method __len__ (line 481) | def __len__(self) -> int:
    method get_frame (line 484) | def get_frame(
    method get_segment (line 647) | def get_segment(self, index: int, context_frame_idx: int = -1, return_...
    method __getitem__ (line 746) | def __getitem__(self, index: int, start_index: int = 0, end_index: int...

FILE: storm/models/decoder.py
  function check_results (line 15) | def check_results(result_dict) -> bool:
  class Decoder (line 26) | class Decoder(nn.Module):
    method __init__ (line 27) | def __init__(
    method forward (line 57) | def forward(self, render_results):
  class ConvDecoder (line 74) | class ConvDecoder(nn.Module):
    method __init__ (line 75) | def __init__(
    method forward (line 110) | def forward(self, render_results) -> Dict[str, Tensor]:
  class ModulatedLinearLayer (line 149) | class ModulatedLinearLayer(nn.Module):
    method __init__ (line 150) | def __init__(self, in_channels, hidden_channels=64, condition_channels...
    method forward (line 160) | def forward(self, x, c):
  class ModulatedMLP (line 171) | class ModulatedMLP(nn.Module):
    method __init__ (line 172) | def __init__(
    method forward (line 196) | def forward(self, x, c):
  class DummyDecoder (line 207) | class DummyDecoder(nn.Module):
    method __init__ (line 208) | def __init__(self, **kwargs):
    method forward (line 211) | def forward(self, render_results):

FILE: storm/models/embedders.py
  class PatchEmbed (line 18) | class PatchEmbed(nn.Module):
    method __init__ (line 23) | def __init__(
    method feat_ratio (line 51) | def feat_ratio(self, as_scalar=True) -> Union[Tuple[int, int], int]:
    method dynamic_feat_size (line 57) | def dynamic_feat_size(self, img_size: Tuple[int, int]) -> Tuple[int, i...
    method forward (line 68) | def forward(self, x: Tensor) -> Tensor:
  class PluckerEmbedder (line 87) | class PluckerEmbedder(nn.Module):
    method __init__ (line 92) | def __init__(
    method forward (line 112) | def forward(
  class TimestepEmbedder (line 186) | class TimestepEmbedder(nn.Module):
    method __init__ (line 192) | def __init__(self, hidden_size, frequency_embedding_size=256):
    method timestep_embedding (line 202) | def timestep_embedding(t, dim, max_period=10000):
    method forward (line 222) | def forward(self, t):
  class NeRFPosEmbedder (line 228) | class NeRFPosEmbedder(nn.Module):
    method __init__ (line 229) | def __init__(
    method get_out_dim (line 246) | def get_out_dim(self) -> int:
    method forward (line 252) | def forward(self, in_tensor: Tensor) -> Tensor:

FILE: storm/models/layers.py
  function modulate (line 17) | def modulate(x, shift=None, scale=None):
  class Mlp (line 23) | class Mlp(nn.Module):
    method __init__ (line 24) | def __init__(self, in_dim: int, hidden_dim=None, out_dim=None, act_lay...
    method forward (line 32) | def forward(self, x):
  class Attention (line 36) | class Attention(nn.Module):
    method __init__ (line 39) | def __init__(
    method forward (line 68) | def forward(self, x: Tensor, data: Tensor = None) -> Tensor:
  class Block (line 100) | class Block(nn.Module):
    method __init__ (line 103) | def __init__(
    method forward (line 127) | def forward(self, x: Tensor, data: Tensor = None) -> Tensor:
  class Transformer (line 135) | class Transformer(nn.Module):
    method __init__ (line 136) | def __init__(
    method forward (line 164) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class GroupNorm (line 174) | class GroupNorm(nn.Module):
    method __init__ (line 175) | def __init__(self, channels):
    method forward (line 179) | def forward(self, x):
  class Swish (line 183) | class Swish(nn.Module):
    method forward (line 184) | def forward(self, x):
  class ResidualBlock (line 188) | class ResidualBlock(nn.Module):
    method __init__ (line 189) | def __init__(self, in_channels, out_channels):
    method forward (line 205) | def forward(self, x):
  class UpSampleBlock (line 212) | class UpSampleBlock(nn.Module):
    method __init__ (line 213) | def __init__(self, channels):
    method forward (line 217) | def forward(self, x):
  class NonLocalBlock (line 222) | class NonLocalBlock(nn.Module):
    method __init__ (line 223) | def __init__(self, channels):
    method forward (line 230) | def forward(self, x):
  class LayerNorm2d (line 238) | class LayerNorm2d(nn.Module):
    method __init__ (line 239) | def __init__(self, num_channels: int, eps: float = 1e-6) -> None:
    method forward (line 245) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  function pos_enc (line 253) | def pos_enc(x, min_deg=0, max_deg=10, append_identity=True):
  function get_2d_sincos_pos_embed (line 267) | def get_2d_sincos_pos_embed(embed_dim, grid_size, cls_token=False, num_e...
  function get_2d_sincos_pos_embed_from_grid (line 287) | def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
  function get_1d_sincos_pos_embed_from_grid (line 298) | def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
  function resample_abs_pos_embed (line 319) | def resample_abs_pos_embed(

FILE: storm/models/storm.py
  class STORM (line 14) | class STORM(ViT):
    method __init__ (line 15) | def __init__(
    method _pos_embed (line 181) | def _pos_embed(self, x: Tensor) -> Tensor:
    method _time_embed (line 186) | def _time_embed(self, x: Tensor, time: Tensor, num_views=1) -> Tensor:
    method forward_decoder (line 205) | def forward_decoder(self, render_results):
    method forward_features (line 220) | def forward_features(self, x, plucker_embeds, time):
    method forward_motion_predictor (line 242) | def forward_motion_predictor(self, x, motion_tokens=None, gs_params=No...
    method forward_gs_predictor (line 281) | def forward_gs_predictor(self, x, origins, directions):
    method forward_renderer (line 302) | def forward_renderer(self, gs_params, data_dict, render_motion_seg=Tru...
    method get_ray_dict (line 508) | def get_ray_dict(self, data_dict):
    method forward (line 534) | def forward(self, data_dict):
    method from_gs_params_to_output (line 608) | def from_gs_params_to_output(self, gs_params, target_dict, num_cams=1):
    method get_gs_params (line 639) | def get_gs_params(self, data_dict):
  function STORM_B_8 (line 669) | def STORM_B_8(**kwargs):
  function STORM_L_8 (line 673) | def STORM_L_8(**kwargs):
  function STORM_B_16 (line 677) | def STORM_B_16(**kwargs):
  function STORM_L_16 (line 681) | def STORM_L_16(**kwargs):
  function STORM_XL_8 (line 685) | def STORM_XL_8(**kwargs):
  function STORM_H_8 (line 689) | def STORM_H_8(**kwargs):
  function STORM_H_16 (line 693) | def STORM_H_16(**kwargs):

FILE: storm/models/vit.py
  class VisionTransformer (line 17) | class VisionTransformer(nn.Module):
    method __init__ (line 20) | def __init__(
    method init_weights (line 64) | def init_weights(self):
    method _pos_embed (line 78) | def _pos_embed(self, x: torch.Tensor) -> torch.Tensor:
    method unpatchify (line 92) | def unpatchify(self, x, hw=None, channel_first=True, patch_size=None) ...
    method forward (line 106) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  function ViT_S_16 (line 114) | def ViT_S_16(**kwargs):
  function ViT_B_16 (line 118) | def ViT_B_16(**kwargs):
  function ViT_L_16 (line 122) | def ViT_L_16(**kwargs):
  function ViT_H_14 (line 126) | def ViT_H_14(**kwargs):

FILE: storm/utils/distributed.py
  function is_enabled (line 28) | def is_enabled() -> bool:
  function get_global_rank (line 33) | def get_global_rank() -> int:
  function get_world_size (line 38) | def get_world_size() -> int:
  function is_main_process (line 43) | def is_main_process() -> bool:
  function _collect_env_vars (line 48) | def _collect_env_vars() -> Dict[str, str]:
  function _is_slurm_job_process (line 60) | def _is_slurm_job_process() -> bool:
  function _parse_slurm_node_list (line 65) | def _parse_slurm_node_list(s: str) -> List[str]:
  function _check_env_variable (line 83) | def _check_env_variable(key: str, new_value: str):
  function _restrict_print_to_main_process (line 89) | def _restrict_print_to_main_process() -> None:
  function _get_master_port (line 105) | def _get_master_port(seed: int = 0) -> int:
  function _get_available_port (line 117) | def _get_available_port() -> int:
  class _TorchDistributedEnvironment (line 126) | class _TorchDistributedEnvironment:
    method __init__ (line 129) | def __init__(self):
    method _set_from_slurm_env (line 160) | def _set_from_slurm_env(self):
    method _set_from_preset_env (line 180) | def _set_from_preset_env(self):
    method _set_from_local (line 195) | def _set_from_local(self):
    method export (line 205) | def export(self, *, overwrite: bool) -> "_TorchDistributedEnvironment":
  function enable (line 223) | def enable(

FILE: storm/utils/logging.py
  class SmoothedValue (line 20) | class SmoothedValue:
    method __init__ (line 23) | def __init__(self, window_size=20, fmt=None):
    method update (line 29) | def update(self, value, num=1):
    method synchronize_between_processes (line 35) | def synchronize_between_processes(self):
    method median (line 45) | def median(self):
    method avg (line 50) | def avg(self):
    method global_avg (line 55) | def global_avg(self):
    method max (line 60) | def max(self):
    method value (line 65) | def value(self):
    method __str__ (line 69) | def __str__(self):
  class MetricLogger (line 80) | class MetricLogger:
    method __init__ (line 81) | def __init__(self, delimiter="\t", output_file=None):
    method update (line 86) | def update(self, **kwargs):
    method __getattr__ (line 95) | def __getattr__(self, attr):
    method __str__ (line 102) | def __str__(self):
    method synchronize_between_processes (line 108) | def synchronize_between_processes(self):
    method add_meter (line 112) | def add_meter(self, name, meter):
    method dump_in_output_file (line 115) | def dump_in_output_file(self, iteration, iter_time, data_time):
    method log_every (line 127) | def log_every(self, iterable, print_freq, header=None, n_iterations=No...
  class WandbLogger (line 203) | class WandbLogger:
    method __init__ (line 204) | def __init__(self, args, resume="must", id=None):
    method wandb_safe_log (line 221) | def wandb_safe_log(*args, **kwargs):
    method set_step (line 228) | def set_step(self, step=None):
    method update (line 232) | def update(self, metrics):
    method flush (line 241) | def flush(self):
    method finish (line 244) | def finish(self):
  function _configure_logger (line 252) | def _configure_logger(
  function setup_logging (line 323) | def setup_logging(

FILE: storm/utils/losses.py
  function compute_depth_loss (line 8) | def compute_depth_loss(pred_depth, gt_depth, max_depth=None):
  function compute_sky_depth_loss (line 41) | def compute_sky_depth_loss(pred_depth, gt_sky_mask, sky_depth: float = 1...
  function compute_loss (line 77) | def compute_loss(output_dict, target_dict, args=None, lpips_loss=None):
  function compute_scene_flow_metrics (line 161) | def compute_scene_flow_metrics(pred, labels):

FILE: storm/utils/lpips.py
  function download (line 20) | def download(url, local_path, chunk_size=1024):
  function md5_hash (line 32) | def md5_hash(path):
  function get_ckpt_path (line 38) | def get_ckpt_path(name, root, check=False):
  class LPIPS (line 49) | class LPIPS(nn.Module):
    method __init__ (line 51) | def __init__(self, use_dropout=True):
    method load_from_pretrained (line 65) | def load_from_pretrained(self, name="vgg_lpips"):
    method from_pretrained (line 71) | def from_pretrained(cls, name="vgg_lpips"):
    method forward (line 79) | def forward(self, input, target):
  class ScalingLayer (line 97) | class ScalingLayer(nn.Module):
    method __init__ (line 98) | def __init__(self):
    method forward (line 103) | def forward(self, inp):
  class NetLinLayer (line 107) | class NetLinLayer(nn.Module):
    method __init__ (line 110) | def __init__(self, chn_in, chn_out=1, use_dropout=False):
  class vgg16 (line 125) | class vgg16(torch.nn.Module):
    method __init__ (line 126) | def __init__(self, requires_grad=False, pretrained=True):
    method forward (line 149) | def forward(self, X):
  function normalize_tensor (line 167) | def normalize_tensor(x, eps=1e-8):
  function spatial_average (line 172) | def spatial_average(x, keepdim=True):

FILE: storm/utils/lpips_loss.py
  class RGBLpipsLoss (line 8) | class RGBLpipsLoss(nn.Module):
    method __init__ (line 18) | def __init__(
    method set_perceptual_loss (line 36) | def set_perceptual_loss(self, enable=True):
    method forward (line 45) | def forward(self, rgb, targets):

FILE: storm/utils/misc.py
  function fix_random_seeds (line 18) | def fix_random_seeds(seed=31):
  function _ntuple (line 25) | def _ntuple(n):
  function cleanup_checkpoints (line 47) | def cleanup_checkpoints(ckpt_dir, keep_num=1):
  function load_model (line 75) | def load_model(args, model_without_ddp, optimizer=None, loss_scaler=None):
  function adjust_learning_rate (line 163) | def adjust_learning_rate(optimizer, iteration, args):
  function unwrap_model (line 198) | def unwrap_model(model):
  function get_grad_norm_ (line 202) | def get_grad_norm_(parameters, norm_type=2.0):
  class NativeScalerWithGradNormCount (line 228) | class NativeScalerWithGradNormCount:
    method __init__ (line 238) | def __init__(self, enabled=True):
    method __call__ (line 241) | def __call__(
    method state_dict (line 262) | def state_dict(self):
    method load_state_dict (line 266) | def load_state_dict(self, state_dict):

FILE: storm/visualization/annotation.py
  function draw_label (line 20) | def draw_label(
  function add_label (line 42) | def add_label(

FILE: storm/visualization/layout.py
  function _sanitize_color (line 34) | def _sanitize_color(color: Color) -> Float[Tensor, "#channel"]:
  function _intersperse (line 48) | def _intersperse(iterable: Iterable, delimiter: Any) -> Generator[Any, N...
  function _get_main_dim (line 56) | def _get_main_dim(main_axis: Axis) -> int:
  function _get_cross_dim (line 63) | def _get_cross_dim(main_axis: Axis) -> int:
  function _compute_offset (line 70) | def _compute_offset(base: int, overlay: int, align: Alignment) -> slice:
  function overlay (line 80) | def overlay(
  function cat (line 111) | def cat(
  function hcat (line 151) | def hcat(
  function vcat (line 173) | def vcat(
  function add_border (line 195) | def add_border(
  function resize (line 210) | def resize(
  function prep_image (line 233) | def prep_image(image: torch.Tensor) -> UInt8[np.ndarray, "height width c...

FILE: storm/visualization/video_maker.py
  function get_pca_map (line 25) | def get_pca_map(x):
  function make_video (line 35) | def make_video(
  function make_video_vis (line 353) | def make_video_vis(
  function make_video_av2 (line 626) | def make_video_av2(

FILE: storm/visualization/visualization_tools.py
  function to8b (line 38) | def to8b(x):
  function sinebow (line 44) | def sinebow(h):
  function matte (line 50) | def matte(vis, acc, dark=0.8, light=1.0, width=8):
  function weighted_percentile (line 60) | def weighted_percentile(x, w, ps, assume_sorted=False):
  function visualize_cmap (line 71) | def visualize_cmap(
  function visualize_depth (line 134) | def visualize_depth(x, acc=None, lo=None, hi=None, depth_curve_fn=lambda...
  function _make_colorwheel (line 147) | def _make_colorwheel(
  function scene_flow_to_rgb (line 197) | def scene_flow_to_rgb(
  function get_robust_pca (line 285) | def get_robust_pca(features: Tensor, m: float = 2, remove_first_componen...
  function get_pca_map (line 319) | def get_pca_map(
  function get_scale_map (line 359) | def get_scale_map(
  function get_similarity_map (line 384) | def get_similarity_map(features: Tensor, img_size=(224, 224)):

FILE: third_party/depth_anything_v2/dinov2.py
  function named_apply (line 27) | def named_apply(
  class BlockChunk (line 42) | class BlockChunk(nn.ModuleList):
    method forward (line 43) | def forward(self, x):
  class DinoVisionTransformer (line 49) | class DinoVisionTransformer(nn.Module):
    method __init__ (line 50) | def __init__(
    method init_weights (line 185) | def init_weights(self):
    method interpolate_pos_encoding (line 192) | def interpolate_pos_encoding(self, x, w, h):
    method prepare_tokens_with_masks (line 225) | def prepare_tokens_with_masks(self, x, masks=None):
    method forward_features_list (line 246) | def forward_features_list(self, x_list, masks_list):
    method forward_features (line 266) | def forward_features(self, x, masks=None):
    method _get_intermediate_layers_not_chunked (line 284) | def _get_intermediate_layers_not_chunked(self, x, n=1):
    method _get_intermediate_layers_chunked (line 298) | def _get_intermediate_layers_chunked(self, x, n=1):
    method get_intermediate_layers (line 314) | def get_intermediate_layers(
    method forward (line 342) | def forward(self, *args, is_training=False, **kwargs):
  function init_weights_vit_timm (line 350) | def init_weights_vit_timm(module: nn.Module, name: str = ""):
  function vit_small (line 358) | def vit_small(patch_size=16, num_register_tokens=0, **kwargs):
  function vit_base (line 372) | def vit_base(patch_size=16, num_register_tokens=0, **kwargs):
  function vit_large (line 386) | def vit_large(patch_size=16, num_register_tokens=0, **kwargs):
  function vit_giant2 (line 400) | def vit_giant2(patch_size=16, num_register_tokens=0, **kwargs):
  function DINOv2 (line 417) | def DINOv2(model_name):

FILE: third_party/depth_anything_v2/dinov2_layers/attention.py
  class Attention (line 27) | class Attention(nn.Module):
    method __init__ (line 28) | def __init__(
    method forward (line 47) | def forward(self, x: Tensor) -> Tensor:
  class MemEffAttention (line 67) | class MemEffAttention(Attention):
    method forward (line 68) | def forward(self, x: Tensor, attn_bias=None) -> Tensor:

FILE: third_party/depth_anything_v2/dinov2_layers/block.py
  class Block (line 34) | class Block(nn.Module):
    method __init__ (line 35) | def __init__(
    method forward (line 80) | def forward(self, x: Tensor) -> Tensor:
  function drop_add_residual_stochastic_depth (line 108) | def drop_add_residual_stochastic_depth(
  function get_branges_scales (line 134) | def get_branges_scales(x, sample_drop_ratio=0.0):
  function add_residual (line 142) | def add_residual(x, brange, residual, residual_scale_factor, scaling_vec...
  function get_attn_bias_and_cat (line 163) | def get_attn_bias_and_cat(x_list, branges=None):
  function drop_add_residual_stochastic_depth_list (line 191) | def drop_add_residual_stochastic_depth_list(
  class NestedTensorBlock (line 218) | class NestedTensorBlock(Block):
    method forward_nested (line 219) | def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]:
    method forward (line 259) | def forward(self, x_or_x_list):

FILE: third_party/depth_anything_v2/dinov2_layers/drop_path.py
  function drop_path (line 15) | def drop_path(x, drop_prob: float = 0.0, training: bool = False):
  class DropPath (line 27) | class DropPath(nn.Module):
    method __init__ (line 30) | def __init__(self, drop_prob=None):
    method forward (line 34) | def forward(self, x):

FILE: third_party/depth_anything_v2/dinov2_layers/layer_scale.py
  class LayerScale (line 15) | class LayerScale(nn.Module):
    method __init__ (line 16) | def __init__(
    method forward (line 26) | def forward(self, x: Tensor) -> Tensor:

FILE: third_party/depth_anything_v2/dinov2_layers/mlp.py
  class Mlp (line 17) | class Mlp(nn.Module):
    method __init__ (line 18) | def __init__(
    method forward (line 35) | def forward(self, x: Tensor) -> Tensor:

FILE: third_party/depth_anything_v2/dinov2_layers/patch_embed.py
  function make_2tuple (line 17) | def make_2tuple(x):
  class PatchEmbed (line 26) | class PatchEmbed(nn.Module):
    method __init__ (line 38) | def __init__(
    method forward (line 69) | def forward(self, x: Tensor) -> Tensor:
    method flops (line 88) | def flops(self) -> float:

FILE: third_party/depth_anything_v2/dinov2_layers/swiglu_ffn.py
  class SwiGLUFFN (line 13) | class SwiGLUFFN(nn.Module):
    method __init__ (line 14) | def __init__(
    method forward (line 29) | def forward(self, x: Tensor) -> Tensor:
  class SwiGLUFFNFused (line 45) | class SwiGLUFFNFused(SwiGLU):
    method __init__ (line 46) | def __init__(

FILE: third_party/depth_anything_v2/dpt.py
  function _make_fusion_block (line 12) | def _make_fusion_block(features, use_bn, size=None):
  class ConvBlock (line 24) | class ConvBlock(nn.Module):
    method __init__ (line 25) | def __init__(self, in_feature, out_feature):
    method forward (line 34) | def forward(self, x):
  class DPTHead (line 38) | class DPTHead(nn.Module):
    method __init__ (line 39) | def __init__(
    method forward (line 126) | def forward(self, out_features, patch_h, patch_w):
  class DepthAnythingV2 (line 164) | class DepthAnythingV2(nn.Module):
    method __init__ (line 165) | def __init__(
    method forward (line 194) | def forward(self, x):

FILE: third_party/depth_anything_v2/util/blocks.py
  function _make_scratch (line 4) | def _make_scratch(in_shape, out_shape, groups=1, expand=False):
  class ResidualConvUnit (line 37) | class ResidualConvUnit(nn.Module):
    method __init__ (line 40) | def __init__(self, features, activation, bn):
    method forward (line 68) | def forward(self, x):
  class FeatureFusionBlock (line 94) | class FeatureFusionBlock(nn.Module):
    method __init__ (line 97) | def __init__(
    method forward (line 135) | def forward(self, *xs, size=None):

FILE: third_party/depth_anything_v2/util/transform.py
  class Resize (line 5) | class Resize(object):
    method __init__ (line 8) | def __init__(
    method constrain_to_multiple_of (line 50) | def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
    method get_size (line 61) | def get_size(self, width, height):
    method __call__ (line 108) | def __call__(self, sample):
  class NormalizeImage (line 132) | class NormalizeImage(object):
    method __init__ (line 135) | def __init__(self, mean, std):
    method __call__ (line 139) | def __call__(self, sample):
  class PrepareForNet (line 145) | class PrepareForNet(object):
    method __init__ (line 148) | def __init__(self):
    method __call__ (line 151) | def __call__(self, sample):