Layer Concatenate and Split (LCS) in Deep Learning

• Layer Concatenate and Split (LCS) is a design pattern that concatenates representations across layers and then selectively splits them through gating or partitioning to retain essential features.
• It improves performance in CNNs by using high-level semantic features to filter shallow ones and in LLM compression by preserving top channel subsets from adjacent layers.
• Empirical evaluations of SFCM and CoMe show that LCS mechanisms lead to improved accuracy, reduced error rates, and better preservation of critical information in diverse tasks.

Layer Concatenate and Split (LCS), in the neural-architecture sense suggested by recent literature, denotes a family of mechanisms that concatenate representations across layers and then apply selection, gating, partitioning, or reassembly before reuse. The literature considered here does not present a single canonical module under that exact name. Instead, closely related realizations appear in the Selective Feature Connection Mechanism (SFCM), which uses high-level semantic features to generate a spatial selector for low-level CNN features before concatenation (Du et al., 2018), and in CoMe, which compresses LLMs by selecting important channels from adjacent layers and concatenating those channel subsets into merged layers (Wang et al., 17 Oct 2025). In both cases, the central design claim is that direct, indiscriminate concatenation or direct layer removal is suboptimal because it either imports irrelevant low-level information or discards useful intermediate mappings.

1. Conceptual scope of LCS-style architectures

An LCS-style design combines two operations. The first is concatenation across layers: features, channels, or parameter subspaces from different depths are brought together into a joint representation. The second is a split-like operation: the combined or source representations are not treated uniformly, but are filtered, partitioned, or reweighted so that only part of the available information is transferred forward.

In CNN feature fusion, the motivating asymmetry is between shallow and deep features. Low-level features contain more local detail, edges, textures, and fine spatial structures, whereas high-level features contain stronger semantic abstraction and are closer to the task label. The difficulty is that shallow features are also more vulnerable to background clutter, semantic ambiguity, and noisy local patterns. SFCM addresses this by letting high-level features determine which shallow activations should survive fusion (Du et al., 2018).

In LLM compression, the motivating asymmetry is between complete layers and their internal channels. CoMe argues that prior structured layer pruning either removes whole blocks and destroys useful intermediate mappings or linearly aggregates layers under a false assumption of channel alignment. Its alternative is to preserve the most critical channels from adjacent layers and reassemble them into a compact layer (Wang et al., 17 Oct 2025). This suggests that “split” in LCS is not restricted to explicit branch splitting; it can also mean saliency-based partitioning of channels or spatial positions prior to concatenative reuse.

2. Selective concatenation in convolutional networks

SFCM is a general network architecture for concatenating CNN features of different layers in a simple and effective way. Let the low-level feature map be

$X \in \mathbf{R}^{H \times W \times C_1},$

and the high-level feature map be

$Y \in \mathbf{R}^{H \times W \times C_2}.$

A naive concatenation baseline is

$O = [X, Y],$

with

$O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$

The paper’s argument is that such direct fusion can introduce irrelevant background information and weaken the semantic representation learned in high layers. SFCM replaces this unconditional transfer with a selector generated from the high-level tensor (Du et al., 2018).

The feature selector is computed from the high-level feature map:

$M = W_g * Y,$

where $*$ denotes convolution and $W_g$ is implemented as a $1 \times 1$ convolution. Softmax normalization over spatial positions gives

$$S_{i,j}= \frac{exp(M_{i,j})}{\sum_{i=1}^W\sum_{j=1}^H exp(M_{i,j})},$$

so that

$S\in \mathbf{R}^{H \times W \times 1}.$

The selector is then broadcast across channels and applied to the low-level tensor:

$Y \in \mathbf{R}^{H \times W \times C_2}.$0

In direct connection mode, the fused output is

$Y \in \mathbf{R}^{H \times W \times C_2}.$1

The paper also defines a residual connection mode:

$Y \in \mathbf{R}^{H \times W \times C_2}.$2

followed by

$Y \in \mathbf{R}^{H \times W \times C_2}.$3

This residual variant is intended to make the block easy to insert into existing pretrained networks without disrupting their original behavior. The data flow is therefore: input tensors $Y \in \mathbf{R}^{H \times W \times C_2}.$4 and $Y \in \mathbf{R}^{H \times W \times C_2}.$5; selector generation from $Y \in \mathbf{R}^{H \times W \times C_2}.$6; spatial selection of $Y \in \mathbf{R}^{H \times W \times C_2}.$7; optional residual refinement; and final channel-wise concatenation.

From an LCS perspective, SFCM does not perform a classical channel split. The low-level tensor is instead separated conceptually into selected versus suppressed spatial components by the selector $Y \in \mathbf{R}^{H \times W \times C_2}.$8. The paper explicitly notes that its “split” is better understood as spatial gating rather than explicit tensor branching.

