Pith. sign in

REVIEW 3 major objections 3 minor 72 references

A Two-Stage Data Selection Framework for Data-Efficient Model Training on Edge Devices

T0 review · 3 major / 3 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read This paper claims that on-device model training under-utilizes streaming data, and that a two-stage selection framework built on a provably optimal classified importance sampling rule cuts training time by up to 43 percent while raising…

desk verdict Solid empirical systems paper on edge data selection, but the theoretical optimality claim doesn't cover the implementation as written due to a missing importance-weighting step. read the letter →

arxiv 2505.16563 v2 pith:SR26QDJA submitted 2025-05-22 cs.LG

Chen Gong , Rui Xing , Zhenzhe Zheng , Fan Wu This is my paper · ORCID
classification cs.LG
keywords on-devicemachinelearningdataselectionimportancesamplingedgecomputingstreaminggradientvarianceclassifiedtwo-stageframework
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

The paper argues that the bottleneck in on-device machine learning is not only hardware but data: devices collect streams of samples but cannot use them all, because throughput is low, storage is small, and samples differ in value. To fix this, it presents Titan, a two-stage framework that first filters streaming data cheaply and then selects the batch that, by a specific theorem, best improves the current training round. The selection rule, C-IS, allocates each class a share of the batch proportional to a class-importance score and picks samples within a class proportional to their gradient norm; the authors prove this minimizes the gradient variance of the selected batch. On real edge hardware this yields up to 43 percent less training time and up to 6.2 percent higher final accuracy across vision, audio, and sensor tasks.

What carries the argument

The load-bearing object is the classified importance sampling (C-IS) rule together with the variance-decomposition theorem that justifies it. Theorem 2 decomposes the gradient variance of any selected batch into a weighted sum over classes, $\alpha_y(\beta_y-\gamma_y)$, where $\alpha_y$ depends on per-class batch allocation, $\beta_y$ is controlled by intra-class sampling, and $\gamma_y$ is a fixed per-class constant; Lemma 2 then shows the allocation $|B_y|^*\propto I_t(y)$ and per-sample probability $P^*(x)\propto$ gradient norm minimize the whole sum, not just $\beta_y$. The framework's efficiency comes from a coarse-grained filter that approximates sample importance with shallow-layer feature distance to the class centroid and average distance to classmates, plus a pipeline that overlaps selection with training via one-round-delayed model parameters.

What would settle it

Run Titan's exact implementation on a small benchmark while logging the mean gradient of each selected batch; if the average selected gradient deviates from the full-dataset gradient beyond a chosen tolerance, the unbiasedness condition in the proof is violated and the deployed system does not realize the theoretical variance reduction. A cleaner comparison would train identical models with and without the 1/(probability x datasize) weights: if the weighted version converges faster or reaches higher accuracy, the unweighted deployed version is not reproducing the theoretically optimal selection.

Watch

Extended reading notes

Core claim

The central discovery is that the state-of-the-art importance sampling is optimal sample-by-sample but sub-optimal batch-by-batch, because it ignores a per-class variance term in the gradient-variance decomposition. The paper proves (Lemma 2) that for mini-batch SGD with a fixed batch size, the optimal per-class selection size is proportional to I_t(y) and the optimal per-sample probability is proportional to I_t(x,y), where I_t(y) is a class-importance score combining gradient variance and gradient-norm variance and I_t(x,y) is the sample's gradient norm. C-IS therefore selects the data batch that maximizes expected reduction in distance to the optimal parameters. Around this rule, Titan builds a coarse-grained filter using representativeness and diversity of shallow-layer features, and a pipeline that hides selection time behind model updates using a one-round delay and idle compute resources.

Load-bearing premise

The deployed implementation selects samples by gradient norm on the last model layer without applying the probability-based reweighting that the proof uses to keep the selected batch's gradient unbiased; if that reweighting is necessary, the realized selection may not achieve the variance reduction the optimality theorem describes.

Editorial extensions

If this is right

  • On-device models can reach a target accuracy in up to 43 percent less wall-clock time, because the selected batch carries more training signal per sample.
  • Small batches, the norm on memory-constrained devices, benefit most, since the overlooked class-variance term grows as batch size shrinks.
  • The selection rule transfers to federated learning: local devices using Titan improve global convergence by a factor of 3.17x and final accuracy by 2.03 percent.
  • The two-stage architecture keeps per-sample processing delay at 4-13 ms, making the approach compatible with real-time data streams on commodity hardware.
  • Co-executing selection on idle computing resources adds less than 10 percent peak memory overhead, so the speedup is realized on the same device without slowing the training loop.

