Pith. sign in

REVIEW 2 major objections 4 minor 61 references

SecEmb: Sparsity-Aware Secure Federated Learning of On-Device Recommender System with Large Embedding

T0 review · 2 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read SecEmb shows that a federated recommender can hide which items a user rated while shrinking per-user traffic to depend on the user's own item count rather than the catalog size.

desk verdict A genuinely clever FSS-based protocol for secure federated recommendation with strong user-side savings, but the 'lossless' claim is broken for heavy users and the server-side cost is not analyzed. read the letter →

arxiv 2505.12453 v2 pith:GTNMQJ3X submitted 2025-05-18 cs.CR

Peihua Mai , Youlong Ding , Ziyan Lyu , Minxin Du , Yan Pang This is my paper · ORCID
classification cs.CR
keywords functionsecretsharingfederatedrecommendersystemssecureaggregationsparseembeddingupdatesprivateretrievalcommunicationefficiencyprivacy-preservingmachinelearningpointfunctions
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

SecEmb claims that a federated recommender can be made communication-efficient by exploiting the sparsity of embedding updates without sacrificing security or accuracy. The paper's central assertion is that rated item indices and individual user gradients can be hidden from the server while each user's per-round traffic depends on the number of items they rated ($m'$) rather than the full catalog size ($m$). On standard public datasets this makes upload and download roughly 4x to 90x smaller than secure federated recommenders and user-side computation up to 70x lower, while remaining lossless — unlike compression methods that trade accuracy for bandwidth. The result matters because the embedding table dominates model size in large-catalog recommenders, so making secure training sparse is what makes on-device participation feasible.

What carries the argument

The load-bearing object is the function-secret-sharing key for a point function: a compact randomized description that lets each of two servers evaluate a function that is zero everywhere except at one hidden index, where it equals a value. Each user encodes every rated item row as such a point function; the servers evaluate the keys over the full item domain, obtaining additive shares of the embedding in the retrieval module and additive shares of the aggregated gradient in the aggregation module. The protocol's second key mechanism exploits the structure of these keys: the binary-tree path that selects the hidden index can be reused from the retrieval stage, so the aggregation stage needs only the final correction word that converts that path into the gradient value, cutting key size and the number of AES operations per update.

What would settle it

Run one training round with two servers that are allowed to pool their keys and intermediate path values for a user with $m'=1$; if they can recover the hidden rated item index with probability meaningfully above $1/m$, the security theorem fails. On the efficiency side, measure the server's wall-clock time for full-catalogue function-secret-sharing evaluation at a catalog size of $m=90{,}000$; if that server cost dominates the user-side reduction, the practical efficiency claim is scope-limited.

Watch

Extended reading notes

Core claim

The paper's central claim is a protocol in which each user encodes their non-zero embedding updates as secret-shared point functions, so two non-colluding servers can retrieve the relevant embeddings and aggregate the updates without ever learning which items the user rated or what the individual gradient values were. Because only the rated rows are downloaded and only compact function-secret-sharing keys are uploaded, per-user communication is $O(m'(\lambda \log m + bd) + |\theta|b)$ for upload and $O(m'bd + |\theta|b)$ for download, and the aggregation is exact: no quantization, low-rank approximation, or top-k sparsification is needed. The paper gives a simulation-based security argument that the servers' joint view reveals nothing beyond the aggregated model, and it reports communication reductions up to 90x and user-side computation reductions up to 70x against a two-server additive-secret-sharing baseline.

Load-bearing premise

The security guarantee collapses if the two servers work together, and the headline savings assume the server can afford to evaluate every user's secret-shared marker over the entire item catalogue and store intermediate values for all catalogue items — server-side costs that grow with catalogue size and are not counted in the per-user complexity headline.

Editorial extensions

If this is right

  • Federated recommenders can be made secure and sparse at the same time without loss: users send compact keys only for the rows they updated, and the server still reconstructs the exact aggregate.
  • Device download no longer scales with catalog size; it scales with the number of items the user rated, which is what makes large-catalog datasets (tens to hundreds of thousands of items) practical on bandwidth-limited devices.
  • Because no information about non-zero positions or values reaches either server, the protocol is compatible with adding differential privacy noise to the aggregate, giving a better privacy-utility trade-off than local differential privacy.
  • The same mechanism extends to sequential recommendation, where the paper measures a roughly 2500x upload reduction on a dataset with more than nine million items.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A general recipe suggested by this design: any federated task where the same sparse coordinates are used for both retrieval and update can reuse the function-secret-sharing path between stages, reducing the second transmission to one correction word per coordinate.
  • The user-side savings are partly a transfer of computation to the server; full-domain evaluation of secret-shared point functions over millions of items is a hidden cost that deserves its own benchmark before large-scale deployment.
  • A testable extension is to vary the padding multiplier that sets $m'$ from the average number of rated items and measure downstream utility; the paper fixes $m'$ empirically, and an automatic rule would make the protocol easier to deploy.
  • Federated language-model fine-tuning has the same sparse structure in token embeddings, so the same two-module protocol could apply to private token-embedding updates; the paper sketches this direction but does not implement it.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 4 minor

Summary. The paper proposes SecEmb, a two-server protocol for federated recommender training that (i) privately retrieves only the embeddings of items a user has rated, using function secret sharing (FSS) point functions, and (ii) securely aggregates the sparse embedding gradients while hiding rated-item indices and update values from the server. The authors claim the protocol is lossless, with per-user upload O(m'(λ log m + bd) + |θ|b) and download O(m'bd + |θ|b), and report up to 90x communication and 70x computation savings over a two-server additive-secret-sharing secure FedRec, plus utility advantages over quantization and low-rank compression baselines. The empirical study covers five datasets and four recommender models, and the appendices contain formal security proofs and additional efficiency comparisons.

Significance. If the correctness and complexity claims held in full, SecEmb would be a practically meaningful contribution: it combines FSS-based private retrieval with row-wise sparse aggregation so that the item-catalog size is removed from the user's per-round payload, and the code is publicly available. The security argument follows the standard two-server FSS hybrid proof with additive secret sharing, and the user-side communication formulas are internally consistent. The empirical evaluation is extensive and includes an ablation study demonstrating the value of the path-sharing optimization. The main claims, however, are currently overstated: the protocol is not lossless as written, and the reported complexity is incomplete on the server side, so the paper needs substantive revision before the contribution can be accepted as stated.

major comments (2)
  1. [§4.2.3, Appendix C (Algorithms 1–2), Eq. (8), Table 11] The paper advertises SecEmb as lossless (Section 1, Table 11) and states that padding/truncation keeps the 'entire sparse update matrix' hidden (§4.2.3). However, Algorithm 2 (PadOrTruncEmb) randomly samples m' rows when the user's actual rating count m'_u exceeds m', and Algorithm 3 then generates FSS keys only for these m' rows. Consequently, the aggregate computed in Eq. (8) is a sum over truncated, randomly subsampled per-user gradients, not a sum of the full local gradients. This biases the aggregated model update, so training is not equivalent to the uncompressed secure FedRec, and the 'Lossless' checkmark for SecEmb in Table 11 is inaccurate. Since Figure 2(a) shows a long-tailed rating distribution and the chosen m' values in Appendix I are 200–500, a non-negligible fraction of users in ML10M, ML25M, and Yelp exceed m'; the paper does not quantify the induced bias or its effect on the reported RMSE values. The authors should either revise the lossless claim and provide a bias/utility analysis of the truncation, or choose m' as a per-dataset maximum and re-derive the communication benefits.
  2. [§4.4.1, Table 1, Algorithm 3] The headline complexity in Table 1 and Section 4.4.1 is explicitly user-side, but the paper's overall efficiency claims (e.g., 'cost independent of item size m for downloads and logarithmic in m for uploads' in Section 6) are presented without the server-side counterpart. In Algorithm 3, each server evaluates FSS.Eval or FSS.ConvertEval for every u in A_t, every i in [m'], and every j in I, i.e., O(n m' m log m · AES) operations per round, and must store the path values (t_{u,i,j}, s_{u,i,j}) for every user, item, and catalog element, an O(n m' m λ)-bit memory footprint. These costs scale linearly or worse in the catalog size m and are absent from the complexity analysis and from the memory/storage evaluation in Appendix K.2, which measures only the user side. The authors should state the server-side complexity and memory explicitly and, when comparing against secure FedRec as an end-to-end system, present the total system cost fairly.