3. Empirical behavior of selective fusion

SFCM is evaluated on image classification, scene text detection, and image-to-image translation. The most direct ablations are the comparison between direct and residual connection modes, the number of DenseNet blocks augmented with SFCM, and the baseline DenseNet versus SFCM-enhanced DenseNet (Du et al., 2018).

On CIFAR-10, the baseline DenseNet error is 7.00%. When SFCM is inserted into the first dense block, the error becomes 6.28% in direct mode and 6.21% in residual mode. With SFCM in the first two dense blocks, the error becomes 6.10% in direct mode and 5.93% in residual mode. With SFCM in all dense blocks, the error becomes 5.92% in direct mode and 5.62% in residual mode. The reported pattern is that SFCM consistently improves performance, that using it in more blocks improves accuracy further, and that the residual connection is usually slightly better on existing architectures.

For scene text detection with EAST, Table 2 reports that the ICDAR2015 F-score improves from 0.8076 to 0.8254, and the COCO-Text F-score improves from 0.3945 to 0.4554. The paper explains this as reducing misclassification of small text regions and improving detection of larger targets.

For image-to-image translation with pix2pix / cGAN on Cityscapes labels→photos, Table 3 reports that per-pixel accuracy improves from 0.66 to 0.71. The qualitative interpretation given in the paper is better edge quality and sharper details, which suggests that useful low-level structure is preserved while irrelevant noise is suppressed.

These results matter for the broader LCS interpretation because they isolate the effect of selective concatenation itself. The comparison is not merely between two backbones, but between naive feature joining and an explicitly guided fusion mechanism.

4. Concatenation-based layer compression in LLMs

CoMe reframes structured pruning as a concatenation-based layer merging problem. Its point of departure is that Direct Layer Pruning removes whole blocks and often destroys useful intermediate mappings, whereas Weighted Sum-based Layer Pruning linearly combines weights under an assumption that adjacent weights or channels are already aligned. The paper argues that this assumption is false, especially for FFN modules, and that linear averaging causes over-smoothing and extra information loss (Wang et al., 17 Oct 2025).

The first stage of CoMe is channel sensitivity estimation. For a linear mapping with weight matrix $Y \in \mathbf{R}^{H \times W \times C_2}.$9, input vector

$O = [X, Y],$0

and output

$O = [X, Y],$1

pruning the $O = [X, Y],$2-th input channel gives an output perturbation

$O = [X, Y],$3

Channel sensitivity is then defined as the expected $O = [X, Y],$4-norm of this perturbation over a calibration dataset $O = [X, Y],$5:

$O = [X, Y],$6

The interpretation given is that $O = [X, Y],$7 captures activation intensity, $O = [X, Y],$8 captures the weight norm for that channel, and their product estimates how much the output changes if that channel is removed.

The second stage chooses adjacent layer groups for merging using block influence and Skip-Block Influence. The group of adjacent layers with the smallest SBI is selected, meaning the group that minimally perturbs features when skipped over. Within a merge group $O = [X, Y],$9, the retention ratio for layer $O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$0 is

$O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$1

The retained channel count is

$O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$2

and the algorithm selects the Top-$O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$3 channel indices. A minimum retention ratio $O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$4 ensures that the most important layer in a merge group keeps at least $O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$5 of the retained parameters.

The core merge rule is column-wise concatenation:

$O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$6

where $O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$7 is the set of top channels selected from layer $O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$8, and $O\in \mathbf{R}^{H\times W\times (C_1+C_2)}.$9 means column-wise concatenation. This is a literal concatenate-and-reassemble operation. The paper further specifies that Norm modules are averaged across layers, MHA heads are treated as atomic units, and FFN channel importance is computed from intermediate features and down projection while coupling is ignored for tractability.

CoMe is progressive rather than one-shot. Starting from the original model $M = W_g * Y,$0, it repeatedly computes channel sensitivities, BI scores, and SBI scores; picks the adjacent group with minimum SBI; computes retention ratios; merges the group by concatenation; and replaces the original layers with the fused layer. The default setting in experiments is to merge two layers per iteration, that is, $M = W_g * Y,$1.

5. Post-training recovery and quantitative performance

After pruning and merging, CoMe performs hierarchical distillation. The progressive merge process creates correspondence pairs

$M = W_g * Y,$2

where $M = W_g * Y,$3 is a layer index in the original teacher model and $M = W_g * Y,$4 is the corresponding merged layer index in the pruned student model. Distillation uses feature-level alignment with KL divergence, and the paper distinguishes CoMe-mp, which trains each mapped layer sequentially, from CoMe-sp, which jointly optimizes all mapped layers (Wang et al., 17 Oct 2025).

