---
title: 'Light-C3k2: Efficient Cross-Stage Partial Block'
url: https://www.emergentmind.com/topics/c3k2-cross-stage-partial-block
type: topic
---

# Light-C3k2: Efficient Cross-Stage Partial Block

The C3k2 Cross-Stage Partial Block, specifically in its Light-C3k2 form, is a lightweight neural network module introduced in the context of the LSP-YOLO architecture for real-time sitting posture recognition on embedded devices. By leveraging partial convolution (PConv) and the parameter-free Similarity-Aware Activation Module (SimAM), Light-C3k2 substantially reduces computational cost and parameter count while maintaining strong feature extraction capability. The resulting building block offers an efficient alternative to standard CSP modules containing full Bottleneck blocks, making it well-suited for edge deployment scenarios where resources are constrained [2511.14322].

## 1. Design Motivation and Network Placement

In the original YOLOv11-Pose backbone, the “C3k2” block is a Cross-Stage-Partial (CSP) module that incorporates two standard Bottleneck sub-blocks composed of 3×3 convolutions applied to all channels. Although powerful for representation, this design is computationally intensive in terms of both parameters and FLOPs. LSP-YOLO seeks to simultaneously (a) drastically reduce the per-block cost and (b) preserve or restore the representational capability lost due to parameter reduction.

Two core mechanisms are introduced in every Bottleneck unit within the CSP module:
- **Partial Convolution (PConv):** Only a fraction $r$ of the channels undergo the $k\times k$ convolution, reducing the compute load by approximately $(1 - r^2)$.
- **SimAM:** This closed-form, parameter-free, energy-based attention mechanism reweights all neurons, compensating for the representational loss in untouched channels.

The resulting Light-C3k2 replaces every traditional C3k2 block within both the backbone and neck regions of LSP-YOLO [2511.14322].

## 2. Module Architecture and Data Flow

Let $X\in\mathbb{R}^{C\times H\times W}$ denote the input feature map. The Light-C3k2 module executes the following sequence:

1. **Split Convolution:** Apply a $1 \times 1$ convolution to reduce channels to $C’ = C/2$:
   $$
   Y_0 = \mathrm{Conv}_{1\times1}^{(C\rightarrow C/2)}(X), \quad Y_0\in\mathbb{R}^{(C/2)\times H\times W}
   $$
   Followed by BatchNorm and SiLU (or ReLU) activation.

2. **Dual Branch Processing:**
   - **Branch A:** Two sequential Light-Bottleneck units, each maintaining channel count $C/2$.
   - **Branch B:** Yields $Y_0$ via identity (no transformation).

3. **Concatenation:** Channelwise concatenation:
   $$
   Y_{\mathrm{cat}} = \mathrm{concat}(B_2\circ B_1(Y_0),\, Y_0) \in \mathbb{R}^{C\times H\times W}
   $$

4. **Merge Convolution:** $1 \times 1$ convolution restores the channel dimension to $C$ (or a configurable $C_{\text{out}}$):
   $$
   Z = \mathrm{Conv}_{1\times1}^{(C\rightarrow C)}(Y_{\mathrm{cat}}) \in \mathbb{R}^{C\times H\times W}
   $$
   With BatchNorm and activation.

Branch A’s Light-Bottleneck units adopt the following internal structure.

## 3. Light-Bottleneck: Internal Mechanisms

Given input $U \in \mathbb{R}^{C’ \times H \times W}$, each Light-Bottleneck operates as follows:

1. **Partial $k \times k$ Convolution:** $r\cdot C’$ channels are convolved, the remainder $(1 - r) \cdot C’$ are statically routed. Followed by BatchNorm and nonlinearity $\sigma$.
2. **First Pointwise $1 \times 1$ Convolution:** Applied to all channels, with BatchNorm and activation.
3. **Second Pointwise $1 \times 1$ Convolution:** BatchNorm only; this design reduces channel mixing cost.
4. **SimAM Attention:** Parameter-free energy-based mask $A\in\mathbb{R}^{C’\times H\times W}$ is computed and applied via elementwise product: $U_4 = A \odot U_3$.
5. **Residual Add & Activation:** Final output is $U' = \sigma(U + U_4)$.