Reading between the lines

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

  • Extension: The unbiasedness gap between the proof and the implementation suggests a low-cost fix: applying the 1/(probability x datasize) weight to selected samples during gradient accumulation would restore the theoretical guarantee, and would clarify whether the measured gains come from an unbiased optimal rule or from a biased but beneficial selection.
  • Extension: Because the class-importance score I_t(y) measures within-class gradient diversity, C-IS could be adapted to class-imbalanced or label-noisy streams without new machinery, since the score already penalizes classes whose gradients are scattered.
  • Extension: The one-round-delay pipeline presumes sample importance is stable across consecutive rounds; testing Titan on a non-stationary stream with concept drift would reveal how much of the speedup survives when the gradient-norm ranking changes quickly.
  • Extension: The coarse-grained filter's representativeness-plus-diversity heuristic could in principle be replaced by a lightweight learned scorer trained from the fine-grained gradient importance labels, giving a principled way to tune the first stage for a given device.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 3 minor

Summary. The paper presents Titan, a two-stage online data-selection framework for on-device model training. A coarse-grained filter scores incoming streaming samples by representativeness and diversity (computed from shallow-layer features) and maintains a small candidate buffer; a fine-grained stage, called C-IS, then allocates the training batch across classes proportionally to a class importance I_t(y) and samples within each class proportionally to the gradient norm. A pipelined execution overlaps selection and update with a one-round delay and offloads selection to idle resources. The paper proves (in Appendices A.1–A.3) that minimizing batch-gradient variance improves a one-step training-performance bound, that standard importance sampling is sub-optimal in batch-level allocation because it ignores a class-dependent term, and that C-IS is optimal under the variance objective. Evaluations on Jetson Nano across CIFAR-10, Google Speech Commands, and HARBOX report up to 43% training-time reduction and up to 6.2% accuracy gain over baselines, with overhead measurements of delay, memory, and energy, plus extensions to fluctuating idle resources, federated learning, and noisy streams.

Significance. If the theoretical claims were fully supported, this would be a valuable contribution to resource-efficient on-device learning: it identifies data under-utilization as a bottleneck, proposes a two-stage design with an explicit variance-based objective, and validates it on real hardware across three modalities and several model families. The empirical study is broad and carefully measured, including time-to-accuracy, per-sample processing latency, peak memory, energy, and additional federated/noisy-data scenarios. The main concern is that the optimality theorem and the deployed algorithm are not connected as written: the proof requires importance-weighted gradients and with-replacement i.i.d. sampling, while the implementation is described as an unweighted average over a without-replacement subset, and Eq. (2) does not formally match the quantity derived in the proof. These issues are fixable, but until they are addressed the central theoretical claim should be regarded as unproven.

major comments (3)
  1. [Section 3.2 / Appendix A.2, Eq. (f)] The proof of Lemma 2 relies on the importance-weighted estimator described in Eq. (f): each selected sample is weighted by 1/(P_{t,y}(x)·|S_y|) so that the expected gradient equals the true dataset expectation and Theorem 1's unbiasedness step (a) holds. The deployed system, however, is described in Sections 2.1 and 3.1 as updating the model with the average gradient of the loaded training data batch, and the practical implementation in Section 3.2 only replaces full-model gradients with last-layer gradients; no per-sample importance weights are mentioned. Without the inverse-probability weights, the expected update gradient is a weighted combination of per-class expectations under the selection distributions rather than the dataset expectation, so the variance-minimization optimality proved in Appendix A.3 does not apply to the implemented algorithm. Please state explicitly whether the deployed update uses importance weights; if it does not, provide a separate analysis for the biased estimator or reformulate the claim.
  2. [Equation (2) / Appendix A.3] The class importance I_t(y) in Eq. (2) is defined with variances computed under the selection distribution P_{t,y}. In the proof of Lemma 2, however, the optimal per-class allocation is proportional to |S_y|·sqrt(β*_y − γ_y), where β*_y − γ_y = (E_{S_y}||g||)^2 − ||E_{S_y}g||^2, a quantity defined with respect to the uniform distribution over S_y. These two expressions are equal only when P_{t,y} is the uniform distribution; under the optimal intra-class choice P_{t,y}(x) ∝ ||g(x)|| they generally differ. As written, Lemma 2 is therefore not proven for the definition of I_t(y) given in Eq. (2). Please restate I_t(y) with an explicit distribution (preferably uniform over S_y) or give a derivation that justifies the displayed expression.
  3. [Appendix A.2, Eq. (e)] The variance decomposition in Eq. (e), V_{B_y∼P}[E_{B_y}g] = (1/|B_y|)·V_{x∼P}[g], holds for i.i.d. draws with replacement. The selection procedure described in Section 3.2 selects a fixed-size subset from each class without replacement, so the finite-population correction is missing. Consequently Theorem 2 and Lemma 2 do not govern the actual batch-formation process as implemented. Please specify whether sampling is with replacement, and if it is not, redo the variance analysis for without-replacement sampling.