The evaluation covers LLaMA-2-7b, LLaMA-2-13b, LLaMA-3-8b, Vicuna-7b, Mistral-7b, Qwen-2.5-7b, and Qwen-3-4b on ARC-c, ARC-e, HellaSwag, OpenBookQA, PIQA, WinoGrande, and MMLU, with perplexity reported on C4 and WikiText-2. For CoMe on LLaMA-2-7b, the main default is Wiki-2 calibration set, 256 samples, 30% sparsity, and merging 2 layers per iteration.

The headline result in the abstract is that when pruning 30% of LLaMA-2-7b’s parameters, the pruned model retains 83% of its original average accuracy. The tabulated values specify the progression. Dense LLaMA-2-7b has Avg = 62.11. At 30% pruning, CoMe reaches Avg = 48.17, RP = 76.47, C4 PPL = 19.93, and Wiki-2 PPL = 16.53. After post-training, CoMe-sp reaches Avg = 52.58 and RP = 82.98. The paper also reports that CoMe beats DLP baselines and WSLP baselines in average accuracy at 30% sparsity, and that CoMe-sp gives the strongest post-training result.

The ablations are unusually direct about the role of concatenation. Removing concatenation from CoMe causes a sharp drop in Avg accuracy and RP, with significantly increased PPL. By contrast, for WSLP methods such as MKA or LaCo, removing the additive merge step changes little or even improves PPL slightly. The appendix further states that

$M = W_g * Y,$5

tends to increase PPL, whereas concatenation-based merge can reduce PPL at certain ratios. Within the LCS interpretation, this is the clearest evidence that concatenation is not a cosmetic detail but the defining merge rule.

6. Relation to skip connections, dense fusion, and terminological ambiguity

SFCM explicitly contrasts itself with standard skip connections, U-Net, and pix2pix, which directly pass low-level features to deeper layers; with DenseNet, which concatenates features from many previous layers to improve gradient flow and representation reuse; with FPN, which combines high- and low-resolution features; and with HyperNet, ParseNet, and ION, which combine features or transformed features before prediction. The claimed novelty is not merely feature combination, but selectivity before concatenation: high-level features generate a spatial attention selector for low-level features, producing a directional dependency high-level → selector → low-level selection (Du et al., 2018).

CoMe makes a related distinction in the pruning setting. It is positioned against Direct Layer Pruning and Weighted Sum-based Layer Pruning. Its central claim is that a fused layer should not be a linear interpolation of whole weights, but a recomposition of salient channels from multiple layers. In that sense, CoMe is closer to a literal layer concatenate-and-split paradigm than SFCM: channels are partitioned by importance, concatenated into a new module, and then remapped through pruning-induced teacher–student correspondences (Wang et al., 17 Oct 2025).

A persistent source of ambiguity is the acronym LCS itself. In algorithmics, LCS ordinarily denotes Longest Common Subsequence rather than any neural layer operation. The paper “Quadratic-time Algorithm for the String Constrained LCS Problem” studies STR-IC-LCS, where the goal is to find a longest common subsequence of two sequences such that a constraining sequence $M = W_g * Y,$6 appears in the result as a substring; it gives a worst-case time complexity of $M = W_g * Y,$7 and a straightforward space complexity of $M = W_g * Y,$8 (Deorowicz, 2011). The paper “Computing SEQ-IC-LCS of Labeled Graphs” extends constrained LCS to labeled directed graphs and gives algorithms running in $M = W_g * Y,$9 time for the acyclic case and $*$0 time when the target graphs may be cyclic and the constraint graph is acyclic (Yonemoto et al., 2023). These are sequence- and graph-comparison problems, not neural architectures. This suggests that “Layer Concatenate and Split” is a context-dependent expansion rather than a universally standardized use of the acronym.

7. Interpretive summary

Across the cited neural papers, LCS is best understood as a design pattern rather than a fixed architecture. In SFCM, the pattern is concatenate after semantic selection: deep features generate a single-channel spatial selector, the selector gates shallow features, and the gated tensor is concatenated back with the deep representation. The split is implicit and spatial. In CoMe, the pattern is split by channel importance, then concatenate and distill: adjacent layers contribute top-ranked channel subsets, those subsets are concatenated into a merged layer, and hierarchical distillation restores performance.

The two realizations therefore differ in granularity and objective. SFCM is a feature-fusion mechanism for visual recognition, with evaluations on image classification, scene text detection, and image-to-image translation. CoMe is a structured compression pipeline for LLMs, with evaluations on seven benchmarks and perplexity measurements. Yet both instantiate the same broader architectural thesis: concatenation across layers is more effective when preceded by task- or semantics-conditioned selection than when performed naively, and compression is more faithful when important internal components are preserved and reassembled rather than averaged away or removed wholesale.

A plausible implication is that “Layer Concatenate and Split” names not a single historical invention but a recurring methodological motif in modern deep learning: concatenate representations across depth, but only after imposing a mechanism that determines what portion of each layer should survive the fusion.