This structure leverages PConv for efficiency, pointwise convolutions for inter-channel blending, and SimAM to compensate for restricted channel mixing.

## 4. Precise Layer Configurations

All operations are specified concretely:
- **Split/merge convolutions:** $1\times1$ kernel, $C \leftrightarrow C/2$ channels, stride 1, zero padding, with BatchNorm and SiLU/RELU.
- **PConv:** $3\times3$ kernel by default ($k=3$), operating on $r\cdot C’$ of $C’$ channels, stride 1, padding 1, followed by BatchNorm and nonlinearity.
- **Pointwise convolutions:** Each $1\times1$, $C’ \rightarrow C’$ (stride 1, zero padding), followed by BatchNorm and activation (first conv), or BatchNorm only (second conv).
- **SimAM:** Applied to all $C’$ channels, yielding a channelwise-sigmoid energy mask; no learnable parameters.

This exact configuration enables plug-and-play adoption for any generic $C$ and $H\times W$, with a default PConv split ratio $r = 0.5$.

## 5. Transformations and Feature Map Notation

The following expressions summarize the intermediate computations:
- **Splitting (input to $Y_0$):**
  $$
  Y_{0} = \mathrm{Conv}_{1\times1}(X), \quad Y_{0}\in\mathbb{R}^{\frac{C}{2}\times H\times W}
  $$
- **Branch A: Sequential Light-Bottlenecks:**
  $$
  U^{(0)} = Y_{0},\quad
  U^{(i+1)} = \sigma\Bigl(U^{(i)} + \mathrm{SimAM}\bigl(\mathrm{Conv}_{1\times1}(\mathrm{Conv}_{1\times1}(\mathrm{PConv}(U^{(i)})))\bigr)\Bigr)
  $$
  for $i=0,1$ (two applications).
- **Branch B:**
  $$
  V = Y_{0}
  $$
- **Concatenate and merge:**
  $$
  Y_{\mathrm{cat}} = \mathrm{concat}(U^{(2)},\, V) \in \mathbb{R}^{C\times H\times W} 
  $$
  $$
  Z = \mathrm{Conv}_{1\times1}(Y_{\mathrm{cat}})\in\mathbb{R}^{C\times H\times W}
  $$

## 6. Parameter and FLOP Analysis

Let $C’ = C/2$. The parameter count for a standard C3k2 block is:
- Split conv: $C \cdot C’$
- Two Bottlenecks: $2$ $\times$ [($1\times 1$ conv $C’\to C’$) + ($3\times 3$ conv $C’\to C’$)] $= 2 \cdot (C’^2 + 9C’^2) = 20C’^2$
- Merge conv: $C’ \cdot C$

Total standard: $C^2 + 5C^2 = 6C^2$

For Light-C3k2 with PConv ratio $r$:
- Split and merge conv: $2C \cdot C’ = C^2$
- Two Light-Bottlenecks: $2 \times [9r^2C’^2 + 2C’^2]$
- Total: $2C^2 + 4.5r^2C^2$

The parameter ratio is:
$$
\frac{\mathrm{Params}_{\text{light}}}{\mathrm{Params}_{\text{std}}} = \frac{2 + 4.5r^2}{6}
$$
For $r=0.5$: $\frac{2+1.125}{6} \approx 0.52$ (about 48% fewer parameters). FLOPs scale analogously [2511.14322].

## 7. Computational Efficiency and Representational Integrity

Key mechanisms by which Light-C3k2 achieves its objectives include:
- **PConv savings:** Avoiding unnecessary convolutions across all channels, saving $(1-r^2)$ of the $k\times k$ cost.
- **SimAM regularization:** Parameter-free, closed-form attention that reweights all activations, mitigating any feature loss from PConv.
- **Residual connections:** Ensure information is preserved when an identity transformation suffices.
- **Balanced design:** Coupling PConv and SimAM within the CSP framework yields nearly the original expressivity at roughly half the parameter and FLOP budget.

This suggests the Light-C3k2 block offers an effective trade-off between computational savings and model capacity, specifically benefiting real-time embedded recognition tasks with stringent resource limits [2511.14322].

Source: https://www.emergentmind.com/topics/c3k2-cross-stage-partial-block