minor comments (3)
  1. [Section 3.2, Theorem 1] The displayed equality in Theorem 1 is not an identity as printed: the last two terms appear outside the expectation and use ∇L(w_t,B) where Appendix A.1 uses ∇L(S,w_t). Please correct the display to match the proof.
  2. [Section 3.4] The one-round-delay scheme means that the C-IS optimality proof, which is derived for selection using the current model w_t, does not strictly apply to the pipelined deployment that selects with the outdated model w_{t−1}. The paper should state this approximation explicitly and frame Figure 5(c) as empirical evidence rather than a proof of continued optimality.
  3. [Appendix A.3] The Cauchy-Schwarz minimizations for β_y and for the per-class batch sizes should state the feasibility constraints Σ_x P_{t,y}(x)=1, P_{t,y}(x)>0, and Σ_y |B_y|=|B|; making these constraints explicit would improve the rigor of the derivation.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the C-IS optimality claim is derived from a variance decomposition and Cauchy-Schwarz bounds, not fitted to the reported accuracy gains, and the self-citations are not load-bearing.

full rationale

The central claim of the paper, Lemma 2, is derived from first principles in Appendix A.3 rather than assumed. The proof starts from the variance decomposition of Theorem 2, optimizes the intra-class sampling probability by Cauchy-Schwarz, and then minimizes the remaining sum over class batch sizes, obtaining |B_y| proportional to |S_y| times the square root of (beta*_y - gamma_y). The paper's class importance I_t(y) equals exactly this quantity because beta*_y - gamma_y = (E||g||)^2 - ||Eg||^2 = V(g) - V(||g||). Thus the optimal forms are derived, not defined into existence. The reported 43% training-time reduction and 6.2% accuracy gain are empirical outcomes measured against external baselines on real edge hardware, not consequences of a fitted parameter renamed as a prediction. The authors' prior works, such as references [16] and [18], appear only in the introduction and related-work discussion as examples of federated and on-device training settings; they are not used to justify the theoretical optimality of C-IS. The only substantive gap is that the proof's unbiased estimator relies on per-sample importance weights of 1/(P_{t,y}(x)|S_y|), stated in Appendix A.2 equation (f), while the practical implementation description in Section 3.2 refers to updating with the average gradient of the loaded batch and does not mention such weights. That mismatch is a correctness or robustness concern about whether the deployed system realizes the theorem's assumptions, but it is not a circularity: the derivation does not reduce to its own input, and no fitted quantity is disguised as a prediction.

Assumptions & free parameters 2 free parameters · 5 assumptions · 0 invented entities

No fitted constants enter the central C-IS formula, but the system relies on several empirical assumptions (last-layer gradients, stale-model pipeline, shallow-feature filter) and two hand-set engineering parameters. The main risk is not hidden fitting but unverified bridging assumptions between the theorem and the implementation.

free parameters (2)
  • Candidate buffer size = 30 samples
    Chosen by hand in Section 4.1; larger buffers improve accuracy (Appendix B) but cost memory, so the default is an engineering trade-off.
  • Feature extraction block depth = first model block
    Selected based on empirical observation in Sections 3.3 and 4.3; deeper blocks degrade accuracy and increase delay.
