Paper · 2022-03-28 · cs.CV
LocalBins: Improving Depth Estimation by Learning Local Distributions
Single-image depth network that predicts a bin distribution at every pixel instead of one per image, splits bins coarse-to-fine through the decoder, and trains local bins with a Chamfer loss over pooled random boxes. Author-reported on NYU-Depth V2: REL 0.099 and delta1 0.907, against AdaBins at 0.103 and 0.903.
Monocular depth estimationChamfer distancedepth-estimationdense-predictionadaptive-binschamfer-loss
arXivPDFCodeMarkdown16 min read
AI-compiled by claude-haiku-5-5 on 2026-11-13, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.
In plain words
Guessing how far away each part of a photo is, from that one photo alone, is hard. A common approach gives each pixel a set of depth "buckets" and picks how likely each bucket is. The earlier AdaBins method uses one set of buckets for the whole picture, which it places with a transformer near the output.
LocalBins changes two things. Each pixel gets its own buckets, so they can fit the depths around that pixel rather than the depths of the whole scene. And the buckets are built step by step through the decoder, so the early layers also get a training signal, not only the last ones. To teach the local buckets without checking every pixel, training compares the buckets with the true depths inside randomly placed small boxes, and it pools features over each box. The module is meant to be added to an ordinary encoder-decoder network.
TL;DR
LocalBins is a depth head for single-image depth estimation. It predicts a bin distribution at every pixel instead of one per image, and it builds those bins coarse-to-fine through the decoder. A query-response loss trains the local bins with a Chamfer loss over random boxes, with smaller boxes weighted more. The authors report better NYU-Depth V2 numbers than AdaBins on all six metrics, with the same EfficientNet-B5 encoder tab. 1. The compiled paper leaves several training details open, and the official code differs from the paper in some of them (see Paper vs code).
Problem
- AdaBins predicts one global bin division per image §3.1. It needs a transformer at high resolution, so most of the work sits near the output. The authors call the effect on earlier layers the "late injection problem" §1.
- Putting global bins earlier, near the bottleneck, or without a transformer led to unstable training, which either diverged or converged to a poor point §1.
- A per-pixel Chamfer loss is too costly: about 300K locations per image at full resolution. Subsampling about 2% of the pixels gave worse results §3.3.1.
- A fixed-size window around each pixel has two problems. The window size is hard to choose, and several sizes at once give inconsistent targets §3.3.
Method
Encoder-decoder. The network uses the same EfficientNet-B5 encoder with skip connections as AdaBins, so the comparison is fair §3.2. The paper calls the LocalBins module lightweight, adding about 1M parameters, and says it can be used with any encoder-decoder §1. The decoder blocks are not described in the text; they are upsample, concatenate with the skip, then two 3×3 convolutions with batch norm and LeakyReLU localbins.py.
Bin embeddings. Every feature map entering the module is projected to a 128-channel "bin embedding space" by a small 1×1-convolution MLP §3.2 a.
Seed bins. At the bottleneck, the module predicts N_seed positive widths per pixel, normalised to sum to one §3.2 b localbins.py.
Coarse-to-fine splitting. At each decoder layer, every bin of the previous layer is split into two. The splitter MLP sees the current embedding plus the upsampled previous embedding §3.2 c. Its output gives a fraction α for each bin eq. 1; the two new widths are α·b and (1−α)·b eq. 2. The paper gives three choices for α: a constant 0.5, a sigmoid, or a linear-norm split §3.2. The linear-norm split is x1/(x1+x2+ε) with ε = 1e-4 eq. 3. The configured model uses the linear-norm splitter config.py.
Output. After n layers the bin count is 2ⁿ·N_seed §3.2. The final layer outputs logits over all bins; a softmax over the bins gives probabilities localbins.py. The bin centres are computed from the widths eq. 4, and depth is the sum of probability times centre eq. 5. The code's centre formula differs from eq. 4 (see Paper vs code).
Query-response training. The training idea is a locality constraint: for any box in the image, the module applied to the box's pooled features must predict the depth distribution inside that box §3.3.1. Per box:
- Pool bottleneck and decoder features over the box with ROIAlign and average pooling §3.3.1 §3.3.2 step 3.
- Run the same seed, embedding and splitter MLPs on the pooled features §3.3.1.
- Compare the resulting bins with the depths inside the box, using the one-dimensional bidirectional Chamfer loss from AdaBins §3.3.1.
Box sets and weights. Five sets of random boxes with sides 3, 7, 15, 31 and 63 pixels, 200 boxes each §3.3.2 step 1. Loss weights decay exponentially with box size, so smaller boxes count more eq. 6. Each decoder layer also has a weight that decays towards the bottleneck eq. 6. Both decay factors are 0.3 §3.3.2.
Total loss. L_total = L_pixel + β·L_bins, with β = 0.02 eq. 7 §3.3.2. L_pixel is the scale-invariant loss of AdaBins and BTS §3.3; the paper gives no formula for it.
Training recipe. Batch size 16, AdamW with weight decay 0.1, learning rate 3.57e-4, decayed by 10⁴ with cosine decay over the last 30% of iterations, for 10 epochs §4.
Pseudocode for the forward pass (the code is the reference where the paper omits a value; see Paper vs code):
# Forward pass of the per-pixel bin head [§3.2] [eq. 1-5]
# Input: image (B, 3, H, W)
# Output: depth (B, 1, h, w); the loss resizes it to the ground truth
def localbins_forward(image):
# Encode, keeping every stage for the skip connections [§3.2]
stages = encoder(image)
# The code passes the bottleneck through an extra 1x1 conv first
# [code: models/localbins.py#L276]
bottleneck = conv_bottleneck(stages[-1])
# Seed: N_seed positive widths per pixel, summing to 1 [§3.2 b]
prev_widths = seed_regressor(bottleneck) # (B, N_seed, h, w)
prev_embed = seed_projector(bottleneck) # (B, 128, h, w)
feat = bottleneck
for up, project, split, skip in decoder_layers:
# Upsample and fuse the skip connection
# [code: models/localbins.py#L33-L42]
feat = up(feat, skip)
# Bin embedding of this layer [§3.2 a]
embed = project(feat)
# Split every previous bin in two [§3.2 c] [eq. 1-3]
prev_widths = split(embed, prev_widths, prev_embed)
prev_embed = embed
# Logits over all final bins, softmax over bins [§3.2] [eq. 5]
probs = softmax(conv_out(feat), dim=1)
# Bin centres from the final widths [eq. 4]
# [code: models/localbins.py#L126-L131]
centres = bin_centres(prev_widths)
# Depth is the probability-weighted sum of the centres [eq. 5]
return sum(probs * centres, dim=1)Bin centres, as the code computes them. This differs from eq. 4 (see Paper vs code):
# Bin centres from normalised widths [eq. 4]
# [code: models/localbins.py#L126-L131]
def bin_centres(widths):
# Scale the widths to the depth range [eq. 4]
widths = (max_depth - min_depth) * widths # (B, n, h, w)
# Append a trailing width of min_depth, then take cumulative edges
widths = pad_last(widths, min_depth)
edges = cumsum(widths, dim=1)
# Centre k is the midpoint of edges k and k + 1
return 0.5 * (edges[:, :-1] + edges[:, 1:])The linear-norm split, as the code computes it (see Paper vs code for ε):
# Split one bin into two fractions [§3.2 eq. 1-3]
# Input: two positive values per bin from the splitter MLP
# Output: fraction for the first and second child bin
def linear_norm_split(x1, x2):
# Add the same small constant to both values before normalising
# [code: models/localbins.py#L112-L116]
x1 = x1 + eps
x2 = x2 + eps
# Fraction of the parent width kept by the first child [eq. 3]
alpha = x1 / (x1 + x2)
return alpha, 1 - alphaThe training loss:
# Training loss [§3.3] [eq. 6-7]
# Inputs: pred (B, 1, h, w); depth_gt (B, 1, H, W) in metres
# Output: scalar loss
def total_loss(pred, depth_gt, layer_bins, boxes):
# Pixel loss on valid ground-truth pixels [§3.3] [eq. 7]
l_pixel = silog(pred, depth_gt)
# Query-response loss over all layers and box sizes [eq. 6]
l_bins = query_response_loss(layer_bins, depth_gt, boxes)
# Weighted sum, beta = 0.02 [eq. 7]
return l_pixel + 0.02 * l_bins# Scale-invariant log loss, constants from the code [§3.3]
# [code: trainers/loss.py#L27-L35]
def silog(pred, depth_gt):
# Log error on the valid pixels (ground truth in (1e-3, 10) m)
diff = log(pred) - log(depth_gt)
# 10 * sqrt(variance + 0.15 * mean^2); the paper gives no formula
return 10 * sqrt(variance(diff) + 0.15 * mean(diff) ** 2)# Query-response Chamfer loss [§3.3.1] [§3.3.2] [eq. 6]
# bins[layer][size]: (B, M, n_bins), with M = 200 boxes per size
# Layers run from the bottleneck to the output
def query_response_loss(bins, depth_gt, boxes):
total = 0
for layer_index, layer in enumerate(layers):
# Layers nearer the bottleneck get a smaller weight [eq. 6]
layer_weight = 0.3 ** (num_layers - 1 - layer_index)
layer_sum = 0
weight_sum = 0
for size_index, size in enumerate(sizes):
# Smaller boxes get a larger weight, 0.3 ** size_index [eq. 6]
size_weight = 0.3 ** size_index
# Keep only boxes with over half of their pixels valid
# [code: trainers/loss.py#L141-L149]
keep = valid_fraction(depth_gt, boxes[size]) > 0.5
# Chamfer distance between predicted bins and box depths [§3.3.1]
loss = chamfer(bins[layer][size][keep],
box_depths(depth_gt, boxes[size][keep]))
layer_sum += size_weight * loss
weight_sum += size_weight
# The code divides each layer's sum by the sum of size weights,
# which eq. 6 does not do [code: trainers/loss.py#L221]
total += layer_weight * layer_sum / weight_sum
return totalHyperparameters
| Name | Value | Where | Notes |
|---|---|---|---|
| Encoder | EfficientNet-B5 with skip connections | §3.2 | Code: tf_efficientnet_b5_ap config.py. Initialised from timm pretrained weights efficientnet.py; the paper does not say this. |
| Bin embedding dimension | 128 | §3.2 §4 | localbins.py |
| Seed MLP hidden width | 256 | §4 | localbins.py |
| Projector and splitter hidden width | 128 | §4 | localbins.py localbins.py |
| N_seed | not stated | §3.2 | Code default 8 localbins.py; final bins 2⁴ × 8 = 128 localbins.py. The LaTeX source has a commented-out paragraph with N_seed = 16 (arxiv.tex line 325); it is not in the compiled paper, so this card does not use it. |
| Number of decoder layers | not stated | §3.2 | Code uses four, at scales 16, 8, 4, 2 localbins.py. |
| Splits per layer | 2 | §3.2 | localbins.py |
| Splitter ε | 1e-4 | §3.2 eq. 3 | Code adds 1e-3 to each value instead (see Paper vs code). localbins.py |
| Batch size | 16 | §4 | config.py |
| Epochs | 10 | §4 | config.py |
| Optimiser | AdamW | §4 | base_trainer.py |
| Learning rate | 3.57e-4 | §4 | config.py |
| Learning-rate schedule | Cosine decay; reduced by 10⁴ over the last 30% | §4 | Code: OneCycle, div_factor 1, pct_start 0.7, final_div_factor 1e4 config.py. With div_factor 1 the rate is flat for the first 70%. This follows from the config, not the paper. |
| Weight decay | 0.1 | §4 | config.py |
| Gradient-norm clip | not stated | not in paper | 0.1 config.py localbins_trainer.py |
| Weight of L_pixel | 1 | eq. 7 | config.py |
| β (weight of L_bins) | 0.02 | eq. 7 §3.3.2 | config.py |
| Box sides | 3, 7, 15, 31, 63 px | §3.3.2 | config.py |
| Boxes per size | 200 | §3.3.2 | config.py |
| γ for layers | 0.3 | eq. 6 §3.3.2 | config.py config.py |
| γ for box sizes | 0.3 | eq. 6 §3.3.2 | config.py loss.py |
| Input resolution | not stated | not in paper | 480 × 640 config.py |
| Depth range | not stated (d_min, d_max only) | §3.1 | 1e-3 to 10 m config.py |
| Softmax temperature | not stated | not in paper | Annealed from init_temp to final_temp; both 1 config.py localbins.py |
| Training augmentation | not stated | not in paper | Horizontal flip, colour and brightness, ±1° rotation; no random crop data_mono.py data_mono.py data_mono.py config.py |
Results
Author-reported. Setup: NYU-Depth V2, the official test set, a model trained on NYU §5.1, EfficientNet-B5 encoder tab. 1. Training hardware is not stated. Baseline numbers are copied from the original papers, per the table caption tab. 1.
NYU-Depth V2 tab. 1
| Method | Encoder | #p | δ1 ↑ | δ2 ↑ | δ3 ↑ | REL ↓ | RMS ↓ | log10 ↓ |
|---|---|---|---|---|---|---|---|---|
| Eigen et al. | - | 141 | 0.769 | 0.950 | 0.988 | 0.158 | 0.641 | -- |
| Laina et al. | ResNet-50 | 64 | 0.811 | 0.953 | 0.988 | 0.127 | 0.573 | 0.055 |
| Hao et al. | ResNet-101 | 60 | 0.841 | 0.966 | 0.991 | 0.127 | 0.555 | 0.053 |
| Lee et al. | - | 119 | 0.837 | 0.971 | 0.994 | 0.131 | 0.538 | -- |
| Fu et al. | ResNet-101 | 110 | 0.828 | 0.965 | 0.992 | 0.115 | 0.509 | 0.051 |
| SharpNet | - | - | 0.836 | 0.966 | 0.993 | 0.139 | 0.502 | 0.047 |
| Hu et al. | SENet-154 | 157 | 0.866 | 0.975 | 0.993 | 0.115 | 0.530 | 0.050 |
| Chen et al. | SENet | 210 | 0.878 | 0.977 | 0.994 | 0.111 | 0.514 | 0.048 |
| Yin et al. | ResNeXt-101 | 114 | 0.875 | 0.976 | 0.994 | 0.108 | 0.416 | 0.048 |
| BTS | DenseNet-161 | 47 | 0.885 | 0.978 | 0.994 | 0.110 | 0.392 | 0.047 |
| AdaBins | EfficientNet-B5 | 78 | 0.903 | 0.984 | 0.997 | 0.103 | 0.364 | 0.044 |
| LocalBins (ours) | EfficientNet-B5 | 74 | 0.907 | 0.987 | 0.998 | 0.099 | 0.357 | 0.042 |
The #p unit is not stated in the table; Table 7 uses millions tab. 7. The text reports about 4% lower absolute relative error than AdaBins §5.1.
Zero-shot, iBims-1 (NYU model, no fine-tuning) tab. 2
| Method | δ1 ↑ | δ2 ↑ | δ3 ↑ | REL ↓ | RMS ↓ | log10 ↓ |
|---|---|---|---|---|---|---|
| BTS | 0.54 | 0.86 | 0.95 | 0.23 | 0.93 | 0.11 |
| AdaBins | 0.55 | 0.87 | 0.96 | 0.21 | 0.90 | 0.11 |
| LocalBins (ours) | 0.56 | 0.88 | 0.97 | 0.21 | 0.88 | 0.10 |
Zero-shot, SUN RGB-D (NYU model, no fine-tuning, official test set of 5050 images) tab. 5
| Method | δ1 ↑ | δ2 ↑ | δ3 ↑ | REL ↓ | RMS ↓ | log10 ↓ |
|---|---|---|---|---|---|---|
| Chen et al. | 0.757 | 0.943 | 0.984 | 0.166 | 0.494 | 0.071 |
| Yin et al. | 0.696 | 0.912 | 0.973 | 0.183 | 0.541 | 0.082 |
| BTS | 0.740 | 0.933 | 0.980 | 0.172 | 0.515 | 0.075 |
| AdaBins | 0.771 | 0.944 | 0.983 | 0.159 | 0.476 | 0.068 |
| LocalBins (ours) | 0.777 | 0.949 | 0.985 | 0.156 | 0.470 | 0.067 |
Ablation (NYU, REL and RMS; ✓ = component on, ✗ = off; the table has no rows 6 and 7) tab. 3
| Row | Enc-Dec | LBM | Naive | QR | L_bins | Foveated | REL ↓ | RMS ↓ |
|---|---|---|---|---|---|---|---|---|
| 1 | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ | 0.111 | 0.419 |
| 2 | ✓ | ✓ | ✗ | ✗ | ✗ | ✗ | 0.106 | 0.375 |
| 3 | ✓ | ✓ | 3×3 | ✗ | ✓ | ✗ | 0.108 | 0.381 |
| 4 | ✓ | ✓ | 5×5 | ✗ | ✓ | ✗ | 0.107 | 0.375 |
| 5 | ✓ | ✓ | 15×15 | ✗ | ✓ | ✗ | 0.108 | 0.377 |
| 8 | ✓ | ✓ | ✗ | ✓ | ✓ | ✗ | 0.099 | 0.364 |
| 9 | ✓ | ✓ | ✗ | ✓ | ✓ | ✓ | 0.099 | 0.357 |
In the Naive column, the number is the box side on the ground truth used for the density tab. 3.
Efficiency of the query-response scheme. Columns: PSCI counts the set comparisons made per image, #px counts the covered pixels, and Coverage is the covered share of the image tab. 4.
| Scheme | PSCI | #px | Coverage (%) ↑ | REL ↓ |
|---|---|---|---|---|
| Naive | 4096 | 4096 | 1.33 | 0.1075 |
| Naive | 8192 | 8192 | 2.67 | 0.1071 |
| Query-Response | 250 | 52,130 | 16.97 | 0.1043 |
| Query-Response | 500 | 104,260 | 33.94 | 0.1002 |
| Query-Response | 1000 | 208,520 | 67.88 | 0.0992 |
Splitter activation tab. 6
| Splitter | REL ↓ | RMS ↓ |
|---|---|---|
| Constant | 0.117 | 0.454 |
| Sigmoid | 0.100 | 0.361 |
| Linear norm | 0.099 | 0.364 |
Backbones (NYU, appendix) tab. 7
| Backbone | #params (M) | δ1 | δ2 | δ3 | REL | RMS | log10 |
|---|---|---|---|---|---|---|---|
| MobileNetV2-100 | 20.26 | 0.812 | 0.963 | 0.992 | 0.141 | 0.480 | 0.060 |
| EfficientNetV2-S | 38.71 | 0.894 | 0.981 | 0.995 | 0.106 | 0.376 | 0.045 |
| EfficientNetV2-M | 71.53 | 0.898 | 0.983 | 0.996 | 0.102 | 0.365 | 0.044 |
| EfficientNetV2-L | 136.3 | 0.910 | 0.986 | 0.997 | 0.098 | 0.351 | 0.042 |
The Table 7 rows change only the encoder; the default EfficientNet-B5 row is not in this table app. A.2.
Qualitative and bin-level figures. Figure 1 contrasts global and local bins fig. 1; Figure 2 gives the architecture fig. 2; Figures 3 and 4 show the LocalBins module and query-response training fig. 3 fig. 4; Figures 5 and 7 are qualitative results on iBims-1 and NYU fig. 5 fig. 7; Figure 6 plots REL against the number of bins fig. 6. The appendix shows bin predictions against local depth histograms fig. 8, and the distance between ground-truth depths in concentric boxes and the nearest predicted bin centre fig. 9 app. A.1.
Paper vs code
Official code: shariqfarooq123/LocalBins at code_commit, linked from the
paper's abstract footnote §1, abstract. The repository's owner is an author.
The repository is GPL-3.0. This card paraphrases it and quotes none of it.
- Layer weights. Eq. 6 uses γ^(n−L) with γ = 0.3 §3.3.2. The default in
the training config is
loss_wts_scale = "0,0,0,1", which would train only the final layer config.py. Butgamma_scale = 0.3replaces it with weights 0.027, 0.09, 0.3 and 1 for scales 16, 8, 4 and 2 [code: utils/config.py#L212-L214] loss.py. Those match eq. 6 for four layers. Read the override, not the default. - Per-layer normalisation. Each layer's sum is divided by the sum of its box-size weights loss.py. Eq. 6 has no such division, so the effective β differs from 0.02 by a per-layer factor.
- Box filtering. Boxes are kept only if over half of their pixels have depth in (1e-3, 10) m loss.py. The paper does not mention this. If no box survives at a size, that size's weight still decays loss.py.
- Chamfer reduction. The code calls pytorch3d's
chamfer_distancewith no reduction argument loss.py loss.py. The paper does not state a reduction. - Scale-invariant loss. The paper gives no formula. The code uses 10·√(Var(g) + 0.15·mean(g)²) with g = log(pred) − log(gt) and no offset loss.py.
- Bin centres are offset by one bin. Eq. 4 gives centre k as the sum of widths before k plus half of width k. The code takes the midpoint of consecutive cumulative edges, after a trailing min-depth width is appended localbins.py. Read this way, code centre k equals eq. 4's centre k+1, and the last centre sits near d_max. The code also has no d_min offset. I read this from the code and did not run it; check it numerically before reimplementing.
- Splitter ε. Eq. 3 puts ε = 1e-4 in the denominator. The code adds 1e-3 to both values before normalising, so the split is (x1+ε)/(x1+x2+2ε) localbins.py.
- MLP depth. The paper says the MLPs have "two hidden layers" §3.2. Each code MLP is two 1×1 convolutions with one activation between them, which is one hidden activation localbins.py localbins.py. If "two hidden layers" means two linear layers, the code matches the paper; the wording is ambiguous.
- N_seed and bin count. The paper gives no value in the compiled text. The
code's decoder default is 8 localbins.py, giving 128 final
bins localbins.py. The config's
n_bins = 256config.py is passed asn_local_bins, which the decoder never uses localbins.py. - Extra bottleneck conv. The bottleneck passes through a 1×1 convolution with padding 1, which enlarges the map by 2 pixels per side. The paper does not describe this layer localbins.py.
- Temperature. The code has a softmax temperature annealed from
init_temptofinal_templocalbins_trainer.py localbins.py. Both are 1 in the config, so it has no effect config.py. The paper does not mention it. - Optimiser and clipping. Encoder and decoder share one learning rate config.py base_trainer.py. The code clips the gradient norm at 0.1 localbins_trainer.py. OneCycle also cycles momentum between 0.85 and 0.95 for AdamW base_trainer.py. None of this is in the paper.
- Augmentation. Training uses horizontal flip, colour and brightness jitter, and ±1° rotation on NYU; it does not crop data_mono.py data_mono.py data_mono.py config.py. Depth is stored in millimetres and divided by 1000 data_mono.py. The paper says none of this.
- Evaluation protocol. Evaluation uses an Eigen crop at rows 45–471 and columns 41–601 misc.py. Ground truth is valid in (1e-3, 10) m, and predictions are clipped to that range misc.py. The compiled paper does not state its crop or depth cap.
- Test-time flip.
evaluate.pyandeval_ibims.pyaverage the prediction with the one for the flipped image evaluate.py eval_ibims.py. Training-time validation does not localbins_trainer.py. The paper does not say whether Tables 1 and 2 use this. - Missing artefacts. There is no SUN RGB-D evaluation code in the repository, so Table 5 cannot be checked against this code. There is no pretrained checkpoint link in the repository; the README is two lines. The paper says code and models "will be made publicly available" §1.
- Tables and text. Table 4 and the text disagree on the headline gains. Table 4 has PSCI 1000 for query-response, which is 200 boxes times 5 sizes per image config.py config.py. The text says 8× fewer comparisons and about 7.6% better §5.3.2. The closest pair in the table is 8192 against 1000 (8.2×), with REL 0.1071 against 0.0992 (7.4%). The basis for 7.6% is not stated.
Pitfalls
- Box extent mismatch. The pooled box runs from x−k to x+k in feature coordinates, which is 2k wide, but the depth samples cover win pixels from −k to k inclusive localbins.py loss.py. For side 3, that is 2 against 3 pixels. Decide which one you match.
- Boxes are in full-resolution pixels. Centres are drawn per box size, with separate random draws for each size, kept inside the image bbox_utils.py. Pooling at each layer uses that layer's stride as the ROI scale localbins.py localbins.py.
- Shared weights. The query branch uses the same seed, embedding and splitter MLPs as the dense branch. Do not give it its own copy localbins.py localbins.py.
- Cost. Each image gives 200 boxes per size, 1000 per layer, and each box contributes a Chamfer term over its side² depth samples, up to 63² = 3969 config.py loss.py.
- Figure, table, equation and appendix numbers. There is no PDF in the tree. I counted figures, tables, equations and appendix sections in source order in arxiv.tex. Check them against the arXiv PDF before citing them elsewhere. Equation 3 is the linear-norm split; equations 4 and 5 are the centres and depth.
- Learning-rate schedule. The paper says "decayed by a factor of 10⁴ in the last 30%", which matches the config's final division. The flat first 70% comes from div_factor 1. The paper does not say it.
- Code license. The code is GPL-3.0. This card is paraphrased, with no verbatim snippets. Do not copy code from the repository into a commercial product without checking the GPL terms.
Lineage
- Builds on: AdaBins for the encoder-decoder, the adaptive bin idea, and the one-dimensional bidirectional Chamfer loss §3.1 §3.3.1. AdaBins itself is the main baseline tab. 1.
- Compared against: AdaBins, BTS, Chen et al., Yin et al., Hu et al., Fu et al., Laina et al., Eigen et al., Lee et al., Hao et al. and SharpNet tab. 1 tab. 5.
- Concurrent work mentioned: GLP-depth §2 and a fully-connected CRF decoder with a vision transformer encoder §2.
- Superseded by: not known from this wiki.
Source and license
Adapted from “LocalBins: Improving Depth Estimation by Learning Local Distributions” by Shariq Farooq Bhat, Ibraheem Alhashim, Peter Wonka (arXiv:2203.15132), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors. Code citations refer to https://github.com/shariqfarooq123/LocalBins at commit 47c1d44f5236 (GPL-3.0). Any quoted code is shown under that license.