acceptodds
Under review as a conference paper at ICLR 2027

FedCensus: Partition-Invariant Federated Learning from Additive Sufficient Statistics

Abstract

Federated learning trains a shared model across clients while keeping their data local. With weight averaging, the model drifts when client data is non-IID, and the accuracy is bounded by the lowest-computation client. Methods that share prototypes, logits, or synthetic data share only the knowledge from each client's own dataset. We present FedCensus, a federated model with a fine and a coarse codebook learned inside the federation, three additive feature statistics computed against them, and a closed-form classifier, so every parameter is computed from additive client statistics. Because additive statistics do not depend on how the data is split, the trained model is the same under every partition and every number of clients. Because the sums cover every class, each client's model achieves nearly the same accuracy on classes absent from its local dataset as on those present. A client with a lower training budget uploads its statistics in installments and chooses its deployment level after training, so the accuracy of the deployed model is not bound by the lowest-computation client. On four datasets, FedCensus exceeds the state-of-the-art computation-heterogeneous, prototype-based, and logit-based methods. On CIFAR-100, FedCensus is comparable to the best homogeneous method at matched deployment FLOPs. FedCensus reaches this accuracy in 18 communication rounds and reduces the communication overhead by 60% compared with FedAvg. The complete source code is available at https://anonymous.4open.science/r/fedcensus-79E5/.

Primary area:
unsupervised, self-supervised, semi-supervised, and supervised representation learning
Keywords:
heterogeneous federated learning, computation heterogeneity, additive statistics, partition invariance

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_1UmoOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces FedCensus, a federated learning framework that replaces gradient-based model aggregation with additive statistics and closed-form computations. The method learns fine and coarse codebooks using federated batch k-means, constructs representations from activation sums, pairwise activation products, and spatial moments, and trains ridge-regression classifiers at multiple deployment levels. The paper establishes partition invariance under full participation and exact arithmetic. Experiments on four image classification datasets demonstrate competitive accuracy under non-IID data partitions.

Critical strengths
  1. Strong empirical results and extensive analysis. The method achieves competitive accuracy, outperforming several computation-heterogeneous baselines under the reported configurations. The evaluation covers multiple datasets, partition settings, deployment levels, and feature ablations, including empirical validation of the theoretical partition-invariance property.
  2. Approach to partition-invariant federated representation learning. The paper proposes a framework in which both the encoder and classifier are constructed from distributed statistics rather than gradient aggregation. The theoretical analysis provides a clear explanation of partition invariance, representing a meaningful conceptual contribution.
Critical weaknesses
  1. Insufficiently matched comparison with computation-heterogeneous federated learning methods. (a) Unmatched computational budgets: HeteroFL and FedRolex use heterogeneous client budgets of 25/98/390 MFLOPs, whereas the smallest FedCensus model requires 223 MFLOPs. Moreover, FedCensus-S/L require 385/790 MFLOPs, compared with the average 160 MFLOPs of HeteroFL. Thus, the reported improvements do not establish superiority under identical per-client computational constraints. (b) Incomplete efficiency comparisons: The reported 60% communication reduction compares FedCensus against FedAvg after 1,000 rounds rather than at matched accuracy. The reduction in communication rounds is also not accompanied by comparable measurements of total client computation, wall-clock time, or memory requirements.

  2. Quadratic communication complexity and an unresolved communication–privacy trade-off. FedCensus requires uploading a Gram matrix with O(D^2) entries (approximately 3.8 GB per client for D = 43,520), potentially limiting scalability and deployment on resource-constrained devices. The installment scheme in Appendix A.13 does not clearly explain how sample-wise partitioning reduces the size of each transmitted Gram matrix. The proposed algorithm seems still limited when dimension goes 10x bigger, and authors need to clarify the effective regime.

Questions for authors

Q1. Fair comparison with heterogeneous FL methods.

Could the authors compare FedCensus against HeteroFL, FedRolex, and DepthFL under identical per-client inference budgets? In particular, how would FedCensus accommodate clients with budgets of 25 or 98 MFLOPs? Would the reported accuracy advantage remain under the same client budget distribution?

Q2. Communication complexity and practical scalability.

