---
title: 'Split DeepJSCC: Modular Neural JSCC Patterns'
url: https://www.emergentmind.com/topics/split-deepjscc
type: topic
---

# Split DeepJSCC: Modular Neural JSCC Patterns

Searching arXiv for recent papers on Split DeepJSCC and closely related DeepJSCC variants.
Split DeepJSCC denotes a family of neural joint source-channel coding designs in which a conventional end-to-end DeepJSCC pipeline is deliberately partitioned by an explicit interface or split point rather than optimized as a single monolithic source-to-channel mapping. In the literature summarized here, the term appears in at least three closely related senses: as split inference for collaborative intelligence, where an intermediate feature tensor is transmitted from device to edge server using a learned JSCC module; as a hybrid communication architecture, where DeepJSCC is used only on a vulnerable wireless segment and conventional digital transmission is used afterward; and as a decoupled framework with a bit-level interface between source and channel coding to improve compatibility with existing layered wireless networks. Across these variants, the common principle is that DeepJSCC’s graceful degradation and task-aware representation learning are retained, while the communication system is made more modular, deployable, or adaptive under practical constraints such as varying signal-to-noise ratio (SNR), finite computation budgets, multi-hop relaying, or interoperability with separate network entities [2506.10699], [2507.12850].

## 1. Concept and scope

Split DeepJSCC is best understood against standard DeepJSCC. In conventional DeepJSCC, the source encoder and channel encoder are trained end-to-end as one neural system, so that the transmitter maps an image directly to channel symbols and the receiver maps noisy channel outputs back to the image. This yields strong semantic performance and graceful adaptation to channel quality, but it is difficult to integrate into existing layered wireless networks because source and channel coding are tightly coupled [2507.12850]. DeepJSCC itself is part of the broader JSCC framework, in which an encoder–channel–decoder chain is optimized jointly rather than by strict source/channel separation; this approach is particularly advantageous in finite blocklength, latency-limited, and channel-uncertain regimes, where it can avoid cliff and levelling-off effects and provide smoother degradation under channel variation [2409.17557].

Within that broader family, Split DeepJSCC introduces an internal boundary. The location and meaning of that boundary differ by application. In collaborative intelligence and split inference, the boundary is an intermediate feature tensor generated by a deep network on a mobile or IoT device, then compressed and transmitted over a wireless channel to a server that completes the downstream task [2109.05779], [2506.10699]. In hybrid multi-hop communication, the boundary is a relay node: the first hop uses analog DeepJSCC, while later hops use digital forwarding to avoid noise accumulation [2311.07028]. In interface-based semantic communication, the boundary is a prescribed or learned bit-level contract between source coding and channel coding, allowing separate design while preserving semantic fidelity and channel adaptability [2507.12850].

A plausible implication is that “Split DeepJSCC” is not a single architecture but a design pattern: it preserves joint source-channel awareness while introducing a structured interface at the point where practical systems require modularity.

## 2. Split inference and collaborative intelligence

A clear early instance appears in collaborative intelligence for multi-task vision. “Deep Joint Source-Channel Coding for Multi-Task Network” proposes a feature-fusion multi-task network, FFMNet, for joint object detection and semantic segmentation, then splits the model into two parts that run on a mobile device and an edge server respectively [2109.05779]. The split occurs at the intermediate feature \(D_1\). The mobile device runs the early feature extraction part up to \(D_1\), a JSCC encoder compresses that feature for transmission over an AWGN channel, and the edge server reconstructs the feature and executes the remaining parsing and task heads. The transmitted object is therefore not the original image, but the intermediate feature tensor at the split point [2109.05779].

This architecture is explicitly motivated by the inadequacy of conventional multi-task learning networks for collaborative intelligence. Standard single-end networks are unsuitable when part of the model must run on a mobile device and the rest on an edge server, because intermediate features can be large, and prior feature-compression methods based on HEVC, PNG, JPEG, or similar coding do not explicitly account for channel noise and thus degrade sharply when the wireless link is imperfect [2109.05779]. The split DeepJSCC-style design replaces separate compression and channel coding with a learned JSCC encoder/decoder trained through the noisy channel model.

The FFMNet system reports that the whole model achieves \(512\times\) compression for the intermediate feature and a performance loss within \(2\%\) on both tasks. The paper gives the specific comparison: the original model attains \(40.8\) mAP and \(44.6\) mIoU, while the \(512\times\) compressed version attains \(39.4\) mAP and \(43.1\) mIoU, corresponding to losses of \(1.4\%\) in mAP and \(1.5\%\) in mIoU [2109.05779]. It further states that the separate source/channel coding baseline can only achieve about \(13\times\) compression at similar performance, whereas the learned JSCC achieves \(512\times\), and that the deep JSCC approach outperforms the separate pipeline substantially and avoids the cliff effect [2109.05779].

This split-inference interpretation remains central in later work. “SNR and Resource Adaptive Deep JSCC for Distributed IoT Image Classification” treats a split-network DNN-based JSCC scheme as one in which early feature extraction runs on the edge device, an intermediate feature representation is compressed and transmitted over the channel, and the remaining inference layers run at the server [2506.10699]. The authors state that this paper is a direct extension of the Split DeepJSCC idea to a more practical distributed IoT setting, with varying wireless channel quality and local device resources [2506.10699].

## 3. Distributed CNN formulation and adaptive split selection

In the distributed IoT formulation, the system consists of a CNN with a total of \(B\) blocks, split after \(m\) blocks. The first \(m\) blocks execute on the IoT device, and the remaining \(B-m\) blocks execute on the server. The split point is not just “where to offload,” but also where the learned feature tensor is turned into a latent vector for wireless transmission [2506.10699].

The forward path is specified as follows: input image \(\mathbf{X} \in \mathbb{R}^{H \times W \times C}\); normalization to \([-1,1]\); local processing through the first \(m\) CNN blocks at the IoT device; JSCC projection of the resulting feature map into a latent vector \(\mathbf{h}\); wireless transmission over an AWGN channel; reconstruction of the feature map \(\hat{\mathbf{F}_m}\) at the server; execution of the remaining CNN blocks at the server; and final classification using global average pooling and a logit layer [2506.10699]. Each CNN block is a convolution followed by batch normalization and PReLU:
\[
\mathbf{F}_l = f_{\theta_l}(\mathbf{F}_{l-1}),
\]
\[
\mathbf{F}_l = \sigma\left(\text{BN}(\mathbf{W}_l * \mathbf{F}_{l-1} + \mathbf{b}_l)\right),
\]
with
\[
\sigma(x) = \max(0,x) + \alpha \min(0,x).
\]

After the \(m\)-th block, the feature map is projected into a latent vector,
\[
\mathbf{h} = \mathbf{W}_{\text{latent}}\mathbf{F}_m + \mathbf{b}_{\text{latent}}, \quad \mathbf{h}\in\mathcal{C}^S,
\]
the server receives
\[
\mathbf{y} = \mathbf{h} + \mathbf{z},
\]
where \(\mathbf{z}\sim \mathcal{CN}(0,\sigma^2)\), and reconstructs the feature map by
\[
\hat{\mathbf{F}_m} = \mathbf{W}_{\text{recover}}\mathbf{y} + \mathbf{b}_{\text{recover}}.
\]
Unlike end-to-end DeepJSCC that transmits the compressed latent for the whole task, this formulation transmits only the intermediate representation at the split point, making it a distributed JSCC inference system [2506.10699].

A central point of the paper is that the best split point depends not only on channel SNR but also on the IoT device’s computation budget. The architecture is therefore adapted by optimizing the split point \(m\), the number of filters \(f\), the kernel size \(k\), and the latent space dimension \(l_s\), under the constrained problem
\[
\max_{\Theta} A(\Theta)
\]
subject to
\[
F(\Theta)\leq F_{\max},
\]
and
\[
\text{SNR}=q,
\]
where
\[
\Theta=\{f,k,l_s,m\}.
\]
The FLOPs cost at the IoT device is modeled as the sum of the FLOPs of the first \(m\) convolutional layers plus the projection to latent space:
\[
F_i = 2 \times \left(k_i^2 \times f_{\text{in}_i} \times f_{\text{out}_i} \times h_i \times w_i\right),
\]
\[
F_{\text{latent}} = 2 \times \left(f_{\text{out}_m} \times h_m \times w_m \times l_s\right),
\]
\[
F(\Theta)=\sum_{i=1}^{m}F_i + F_{\text{latent}}.
\]
The paper reports that the selected number of local layers increases monotonically with available FLOPs, and the optimal architecture changes with SNR as well [2506.10699].

This redefines the split as a jointly communication-and-architecture-dependent quantity rather than a static placement decision. A low-SNR link may favor a different latent dimensionality or deeper local feature extraction than a high-SNR link, while a tight FLOPs budget may force an earlier split [2506.10699].

## 4. Optimization, training, and robustness mechanisms

The main mechanism used to search the adaptive architecture space in the IoT setting is the Learning-Assisted Intelligent Genetic Algorithm (LAIGA), which extends split DeepJSCC beyond a fixed split-layer design. Each candidate architecture is represented by
\[
\Theta=\{f,k,l_s,m\},
\]
encoding filter count, kernel size, latent dimension, and split point [2506.10699]. A crucial rule is that any candidate violating the computational budget is immediately rejected; if
\[
F(c) > F_{\max},
\]
the fitness is set to
\[
(-\infty,\infty),
\]
so infeasible configurations are effectively removed from the search [2506.10699].

To avoid exhaustive simulation, the paper builds an offline dataset \(\mathcal{D}\) by simulating a manageable subset of configurations across several SNR values, storing both FLOPs and classification accuracy. Two Random Forest regressors are trained,
\[
\hat{F}(\Theta)=R_F(f,k,l_s,m),
\]
\[
\hat{A}(\Theta)=R_A(f,k,l_s,m),
\]
and are used to predict FLOPs and accuracy for unseen configurations [2506.10699]. The fitness score is
\[
\text{fitness}(c) = \left(A(c)+U(c), \, F_{\max}-F(c)\right),
\]
with
\[
U(c)=\max\left(0,\frac{F(c)-0.9\times F_{\max}}{0.1\times F_{\max}}\right).
\]
This encourages configurations that use about \(90\%-100\%\) of the available FLOPs rather than wasting budget. The GA proceeds via tournament selection, uniform crossover, and mutation:
\[
P_{t+1} = \text{Selection}\left(\text{Mutation}\left(\text{Crossover}(P_t)\right)\right).
\]
The final chosen configuration is the one with the highest predicted accuracy, and in case of ties, the one with the smallest FLOPs gap [2506.10699].

The multi-task collaborative-intelligence system uses a different training decomposition but the same split-learning logic. There, training proceeds in three steps: train FFMNet alone with
\[
\mathcal{L}_{MTL} = \mathcal{L}_{det} + \mathcal{L}_{seg},
\]
attach the JSCC encoder/decoder at the split point and train them while keeping FFMNet fixed using the loss
\[
\mathcal{L}_{\text{JSCC}} = \|X - X'\|_1 + \mathcal{L}_{MTL},
\]
and finally fine-tune the whole system end-to-end using \(\mathcal{L}_{MTL}\) [2109.05779].

Both lines of work emphasize robustness through noise-aware training. In the multi-task system, the channel is modeled as AWGN,
\[
z' = z + n,\qquad n \sim \mathcal{N}(0,\sigma^2),
\]
with
\[
\text{SNR} = \frac{P}{\sigma^2},
\]
and average transmit power constraint
\[
\frac{1}{B}\sum_{i=1}^{B} z_i^2 = P,
\]
with \(P=1\). Models are trained with \(\text{SNR}_{train}=0\) dB, \(5\) dB, and \(10\) dB, and the paper finds that training at \(5\) dB gives the best trade-off across test SNRs [2109.05779]. In the IoT image-classification system, the latent noise variance is tied to SNR through
\[
\sigma^2 = \frac{\mathbb{E}[\|\mathbf{h}\|^2]}{10^{\text{SNR(dB)}/10}}.
\]
Because the transmitted signal is a learned latent representation rather than a conventional source-coded bitstream, the method is described as inheriting the robustness properties of DeepJSCC, especially under low SNR [2506.10699].

## 5. Hybrid and interface-based variants

Another major interpretation of Split DeepJSCC appears in multi-hop communication. “A Hybrid Joint Source-Channel Coding Scheme for Mobile Multi-hop Networks” proposes a split architecture matched to a realistic topology in which the first hop from the mobile user to the first relay is potentially weak and time-varying, while subsequent hops inside the mobile core network are stable and of high quality [2311.07028]. The key idea is to use analog neural joint source-channel coding only where it is needed most, on the unreliable first hop, and then switch to conventional digital transmission after the first relay to prevent the progressive noise accumulation that hurts fully analog schemes [2311.07028].

The source node encodes an image \(\bm{S}\in\mathbb{R}^{C\times H\times W}\) into a complex-valued channel input \(\bm{x}_s\in\mathbb{C}^k\) using a DeepJSCC encoder \(f_s(\cdot)\), subject to
\[
\frac{1}{k}\|\bm{x}_s\|^2 \le 1.
\]
The first hop is AWGN,
\[
\bm{y}_1 = \bm{x}_s + \bm{w}_s,\qquad \bm{w}_s\sim\mathcal{CN}(0,\sigma_s^2\bm{I}_k),
\]
with \(\mathrm{SNR}_s = 1/\sigma_s^2\) [2311.07028]. At the first relay, a DeepJSCC decoder reconstructs an image-shaped tensor
\[
\widetilde{\bm{S}} = f_d(\bm{y}_1),
\]
and a hyperprior-based learned image codec converts \(\widetilde{\bm{S}}\) into a bitstream \(\bm{b}_1\), which is forwarded digitally through the core network. The split point is therefore exactly the first relay: everything before \( \mathrm{R}_1 \) is treated as DeepJSCC, and everything after \( \mathrm{R}_1 \) is treated as a conventional digital pipeline [2311.07028].

The digital compression stage uses a nonlinear analysis transform \(g_a(\cdot)\) and hyper-analysis transform \(h_a(\cdot)\), with arithmetic coding producing
\[
\bm{b}_1 = (\bm{b}_z,\bm{b}_v).
\]
The overall hybrid loss introduces a rate-distortion tradeoff,
\[
\mathcal{L} = \lambda \|\bm{S}-\hat{\bm{S}}\|_F^2 + I,
\]
with
\[
I = I_z + I_v.
\]
This formulation contrasts with the fully analog baseline, for which the effective SNR over multiple hops is
\[
\mathrm{SNR}_{eff} = \frac{1}{\sum_{i=0}^{n-1}\sigma_i^2\prod_{j=0}^{i-1}(1+\sigma_j^2)},
\]
making explicit why analog relaying degrades as hop count grows [2311.07028].

A different kind of split is introduced by the learning-based interface framework. In “Learning-Based Interface for Semantic Communication with Bit Importance Awareness,” Split DeepJSCC is described as a decoupled JSCC framework with a bit-level interface between the source code and the channel code [2507.12850]. The source node performs source coding and outputs a bitstream, the wireless access node performs channel coding over the wireless hop, and the interface specifies the reliability level of different bit positions at the output of the source code. The paper states that Split DeepJSCC “introduces a multi-level reliability binary interface,” enables separate design of source and channel codes, and preserves the advantages of JSCC while being compatible with existing networks [2507.12850].

This interface is implemented using an array of binary symmetric channels with bit-flipping probabilities \(\{\epsilon_n\}_{n=1}^M\). The transmitted image \(\bm{s}\in \mathbb{R}^{H \times W \times C}\) is mapped to a source bitstream \(\bm{b}\in \{0,1\}^M\), then to channel symbols \(\bm{x}\in\mathbb{R}^L\), with channel bandwidth ratio
\[
r = \frac{L}{C \times H \times W}.
\]
The bit-level interface is modeled by
\[
p_{\text{BSC}}(\hat{b}_n|b_n)=
\begin{cases}
\epsilon_n, & \hat{b}_n \neq b_n \\
1-\epsilon_n, & \hat{b}_n = b_n.
\end{cases}
\]
Lower \(\epsilon_n\) means a more important bit, higher \(\epsilon_n\) means a less important bit. To prevent collapse to an error-free interface, the training adds
\[
\mathcal{L}_{\text{reg}}= \frac{\lambda}{M}\sum_{n=1}^M(\epsilon_n-0.5)^2.
\]
The first-stage objective becomes
\[
\mathcal{L}(\bm{\theta},\bm{\phi},\bm{\epsilon}) = \mathcal{L}_{\text{MSE}} + \lambda \mathcal{L}_{\text{reg}},
\]
and non-differentiable sampling and rounding are handled by the Straight-Through Estimator [2507.12850].

