Split learning

Also known as: split neural network

On this page 7

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.

StepWhere it runsWhat is transmitted
Forward pass to cut layerClient deviceCut-layer activations to server
Forward pass to outputServerNothing
Loss computationServer (needs labels)Labels from client, if not held by server
Backward pass to cut layerServerActivation gradients to client
Backward pass through early layersClient deviceNothing
Client weight handoffClient to next clientClient-side weights after its turn
One training step in vanilla split learning

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.

ConfigurationHow it is arrangedMain benefitMain drawback
Vanilla split learningOne cut; server holds the upper layers and the lossSimplest design, lightest clientServer sees labels; sequential clients
U-shaped split learningClient keeps both the first and the last layersLabels stay on the clientMore client compute, two exchanges per step
Vertical split learningClients hold different features of the same recordsJoins data silos without sharing columnsRequires record alignment across parties
SplitFed learningClients run in parallel; client segments averaged as in federated averagingMuch faster wall-clock trainingWeaker isolation, more coordination
Parallel split learningServer trains several client branches simultaneouslyBetter server utilizationClient drift and stale updates
Common split learning configurations

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 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.

TechniqueWhat is dividedWhat leaves the deviceTypical client load
Split learningTraining across a cut layerActivations every batchLow: only early layers
Cross-device federated learningData across clients; full model on eachModel updates once per roundHigh: full model training
Split computingInference across a cut layerActivations per requestLow: only early layers
Cloud offloadingNothing; whole task movesRaw input dataMinimal
On-device trainingNothing; all training localNothing, or occasional updatesHighest
How split learning relates to neighboring concepts

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 positionClient computeActivation sizePrivacy exposure
After one or two layersVery lowOften larger than the inputHigh: input easy to reconstruct
Middle of the networkModerateReduced by poolingMedium
Near the bottleneckHighSmallestLower, still not zero
Effect of cut-layer placement

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.