minor comments (4)
  1. [Appendix E, Algorithm 6 (FSS.PathEval)] Algorithm 6 assigns the same left-branch values in both the x_i = 0 and x_i = 1 cases; the else branch should select s_R and t_R instead of s_L and t_L. As printed, the pseudocode cannot correctly evaluate the point function, so this typo should be fixed.
  2. [Algorithm 3 vs Algorithm 7] Algorithm 3 stores the intermediate values as (t^1_{u,i}, s^0_{u,i}, s^1_{u,i}), while FSS.PathGen in Algorithm 7 returns (t^{(n)}_1, s^{(n)}_0, s^{(n)}_1); the superscript/subscript notation should be aligned to avoid ambiguity.
  3. [§4.2.1, Step 1] The phrase 'encode rated item with a point function, giu→fu,i' is garbled notation and should be rewritten for clarity.
  4. [§5.1 and Appendix I] The per-dataset m' values (200, 300, 300, 500, 500) appear only in Appendix I; they should be stated in the main experiments section because they directly determine the reported reduction ratios.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: SecEmb's security and efficiency claims are derived from external FSS correctness/security and direct complexity accounting, and the utility results are measured.

full rationale

SecEmb's aggregation correctness follows from Eq. (8), which directly applies the external FSS correctness property: each server evaluates the same shared point function and the two shares sum to the intended sparse gradient. The security claim (Theorem 4.1 and Appendix F) is established by hybrid arguments whose indistinguishability is inherited from the FSS construction of Boyle et al. (2015; 2016) and from standard PRG/Convert assumptions, not from a result unique to this paper. The upload/download complexity bounds in Table 1 are arithmetic consequences of the stated FSS key sizes (λ+2)log m and bd, not fitted parameters. The 90x/70x communication and computation reductions are measured against the two-server ASS baseline in Tables 2 and 12 and Figure 5, so they are empirical observations rather than conclusions derived from the desired outcome. The only self-citation, Mai & Pang (2023), appears in the related-work survey and is not load-bearing for any protocol, security, or efficiency claim. Possible weaknesses such as the truncation behavior of PadOrTruncEmb for users with m'_u > m' are correctness or accuracy concerns, not circularity: they do not make any claimed output equivalent to an input by construction. Therefore, no derivation step reduces to its own input.

