FedAcross+: Federated Few-Shot Adaptation

• FedAcross+ is a federated learning framework that enables personalized few-shot domain adaptation using prototype-based inference on low-resource edge devices.
• It decomposes the model into a frozen backbone and classifier paired with a trainable domain-adaptive layer, reducing computational load and mitigating overfitting.
• The framework integrates streaming data handling with on-device sample selection and dynamic prototype updating to address non-stationary target distributions.

Searching arXiv for the specified paper and closely related entries. {"query":"ti:\"Domain Borders Are There to Be Crossed With Federated Few-Shot Adaptation\" OR (Röder et al., 14 Jul 2025)","max_results":5} FedAcross+ is a personalized, prototype-based federated learning framework for few-shot domain adaptation on resource-constrained edge devices, explicitly extended to streaming and non-stationary data. It assumes a central server with full access to a labeled source dataset, multiple cross-device clients with target-domain data, a shared label space across domains, and a covariate-shift regime in which $p_S(X_S,Y_S)\neq p_{T_i}(X_{T_i},Y_{T_i})$. The framework combines transfer learning, few-shot learning, and prototype-based inference by training a source model centrally, freezing the backbone and classifier on clients, and adapting only a domain-adaptive linear layer from a few labeled target samples or from samples selected online from an unlabeled stream (Röder et al., 14 Jul 2025).

1. Problem formulation and operating regime

FedAcross+ is defined for federated few-shot adaptation under three concurrent constraints: costly labeling for target adaptation, covariate or domain shift across clients, and resource and communication limitations on edge devices (Röder et al., 14 Jul 2025). The server holds a labeled source dataset

$$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$

while each client $i$ has a target domain $T_i$ with data

$$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$

The label space is shared, $y_l\in Y$ with $|Y|=L$, but the input distributions differ across domains.

The few-shot regime is explicit. Operators at each site can label only a small number of examples per class, with

$k_i=k\in\{0,3,5,10\}.$

This places adaptation in an extreme few-shot setting. The intended shifts arise from facilities, sensors, lighting, background, noise, and viewpoint. The clients are low-end devices with limited CPU, memory, and power; uplink is constrained; channel availability is sporadic; and continuous full-model updates of the type used in standard FedAvg are often infeasible.

FedAcross+ also formalizes a streaming scenario in which client $i$ observes an unlabeled stream

$U_i=\{x_t\}_{t\ge 1}$

whose distribution may vary over time. Rather than assuming that all target data is available a priori, the client constructs its $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$0-shot support set online by selecting informative stream samples for labeling. A common misconception is to treat the method as a conventional iterative FL procedure with persistent global synchronization. In the default personalization regime, the global model is trained centrally and then adapted locally by each client without gradient transfer to the server; client models are personalized and need not be identical (Röder et al., 14 Jul 2025).

2. Architectural decomposition and adaptation mechanism

FedAcross+ decomposes the model into three trainable components: a feature extractor or backbone $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$1, an adaptation module $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$2, and a classifier head $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$3, together with an input transformation module $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$4 defined by $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$5 (Röder et al., 14 Jul 2025). The server-side end-to-end decision function is

$$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$6

A pre-trained ResNet-34 or ResNet-50 is used as the backbone. It is first initialized from ImageNet and then further pre-trained on the source dataset $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$7. On clients, the backbone parameters are frozen during adaptation. The classifier $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$8 is a fully connected linear layer mapping the adapted representation to class logits, and it is likewise frozen on clients.

The central adaptive component is a domain-adaptive linear layer with batch-normalization terms. Given backbone output $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$9, the adaptation module is

$i$0

Here $i$1 and $i$2 are linear parameters; $i$3 and $i$4 are batch-normalization statistics; and $i$5 and $i$6 are batch-normalization scale and shift parameters. Domain-specific batch-normalization statistics and parameters, together with domain-specific linear weights, are allocated per domain. This layer is the only component adapted on clients and is intended to encapsulate domain shift while the backbone remains domain-agnostic.

For each client $i$7, the fixed and trainable components are separated as follows:

