---
title: 'YOLOv5-SPD: Enhanced Object Detection'
url: https://www.emergentmind.com/topics/yolov5-spd
type: topic
---

# YOLOv5-SPD: Enhanced Object Detection

YOLOv5-SPD refers to a family of modifications to the YOLOv5 object detection architecture, specifically involving integration of the SPD-Conv (Space-to-Depth Convolution) block in place of traditional strided convolution and pooling layers. This approach fundamentally alters the downsampling pathway to preserve more fine-grained spatial information, resulting in improved performance, especially for low-resolution images and small objects. The YOLOv5-SPD design has been empirically validated on benchmark datasets, demonstrating consistent improvements in small object detection metrics with only minor increases in model size and computational cost [2208.03641].

## 1. SPD-Conv Block and Model Architecture Alterations

YOLOv5-SPD replaces every stride-2 convolution and pooling operation in the standard YOLOv5 backbone (CSPDarknet53-SPP) and PANet neck with an SPD-Conv block. In the YOLOv5 backbone, there are five stride-2 convolutions responsible for progressively halving feature map resolution, and two more downsampling layers in the neck; all seven are replaced. The SPD-Conv block consists of a parameter-free SPD layer, which spatially rearranges the input tensor with scale factor $p=2$, followed by a standard $3\times3$ convolution with stride 1 that mixes the expanded set of channels.

The SPD operation maps an input $X\in\mathbb{R}^{H\times W\times C}$ to $\mathbb{R}^{(H/p)\times(W/p)\times(C\cdot p^2)}$, via deterministic reshuffling: for each input channel, the SPD operation extracts $p^2$ interleaved submaps and concatenates them along the channel axis.

The full sequence for downsampling thus becomes:
- An SPD layer rearranging the feature map to coalesce spatial neighborhoods into channels,
- Followed by a $3\times3$ convolution operating at stride 1.

| Stage                  | Original              | YOLOv5-SPD Operation    |
|------------------------|----------------------|-------------------------|
| Backbone conv1–5       | Conv2d (stride=2)    | SPD-Conv (scale=2)      |
| Neck downsample1–2     | Conv2d (stride=2)    | SPD-Conv (scale=2)      |

This design leaves the overall downsampling schedule and receptive field unchanged compared to the original stride-2 convolution design [2208.03641].

## 2. Mathematical Specification and Computational Properties

Let $X\in\mathbb{R}^{H\times W\times C}$ be a feature map and $p$ the scale factor. Space-to-depth reshuffling is defined as:
\[
\mathrm{SPD}(X)_{i,j,c\cdot p^2 + u\cdot p + v} = X_{i\cdot p + u,\,j\cdot p + v,\,c}
\]
for $c=0\ldots C-1$, $u,v=0\ldots p-1$.

Following the SPD layer, a regular $3\times3$ convolution with stride 1 is applied, with in-channels $C\cdot p^2$ and a chosen out-channels $C_2$ (typically close to input $C$ or the original YOLOv5 setting, to control model size).

Key computational effects:
- The receptive field after SPD-Conv matches the original stride-2 conv: the SPD + $3\times3$ conv covers a $6\times6$ region in the input, corresponding to a $3\times3$ patch in the downsampled grid.
- Parameter count can be matched to the original by setting $C_2 \approx C_{out}/p^2$.
- FLOPs are effectively unchanged since the SPD rearrangement is a reshaping and the convolution is sized to maintain equal computation:
\[
\mathrm{FLOPs}_{\mathrm{SPD}} = H\,W\,k^2\,C_{in}\,C_2
\]
\[
\text{Set } C_2\approx C_{out}/p^2 \implies \text{FLOPs}_{\mathrm{SPD}}\approx \text{FLOPs}_{\mathrm{orig}}
\]
[2208.03641].

## 3. Empirical Performance on Object Detection Benchmarks