Given the O(D^2) communication complexity of the Gram matrix, could the authors clarify how the installment scheme reduces per-upload communication without increasing total communication? Could the authors report actual transmitted bytes, peak memory, and client-side computation costs, and discuss the practical limitations as the feature dimension D increases? An accuracy-matched communication comparison with FedAvg and heterogeneous FL baselines would also be helpful.

Q3. Privacy guarantees and attack evaluation.

Appendix A.14 demonstrates information leakage from individual class statistics, while the factor-based communication scheme is incompatible with secure aggregation. Could the authors clarify the intended privacy threat model? In particular, have reconstruction or inference attacks been evaluated against the per-image seeding centroids and secure-aggregated statistics when only a few clients contribute to a class?

4 comments

We thank the reviewer for recognizing partition invariance and for the detailed suggestions on fair comparisons, communication, and privacy. The references and main manuscript are revised for the rebuttal revision.

Q1. Comparison at the same inference budgets

We train a smaller encoder with whitening rank 27 and 128 coarse codewords, then derive its deployment levels from the same aggregated statistics. Table 4 in the revised main text compares it with the strongest baseline at each nearby budget on CIFAR-100.

FedCensus reaches 0.5326 macro accuracy at 22.1 MFLOPs, against Federated Importance-Aware Submodel Extraction (FIARSE) at 0.2336 and 25.0 MFLOPs. At 99.2 MFLOPs it reaches 0.5689, against FedRolex at 0.3313 and 98.3 MFLOPs. At 181.5 MFLOPs it reaches 0.5786, against DepthFL at 0.4295 and 172.8 MFLOPs. The first comparison uses fewer FLOPs, and the other two use 1% and 5% more. Table 27 reports all six levels.

Q2. Communication and practical scalability

You are correct about installments. Each partial Gram matrix has the full matrix dimensions. Splitting samples into R installments reduces computation per slot by a factor of R, but each statistics upload remains 3805.8 MB and total statistics communication grows by R. We have corrected Section 3.2 and Appendix A.13.

At approximately the same macro accuracy, FedCensus reaches 0.6246 in 18 rounds with 3.99 GB per client and 21.39 TFLOPs of client computation. FedAvg reaches 0.6250 in 535 rounds with 5.35 GB and 15.06 TFLOPs. We have replaced the 60% communication claim with the resulting 25% reduction. FedCensus uses 1.42 times the client computation. At the lower target of 0.600 accuracy, FedAvg needs 190 rounds and 1.90 GB. Table 29 gives the full comparison. The FedCensus run took 1 h 32 m on 24 CPU threads, while 1000-round FedAvg took 3 h 48 m on a GPU.

We also evaluate preconditioned conjugate gradient (PCG) with low-rank preconditioning (Frangella et al., 2023). With 1024 sampled columns, the largest array falls from 3788.1 to 178.3 MB. The solver takes 98 iterations and reaches 0.6234 macro accuracy, against 0.6237 for direct ridge regression. Total classifier communication decreases from 3805.5 to 3607.6 MB per client, and the full pipeline takes 116 rounds. With 256 columns, the largest array is 44.6 MB, but 168 iterations raise communication to 5911.1 MB (Table 28).

We solve the aggregated ridge system numerically and calculate communication from the exchanged arrays. Clients can compute the matrix products from their features without storing a Gram matrix, and the uploads support secure aggregation. Runtime peak memory includes these arrays, encoder batches, and solver workspace.

At feature dimension D = 435,200, the upper Gram triangle would occupy 378.8 GB. With 100 classes and 1024 sampled columns, PCG requires a 1.78 GB preconditioner upload and 174.1 MB in each direction per iteration. Each array grows linearly with D at the cost of repeated communication. Appendix B.4 gives more details and analysis.

Q3. Privacy and attack experiments

We consider an honest-but-curious server receiving secure aggregates and individual seeding centroids. On 500 CIFAR-100 targets, the centroid attack reaches a PSNR of 15.72 and a SSIM index of 0.556 against the closest true patch, compared with 11.71 and 0.390 for a random other image. Source-image identification within the client's images reaches 0.158 against 0.0016 chance (Table 30). The centroids therefore reveal source information. Sampling one fifth before upload reduces their count from 22,361 to 4,472 while changing micro accuracy by at most 0.0009 across deployment levels (Table 31).