Assumptions & free parameters 3 free parameters · 6 assumptions · 0 invented entities

The central claim depends on the sparse-gradient assumption, the non-colluding two-server model, and the chosen m' hyperparameters. No new cryptographic entity is introduced; the protocol composes existing FSS and additive secret sharing, so the ledger contains no invented entities.

free parameters (3)
  • m' (unified update size) = 200, 300, 300, 500, 500 for ML100K, ML1M, ML10M, ML25M, Yelp
    Chosen per dataset based on the distribution of rated items; it determines the upload/download payload and the cutoff at which surplus gradient rows are dropped.
  • α multiplier in m' = α * average = unspecified
    Appendix C defines m' as α times the average number of rated items, but the α value used in experiments is not reported.
  • range bound R_u for gradient values = unspecified
    Appendix L.2 requires constraining each user's transmitted values to avoid overflow in the finite group; the bound used in experiments is not stated.
assumptions (6)
  • standard math FSS correctness and security for point functions
    Invoked in Section 3.2 and used throughout the protocol; the construction relies on Boyle et al. 2015 and 2016.
  • domain assumption The two servers do not collude
    Stated in Section 4.4.2 and Appendix L.1; if both servers collude, user indices and gradients are revealed.
  • standard math FSS key size is O(λ log m + |G|), specifically (λ+2)log m for the index and bd for the output
    Used in the complexity analysis in Section 4.4.1, attributed to Boyle et al. 2016.
  • domain assumption Gradients can be encoded into a finite group with bounded range to avoid overflow
    Appendix L.2 imposes range constraints on user inputs; this is required for correct aggregation over the group.
  • domain assumption Item embedding gradients are sparse and confined to rated items
    Section 4.1 and Figure 2(a) rely on this sparsity; if users rated a large fraction of the catalog, m' would approach m and the efficiency gain disappears.
  • domain assumption The server can perform full-domain FSS evaluations over all m items and store intermediate path values
    Algorithm 3 instructs the server to compute and store (t_{u,i,j}, s_{u,i,j}) for all j in the item set; feasibility for large m is not analyzed.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SecEmb: Sparsity-Aware Secure Federated Learning of On-Device Recommender System with Large Embedding." pith.science (2026). https://pith.science/paper/GTNMQJ3X