YOLOv5-SPD was evaluated on COCO-2017 object detection benchmarks. For all model scales (nano, small, medium, large), the SPD-Conv replacement yielded consistent gains in AP on small objects (APS), with either matched or improved overall AP@[.5:.95]. Modest increases in parameter count (within 20%) were observed relative to the baseline.

Significant benchmark results:

| Model         | Params (M) | AP@[.5:.95] | APS  | ΔAPS vs. YOLOv5 |
|---------------|------------|------------|------|-----------------|
| YOLOv5n       | 1.9        | 28.1       |12.7  | —               |
| YOLOv5-SPD-n  | 2.2        | 30.4       |15.1  | +19.0%          |
| YOLOv5s       | 7.2        | 37.1       |20.0  | —               |
| YOLOv5-SPD-s  | 8.7        | 39.7       |21.9  | +9.5%           |
| YOLOv5m       |21.2        |45.5        |26.6  | —               |
| YOLOv5-SPD-m  |24.6        |46.6        |28.2  | +6.0%           |
| YOLOv5l       |46.5        |49.0        |29.9  | —               |
| YOLOv5-SPD-l  |52.7        |48.8        |30.0  | +0.3%           |

These results demonstrate that SPD-Conv consistently improves APS by 6–19% relative across all scales [2208.03641].

## 4. Training Strategy and Implementation

YOLOv5-SPD utilizes standard PyTorch implementations. The COCO-2017 dataset (train2017, val2017, test-dev2017) is used for training and evaluation, with input resolution fixed at $640\times640$ to accentuate small object performance. Training employs stochastic gradient descent with momentum (0.937), weight decay ($5\times10^{-4}$), a warm-up linear schedule followed by cosine decay, and batch sizes adapted to model scale.

Losses: Complete IoU (CIoU) for bounding box regression, binary cross-entropy for objectness and class. Data augmentation includes hue/saturation/value jitter, random translation/scale/shear, horizontal and vertical flips, Mosaic, and CutMix. No additional hyper-parameter tuning is required beyond inherited YOLOv5 defaults.

## 5. Practical Implementation: PyTorch Pseudocode

A succinct PyTorch-style pseudocode for the SPD-Conv block is given below:
```python
import torch
import torch.nn as nn

class SpaceToDepth(nn.Module):
    def __init__(self, p):
        super().__init__()
        self.p = p

    def forward(self, x):
        B, C, H, W = x.shape
        p = self.p
        assert H % p == 0 and W % p == 0
        x = x.view(B, C, H//p, p, W//p, p)
        x = x.permute(0, 1, 3, 5, 2, 4).contiguous()
        return x.view(B, C * p * p, H//p, W//p)

class SPDConv(nn.Module):
    def __init__(self, in_ch, out_ch, scale=2, k=3):
        super().__init__()
        self.spd = SpaceToDepth(scale)
        self.conv = nn.Conv2d(in_ch * scale * scale, out_ch, kernel_size=k, stride=1, padding=(k//2), bias=False)
        self.bn   = nn.BatchNorm2d(out_ch)
        self.act  = nn.SiLU()
    def forward(self, x):
        x = self.spd(x)
        x = self.conv(x)
        x = self.bn(x)
        return self.act(x)
```
To convert YOLOv5 to YOLOv5-SPD, replace each `Conv(c1, c2, k, s=2)` with `SPDConv(c1, c2, scale=2, k)` in the model definition [2208.03641].

## 6. Significance and Implications

The YOLOv5-SPD architecture eliminates information loss associated with strided convolutions and pooling, preserving fine spatial detail that is beneficial for tasks involving small objects and low-resolution imagery. The design achieves these improvements with minimal or negligible extra implementation complexity, only slight increases in model size, and essentially unchanged inference-time compute (FLOPs). The consistent APS gains across model sizes suggest that the SPD-Conv approach generalizes well. A plausible implication is that SPD-Conv can be adapted to other detection and classification backbones with similar benefits, particularly wherever fine-grained localization fidelity is crucial. The open-source code provided by LabSAINT enables further experimentation and broader adoption [2208.03641].

Source: https://www.emergentmind.com/topics/yolov5-spd