assumptions (5)
  • domain assumption Gradient variance of the training batch is negatively correlated with model training performance (Theorem 1, from refs 28 and 67).
    Background result the optimality argument is built on; adopted without re-derivation.
  • domain assumption Each selected sample in a class is weighted by 1/(probability x datasize) so the batch gradient remains unbiased (Appendix A.2, Equation (f)).
    Required for the variance decomposition; not stated in the implementation section.
  • domain assumption Partial gradients over the last model layer reflect the trend of full-model gradients (Section 3.2, Practical Implementation, citing refs 27, 32, 36).
    Bridges the full-gradient theory to the last-layer implementation; only empirically supported here.
  • domain assumption A one-round-stale model preserves per-sample importance ranking across consecutive training rounds (Figure 5(c), correlation 0.98).
    Justifies the pipeline's one-round-delay scheme; an empirical observation, not a bound.
  • domain assumption Shallow-layer features are sufficient to filter a candidate set that preserves C-IS performance (Section 3.3).
    Empirical justification for the coarse filter; no theoretical guarantee.

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Two-Stage Data Selection Framework for Data-Efficient Model Training on Edge Devices." pith.science (2026). https://pith.science/paper/SR26QDJA

@misc{pith2026250516563,
  author       = {Pith},
  title        = {Pith review of: A Two-Stage Data Selection Framework for Data-Efficient Model Training on Edge Devices},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/SR26QDJA}},
  note         = {Machine review of arXiv:2505.16563}
}
abstract

The demand for machine learning (ML) model training on edge devices is escalating due to data privacy and personalized service needs. However, we observe that current on-device model training is hampered by the under-utilization of on-device data, due to low training throughput, limited storage and diverse data importance. To improve data resource utilization, we propose a two-stage data selection framework {\sf Titan} to select the most important data batch from streaming data for model training with guaranteed efficiency and effectiveness. Specifically, in the first stage, {\sf Titan} filters out a candidate dataset with potentially high importance in a coarse-grained manner.In the second stage of fine-grained selection, we propose a theoretically optimal data selection strategy to identify the data batch with the highest model performance improvement to current training round. To further enhance time-and-resource efficiency, {\sf Titan} leverages a pipeline to co-execute data selection and model training, and avoids resource conflicts by exploiting idle computing resources. We evaluate {\sf Titan} on real-world edge devices and three representative edge computing tasks with diverse models and data modalities. Empirical results demonstrate that {\sf Titan} achieves up to $43\%$ reduction in training time and $6.2\%$ increase in final accuracy with minor system overhead, such as data processing delay, memory footprint and energy consumption.

Figures

Figures reproduced from arXiv: 2505.16563 by the authors.