@misc{pith2026250512453,
  author       = {Pith},
  title        = {Pith review of: SecEmb: Sparsity-Aware Secure Federated Learning of On-Device Recommender System with Large Embedding},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/GTNMQJ3X}},
  note         = {Machine review of arXiv:2505.12453}
}
read the original abstract

Federated recommender system (FedRec) has emerged as a solution to protect user data through collaborative training techniques. A typical FedRec involves transmitting the full model and entire weight updates between edge devices and the server, causing significant burdens to devices with limited bandwidth and computational power. While the sparsity of embedding updates provides opportunity for payload optimization, existing sparsity-aware federated protocols generally sacrifice privacy for efficiency. A key challenge in designing a secure sparsity-aware efficient protocol is to protect the rated item indices from the server. In this paper, we propose a lossless secure recommender systems on sparse embedding updates (SecEmb). SecEmb reduces user payload while ensuring that the server learns no information about both rated item indices and individual updates except the aggregated model. The protocol consists of two correlated modules: (1) a privacy-preserving embedding retrieval module that allows users to download relevant embeddings from the server, and (2) an update aggregation module that securely aggregates updates at the server. Empirical analysis demonstrates that SecEmb reduces both download and upload communication costs by up to 90x and decreases user-side computation time by up to 70x compared with secure FedRec protocols. Additionally, it offers non-negligible utility advantages compared with lossy message compression methods.

Figures

Figures reproduced from arXiv: 2505.12453 by the authors.

