Multi-branch 1D CNNs

• Multi-branch 1D CNNs are neural architectures that employ parallel convolutional branches to extract channel-specific and multi-scale features.
• They use late fusion, typically via concatenation and dense layers, to combine independently processed representations for enhanced regression and classification performance.
• Empirical studies show that three-branch designs optimize performance by reducing noise interference and improving accuracy in tasks like train speed estimation and mesh segmentation.

A multi-branch 1D Convolutional Neural Network (CNN) is a neural architecture that employs several parallel branches, each composed of 1D convolutional layers, to process distinct input channels or multi-scale feature sets. These parallel branches extract representations independently before a late-stage fusion mechanism combines their outputs, enabling enriched feature learning and enhanced robustness in various regression or classification tasks. This approach is distinguished from single-branch models by its ability to isolate channel- or scale-specific information, reducing detrimental cross-signal noise and improving accuracy in domains where different modalities or neighborhood contexts convey complementary information (Tian et al., 23 Aug 2025, George et al., 2017).

1. Architectural Principles of Multi-branch 1D CNNs

The defining characteristic of multi-branch 1D CNNs is their use of multiple, structurally similar convolutional blocks, each branch specialized for either an input modality (e.g., sensor channel) or a feature scale. Each branch typically applies several Conv1D layers with ReLU or other standard activations, often followed by pooling operations. In channel-wise architectures, examples include parallel branches for wheel speed, GPS speed, and time stamp histories, each independently processing temporal sequences before feature fusion (Tian et al., 23 Aug 2025). In multi-scale settings, like mesh segmentation, separate branches handle feature vectors averaged over different neighborhood graphs, capturing local-to-global geometric context (George et al., 2017).

Branch outputs are fused at a later network stage. The most frequent mechanism is hard concatenation along the feature dimension, followed by fully connected (dense) layers for either regression (scalar prediction) or classification (softmax over segments or labels). Dropout and batch normalization are commonly employed for regularization and internal covariate shift mitigation, depending on the application and dataset characteristics.

2. Channel-wise and Multi-scale Branching: Design Instantiations

Two distinct multi-branch 1D CNN paradigms have been established:

1. Channel-wise Branching: Each input channel is mapped to a distinct Conv1D branch. For train speed estimation, three branches handle wheel-speed, GPS-speed, and timestamps. Each branch processes a history of 30 samples via two stacked Conv1D-ReLU blocks (filters=46, 92; kernel size=2), with a global max-pooling collapsing the result to a fixed-length latent vector. The three latent vectors are then concatenated for downstream regression (Tian et al., 23 Aug 2025).
2. Multi-scale Feature Branching: In 3D mesh segmentation, each branch processes features aggregated over different neighborhood scales. For example, features are averaged over one-ring and two-ring mesh neighborhoods, producing three 800-dimensional descriptors per face. Each is processed independently through a two-stage 1D convolution and pooling chain (Conv1D-BatchNorm-LeakyReLU-MaxPool), then concatenated at depth before fully connected classification (George et al., 2017).

The following table summarizes typical design choices:

Application Domain	Branch Specialization	Fusion Strategy
Train speed estimation	Input channels (sensors)	Hard concatenation, Dense
Mesh segmentation	Neighborhood scale	Depth concatenation, Dense

3. Mathematical Formulation

A single 1D convolutional layer in branch $k$ at layer $\ell$, with input $h^{k,\ell-1}[c_{in}, t]$ (input channel, position), computes the output:

$$h^{k,\ell}[c_{out}, t] = \sum_{c_{in}=1}^{C_{in}} \sum_{i=0}^{K-1} W^{\ell}[c_{out},c_{in},i] \cdot h^{k,\ell-1}[c_{in}, t + i - \lfloor K/2 \rfloor] + b^{\ell}[c_{out}]$$

where $W$ are the learnable weights, $b$ is the bias, $K$ is the kernel size, and zero-padding maintains sequence length (George et al., 2017).

After branch-specific feature extraction and global pooling (e.g., max-pooling in time), latent descriptors $h^{(j)}$ or $P^k$ are concatenated to produce a global feature vector $H$. For regression tasks:

$\ell$0

Loss functions are task-dependent: mean squared error (MSE) for regression,

$\ell$1

and categorical cross-entropy for segmentation/classification,

$\ell$2

where $\ell$3 is a one-hot ground-truth label and $\ell$4 is the softmax prediction (Tian et al., 23 Aug 2025, George et al., 2017).

4. Benchmark Performance and Comparative Ablations

Systematic benchmarks demonstrate superior performance of multi-branch 1D CNNs over single-branch or conventional methods. In train speed estimation on simulated datasets, the multi-branch 1D CNN achieves lowest RMSE and MAE:

Model	RMSE (no WSP)	MAE (no WSP)	RMSE (WSP)	MAE (WSP)
Adaptive Kalman Filter	0.483	≈0.42	0.527	≈0.45
Single-branch 2D CNN	1.299	≈1.05	0.417	≈0.36
Single-branch 1D CNN	0.697	≈0.61	≈0.75	≈0.63
Multi-branch 1D CNN	0.381	≈0.32	0.424	≈0.36

Under challenging wheel-slide protection (WSP) conditions, multi-branch models retain accuracy and robustness due to reduced cross-signal noise (Tian et al., 23 Aug 2025).

In mesh segmentation, the multi-branch 1D CNN outperforms 2D CNNs by 2–6% absolute accuracy, both on PSB and COSEG benchmarks. An ablation over the number of branches reveals a performance plateau at three branches:

# Branches	Mean Accuracy (PSB, 5-fold)
1	94.22%
2	94.63%
3	94.81%
4	94.81%

This suggests three-branch designs are typically optimal for efficiency and representational capacity (George et al., 2017).

5. Advantages, Limitations, and Mechanistic Insights

Multi-branch 1D CNNs achieve robust, high-accuracy predictions by leveraging independent channel- or scale-specific processing, which isolates domain- or sensor-specific noise and enables specialized feature learning. In train speed estimation, late fusion via global pooling and dense layers ensures that only the most significant features are combined, mitigating negative interference from highly oscillatory or noisy channels such as those affected by WSP events (Tian et al., 23 Aug 2025). In mesh analysis, multi-scale branch structures allow the network to integrate geometric cues without sensitivity to feature resizing, and robust features such as Laplacian-smoothed conformal factors provide further accuracy gains (George et al., 2017).

A key limitation is that the benefits plateau with excessive branching; three branches suffice in observed applications. Multi-branch models also require careful hyperparameter tuning (e.g., branch width, filter size, pooling method), which may drive up training cost compared with simpler methods (e.g., PCA+NN or AE+RF alternatives in mesh segmentation).

6. Application Domains and Future Directions

Multi-branch 1D CNNs are established in time-series regression (e.g., railway speed estimation) and geometric segmentation of 3D meshes. Their architecture generalizes to any context where channel or scale partitioning yields decorrelated, complementary latent information.

Potential future directions include integration with attention mechanisms during branch fusion, exploration of dynamic branch selection driven by data properties, and extension to semi-supervised or transfer learning settings where annotated data is scarce. A plausible implication is that multi-branch 1D processing will continue to see adoption in multi-modal sensor fusion, structured temporal reasoning, and scalable geometric learning tasks, contingent on their empirically proven advantages for robustness and state-of-the-art accuracy (Tian et al., 23 Aug 2025, George et al., 2017).