Partial Convolutions for Efficient Feature Extraction

94 concepts59 papers1 proposal

In the pursuit of deploying deep neural networks to resource-constrained edge devices, researchers have traditionally focused on minimizing the total number of floating-point operations (FLOPs). This focus led to the widespread adoption of depthwise separable convolutions (DWConv). However, minimizing FLOPs does not always translate to faster real-world inference. DWConv often suffers from low arithmetic intensity—the ratio of computation to memory access—which leads to severe memory bottlenecks and underutilization of hardware capabilities.

To overcome this limitation, a powerful architectural paradigm has emerged: Partial Convolution (PConv). By processing only a selective subset of feature channels while leaving the rest untouched, this approach eliminates computational redundancy and optimizes memory traffic, achieving significant speedups without sacrificing model accuracy.


The Redundancy Problem in Deep Feature Maps

If you visualize the feature maps across the layers of a deep convolutional neural network (CNN), you will notice a striking phenomenon: many channels look remarkably similar to one another. This high degree of cross-channel correlation represents significant computational redundancy.

Standard convolutional layers apply spatial filters to every single input channel, repeatedly recalculating highly correlated spatial structures. While DWConv attempts to save computation by separating spatial and channel-wise filtering, it requires frequent memory access to read and write every channel map. Because memory bandwidth is often the primary bottleneck on modern hardware, DWConv layers can spend more time moving data than performing actual computations.


The Core Mechanism: Channel-Selective Processing

Partial Convolution addresses this bottleneck through a simple yet highly effective strategy: split and select. Instead of applying spatial filters to the entire feature map, PConv splits the input channels into two groups:

  1. The Active Subset: A fraction of the input channels (typically $1/4$ or $1/2$) undergoes standard spatial convolution.
  2. The Passive Bypass: The remaining channels bypass the spatial operation entirely and are treated as an identity mapping.
Input Channels
[ C_1, C_2, ..., C_k ] --------> Spatial Convolution (3x3) ------> Output Sub-map \
                                                                                   ===> Concatenate
[ C_k+1, ..., C_in  ] --------> Identity Bypass -----------------> Output Sub-map /

As detailed by Jierun Chen et al. in Run, Don't Walk: Chasing Higher FLOPS for Faster Neural Networks, this mechanism drastically lowers both the parameter count and the computational workload. Crucially, because the passive channels require no computation and no memory modification during the spatial filtering phase, the layer maintains high arithmetic intensity on the active subset while avoiding unnecessary memory traffic.


Why It Works: Intuition and Information Flow

It might seem counterintuitive that ignoring a large portion of the channels during spatial convolution preserves accuracy. PConv works effectively due to three core principles:

1. Exploiting Redundancy

Because adjacent feature channels share highly correlated structural information, extracting spatial features from a representative subset is sufficient to capture the geometric context of the scene. The network does not lose critical spatial awareness; it simply stops recalculating it redundantly.

2. Implicit Residual Connections

By leaving a portion of the channels unchanged, PConv creates a natural bypass mechanism. As observed by Hao Yu et al. in FreeNet: Liberating Depth-Wise Separable Operations for Building Faster Mobile Vision Architectures, these unprocessed channels serve as an implicit residual connection. This design choice eliminates the need for explicit element-wise addition operations or separate residual branches, simplifying the computational graph and further reducing memory overhead during inference.

3. Information Multiplexing

To ensure that information flows across all channels over the course of the network, PConv is rarely used in isolation. It is typically paired with pointwise ($1 \times 1$) convolutions or channel shuffling operations. For example, Zhichao Lu et al. in MUXConv: Information Multiplexing in Convolutional Neural Networks utilize a channel shuffle step immediately following selective channel processing. This redistributes the newly extracted spatial features across the entire feature map, ensuring that subsequent layers can leverage the transformed information.


Maximizing Real-World Throughput (FLOPS)

The ultimate validation of PConv lies in its hardware efficiency. In hardware acceleration, there is a vital distinction between minimizing FLOPs (the total number of operations) and maximizing FLOPS (Floating-point Operations Per Second, or throughput).

While architectures like MobileNet minimize FLOPs, their low arithmetic intensity causes hardware execution units to sit idle waiting for data from memory. PConv strikes an optimal balance. By confining expensive spatial operations to a continuous block of memory (the active subset) and leaving the rest untouched, it achieves high hardware utilization. The network runs faster not just because it does less work, but because it does its work in a manner optimized for modern memory hierarchies.


Architectural Adaptations and Applications

The principle of partial channel computation has been adapted across various domains to optimize gradient flow and feature representation:

  • Gradient Path Optimization: The strategy of splitting feature maps so that only a subset undergoes intensive computation aligns with broader network design philosophies. Chien-Yao Wang et al. demonstrated in Designing Network Design Strategies Through Gradient Path Analysis that partial computation strategies reduce redundant gradient information, allowing more efficient backpropagation and parameter utilization.
  • Large-Kernel Scaling: Weihao Yu et al. in InceptionNeXt: When Inception Meets ConvNeXt applied this concept to large-kernel architectures. They showed that running expensive, large spatial kernels on only a fraction of the channels provides the benefits of an expansive receptive field while avoiding the steep computational tax typically associated with large kernels.
  • Edge Deployment: Because of its high efficiency, PConv has become a staple in real-time object detection models tailored for edge devices. For instance, Mingming Hu et al. in The application of a lightweight model FA-YOLOv5 with fused attention mechanism in insulator defect detection integrated partial convolutions into the YOLO framework, demonstrating substantial reductions in parameter counts and latency while maintaining the high precision required for real-time industrial deployment.

Key Foundational Work

NeST: A Neural Network Synthesis Tool Based on a Grow-and-Prune Paradigm (2019) — contributed 1 concept elements to this direction.
MUXConv: Information Multiplexing in Convolutional Neural Networks (2020) — contributed 1 concept elements to this direction.
History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 64 papers
  2. Version 1 · 2026-10-04 · 58 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_partial_convolution_f6b82c91,
  title = {partial convolution},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/partial-convolution/rdr_f6b82c91d15c49a2bb75c20232bb057b},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 2, frozen text):

@misc{lacuna_partial_convolution_f6b82c91_v2,
  title = {partial convolution},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/partial-convolution/rdr_f6b82c91d15c49a2bb75c20232bb057b/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake