Split learning is a distributed training method in which a neural network is cut into two or more segments, with the early layers trained on the data owner’s device and the remaining layers trained on a server, so that raw data never leaves the client. In Edge AI, it lets phones, sensors, hospitals or vehicles contribute to training a shared model while sending only intermediate activations at the cut layer and receiving the matching gradients in return.
The approach is also called a split neural network (SplitNN). It belongs to the same privacy-oriented family as federated learning, but it divides the model rather than replicating it, which reduces the compute and memory burden on the device at the cost of constant communication during training.
How split learning divides training between client and server
Split learning works by placing a cut layer inside the network and running forward and backward propagation across that boundary. The client computes the forward pass up to the cut layer and sends the resulting tensor, often called the smashed data, to the server. The server completes the forward pass, computes the loss, backpropagates to the cut layer and returns the gradient of the loss with respect to the activations, which the client uses to update its own layers.
In the basic vanilla configuration, the server needs the labels to compute the loss. When multiple clients participate, they usually train sequentially: one client finishes its batches, then passes its updated client-side weights to the next client, either directly or through the server. This relay is what keeps a single, consistent client-side segment across the population.
The following table summarizes one training step and what crosses the network at each stage.
| Step | Where it runs | What is transmitted |
|---|---|---|
| Forward pass to cut layer | Client device | Cut-layer activations to server |
| Forward pass to output | Server | Nothing |
| Loss computation | Server (needs labels) | Labels from client, if not held by server |
| Backward pass to cut layer | Server | Activation gradients to client |
| Backward pass through early layers | Client device | Nothing |
| Client weight handoff | Client to next client | Client-side weights after its turn |
Configurations and variants of split learning
Split learning has several configurations that trade label privacy, parallelism and convergence speed against each other. The choice depends on who owns the labels, how many clients take part and whether they can wait for one another.
| Configuration | How it is arranged | Main benefit | Main drawback |
|---|---|---|---|
| Vanilla split learning | One cut; server holds the upper layers and the loss | Simplest design, lightest client | Server sees labels; sequential clients |
| U-shaped split learning | Client keeps both the first and the last layers | Labels stay on the client | More client compute, two exchanges per step |
| Vertical split learning | Clients hold different features of the same records | Joins data silos without sharing columns | Requires record alignment across parties |
| SplitFed learning | Clients run in parallel; client segments averaged as in federated averaging | Much faster wall-clock training | Weaker isolation, more coordination |
| Parallel split learning | Server trains several client branches simultaneously | Better server utilization | Client drift and stale updates |
The U-shaped design is the usual answer when labels are themselves sensitive, such as a diagnosis. SplitFed combines the light client of split learning with the parallelism of federated learning and is now the most common starting point for research prototypes with many devices.
Split learning compared with related Edge AI techniques
Split learning differs from neighboring techniques mainly in what is divided and when. It splits training, whereas split computing splits inference, and it shares a model segment, whereas federated learning shares full model updates.
| Technique | What is divided | What leaves the device | Typical client load |
|---|---|---|---|
| Split learning | Training across a cut layer | Activations every batch | Low: only early layers |
| Cross-device federated learning | Data across clients; full model on each | Model updates once per round | High: full model training |
| Split computing | Inference across a cut layer | Activations per request | Low: only early layers |
| Cloud offloading | Nothing; whole task moves | Raw input data | Minimal |
| On-device training | Nothing; all training local | Nothing, or occasional updates | Highest |
The practical consequence is that split learning suits devices too weak to train a full model but too sensitive to upload raw data. Federated learning, by contrast, fits devices that can train locally and have limited, intermittent bandwidth.
Choosing the cut layer and deploying split learning
Placing the cut layer is the central design decision in split learning, because it fixes client compute, communication volume and privacy exposure at once. A shallow cut keeps the device light but sends activations that still closely resemble the input; a deeper cut hides more of the input but demands more device memory and energy.
| Cut position | Client compute | Activation size | Privacy exposure |
|---|---|---|---|
| After one or two layers | Very low | Often larger than the input | High: input easy to reconstruct |
| Middle of the network | Moderate | Reduced by pooling | Medium |
| Near the bottleneck | High | Smallest | Lower, still not zero |
Engineers often add a compression layer or bottleneck at the cut, apply INT8 quantization to the transmitted tensors, or send activations only every few steps to cut bandwidth. Because traffic scales with batch size times activation size per step, the total communication of split learning can exceed that of federated learning for small models and very large datasets, while it is usually lower for large models with few samples per client.
Privacy limits and common misconceptions
Split learning does not guarantee privacy on its own. Keeping raw data local is a meaningful improvement, yet the transmitted activations and gradients carry information that a curious server or an eavesdropper can exploit.
- Model inversion attacks can reconstruct inputs from shallow-layer activations, especially for images.
- Label leakage occurs in two-party settings, because the gradient returned to the client reveals which class was predicted.
- Feature-space hijacking lets a malicious server steer the client segment so that its activations become invertible.
- Sequential training is slow: with hundreds of clients, each must wait its turn, and stragglers stall the whole process.
- Catastrophic forgetting across clients with non-identical data distributions can degrade the shared client segment.
Practical deployments therefore combine split learning with differential privacy noise on activations, distance-correlation regularization that decorrelates activations from inputs, secure aggregation in SplitFed variants, and encrypted transport. The honest summary is that split learning reduces exposure rather than eliminating it.
Stripped to the essentials
Split learning means two parties train one AI model together without handing over the raw data. The model is cut in half. Your device runs the first half and sends the server a partly processed version of the data, not the data itself. The server runs the second half, works out how wrong the answer was, and sends back a short correction note so your device can improve its half.
It is a bit like two cooks preparing one dish: the first cook chops and seasons in a private kitchen, and the second cook only ever sees the prepared ingredients. The key takeaway is that split learning keeps the original data at home and lets weak devices help train a large model, although the prepared ingredients can still reveal more than intended.
Where it is applied
A group of four regional hospitals wants to train a chest X-ray classifier, but privacy rules prevent them from pooling patient images. A central research server hosts most of a convolutional network. Each hospital runs only the first three convolutional blocks on a modest workstation and sends the resulting activations, compressed to 8-bit values, to the server. A U-shaped arrangement keeps the final classification layer and the diagnosis labels inside each hospital.
Training runs in a SplitFed style, with all four hospitals working in parallel and their client segments averaged after every epoch. The team also adds a small amount of noise to the activations. The outcome is a model trained on roughly four times more images than any single hospital holds, with accuracy close to a centrally trained baseline, while no raw X-ray or label ever leaves its hospital.