Figure 1
Figure 1. Final inference accuracy and normalized training [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 4
Figure 4. Comparison between IS and C￾IS. IS will select an equal number of data samples from classes 1 and 2 , while C-IS will select more samples from class 1 by considering its larger gradient variance. without significant deviation in parameter update direction. Previ￾ous research formulated the gradient estimation error of the coreset as a sub-modular function, and derived the optimal coreset by min￾imizing such error. W… view at source ↗
Figure 5
Figure 5. Preliminary experiments on CIFAR-10 dataset and different models with learning rate 0.1 to support some claims, [PITH_FULL_IMAGE:figures/full_fig_p006_5.png] view at source ↗
Figures from the paper (5 more)
Figure 6
Figure 6. Figure 6: Overall analysis of Titan’s system overhead, including time, memory and energy. Titan’s data selection method is theoretically guaranteed to opti￾mize the model performance in each round and its pipeline design further overlaps the extra time cost. Titan maintains or i…
Figure 7
Figure 7. Figure 7: Training curves of different methods. Horizontal [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]
Figure 8
Figure 8. Figure 8: Impact of coarse-grained filter on data processing [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]
Figure 9
Figure 9. Figure 9: Performance on fluctuant idle computing resource. [PITH_FULL_IMAGE:figures/full_fig_p012_9.png]
Figure 11
Figure 11. Figure 11: Titan Performance on noisy data distribution. training time (i.e., number of communication rounds) to target accuracy by a factor of 3.17×. These findings highlight the potential of applying Titan to federated learning for improving the training performance of global …

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

72 extracted references · 64 canonical work pages

  1. [1]

    Siri - Apple

    2019. Siri - Apple. https://www.apple.com/siri//

    work page 2019

  2. [2]

    Google Lens - Search What You See

    2024. Google Lens - Search What You See. https://lens.google/

    work page 2024

  3. [3]

    Microsoft SwiftKey Keyboard

    2024. Microsoft SwiftKey Keyboard. https://www.microsoft.com/en-us/swiftkey

    work page 2024

  4. [4]

    Kallista A. Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloé Kiddon, Jakub Konečný, Stefano Mazzocchi, Brendan McMahan, Timon Van Overveldt, David Petrou, Daniel Ramage, and Jason Roselander. 2019. Towards Federated Learning at Scale: System Design. In Annual Conference on Machine Learning and Systems (MLSy...

    work page 2019

  5. [5]

    Fedor Borisyuk, Krishnaram Kenthapadi, David Stein, and Bo Zhao. 2016. CaS- MoS: A Framework for Learning Candidate Selection Models over Structured Queries and Documents. In SIGKDD. 441–450

    work page 2016

  6. [6]

    Dongqi Cai, Qipeng Wang, Yuanqiang Liu, Yunxin Liu, Shangguang Wang, and Mengwei Xu. 2021. Towards ubiquitous learning: A first measurement of on- device training performance. In EMDL. 31–36

    work page 2021

  7. [7]

    Cody Coleman, Christopher Yeh, Stephen Mussmann, Baharan Mirzasoleiman, Peter Bailis, Percy Liang, Jure Leskovec, and Matei Zaharia. 2020. Selection via Proxy: Efficient Data Selection for Deep Learning. In International Conference on Learning Representations (ICLR)

    work page 2020

  8. [8]

    Paul Covington, Jay Adams, and Emre Sargin. 2016. Deep Neural Networks for YouTube Recommendations. In RecSys. 191–198

    2016

Show all 72 references
  1. [9]

    Anish Das, Young D Kwon, Jagmohan Chauhan, and Cecilia Mascolo. 2022. Enabling on-device smartphone gpu based training: Lessons learned. In PerCom Workshops. 533–538

    2022

  2. [10]

    Apple Developer. 2023. Maximum build file sizes. https://developer.apple.com/ help/app-store-connect/reference/maximum-build-file-sizes/

    2023

  3. [11]

    Chantat Eksombatchai, Pranav Jindal, Jerry Zitao Liu, Yuchen Liu, Rahul Sharma, Charles Sugnet, Mark Ulrich, and Jure Leskovec. 2018. Pixie: A system for recommending 3+ billion items to 200+ million users in real-time. In ACM The Web Conference (WWW). 1775–1784

    2018

  4. [12]

    Chantat Eksombatchai, Pranav Jindal, Jerry Zitao Liu, Yuchen Liu, Rahul Sharma, Charles Sugnet, Mark Ulrich, and Jure Leskovec. 2018. Pixie: A System for Recommending 3+ Billion Items to 200+ Million Users in Real-Time. In ACM The Web Conference (WWW). 1775–1784

    2018

  5. [13]

    Dante Everaert and Christopher Potts. 2024. GIO: Gradient Information Opti- mization for Training Dataset Selection. In International Conference on Learning Representations (ICLR)

    2024

  6. [14]

    Amirata Ghorbani and James Y. Zou. 2019. Data Shapley: Equitable Valuation of Data for Machine Learning. In International Conference on Machine Learning (ICML). 2242–2251

    2019

  7. [15]

    In Gim and JeongGil Ko. 2022. Memory-efficient DNN training on mobile devices. In ACM International Conference on Mobile Systems, Applications, and Services (MobiSys). 464–476

    2022

  8. [16]

    Chen Gong, Zhenzhe Zheng, Yunfeng Shao, Bingshuai Li, Fan Wu, and Guihai Chen. 2024. ODE: An Online Data Selection Framework for Federated Learning With Limited Storage. IEEE/ACM Transactions on Networking (TON) 32, 4 (2024), 2794–2809

    2024

  9. [17]

    Chen Gong, Zhenzhe Zheng, Fan Wu, Xiaofeng Jia, and Guihai Chen. 2024. Delta: A Cloud-assisted Data Enrichment Framework for On-Device Continual Learning. In International Conference on Mobile Computing and Networking (MobiCom) . 1408–1423

    2024

  10. [18]

    Chen Gong, Zhenzhe Zheng, Fan Wu, Yunfeng Shao, Bingshuai Li, and Guihai Chen. 2023. To Store or Not? Online Data Selection for Federated Learning with Limited Storage. In ACM The Web Conference (WWW) . 3044–3055

    2023

  11. [19]

    Google. [n. d.]. Android Developers: APK Expansion Files. https://developer. android.com/google/play/expansion-files

  12. [20]

    Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. 2017. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv:1706.02677 (2017)

    2017 arXiv

  13. [21]

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016. Deep resid- ual learning for image recognition. In IEEE / CVF Computer Vision and Pattern Recognition Conference (CVPR). 770–778

    2016

  14. [22]

    Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. 2017. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861 (2017)

    2017 arXiv

  15. [23]

    Kai Huang, Boyuan Yang, and Wei Gao. 2023. ElasticTrainer: Speeding Up On- Device Training with Runtime Elastic Tensor Selection. In ACM International Conference on Mobile Systems, Applications, and Services (MobiSys) . 56–69

    2023

  16. [24]

    HUAWEI. 2023. HUAWEI WiFi AX3 Pro. https://consumer.huawei.com/en/ routers/ax3-pro/specs/

    2023

  17. [25]

    Forrest N Iandola, Song Han, Matthew W Moskewicz, Khalid Ashraf, William J Dally, and Kurt Keutzer. 2016. SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and< 0.5 MB model size. arXiv:1602.07360 (2016)

    2016 arXiv

  18. [26]

    Fucheng Jia, Deyu Zhang, Ting Cao, Shiqi Jiang, Yunxin Liu, Ju Ren, and Yaoxue Zhang. 2022. CoDL: efficient CPU-GPU co-execution for deep learning infer- ence on mobile devices. In ACM International Conference on Mobile Systems, Applications, and Services (MobiSys). 209–221

    2022

  19. [27]

    Angelos Katharopoulos and François Fleuret. 2017. Biased Importance Sampling for Deep Neural Network Training. (2017). arXiv:1706.00043

    2017 arXiv

  20. [28]

    Angelos Katharopoulos and François Fleuret. 2018. Not All Samples Are Created Equal: Deep Learning with Importance Sampling. In International Conference on Machine Learning (ICML). 2530–2539

    2018

  21. [29]

    Alex Krizhevsky, Geoffrey Hinton, et al. 2009. Learning multiple layers of features from tiny images. (2009)

    2009

  22. [30]

    Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. 2012. ImageNet Classifi- cation with Deep Convolutional Neural Networks. In NeurIPS

    2012

  23. [31]

    Chenning Li, Xiao Zeng, Mi Zhang, and Zhichao Cao. 2022. PyramidFL: a fine- grained client selection framework for efficient federated learning. In Annual International Conference on Mobile Computing and Networking (MobiCom) . 158– 171

    2022

  24. [32]

    Yiming Li, Yanyan Shen, and Lei Chen. 2022. Camel: Managing Data for Efficient Stream Learning. In SIGMOD. 1271–1285

    2022

  25. [33]

    Bingyan Liu, Yuanchun Li, Yunxin Liu, Yao Guo, and Xiangqun Chen. 2020. Pmc: A privacy-preserving deep learning model customization framework for edge computing. Proceedings of the ACM on Interactive, Mobile, Wearable and Ubiquitous Technologies (IMWUT) 4, 4 (2020), 1–25

    2020

  26. [34]

    Haibo Liu, Chen Gong, Zhenzhe Zheng, Shengzhong Liu, and Fan Wu. 2025. Enabling Real-Time Inference in Online Continual Learning via Device-Cloud Collaboration. In Proceedings of the ACM on Web Conference(WWW) . 2043–2052

    2025

  27. [35]

    Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas. [n. d.]. Communication-Efficient Learning of Deep Net- works from Decentralized Data. In Artificial Intelligence and Statistics (AISTATS)

  28. [36]

    Bilmes, and Jure Leskovec

    Baharan Mirzasoleiman, Jeff A. Bilmes, and Jure Leskovec. 2020. Coresets for Data-efficient Training of Machine Learning Models. In International Conference on Machine Learning (ICML) . 6950–6960

    2020

  29. [37]

    NVIDIA. 2023. Jetson Nano Developer Kit. https://developer.nvidia.com/ embedded/jetson-nano-developer-kit

    2023

  30. [38]

    Official Journal of the European Union. 2021. General data protection regulation. https://gdpr-info.eu/

    2021

  31. [39]

    OpenAI. 2023. ChatGPT General FAQ. https://help.openai.com/en/articles/ 6783457-chatgpt-general-faq

    2023

  32. [40]

    Xiaomin Ouyang, Zhiyuan Xie, Jiayu Zhou, Jianwei Huang, and Guoliang Xing

  33. [41]

    Xiaoyi Pang, Zhibo Wang, Jingxin Li, Ruiting Zhou, Ju Ren, and Zhetao Li

  34. [42]

    Allan Pinkus. 1999. Approximation theory of the MLP model in neural networks. Acta numerica 8 (1999), 143–195

    1999

  35. [43]

    Omead Pooladzandi, David Davini, and Baharan Mirzasoleiman. 2022. Adap- tive second order coresets for data-efficient machine learning. In International Conference on Machine Learning (ICML) . 17848–17869

    2022

  36. [44]

    Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H. Lampert. 2017. iCaRL: Incremental Classifier and Representation Learning. In IEEE / CVF Computer Vision and Pattern Recognition Conference (CVPR) . 5533– 5542

    2017

  37. [45]

    Herbert Robbins and Sutton Monro. 1951. A stochastic approximation method. The Annals of Mathematical Statistics (1951), 400–407

    1951

  38. [46]

    Burr Settles. 2009. Active learning literature survey. (2009)

    2009

  39. [47]

    Vatsal Shah, Xiaoxia Wu, and Sujay Sanghavi. [n. d.]. Choosing the Sample with Lowest Loss makes SGD Robust. InArtificial Intelligence and Statistics (AISTATS)

  40. [48]

    Lillicrap, Fan Hui, Laurent Sifre, George van den Driess- che, Thore Graepel, and Demis Hassabis

    David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy P. Lillicrap, Fan Hui, Laurent Sifre, George van den Driess- che, Thore Graepel, and Demis Hassabis. 201...

    2017

  41. [49]

    Prashanthi SK, Sai Anuroop Kesanapalli, and Yogesh Simmhan. 2022. Charac- terizing the performance of accelerated Jetson edge devices for training deep learning models. SIGMETRICS 6, 3 (2022), 1–26

    2022

  42. [50]

    Smith, Pieter-Jan Kindermans, Chris Ying, and Quoc V

    Samuel L. Smith, Pieter-Jan Kindermans, Chris Ying, and Quoc V. Le. 2018. Don’t Decay the Learning Rate, Increase the Batch Size. In International Conference on Learning Representations (ICLR)

    2018

  43. [51]

    Chen Sun, Abhinav Shrivastava, Saurabh Singh, and Abhinav Gupta. 2017. Revis- iting Unreasonable Effectiveness of Data in Deep Learning Era. In International Conference on Computer Vision (ICCV) . 843–852

    2017

  44. [52]

    Tong Sun, Bowen Jiang, Hailong Lin, Borui Li, Yixiao Teng, Yi Gao, and Wei Dong

  45. [53]

    Ammar Tahir, Yongzhou Chen, and Prashanti Nilayam. 2022. FedSS: Federated learning with smart selection of clients. arXiv preprint arXiv:2207.04569 (2022)

    2022 arXiv

  46. [54]

    Tianxiang Tan and Guohong Cao. 2022. Deep learning on mobile devices through neural processing units and edge computing. In IEEE International Conference on A Two-Stage Data Selection Framework for Data-Efficient Model Training on Edge Devices KDD ’25, August 3–7, 2025, Toront...

    2022

  47. [55]

    Manni Wang, Shaohua Ding, Ting Cao, Yunxin Liu, and Fengyuan Xu. 2021. AsyMo: scalable and efficient deep-learning inference on asymmetric mobile CPUs. In Annual International Conference on Mobile Computing and Networking (MobiCom). 215–228

    2021

  48. [56]

    Qipeng Wang, Mengwei Xu, Chao Jin, Xinran Dong, Jinliang Yuan, Xin Jin, Gang Huang, Yunxin Liu, and Xuanzhe Liu. 2022. Melon: breaking the memory wall for resource-efficient on-device machine learning. In ACM International Conference on Mobile Systems, Applications, and Servic...

    2022

  49. [57]

    Shibo Wang, Shusen Yang, and Cong Zhao. 2020. SurveilEdge: Real-time video query based on collaborative cloud-edge deep learning. In IEEE International Conference on Computer Communications (INFOCOM) . 2519–2528

    2020

  50. [58]

    Pete Warden. 2018. Speech commands: A dataset for limited-vocabulary speech recognition. arXiv preprint arXiv:1804.03209 (2018)

    2018 arXiv

  51. [59]

    Jianyu Wei, Ting Cao, Shijie Cao, Shiqi Jiang, Shaowei Fu, Mao Yang, Yanyong Zhang, and Yunxin Liu. 2023. NN-Stretch: Automatic Neural Network Branching for Parallel Inference on Heterogeneous Multi-Processors. In ACM International Conference on Mobile Systems, Applications, a...

    2023

  52. [60]

    Daliang Xu, Mengwei Xu, Qipeng Wang, Shangguang Wang, Yun Ma, Kang Huang, Gang Huang, Xin Jin, and Xuanzhe Liu. 2022. Mandheling: mixed- precision on-device DNN training with DSP offloading. In Annual International Conference on Mobile Computing and Networking (MobiCom) . 214–227

    2022

  53. [61]

    Mengwei Xu, Jiawei Liu, Yuanqiang Liu, Felix Xiaozhu Lin, Yunxin Liu, and Xuanzhe Liu. 2019. A first look at deep learning apps on smartphones. In ACM The Web Conference (WWW). 2125–2136

    2019

  54. [62]

    Mengwei Xu, Feng Qian, Qiaozhu Mei, Kang Huang, and Xuanzhe Liu. 2018. DeepType: On-Device Deep Learning for Input Personalization Service with Minimal Privacy Concern. Proceedings of the ACM on Interactive, Mobile, Wearable and Ubiquitous Technologies (IMWUT) (2018), 197:1–197:26

    2018

  55. [63]

    Dixi Yao, Liyao Xiang, Zifan Wang, Jiayu Xu, Chao Li, and Xinbing Wang. 2021. Context-aware compilation of dnn training pipelines across edge and cloud. Pro- ceedings of the ACM on Interactive, Mobile, Wearable and Ubiquitous Technologies (IMWUT) 5, 4 (2021), 1–27

    2021

  56. [64]

    Rongjie Yi, Ting Cao, Ao Zhou, Xiao Ma, Shangguang Wang, and Mengwei Xu

  57. [65]

    Jaehong Yoon, Divyam Madaan, Eunho Yang, and Sung Ju Hwang. 2022. On- line Coreset Selection for Rehearsal-based Continual Learning. In International Conference on Learning Representations (ICLR)

    2022

  58. [66]

    Xiao Zeng, Ming Yan, and Mi Zhang. 2021. Mercury: Efficient on-device dis- tributed dnn training via stochastic importance sampling. In Sensys. 29–41

    2021

  59. [67]

    Peilin Zhao and Tong Zhang. 2015. Stochastic Optimization with Importance Sampling for Regularized Loss Minimization. In International Conference on Machine Learning (ICML). 1–9

    2015

  60. [68]

    Yan Zhuang, Zhenzhe Zheng, Fan Wu, and Guihai Chen. 2024. LiteMoE: Cus- tomizing On-device LLM Serving via Proxy Submodel Tuning. In Proceedings of the 22nd ACM Conference on Embedded Networked Sensor Systems (SenSys) . 521–534. A Proofs A.1 Proof of Theorem 1 According to the...

    2024

  61. [2021]

    In ACM International Conference on Mobile Systems, Applications, and Services (MobiSys)

    Clusterfl: a similarity-aware federated learning system for human activity recognition. In ACM International Conference on Mobile Systems, Applications, and Services (MobiSys). 54–66

  62. [2022]

    In IEEE International Conference on Computer Communications (INFOCOM)

    Towards online privacy-preserving computation offloading in mobile edge computing. In IEEE International Conference on Computer Communications (INFOCOM). 1179–1188

  63. [2023]

    In ACM International Conference on Mobile Systems, Applications, and Services (MobiSys)

    Boosting DNN Cold Inference on Edge Devices. In ACM International Conference on Mobile Systems, Applications, and Services (MobiSys) . 516–529

  64. [2025]

    arXiv:2505.22735 [cs.CR] https://arxiv.org/abs/2505.22735

    TensorShield: Safeguarding On-Device Inference by Shielding Critical DNN Tensors with TEE. arXiv:2505.22735 [cs.CR] https://arxiv.org/abs/2505.22735

    arXiv

Pith tools

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