LR-ASPP: Lite Reduced Atrous Spatial Pyramid Pooling

• The paper introduces LR-ASPP, a semantic segmentation module that replaces expensive 3×3 atrous convolutions with efficient 1×1 convolutions and coarse pooling.
• It employs an additive fusion of pointwise, pooling, and skip connection branches to capture multi-scale context while reducing parameters and latency.
• LR-ASPP achieves near-identical accuracy to traditional ASPP with about 34% lower latency, making it ideal for mobile and resource-constrained applications.

Lite Reduced Atrous Spatial Pyramid Pooling (LR-ASPP) is an efficient semantic segmentation module introduced to deliver multi-scale contextual aggregation for real-time and resource-constrained applications. LR-ASPP achieves the essential field-of-view effects of classical Atrous Spatial Pyramid Pooling (ASPP) modules, while drastically reducing parameters, floating-point operations (FLOPs), and memory. Originating from research on mobile-centric segmentation models such as MobileNetV3, LR-ASPP is now a canonical approach in compact decoder architectures due to its strong trade-off between accuracy and computational cost, particularly on mobile CPUs (Howard et al., 2019).

1. Origins and Foundational Concepts

LR-ASPP is a direct descendant of the ASPP architecture first introduced in DeepLab for semantic segmentation (Chen et al., 2016). Classical ASPP employs parallel atrous convolutions with varying dilation rates to capture multi-scale context in a dense prediction setting. However, 3×3 atrous convolutions are computationally demanding, especially when applied to high-resolution feature maps. Early ASPP reductions included channel bottlenecking, branch pruning, and replacing spatial convolutions with depthwise separable variants (Chen et al., 2018).

The architectural philosophy of LR-ASPP, as delineated in "Searching for MobileNetV3" (Howard et al., 2019), is to eliminate expensive spatial convolutions entirely within the decoder, relying on 1×1 convolutions, very coarse pooling, and simple elementwise fusion strategies—making the design quantization-friendly and highly efficient on mobile hardware.

2. LR-ASPP Architecture and Data Flow

The canonical LR-ASPP module consists of three main pathways operating on backbone feature maps:

1. Pointwise Context Branch: Applies a 1×1 convolution to the high-level feature map (𝐹 ∈ ℝ^{B×H×W×C}), followed by batch normalization and a nonlinearity.
2. Coarse (SE-style) Pooling Branch: Pools the high-level feature map to a coarse spatial resolution (extremely coarse, possibly global), passes it through a 1×1 convolution, and bilinearly upsamples the result to match input spatial resolution.
3. Low-level Skip Connection: Projects low-level backbone features with a 1×1 convolution, upsamples to match the main branch's resolution, and adds it to the merged context.

Fusion in LR-ASPP is performed via elementwise addition (not concatenation), eliminating the need for a post-concatenation 1×1 fusion convolution. The final output is produced by a 1×1 classification layer, followed by a final upsampling step.

Pseudocode for the LR-ASPP forward pass (as in (Howard et al., 2019)):

def LR_ASPP(high_feats, low_feats): # high_feats: [B, H, W, C], low_feats: [B, H_s, W_s, C_s] F = decoder_channels # e.g. 256 or 128 # Branch 1: 1×1 conv y1 = Conv1x1(high_feats, out_ch=F) y1 = BatchNorm(y1) y1 = Activation(y1) # Branch 2: coarse pooling + 1×1 conv p = PoolSize # e.g. H or some divisor s = AvgPool(high_feats, ksize=(p,p), stride=(p,p)) s = Conv1x1(s, out_ch=F) s = BatchNorm(s) s = Activation(s) y2 = BilinearUpsample(s, size=(H, W)) # Merge context m = y1 + y2 # elementwise addition # Skip connection from low-level s3 = Conv1x1(low_feats, out_ch=F) s3 = BatchNorm(s3) s3 = Activation(s3) s3_up = BilinearUpsample(s3, size=(H, W)) # Fuse m2 = m + s3_up # Final logits logits = Conv1x1(m2, out_ch=num_classes) out = BilinearUpsample(logits, orig_size) return out

3. Computational Complexity and Parameter Analysis

LR-ASPP eliminates all spatial 3×3 or dilated convolutions from the decoder, operating primarily with 1×1 convolutions and coarse pooling, which are highly optimized on mobile hardware. The computational cost of the main operations is:

• FLOPs for pointwise branch: $H \cdot W \cdot C \cdot F$
• FLOPs for pooled context: $$\frac{H \cdot W}{P^2} \cdot C \cdot F + H \cdot W \cdot F$$ (upsample)
• FLOPs for skip connection: $$H_s \cdot W_s \cdot C_s \cdot F + H \cdot W \cdot F$$ (upsample)

Total parameter count:

$P_{\text{LR-ASPP}} = 2CF + C_s F$

For MobileNetV3 + LR-ASPP (OS=16, filters=256), total FLOPs are 10.33B, compared to 13.68B for a MobileNetV2 + R-ASPP baseline (Howard et al., 2019).

LR-ASPP achieves $\sim$34% lower latency at nearly identical accuracy: 72.37% mean IoU (mIoU) for Cityscapes full-resolution inference (1024×2048) at 2.55s per image, versus 72.56% and 3.03s for the R-ASPP baseline (Howard et al., 2019).

4. Context Field and Multi-scale Aggregation

Unlike classical ASPP modules—where multi-scale context is captured via parallel atrous convolutions with diverse dilation rates—LR-ASPP approximates contextual coverage by combining a 1×1 context branch (receptive field=1) and a pooled context branch (receptive field ≈ input height). The effective receptive field is:

$R_{\text{LR-ASPP}} = \max(R_1, R_2) \approx H$

where $R_1=1$ (for 1×1 conv) and $R_2 \approx H$ (for pooled context). The dense context modeling effect is transferred from spatially dilated convolutions to pooling and pointwise feature mixing.

Atrous convolutions are retained in the backbone for optional output stride adjustment (e.g., rate=2 or 4), but are not used inside the LR-ASPP decoder itself (Howard et al., 2019).

5. Comparison with Alternative ASPP Variants

A summary contrast of LR-ASPP with classical ASPP and intermediate reduced forms is as follows:

Module	Context Capture	Params (typ.)	FLOPs (typ.)	Key Design
ASPP	3×3 atrous, multi-rate	~2M	High	4-5 parallel spatial branches (Chen et al., 2016)
R-ASPP	1×1 conv + global pooling	Reduced	Reduced	Two-branch concat/fuse (Howard et al., 2019)
LR-ASPP	1×1 conv + pooled avg	Minimal	Minimal	Additive fusion, no spatial convs, skip for boundaries (Howard et al., 2019)

This reduction is achieved with a minor degradation in mIoU (–0.19% on Cityscapes vs R-ASPP, see Section 5), while latency and memory are substantially reduced. Depthwise separable convolutions, as employed in earlier "lite" ASPP modules (Chen et al., 2018), offer an alternative form of reduction, but LR-ASPP goes further by obviating spatial convolutions in the decoder entirely.

6. Practical Impact and Deployment Considerations

LR-ASPP is specifically designed for real-time and mobile deployment. Branch merging is additive rather than concatenative, which avoids channel inflation and further reduces memory movement. All decoder operations—1×1 convolutions and pooling—are efficient on mobile CPUs and compatible with quantized inference.

Skip connections from early backbone features (e.g., stride-4 or stride-8 outputs) allow efficient recovery of boundary information despite the absence of a full decoder module. This approach enables minimal accuracy loss (<0.3% mIoU on PASCAL VOC and Cityscapes for comparable branch width) while cutting ASPP parameters up to 12× and end-to-end inference time by 1.5× or more in conventional GPU settings (Chen et al., 2018).

7. Limitations and Hyper-parameter Sensitivity

LR-ASPP introduces an explicit trade-off between parameter efficiency and segmentation accuracy. Choosing overly small decoder widths (e.g., fewer than 32 channels) leads to marked accuracy deterioration (>1% mIoU drop (Chen et al., 2018)). The principal tuning parameter is the number of decoder output channels (F); empirical results indicate diminishing returns past 128 or 256 channels, but this should be cross-validated for each application and backbone.

Ablation studies report a 0.46% mIoU gain with LR-ASPP versus omitting the context module entirely (MobileNetV3, Cityscapes), at an 8.1% reduction in FLOPs and 1.3% latency savings (Howard et al., 2019). The design omits fine-grained multi-scale context available in classical ASPP, but achieves a favorable Pareto frontier for real-time applications where computational budget is paramount.

---

LR-ASPP thus represents a principled re-architecture of the ASPP paradigm, retaining essential dense prediction capabilities while tailoring design trade-offs to the operational constraints of mobile and embedded inference. Its widespread adoption reflects consensus on its effectiveness for resource-limited segmentation tasks (Howard et al., 2019, Chen et al., 2018, Chen et al., 2016).