Component	Client status	Parameters
Backbone	Frozen	$i$8
Classifier	Frozen	$i$9
Adaptation module	Trainable	$T_i$0

Client adaptation is therefore posed as

$T_i$1

The paper states that freezing the large backbone and classifier dramatically reduces computational costs and mitigates overfitting under few-shot supervision. This supports a low-dimensional adaptation problem built on top of a high-capacity but fixed representation (Röder et al., 14 Jul 2025).

3. Federated optimization, deployment, and communication

Server-side source-model training uses the full source dataset $T_i$2 and jointly optimizes the backbone, adaptation module, and classifier (Röder et al., 14 Jul 2025). Initialization proceeds from ImageNet weights for the ResNet backbone; linear weights in the adaptation module are initialized from $T_i$3, batch-normalization parameters via Xavier or similar, and the classifier by standard random initialization. Data augmentation consists of horizontal flip, random resized crop, and color jittering. The source objective is

$T_i$4

with label smoothing regularization. Optimization uses SGD with learning rate $T_i$5, momentum $T_i$6, weight decay $T_i$7, batch size $T_i$8, and $T_i$9 epochs with learning-rate scheduling.

The trained parameters $$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$0 are then distributed to clients. The paper specifies three operational modes. In the on demand mode, the server sends the full model when a client first joins. In the pre-configured mode, the model is deployed with the device and there is no initial network transfer. In the differential sync mode, clients hold a base model and the server sends only deltas from that baseline to the current global model.

Client adaptation follows a fixed protocol. The client initializes

$$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$1

freezes $$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$2 and $$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$3, obtains a support set either offline or through streaming selection, and updates only $$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$4 for multiple local epochs using SGD with learning rate $$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$5, batch size $$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$6, and, in the experiments, $$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$7 epochs. No gradients are transferred to the server. The paper is explicit that FedAcross+ is not FedAvg-style during client personalization; the server-side global model is fixed while clients personalize locally (Röder et al., 14 Jul 2025).

Communication is correspondingly asymmetric. Downlink traffic consists of initial model parameters or deltas. Optional uplink traffic consists of adaptation parameters $$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$8 and local prototypes $$D_{T_i}=\{(x_l,y_l)\}_{l=1}^{k_i}\sim p_{T_i}(X_{T_i},Y_{T_i}).$$9. The server may then aggregate adaptation parameters via standard FedAvg and prototypes via FedProto-style aggregation or other fusion:

$y_l\in Y$0

This is intended to support onboarding of new clients using refined global adaptation parameters and prototypes. Communication complexity is therefore dominated by adaptation parameters and prototype vectors rather than full backbone weights or gradients.

4. Prototypes, few-shot inference, and streaming extension

FedAcross+ uses support-set prototypes as the basis for lightweight on-device inference (Röder et al., 14 Jul 2025). For client $y_l\in Y$1, the adapted embedding function is

$y_l\in Y$2

Given a support set

$y_l\in Y$3

the class prototype for class $y_l\in Y$4 is computed as

$y_l\in Y$5

The paper characterizes this as a ProtoNet-style class centroid in the adapted feature space.

Inference for a query sample $y_l\in Y$6 on client $y_l\in Y$7 proceeds by transformation, embedding, Euclidean-distance evaluation to prototypes, and nearest-prototype prediction:

$y_l\in Y$8

The stated advantages are computational: only a few vector subtractions and norms are required, and a softmax over a large linear head can be avoided if prototypes are used instead of the classifier layer. The paper also notes that this aligns with the theory of Bregman divergences used in ProtoNet.

The “+” in FedAcross+ refers to the streaming extension beyond the original FedAcross framework, which assumed static, pre-collected support sets (Röder et al., 14 Jul 2025). In the streaming setting, clients observe an unlabeled stream $y_l\in Y$9 and must decide which instances to label, maintain a balanced support set with at most $|Y|=L$0 labeled samples per class, and continuously update the adaptation module and prototypes when resources permit. Sample selection is based on VeSSal-style volume sampling. For embedding $|Y|=L$1 of incoming sample $|Y|=L$2, the selection probability is