We apply the closed-form reconstruction attack to aggregates of 1 to 50 images of the same class, keeping the encoder, recognizability classifier, and 200 target images fixed. With one image, top-1 recognizability is 0.025 against 0.400 for the originals. At 50 images, PSNR falls from 8.79 to 7.48 and recognizability remains 0.025. Table 32 reports all results, and Appendix B.5 describes the attacks.

Reviewer_1UmoOpenReview ↗

I will raise my score accordingly to 2.5, while the communication/memory cost and privacy issues above remain my main reservations.

Thank you for the detailed rebuttal and the additional experiments. Below is my response to each point.

Q1. Comparison at matched inference budgets. I appreciate the new smaller encoder (whitening rank 27, 128 coarse codewords) and the level-by-level comparison against FIARSE, FedRolex, and DepthFL on CIFAR-100 at comparable FLOPs (22.1 / 99.2 / 181.5 MFLOPs). This directly answers my question about clients with 25 or 98 MFLOPs budgets, and I consider this concern largely resolved. However, as Reviewer yvBB also pointed out, part of the large margin may come from the baselines being weak under your evaluation protocol (e.g., FedProto reaches 0.0217 on your split versus 0.2704 on the native HtFLlib split). I suggest stating this protocol difference clearly in the main text next to Table 4, so readers can interpret the size of the gains correctly.

Q2. Communication and practical scalability. Thank you for acknowledging that installments do not reduce the per-upload size (each upload is still 3805.8 MB and total communication grows by a factor of R), and for correcting Section 3.2 and Appendix A.13. I also appreciate that the 60% communication claim was replaced with an accuracy-matched comparison. Two concerns remain:

Peak memory. The rebuttal describes peak memory only qualitatively (arrays, encoder batches, solver workspace). Could you report measured peak client-side memory for both the direct ridge solver and the PCG variant? This number is central to judging deployability on constrained devices. Consistency with the target setting. In your response to Reviewer hYCJ, the target scenario is described as coordinated IoT systems with limited computation budgets. However, according to Table 29, each client uploads about 4 GB (3.99 GB) and uses 1.42× the client computation of FedAvg (21.39 vs. 15.06 TFLOPs). Moreover, at the 0.600 accuracy target, FedAvg needs only 1.90 GB. These numbers are difficult to reconcile with resource-constrained IoT devices. Could you clarify the realistic deployment regime (device memory, bandwidth, and feature dimension D) in which FedCensus is preferable, and state this limitation explicitly in the paper? Q3. Privacy. Thank you for specifying the honest-but-curious threat model and adding the attack experiments. However, the seeding-centroid leakage remains substantial: source-image identification reaches 0.158 against 0.0016 chance. Subsampling one fifth of the centroids reduces the amount of leaked information but does not remove it, and there is no formal guarantee such as differential privacy. In addition, the aggregated statistics are evaluated against only one attack (closed-form reconstruction), so the conclusion that aggregates are safe seems optimistic. I encourage the authors to (i) discuss DP-noised centroids or seeding schemes that avoid uploading per-image centroids, and (ii) evaluate stronger attacks such as optimization-based reconstruction or membership inference, or at least state these as limitations.

I will raise my score accordingly to 2.5-3, while the communication/memory cost and privacy issues above remain my main reservations.

Thank you very much for the detailed response and for increasing our score! I agree with your concerns about privacy and communication. I will add more experiments to better quantify privacy and communication costs and show how to address these issues.

We have conducted further analysis of the memory overhead.

Measured peak client memory is 10.31 GB for direct ridge regression and 2.92 GB for PCG in the default configuration. PCG uses 1024 preconditioner columns and computes local matrix products in batches without storing the Gram matrix. We profiled the largest CIFAR-100 client, with 3,507 images, three views per image, and feature dimension D = 43,520. Peak memory includes Python/PyTorch, local images, cached features, encoding and statistics workspaces, and communication buffers.

We hope this information addresses your concerns about the memory usage.

Reviewer_hYCJOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper present FedCensus, a federated model with an additive-statistics - based learning and aggregating methods. They replace the standard SGD training by two learnable codebooks, three additive feature statistics and a closed-form classifier. The emprical results show that the method can outperform existing baselines in the same setting.

Critical strengths
  • Good visualization
  • Extensive empirical results