Figure 1
Figure 1. Overview of SecEmb, which is comprised of two secure and communication-efficient modules: (1) A secure embedding retrieval module and (2) A secure embedding aggregation module. 4.1. Key observation In most practical recommendation scenarios, the number of items a user has previously interacted with is typically much smaller than the total number of available items (see [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. (a) The long-tailed distribution of the number of rated items in ML10M. The x-axis is the user id sorted by their activeness, and the y-axis represents the number of rated items for the user. For ML10M dataset with 27,278 items, nearly 90% users have rated only up to 300 items. (b) The proportion of item embeddings and other parameters within a three-layer deep factorization machine (DeepFM) for ML25M and Yelp, unde… view at source ↗
Figure 3
Figure 3. Evaluation of FSS scheme for party b ∈ {0, 1}. For simplification, we use s 0 b (t 0 b ) and s 0 (t 0 ) interchangeably. 4.3.1. EFFICIENT ROW-WISE ENCODING The gradient update of item embeddings forms a row-wise sparse matrix, with a few rows containing non-zero values. The initial method generate FSS keys separately for each element, introducing redundancy for updates from the same item. A more efficient approach i… view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Row-wise encoding of item embedding gradient. Specifically, user u encodes the embedding gradients for targeted items into m′ point functions fu,i : I → G for i ∈ [m′ ]. The function fu,i takes an item id x ∈ I as input and outputs fu,i(x) = gQu i ∈ R d if x = idx(i), …
Figure 5
Figure 5. Figure 5: User computation time (in milliseconds) for secret shares generation during training phase. NCF that includes a small share of dense updates, SecEmb achieves overhead reductions ranging from roughly 3.5x to 70x. For DeepFM, the reduction is less pronounced for the ML10…
Figure 6
Figure 6. Figure 6: Performance on ML1M dataset under various differential privacy budget ϵ [PITH_FULL_IMAGE:figures/full_fig_p019_6.png]
Figure 7
Figure 7. Figure 7: Performance of SecEmb and DP-FedRec under various privacy budget ϵ using MF. H. Dataset and Pre-processing For each dataset, we encode the user and item features into binary vectors for model training. The features we select for binary encoding are given as follows: • …
Figure 8
Figure 8. Figure 8: Average memory cost (in MB) and storage cost (in 103 parameters) per user during training phase. The memory cost is computed with batch size of 1. because: (1) Besides the non-zero embedding gradients, SecAggMask requires the user to send a certain proportion of random…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

61 extracted references · 43 canonical work pages

  1. [1]

    B., Mironov, I., Talwar, K., and Zhang, L

    Abadi, M., Chu, A., Goodfellow, I., McMahan, H. B., Mironov, I., Talwar, K., and Zhang, L. Deep learning with differential privacy. In Proceedings of the 2016 ACM SIGSAC conference on computer and communications security, pp.\ 308--318, 2016

    2016

  2. [2]

    Prio+: Privacy preserving aggregate statistics via boolean shares

    Addanki, S., Garbe, K., Jaffe, E., Ostrovsky, R., and Polychroniadou, A. Prio+: Privacy preserving aggregate statistics via boolean shares. In International Conference on Security and Cryptography for Networks, pp.\ 516--539. Springer, 2022

    work page 2022

  3. [3]

    Aji, A. F. and Heafield, K. Sparse communication for distributed gradient descent. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp.\ 440--445, 2017

    work page 2017

  4. [4]

    A., Oyomno, W., Fu, Q., Tan, K

    Ammad-Ud-Din, M., Ivannikova, E., Khan, S. A., Oyomno, W., Fu, Q., Tan, K. E., and Flanagan, A. Federated collaborative filtering for privacy-preserving personalized recommendation system. arXiv preprint arXiv:1901.09888, 2019

    arXiv 1901

  5. [5]

    H., Bonawitz, K

    Bell, J. H., Bonawitz, K. A., Gasc \'o n, A., Lepoint, T., and Raykova, M. Secure single-server aggregation with (poly) logarithmic overhead. In Proceedings of the 2020 ACM SIGSAC Conference on Computer and Communications Security, pp.\ 1253--1269, 2020

    work page 2020

  6. [6]

    B., Patel, S., Ramage, D., Segal, A., and Seth, K

    Bonawitz, K., Ivanov, V., Kreuter, B., Marcedone, A., McMahan, H. B., Patel, S., Ramage, D., Segal, A., and Seth, K. Practical secure aggregation for privacy-preserving machine learning. In proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, pp.\ 1175--1191, 2017

    2017

  7. [7]

    Towards federated learning at scale: System design

    Bonawitz, K., Eichner, H., Grieskamp, W., Huba, D., Ingerman, A., Ivanov, V., Kiddon, C., Kone c n \`y , J., Mazzocchi, S., McMahan, B., et al. Towards federated learning at scale: System design. Proceedings of Machine Learning and Systems, 1: 0 374--388, 2019

    work page 2019

  8. [8]

    Lightweight techniques for private heavy hitters

    Boneh, D., Boyle, E., Corrigan-Gibbs, H., Gilboa, N., and Ishai, Y. Lightweight techniques for private heavy hitters. In 2021 IEEE Symposium on Security and Privacy (SP), pp.\ 762--776. IEEE, 2021

    work page 2021

Show all 61 references
  1. [9]

    Function secret sharing

    Boyle, E., Gilboa, N., and Ishai, Y. Function secret sharing. In Annual international conference on the theory and applications of cryptographic techniques, pp.\ 337--367. Springer, 2015

    2015

  2. [10]

    Function secret sharing: Improvements and extensions

    Boyle, E., Gilboa, N., and Ishai, Y. Function secret sharing: Improvements and extensions. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pp.\ 1292--1303, 2016

    2016

  3. [11]

    Boyle, E., Gilboa, N., Ishai, Y., and Kolobov, V. I. Information-theoretic distributed point functions. In 3rd Conference on Information-Theoretic Cryptography, 2022

    2022

  4. [12]

    Secure federated matrix factorization

    Chai, D., Wang, L., Chen, K., and Yang, Q. Secure federated matrix factorization. IEEE Intelligent Systems, 36 0 (5): 0 11--20, 2020

    2020

  5. [13]

    Slide: In defense of smart algorithms over hardware acceleration for large-scale deep learning systems

    Chen, B., Medini, T., Farwell, J., Gobriel, S., Tai, C., and Shrivastava, A. Slide: In defense of smart algorithms over hardware acceleration for large-scale deep learning systems. arXiv preprint arXiv:1903.03129, 2019

    1903 arXiv

  6. [14]

    L., Dao, T., Song, Z., Shrivastava, A., and Re, C

    Chen, B., Liu, Z., Peng, B., Xu, Z., Li, J. L., Dao, T., Song, Z., Shrivastava, A., and Re, C. Mongoose: A learnable lsh framework for efficient neural network training. In International Conference on Learning Representations, 2020

    2020

  7. [15]

    Your vision-language model itself is a strong filter: Towards high-quality instruction tuning with data selection

    Chen, R., Wu, Y., Chen, L., Liu, G., He, Q., Xiong, T., Liu, C., Guo, J., and Huang, H. Your vision-language model itself is a strong filter: Towards high-quality instruction tuning with data selection. In ACL (Findings), 2024 a

    2024

  8. [16]

    De-mark: Watermark removal in large language models

    Chen, R., Wu, Y., Guo, J., and Huang, H. De-mark: Watermark removal in large language models. arXiv preprint arXiv:2410.13808, 2024 b

    2024 arXiv

  9. [17]

    Improved unbiased watermark for large language models

    Chen, R., Wu, Y., Guo, J., and Huang, H. Improved unbiased watermark for large language models. arXiv preprint arXiv:2502.11268, 2025

    2025 arXiv

  10. [18]

    H., Kim, A., Kim, M., and Song, Y

    Cheon, J. H., Kim, A., Kim, M., and Song, Y. Homomorphic encryption for arithmetic of approximate numbers. In Advances in Cryptology--ASIACRYPT 2017: 23rd International Conference on the Theory and Applications of Cryptology and Information Security, Hong Kong, China, December...

    2017

  11. [19]

    Privacy at scale: Local differential privacy in practice

    Cormode, G., Jha, S., Kulkarni, T., Li, N., Srivastava, D., and Wang, T. Privacy at scale: Local differential privacy in practice. In Proceedings of the 2018 International Conference on Management of Data, pp.\ 1655--1658, 2018

    2018

  12. [20]

    and Boneh, D

    Corrigan-Gibbs, H. and Boneh, D. Prio: Private, robust, and scalable computation of aggregate statistics. In 14th USENIX symposium on networked systems design and implementation (NSDI 17), pp.\ 259--282, 2017

    2017

  13. [21]

    B., et al

    Cramer, R., Damg rd, I. B., et al. Secure multiparty computation. Cambridge University Press, 2015

    2015

  14. [22]

    8-bit approximations for parallelism in deep learning

    Dettmers, T. 8-bit approximations for parallelism in deep learning. arXiv preprint arXiv:1511.04561, 2015

    2015 arXiv

  15. [23]

    The llama 3 herd of models

    Dubey, A., Jauhri, A., Pandey, A., Kadian, A., Al-Dahle, A., Letman, A., Mathur, A., Schelten, A., Yang, A., Fan, A., et al. The llama 3 herd of models. arXiv preprint arXiv:2407.21783, 2024

    2024 arXiv

  16. [24]

    Differential privacy

    Dwork, C. Differential privacy. In International colloquium on automata, languages, and programming, pp.\ 1--12. Springer, 2006

    2006

  17. [25]

    U., and Guler, B

    Ergun, I., Sami, H. U., and Guler, B. Sparsified secure aggregation for privacy-preserving federated learning. arXiv preprint arXiv:2112.12872, 2021

    2021 arXiv

  18. [26]

    D., Rieger, P., Sadeghi, A.-R., Schneider, T., Yalame, H., et al

    Fereidooni, H., Marchal, S., Miettinen, M., Mirhoseini, A., M \"o llering, H., Nguyen, T. D., Rieger, P., Sadeghi, A.-R., Schneider, T., Yalame, H., et al. Safelearn: Secure aggregation for private federated learning. In 2021 IEEE Security and Privacy Workshops (SPW), pp.\ 56-...

    2021

  19. [27]

    Deepfm: a factorization-machine based neural network for ctr prediction

    Guo, H., Tang, R., Ye, Y., Li, Z., and He, X. Deepfm: a factorization-machine based neural network for ctr prediction. In Proceedings of the 26th International Joint Conference on Artificial Intelligence, pp.\ 1725--1731, 2017

    2017

  20. [28]

    Gupta, V., Choudhary, D., Tang, P., Wei, X., Wang, X., Huang, Y., Kejariwal, A., Ramchandran, K., and Mahoney, M. W. Training recommender systems at scale: Communication-efficient model and data parallelism. In Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discove...

    2021

  21. [29]

    Han, Z., Gao, C., Liu, J., Zhang, J., and Zhang, S. Q. Parameter-efficient fine-tuning for large models: A comprehensive survey. arXiv preprint arXiv:2403.14608, 2024

    2024 arXiv

  22. [30]

    Harper, F. M. and Konstan, J. A. The movielens datasets: History and context. Acm transactions on interactive intelligent systems (tiis), 5 0 (4): 0 1--19, 2015

    2015

  23. [31]

    Neural collaborative filtering

    He, X., Liao, L., Zhang, H., Nie, L., Hu, X., and Chua, T.-S. Neural collaborative filtering. In Proceedings of the 26th international conference on world wide web, pp.\ 173--182, 2017

    2017

  24. [32]

    J., Wallis, P., Allen-Zhu, Z., Li, Y., Wang, S., Wang, L., Chen, W., et al

    Hu, E. J., Wallis, P., Allen-Zhu, Z., Li, Y., Wang, S., Wang, L., Chen, W., et al. Lora: Low-rank adaptation of large language models. In International Conference on Learning Representations, 2022

    2022

  25. [33]

    Differentially private matrix factorization

    Hua, J., Xia, C., and Zhong, S. Differentially private matrix factorization. In Proceedings of the 24th International Conference on Artificial Intelligence, IJCAI'15, pp.\ 1763–1770. AAAI Press, 2015. ISBN 9781577357384

    2015

  26. [34]

    O., and Ramchandran, K

    Kadhe, S., Rajaraman, N., Koyluoglu, O. O., and Ramchandran, K. Fastsecagg: Scalable secure aggregation for privacy-preserving federated learning. arXiv preprint arXiv:2009.11248, 2020

    2009 arXiv

  27. [35]

    and McAuley, J

    Kang, W.-C. and McAuley, J. Self-attentive sequential recommendation. In 2018 IEEE international conference on data mining (ICDM), pp.\ 197--206. IEEE, 2018

    2018

  28. [36]

    Kingma, D. P. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014

    2014 arXiv

  29. [37]

    Matrix factorization techniques for recommender systems

    Koren, Y., Bell, R., and Volinsky, C. Matrix factorization techniques for recommender systems. Computer, 42 0 (8): 0 30--37, 2009

    2009

  30. [38]

    J., and Wang, Y.-X

    Li, M., Liu, Z., Smola, A. J., and Wang, Y.-X. Difacto: Distributed factorization machines. In Proceedings of the Ninth ACM International Conference on Web Search and Data Mining, pp.\ 377--386, 2016

    2016

  31. [39]

    Fedrec: Federated recommendation with explicit feedback

    Lin, G., Liang, F., Pan, W., and Ming, Z. Fedrec: Federated recommendation with explicit feedback. IEEE Intelligent Systems, 36 0 (5): 0 21--30, 2020

    2020

  32. [40]

    A generic federated recommendation framework via fake marks and secret sharing

    Lin, Z., Pan, W., Yang, Q., and Ming, Z. A generic federated recommendation framework via fake marks and secret sharing. ACM Transactions on Information Systems, 41 0 (2): 0 1--37, 2022

    2022

  33. [41]

    Z., and Smith, V

    Liu, K., Hu, S., Wu, S. Z., and Smith, V. On privacy and personalization in cross-silo federated learning. Advances in neural information processing systems, 35: 0 5925--5940, 2022

    2022

  34. [42]

    Efficient and secure federated learning for financial applications

    Liu, T., Wang, Z., He, H., Shi, W., Lin, L., An, R., and Li, C. Efficient and secure federated learning for financial applications. Applied Sciences, 13 0 (10): 0 5877, 2023

    2023

  35. [43]

    Top-k sparsification with secure aggregation for privacy-preserving federated learning

    Lu, S., Li, R., Liu, W., Guan, C., and Yang, X. Top-k sparsification with secure aggregation for privacy-preserving federated learning. Computers & Security, 124: 0 102993, 2023

    2023

  36. [44]

    and Pang, Y

    Mai, P. and Pang, Y. Privacy-preserving multiview matrix factorization for recommender systems. IEEE Transactions on Artificial Intelligence, 5 0 (1): 0 267--277, 2023

    2023

  37. [45]

    McMahan, B., Moore, E., Ramage, D., Hampson, S., and y Arcas, B. A. Communication-efficient learning of deep networks from decentralized data. In Artificial intelligence and statistics, pp.\ 1273--1282. PMLR, 2017

    2017

  38. [46]

    and Zhang, Y

    Mohassel, P. and Zhang, Y. Secureml: A system for scalable privacy-preserving machine learning. In 2017 IEEE symposium on security and privacy (SP), pp.\ 19--38. IEEE, 2017

    2017

  39. [47]

    T., Le, D

    Nguyen, N.-H., Nguyen, T.-A., Nguyen, T., Hoang, V. T., Le, D. D., and Wong, K.-S. Towards efficient communication and secure federated recommendation system via low-rank training. In Proceedings of the ACM on Web Conference 2024, pp.\ 3940--3951, 2024

    2024

  40. [48]

    and Efraimidis, P

    Perifanis, V. and Efraimidis, P. S. Federated neural collaborative filtering. Knowledge-Based Systems, 242: 0 108441, 2022

    2022

  41. [49]

    Large-scale distributed learning via private on-device locality-sensitive hashing

    Rabbani, T., Bornstein, M., and Huang, F. Large-scale distributed learning via private on-device locality-sensitive hashing. In Proceedings of the 37th International Conference on Neural Information Processing Systems, pp.\ 16153--16171, 2023

    2023

  42. [50]

    Factorization machines

    Rendle, S. Factorization machines. In 2010 IEEE International conference on data mining, pp.\ 995--1000. IEEE, 2010

    2010

  43. [51]

    Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter

    Sanh, V. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. In Proceedings of Thirty-third Conference on Neural Information Processing Systems (NIPS2019), 2019

    2019

  44. [52]

    Lightsecagg: a lightweight and versatile design for secure aggregation in federated learning

    So, J., He, C., Yang, C.-S., Li, S., Yu, Q., E Ali, R., Guler, B., and Avestimehr, S. Lightsecagg: a lightweight and versatile design for secure aggregation in federated learning. Proceedings of Machine Learning and Systems, 4: 0 694--720, 2022

    2022

  45. [53]

    and Wang, K

    Tang, J. and Wang, K. Personalized top-n sequential recommendation via convolutional sequence embedding. In Proceedings of the eleventh ACM international conference on web search and data mining, pp.\ 565--573, 2018

    2018

  46. [54]

    H., Farokhi, F., Jin, S., Quek, T

    Wei, K., Li, J., Ding, M., Ma, C., Yang, H. H., Farokhi, F., Jin, S., Quek, T. Q., and Poor, H. V. Federated learning with differential privacy: Algorithms and performance analysis. IEEE transactions on information forensics and security, 15: 0 3454--3469, 2020

    2020

  47. [55]

    Terngrad: Ternary gradients to reduce communication in distributed deep learning

    Wen, W., Xu, C., Yan, F., Wu, C., Wang, Y., Chen, Y., and Li, H. Terngrad: Ternary gradients to reduce communication in distributed deep learning. Advances in neural information processing systems, 30, 2017

    2017

  48. [56]

    Efficient privacy-preserving computation based on additive secret sharing

    Xiong, L., Zhou, W., Xia, Z., Gu, Q., and Weng, J. Efficient privacy-preserving computation based on additive secret sharing. arXiv preprint arXiv:2009.05356, 2020

    2009 arXiv

  49. [57]

    Adaptive sparse federated learning in large output spaces via hashing

    Xu, Z., Liu, L., Xu, Z., and Shrivastava, A. Adaptive sparse federated learning in large output spaces via hashing. In Workshop on Federated Learning: Recent Advances and New Challenges (in Conjunction with NeurIPS 2022), 2022

    2022

  50. [58]

    Deep matrix factorization models for recommender systems

    Xue, H.-J., Dai, X., Zhang, J., Huang, S., and Chen, J. Deep matrix factorization models for recommender systems. In IJCAI, volume 17, pp.\ 3203--3209. Melbourne, Australia, 2017

    2017

  51. [59]

    Yelp dataset

    Yelp. Yelp dataset. 2015. URL https://www.yelp.com/dataset

    2015

  52. [60]

    Lightfr: Lightweight federated recommendation with privacy-preserving matrix factorization

    Zhang, H., Luo, F., Wu, J., He, X., and Li, Y. Lightfr: Lightweight federated recommendation with privacy-preserving matrix factorization. ACM Transactions on Information Systems, 41 0 (4): 0 1--28, 2023

    2023

  53. [61]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.