$|Y|=L$3

where $|Y|=L$4 is the inverse covariance over previously selected samples and $|Y|=L$5 is an adaptive labeling frequency. The numerator approximates the sample’s determinantal contribution to the selected set, thereby encouraging diversity.

The streaming adaptation loop transforms and embeds each incoming sample, computes $|Y|=L$6, keeps or discards the sample probabilistically, requests a label when selected, inserts the labeled example into the support set with per-class eviction if necessary, and periodically fine-tunes $|Y|=L$7 and recomputes prototypes. This makes the framework stream-aware, compatible with sporadic or irregular updates, and directly responsive to labeling budget, channel availability, and energy constraints. The implementation and evaluation pipeline are described as using PyTorch Lightning and Flower, with an emphasis on deployment-readiness for industrial streaming scenarios (Röder et al., 14 Jul 2025).

5. Empirical evaluation and benchmark behavior

The experiments target cross-domain image classification with a waste-sorting motivation (Röder et al., 14 Jul 2025). The paper evaluates on Office-31, OfficeHome, and waste-focused subsets derived from OfficeHome and DomainNet. Office-31 contains $|Y|=L$8 classes across the Amazon, DSLR, and Webcam domains. OfficeHome contains $|Y|=L$9 classes across Art, Clipart, Product, and Real-World. The waste-focused subsets use $k_i=k\in\{0,3,5,10\}.$0 waste-related classes from OfficeHome and $k_i=k\in\{0,3,5,10\}.$1 waste-related classes from DomainNet Clipart and Real.

Baselines include centralized source-free domain adaptation methods using full unlabeled target data—SHOT, SFDA, and SDDA—together with few-shot adaptation methods FLUTE and LCCS, plus an off-the-shelf ResNet-50 baseline with a linear classifier and no adaptation. For the benchmark comparisons, FedAcross+ uses ResNet-50 to match baselines.

The principal average-accuracy results are summarized below.

Setting	Method	Accuracy
Office-31 average over all domain pairs	ResNet-50 baseline	76.1%
Office-31 average over all domain pairs	SHOT (all unlabeled target)	88.6%
Office-31 average over all domain pairs	LCCS (5-shot)	88.9%
Office-31 average over all domain pairs	FedAcross+, $k_i=k\in\{0,3,5,10\}.$2	81.4%
Office-31 average over all domain pairs	FedAcross+, $k_i=k\in\{0,3,5,10\}.$3	89.0%
OfficeHome average over all domain pairs	ResNet-50 baseline	46.1%
OfficeHome average over all domain pairs	SHOT (all unlabeled target)	71.8%
OfficeHome average over all domain pairs	LCCS (5-shot)	67.8%
OfficeHome average over all domain pairs	FLUTE (5-shot)	61.2%
OfficeHome average over all domain pairs	FedAcross+, $k_i=k\in\{0,3,5,10\}.$4	59.9%
OfficeHome average over all domain pairs	FedAcross+, $k_i=k\in\{0,3,5,10\}.$5	70.9%

On Office-31, FedAcross+ with $k_i=k\in\{0,3,5,10\}.$6 labeled samples per class reaches $k_i=k\in\{0,3,5,10\}.$7, slightly above LCCS at $k_i=k\in\{0,3,5,10\}.$8, while SHOT attains $k_i=k\in\{0,3,5,10\}.$9 using all target images, approximately $i$0 per class, rather than $i$1 labeled samples per class. On OfficeHome, SHOT remains best at $i$2, but FedAcross+ with $i$3 reaches $i$4 under substantially stricter annotation and on-device compute constraints. The paper’s interpretation is that the method is competitive in a constrained few-shot regime rather than optimized for the fully unlabeled-target setting.

The waste-oriented experiments simulate a central service provider and multiple facilities. The server pre-trains on all waste classes, and each client specializes on $i$5 classes, fine-tuning only on its subset. For OfficeHome (Waste), the reported accuracies $i$6 standard deviation over $i$7 runs are:

$i$8	$i$9	$U_i=\{x_t\}_{t\ge 1}$0
0	87.82 ± 0.26	78.68 ± 0.86
3	84.42 ± 0.25	75.73 ± 0.73
5	89.43 ± 0.45	84.44 ± 0.29
10	93.45 ± 0.56	88.91 ± 0.19

For DomainNet (Waste), the corresponding values are:

$U_i=\{x_t\}_{t\ge 1}$1	$U_i=\{x_t\}_{t\ge 1}$2	$U_i=\{x_t\}_{t\ge 1}$3
0	54.51 ± 0.12	65.0 ± 0.50
3	54.74 ± 0.06	69.0 ± 0.65
5	57.77 ± 0.24	76.87 ± 0.25
10	66.48 ± 0.32	83.18 ± 0.53

These results show a strong positive effect from increasing $U_i=\{x_t\}_{t\ge 1}$4, with especially pronounced improvements at $U_i=\{x_t\}_{t\ge 1}$5 under substantial domain shift. The paper also notes that in some cases $U_i=\{x_t\}_{t\ge 1}$6 already yields high performance because of a strong source model and a small domain gap. Qualitative analysis via t-SNE shows that baseline ResNet features exhibit overlapping class clusters, server pre-training improves class separation, and client adaptation via $U_i=\{x_t\}_{t\ge 1}$7 further tightens clusters with prototypes near cluster centers (Röder et al., 14 Jul 2025).

6. Theoretical grounding, privacy posture, and limitations

FedAcross+ is described as largely empirical and architectural rather than theorem-driven (Röder et al., 14 Jul 2025). It does not present new formal convergence or sample-complexity results. Its theoretical motivation is instead drawn from established ideas. The use of Euclidean-distance prototypes is linked to the ProtoNet perspective in which class means are optimal for certain clustering objectives under Bregman-divergence analysis. The use of domain-specific batch-normalization statistics and parameters is motivated by prior work indicating that such mechanisms support effective adaptation under covariate shift. A plausible implication is that the method’s inductive bias is intentionally conservative: it limits client plasticity to a small domain-alignment layer while preserving source-learned semantic structure in the frozen backbone.

The privacy model is structural rather than formal. No raw data leaves the clients, and no gradients are transmitted, which reduces the gradient-leakage surface associated with standard FL. Optional prototype sharing transmits class means in feature space rather than examples. The paper argues qualitatively that reconstruction from such means in a high-dimensional embedding is difficult. At the same time, it explicitly states that no differential privacy mechanism is deployed and no secure aggregation scheme is integrated in the implementation. The framework is presented as compatible with DP-FL and secure aggregation, but those guarantees are not part of the reported system (Röder et al., 14 Jul 2025).

Several limitations are stated directly. First, the method depends on moderate domain overlap; if source and target are extremely dissimilar, adapting only $U_i=\{x_t\}_{t\ge 1}$8 may be insufficient. Second, the evaluated few-shot regime is $U_i=\{x_t\}_{t\ge 1}$9, and performance degrades on harder datasets when $$D_S=\{X_S,Y_S\}=\{(x_l,y_l)\}_{l=1}^N\sim p_S(X_S,Y_S),$$00 is very small. Third, there is no formal FL convergence analysis under client heterogeneity and streaming drift. Fourth, although streaming and sampling are supported, explicit drift detection and forgetting mechanisms such as windowing or adaptive prototype decay are not yet integrated; the current formulation assumes slow or manageable drift. Fifth, privacy protection is not formalized with explicit DP or secure aggregation.

The research directions identified by the authors follow directly from these gaps: integrating concept-drift detection and adaptive forgetting into the streaming loop; refining sample-quality assessment beyond volume-based selection; incorporating differential privacy and secure aggregation while maintaining performance; extending the framework beyond waste sorting to settings such as supply chain optimization, smart grids, and public health surveillance, including non-vision modalities; and developing theoretical analyses of sample complexity and convergence for streaming federated adaptation with prototype sharing (Röder et al., 14 Jul 2025).