Critical weaknesses
  • How to scale this method with other modalities, e.g., text, audio etc. Does this method require special forms of encoder such as patch encoders the paper suggests?
  • The method replaces standard deep learning methods by additive statistics - based parameters. While this method offers benefits (such as computation-robust), it is difficult to scale it up with computes, limiting its applications in the real world.
  • How would FedCensus converge? The convergence rates between standard SGD-based FL and the proposal might not be comparable, but it is important to understand how parameters behave in the proposed method.
Questions for authors

See Weaknesses

3 comments

We thank the reviewer for the careful review and the questions on generalization, scalability, and convergence. The references and main manuscript are revised for the rebuttal revision.

W1. Other modalities and the encoder

FedCensus generalizes to sensor signals, text, audio, and medical images. For sensors, we replace image patches with time windows spanning all channels. For text, we use token windows. Audio uses log-mel spectrograms with the two-dimensional encoder. The codebooks remain shared across positions, and the encoder computes the same activation sums, pair products, and spatial moments.

With 20 clients and Dirichlet α = 0.1, FedCensus reaches 0.9541 macro accuracy on Human Activity Recognition Using Smartphones (UCI HAR) and 0.8785 on Physical Activity Monitoring (PAMAP2), against centralized CNNs at 0.9413 and 0.8935 (Table 3). PAMAP2 uses a test set from separate subjects.

On AG News, character input requires no pretrained embedding. FedCensus reaches 0.7988, close to the centralized CNN at 0.8054 and above FedAvg with the same CNN at 0.5367. Pair products and spatial moments improve accuracy from 0.7529 to 0.7988. Global Vectors for Word Representation (GloVe) embeddings raise FedCensus to 0.8964, while term frequency and inverse document frequency (tf-idf) features with ridge regression reaches 0.9035. Tables 21 and 22 give the complete comparisons.

Without augmentation, FedCensus reaches 0.9142 on Speech Commands v2, 0.8760 on PathMNIST, and 0.9435 on BloodMNIST. The strongest baselines reach 0.9184, 0.6940, and 0.6702. Time-shift augmentation raises Speech Commands accuracy to 0.9175 (Table 23 and Appendix B.1).

The encoder benefits from local windows that share structure. On Forest CoverType, whose attributes lack a natural spatial order, windows of six attributes capture 0.500 of the centralized model's gain over raw-input ridge regression, against 0.843 for encoding the whole row (Table 24).

W2. Scaling with computation

The current encoder gains little expressive capacity from further increases in parameter count. On CIFAR-100, doubling the fine codebook size J from 4096 to 8192 nearly doubles distance computation but improves micro accuracy by 0.0012. Increasing the pair count m_P from 8192 to 24576 improves macro accuracy from 0.5729 to 0.6123 at a deployment level with J' = 256 fine codewords (Tables 25 and 37). So, a performance scaling may come from a more complex encoder feature design that increases the computation instead of adding more codewords.

At deployment, increasing the computation budget of the same trained model produces a clear accuracy gain. The smaller encoder reaches macro accuracies of 0.5326, 0.5689, and 0.5786 at 22.1, 99.2, and 181.5 MFLOPs. Increasing the budget from the first to the last level improves accuracy by 4.60 percentage points. All levels use the same trained codebooks and aggregated statistics (Table 4).

FedCensus targets coordinated IoT systems whose devices participate in each round and have different, limited computation budgets. Installments spread each client's training computation across upload slots, and each device selects a deployment level that fits its budget.

W3. Convergence

FedCensus learns its parameters in stages. We compute whitening once from patch statistics, then learn the two codebooks through batch k-means. Each update replaces a codeword with the mean of its assigned patches. Pair screening then fixes the feature set, and we solve the ridge classifier.

With full participation, exact arithmetic, and deterministic sampling and updates, each federated update equals the centralized update on the same fixed patch set. Corollary 1 establishes non-increasing quantization error and convergence to a fixed point in finitely many updates.

Figure 6 in Appendix B.2 traces both codebooks through 97 rounds on CIFAR-100, with means over three runs. Quantization error decreases at every update. We define relative parameter change as the Frobenius norm of an update divided by that of the previous codebook. From round 15 to round 97, the mean change falls from 0.0316 to 0.0014 for the fine codebook and from 0.0263 to 0.0033 for the coarse codebook.

Micro accuracy rises from 0.6114 after one codebook round to 0.6271 after five, then stays between 0.6250 and 0.6281 through 97 rounds (Table 26). Accuracy reaches a plateau while the codebooks continue to change. The default uses 15 codebook rounds and 18 communication rounds in total.