This paper treats the prescribed Split DeepJSCC interface as a baseline, then replaces it with a trainable interface whose learned bit-flipping probabilities encode bit importance. The resulting Importance-Aware Net uses the transformed interface values \(1-2\bm{\epsilon}\) as an attention-like signal in the channel mapper and demapper, enabling dynamical adaptation to diverse channel bandwidth ratios and time-varying channel conditions [2507.12850].

## 6. Performance, practical implications, and limitations

The distributed IoT extension reports that the proposed framework outperforms fixed-split architectures and existing SNR-adaptive methods, especially under low SNR and limited computational resources. Specifically, it achieves a \(10\%\) increase in classification accuracy as compared to an existing JSCC-based SNR-adaptive multilayer framework at an SNR as low as \(-10\) dB across a range of available computational budget from \(1\)M to \(70\)M FLOPs at the IoT device [2506.10699]. The experiments use PyTorch on an NVIDIA RTX A2000 GPU using CIFAR-10, with a discrete search space
\(f \in \{8,16,32,64,128,256\}\),
\(k \in \{2,3,4,5,6,7,8,9\}\),
\(l_s \in \{32,64,128,256,512\}\),
\(m \in \{1,2,3,4,5,6\}\),
and SNR sampled from
\[
\{-20,-15,-10,-5,0,5,10,15,20,25\}\text{ dB}.
\]
The baselines are a fixed split-point architecture from prior work, ADJSCC-l, and LAIGA-N, the non-SNR-adaptive version of the proposed approach [2506.10699].

The hybrid multi-hop system reports that with one hop all methods are similar at about \(29.1\) dB PSNR; with more hops, analog schemes degrade due to noise accumulation; the proposed JSC drops to around \(28.2\) dB after the first lossy compression, then remains essentially flat as hop count increases; for more than \(3\) hops, the proposed method outperforms both DeepJSCC-AF and DeepJSCC-PF; and against the fully digital baseline in a fair comparison, it achieves \(26.19\) dB versus \(25.39\) dB for digital, while using fewer bits at the first relay in the tested setup [2311.07028]. These findings support the claim that analog DeepJSCC on the weak first hop avoids the cliff effect, while digital transmission after the first relay avoids noise accumulation in the core network [2311.07028].

The interface-based extension reports that the proposed learning-based interface outperforms Split DeepJSCC across all tested datasets, under both AWGN and Rayleigh fading, and achieves larger gains at higher channel bandwidth ratios. The evaluations use CIFAR-10, CIFAR-100, SVHN, and ImageNet32, with CBRs \(1/4\), \(1/8\), \(1/16\), and \(1/24\), and PSNR as the primary metric [2507.12850]. The paper further reports that under Rayleigh fading, removing the Interface Attention Module can even make the system fall below Split DeepJSCC at high SNR, while the full proposed model performs best across all SNRs [2507.12850]. This suggests that the learned interface-derived importance information is functionally significant rather than merely descriptive.

The literature also identifies limitations. In the IoT architecture-search system, the method relies on offline-simulated training data for the surrogate models, so the quality of LAIGA depends on how representative that dataset is; the demonstration is on image classification, although the authors expect the idea to generalize to speech and video tasks [2506.10699]. In the broader DeepJSCC literature, practical barriers include integration into legacy networks, compatibility with existing modulation and coding hardware, difficulty of combining with ARQ and CRC-style retransmission protocols, and security concerns because analog-like mappings may leak source information to eavesdroppers [2409.17557]. The interface-based Split DeepJSCC line addresses some of these issues by restoring a bit-level contract between source and channel layers, while the hybrid multi-hop line addresses them by using DeepJSCC only where its graceful degradation is most valuable [2507.12850], [2311.07028].

Taken together, these results support a consistent interpretation: Split DeepJSCC is a modularization strategy for DeepJSCC, used when a fully end-to-end analog-style neural transceiver is either computationally impractical, architecturally incompatible with existing systems, or suboptimal over part of the network. The modularity is not identical to classical source/channel separation, because task fidelity, semantic structure, or channel robustness remain jointly optimized around the split. This suggests that the main research significance of Split DeepJSCC lies not in abandoning DeepJSCC’s end-to-end principles, but in introducing structured interfaces that preserve those principles under practical system constraints [2409.17557].

Source: https://www.emergentmind.com/topics/split-deepjscc