Thank you for your response. My main concern on scaling with computation is not well addressed; it seems difficult or requires significant efforts to scale the performance compared to standard gradient-based optimization, limiting its benefits in real worlds. Hence, I will maintain my score.

Thank you for your follow-up to our rebuttal. We would like to further address your concern about scalability.

We want to make the following two points regarding scalability.

  1. Increasing training computation can improve FedCensus without redesigning the encoder or communication protocol.

On CIFAR-100, increasing training views from three to six raises macro accuracy from 0.6248 to 0.6353. Average client computation increases from 21.39 to 39.51 TFLOPs, with communication and inference computation unchanged (Table 38).

  1. FedCensus can make deployments more scalable and enable more applications in resource-limited scenarios by lowering the computation required per device while preserving its centralized model across client partitions. Also, scaling with partitions is more important than the model's parametric scaling in non-IID distributions.

We made a mistake in the FedAvg FLOPs count and corrected it to include convolution at every output position. FedCensus reaches mean macro accuracy 0.6246 across three runs with 21.39 TFLOPs per client. FedAvg on the small convolutional neural network (CNN-S) needs 2344 TFLOPs to first exceed 0.625. At a comparable overhead of 21.9 TFLOPs (FedCensus 21.39 TFLOPs), FedAvg reaches 0.1153 (Table 29).

FedAvg's multiple local gradient steps before aggregation make its optimization depend on the partition. Its accuracy falls from 0.709 with IID clients to 0.564 at α = 0.05 (Figure 2b). FedCensus learns from additive statistics and gives identical performance across five partitions and at 100 clients with α = 0.1 on the same training set (Table 17). For IoT systems, FedCensus's lower computational overhead can reduce processor requirements and enable larger deployments of less expensive devices.

Reviewer_yvBBOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This work proposes FedConsensus - a federated image classification approach where every parameter is computed from additive client statistics, without any gradient steps or pretraining. Two codebooks (4096 fine, 512 coarse codewords) are seeded from per-image patch centroids and learned with communication rounds of federated batch k-means, where clients send only sums per patch statistics. Then, for classification, a ridge classifier is then solved from the aggregated Gram matrix and class sums. Since all uploads are sums, the model is identical under any partition and equals the centrally trained one.

Critical strengths
  1. Simple concept with gradient-free federated learning approach, which is partition invariant.
  2. Multi-level deployment where computational heterogeneity is supported.
  3. The paper seems to be polished, with provided anonymized source code and extensive appendices.
Critical weaknesses
  1. Several baselines have really low accuracy, and it seems that the hyper-parameters selection or the method adaptation was not done properly, Prototype and logit baselines score below local-only, and FD is at chance under IID.
  2. Novelty is limited. Prop. 1 and Lemma 1 follow from the sum-decomposability of batch k-means, PCA and ridge regression. I've checked the given reference, and it seems to be mainly based on mentioned (Chu et al., 2006) work. Patch based methods - patch-based methods (Coates & Ng 2012; Thiry et al. 2021)
  3. The comparison of the gradient-based method vs training-free ones in the main table is not very clear and can be done in different ways. The large margins in Table 1 come from comparisons that are not exactly budget-matched or from baselines that fail sanity checks (the first weakness in this list). The per-round communication cost is also important here (appendix Tab.9, not overall). So, even the claim about different installments and use of small devices still requires transferring all data per client, which installment does not reduce. Each installment's contribution to G_k is still a full D×D matrix (i.e., 3.8 GB fp32, Table 9).
  4. No clear info how were λ, m_P and J chosen (Tab.4)? Was any data held out from the train/test set?
Questions for authors
  1. Why not present Fed3R (strong baseline) in the Tab.1 with the same patch encoder?
  2. How were λ, m_P and J chosen (Tab. 4)? Was any data held out from the test set?
2 comments

We thank the reviewer for the constructive feedback on the baselines, contribution, and experimental protocol. The references and main manuscript are revised for the rebuttal revision.

W1. Baseline accuracy

We ran FD and FedProto with the HtFLlib implementations on its native split and our split (Table 33). FD reaches 0.0150 on the native split, near 0.0100 chance. FedProto reaches 0.2704 on the native split and 0.0217 on our split under HtFLlib evaluation. Applying our deployed evaluation to the same models gives 0.0221. The larger difference comes from the split. HtFLlib tests each client on its Dirichlet shard, whereas we use the shared test set and an argmax over all classes.

We also evaluated stored predictions with both test classes and predictions restricted to each client's present classes. ProtoNorm's CIFAR-100 macro accuracy rises from 0.0855 to 0.1880. Local-only reaches at least 0.3060 under this personalized protocol. Table 34 reports both evaluations, and Appendix B.6 describes the protocols. We corrected the personalized accuracy in the main text.

W2. Contribution

FedCensus learns both the encoder and classifier from scratch within the federation using additive client statistics. This extends partition invariance from a classifier on pretrained features, as in Fed3R, to the entire model learned from raw inputs.

Our contribution is proposing the design of a representation that combines activation sums from a fine codebook with pair products and spatial moments from a coarse codebook. This design captures co-activation and spatial information beyond activation sums while retaining these features across deployment levels. With our ridge solver, the complete representation raises CIFAR-100 micro accuracy from 0.5510 to 0.6251 (Table 35).

Our optimization and guarantees build on the summation form of Chu et al. (2006), and our patch encoding builds on Coates and Ng (2012) and Thiry et al. (2021). Proposition 1 and Lemma 1 establish partition and installment invariance for the complete model, including its learned encoder and deployment levels.

W3. Inference budgets and communication

We train a smaller encoder with whitening rank 27 and 128 coarse codewords, then derive its deployment levels from the same aggregated statistics. Table 4 reports macro accuracies of 0.5326, 0.5689, and 0.5786 at 22.1, 99.2, and 181.5 MFLOPs. FIARSE, FedRolex, and DepthFL reach 0.2336, 0.3313, and 0.4295 at 25.0, 98.3, and 172.8 MFLOPs. FedCensus uses fewer FLOPs in the first comparison and 1% and 5% more in the other two.

You are correct that installments do not reduce Gram matrix dimensions. They reduce computation per slot but increase total communication. We corrected Section 3.2 and Appendix A.13. Preconditioned conjugate gradient (PCG) with low-rank preconditioning (Frangella et al., 2023) reduces the largest array from 3788.1 to 178.3 MB and classifier communication from 3805.5 to 3607.6 MB, with macro accuracy 0.6234 against 0.6237. It requires 98 iterations and 116 rounds for the full pipeline. Table 28 reports the experiment on the aggregated ridge system, with communication calculated from the exchanged arrays.

At approximately the same accuracy, the original pipeline takes 18 rounds and 3.99 GB per client, compared with 535 rounds and 5.35 GB for FedAvg. We replaced the 60% claim with this 25% reduction. FedAvg reaches 0.600 macro accuracy with 1.90 GB per client (Table 29).

Q1. Fed3R with the same encoder

Fed3R (Fanì et al., 2024) and our classifier both solve ridge regression on fixed features. With identical features, preprocessing, and ridge objective, both give the same linear system. Using our patch encoder and ridge solver, activation sums alone reach 0.5510 micro accuracy (Table 35). Adding pair products raises it to 0.6164, and adding spatial moments raises it to 0.6251. The same feature additions raise macro accuracy from 0.8786 to 0.9142 on Speech Commands v2 and from 0.7529 to 0.7988 on AG News. Appendix B.7 describes the implementation differences. Table 9 in Appendix A.5 reports the pretrained Fed3R experiment.

Q2. Hyperparameters and held-out data

After the 75/25 training/test split, we hold out one tenth of the training pool to select ridge weight λ and fine codebook size J, giving λ = 100 and J = 4096. We select the pair count m_P = 24,576 at the knee of the accuracy curve against deployed parameter count. The final ridge classifier uses all training samples. Pair screening excludes a fixed tenth of training samples.

Appendix B.8 gives the selection procedure. Test micro accuracy is 0.6251 at λ = 100 and 0.6253 at λ = 300. Doubling J to 8192 gives 0.6263. Tables 36 and 37 report the ridge and pair-count sweeps. We use these defaults across the image datasets and partitions.

Dear reviewer, as today is the last day of the rebuttal, we would like to learn from you about your opinion of our response. Your opinion matters a lot in how we can further improve our manuscript. If you have any concerns, please let us know.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.