Pith. sign in

REVIEW 3 major objections 5 minor 28 references

Empowering On-Device Model Adaptation with an Edge AI Inference Accelerator

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

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

Pith's one-line read An inference-oriented edge chip can serve as a training co-processor by running the frozen backbone in INT8 while the host CPU fine-tunes a small FP32 head, yielding up to 15.4x faster on-device adaptation than a CPU-only baseline.

desk verdict Useful engineering benchmark with real measurements, but the accuracy numbers are the best-of-five restoration strategies chosen post hoc—treat them as an upper bound. read the letter →

arxiv 2607.18101 v1 pith:K7KSVAPY submitted 2026-07-20 cs.LG cs.ARcs.CV

Mateusz Piechocki , Alessandro Capotondi , Marek Kraft This is my paper · ORCID
classification cs.LGcs.ARcs.CV
keywords on-devicetrainingmodeladaptationpost-trainingquantizationedgeAIacceleratorfrozenbackbonefine-tuningINT8energyefficiencyheterogeneouscomputing
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 claims that a low-power inference accelerator intended for inference can also accelerate on-device fine-tuning. Its proposed pipeline freezes a pre-trained backbone, quantizes it to INT8, and runs it on the Hailo-8L accelerator, while the host CPU fine-tunes only a lightweight FP32 classification head with backpropagation truncated at the accelerator boundary. Across four architectures and two datasets, the approach reaches up to 15.4x faster wall-clock training time than a CPU-only baseline on a small single-board computer, matches or exceeds an edge GPU at small batch sizes, and reduces energy per training sample in every configuration. The paper also shows that the choice of post-training quantization restoration strategy determines whether quantized features remain accurate enough for training: knowledge-distillation fine-tuning or AdaRound is required for quantization-sensitive backbones, and even then large accuracy gaps can remain.

What carries the argument

The load-bearing mechanism is graph partitioning with truncated backward pass: the model is written as f(x;θ_b,θ_h)=h(g(x;θ_b);θ_h), with θ_b frozen and executed on the accelerator as INT8, θ_h trainable on the CPU in FP32. This is realized through an ONNX-based toolchain where the Hailo Dataflow Compiler quantizes the backbone, applies performance restoration, and embeds a delegate node into the training graph. The work that this machinery does is moving the computational bottleneck (the backbone forward pass) onto dedicated 13 TOPS hardware while keeping gradient math on the host, and its effectiveness is bounded by how much INT8 quantization degrades the features that feed the head.

What would settle it

Measure the pipeline on an architecture with a tiny backbone combined with a large trainable head (or on a quantization-sensitive architecture with Hard-Swish/self-attention) and compare final accuracy and wall-clock time against the FP32 CPU baseline: the speedup shrinks toward 1x and test accuracy drops by more than 10 points, which would contradict the claim of a generally applicable practical approach. Also, a controlled experiment with a deliberately disabled restoration strategy would show whether the accuracy gap for MobileNetV3/FastViT is attributable to feature degradation.

Watch

Extended reading notes

Core claim

The central discovery is that a heterogeneous execution graph—frozen backbone quantized to INT8 and run on a Hailo-8L accelerator, lightweight FP32 head fine-tuned on host CPU, with backprop truncated at the accelerator boundary—turns an inference-only edge AI chip into a usable training co-processor. Good post-training quantization restoration (channel equalization plus iterative bias correction, knowledge-distillation fine-tuning, or AdaRound) is necessary to keep the INT8 features accurate enough for gradient stability. The paper demonstrates its claim across four architectures and two datasets, but finds that the approach works cleanly only for backbones that are robust to INT8 degradati

Load-bearing premise

The whole benefit rests on the assumption that the frozen backbone's forward pass is the dominant cost during fine-tuning and that INT8-quantized features from the accelerator remain accurate enough to train a good classification head; both parts fail for some architectures and datasets.

Editorial extensions

If this is right

  • For quantization-resilient backbones like ResNet18, the heterogeneous pipeline reaches 6.04 ms/sample and 38.65 mJ/sample on CIFAR-100, beating the edge GPU baseline in both throughput and energy.
  • Speedups are architecture-dependent: MobileNetV3 Large achieves only ~4.2x because its heavy classifier head runs on the host CPU, making the backward pass the bottleneck.
  • Post-training quantization restoration methods calibrated for inference transfer to the training setting; low-cost methods (equalization, iterative bias correction) suffice for ReLU/SiLU convolutional backbones, while data-driven methods (fine-tuning, AdaRound) are needed for Hard-Swish or attention-based models.
  • The pipeline consistently reduces energy per sample across all tested models and batch sizes, supporting more frequent in-field updates.
  • The work is scoped to frozen-backbone head fine-tuning and does not claim to enable full end-to-end training on the edge.

Reading between the lines

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

  • If the pattern generalizes, the same partition could be applied to parameter-efficient methods like adapters or LoRA, where the trainable module is even lighter and the relative benefit of the accelerator likely grows.
  • The accuracy collapses on MobileNetV3 and FastViT-SA12 suggest that quantization-robust feature extraction should be a selection criterion for backbones deployed with this pipeline, or a prompt for quantization-aware training during the original model development.
  • A concrete next experiment: vary the head size while keeping the backbone fixed to map the speedup ceiling as a function of the backbone-to-head compute ratio.
  • The energy savings imply that batch sizes of 4-16 saturate throughput; a scheduler that batches incoming adaptation data could multiply the practical benefit.
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

3 major / 5 minor

Summary. The paper proposes a heterogeneous on-device adaptation pipeline: a frozen INT8 backbone is executed on a Hailo-8L inference accelerator while a lightweight FP32 classification head is fine-tuned on a Raspberry Pi 5 host CPU, all implemented with an ONNX Runtime training API. Four timm models (ResNet18, EfficientNet-Lite 4, MobileNetV3 Large, FastViT-SA12) are evaluated on CIFAR-100 and Oxford-IIIT Pet, with comparisons to a Raspberry Pi 5 CPU baseline and a Jetson Orin Nano GPU baseline. The pipeline reports up to 15.4x wall-clock speedup, consistently lower energy per sample, and throughput that is competitive in favorable settings. The paper also evaluates five post-training quantization restoration strategies for the Hailo-compiled backbone and finds that restoration quality strongly affects downstream accuracy.

Significance. If the results hold, the paper provides a useful and timely contribution to on-device model adaptation by showing that a commodity inference accelerator can be repurposed to accelerate frozen-backbone feature extraction during head fine-tuning. The release of implementation code and the systematic comparison of PTQ restoration strategies are concrete strengths. The main value is practical: the proposed pipeline gives large speedups and energy savings for quantization-resilient architectures such as ResNet18 and EfficientNet-Lite 4. However, the paper's broad applicability claim is weakened by its own data for MobileNetV3 and FastViT-SA12, where accuracy drops substantially even with the best restoration strategy, and by the absence of statistical variance in the reported measurements.

major comments (3)
  1. [§3.3 and Table 3 / Fig. 4] The paper describes the design as 'architecture-agnostic' (§3.3), but the data contradict this. In Table 3, MobileNetV3 Large falls from 68.26 to 55.53 on CIFAR-100 (a 12.7-point drop) and FastViT-SA12 falls from 71.19 to 50.19 (a 21.0-point drop), even with the best restoration strategy. The conclusion later acknowledges architecture-specific robustness, but the abstract and contribution 1 frame the method as broadly applicable. The load-bearing claim should be reframed to the favorable settings, or additional evidence should be provided showing that the failure cases can be mitigated within the proposed pipeline.
  2. [§3.3, Table 3 caption, and Fig. 4] Reported 'Proposed' results in Table 3 are selected per dataset as the maximum over five restoration strategies after observing outcomes. While Fig. 4 does plot all five strategies and therefore mitigates the concern that the full matrix is hidden, Table 3 still reports only the maxima, and no fixed deployment policy is evaluated. A practitioner must choose a strategy before seeing test accuracy. The paper should report at least one fixed strategy (e.g., always Eq.+AdaRound or always Eq.+FT) across all model-dataset pairs, or describe a validation-based selection procedure and report the resulting accuracy. Without this, the headline accuracy numbers overstate what a real deployment would achieve.
  3. [§3.3 (Evaluation protocol) and Table 3] All experiments use a single fixed random seed and no repeated trials, so no variance or confidence intervals are reported. This matters because several key comparisons are very close: e.g., ResNet18 on CIFAR-100 is 64.62 (proposed) vs 64.67 (CPU) and 86.94 vs 87.00 on Oxford-IIIT Pet. These differences are likely within seed-to-seed variation, and the claim of 'accuracy close to the FP32 reference' is not statistically supported. Please run at least three seeds and report mean ± standard deviation for accuracy (and ideally for throughput and energy as well).
minor comments (5)
  1. [§4.3 and Fig. 5] The claim that Hailo-8L 'matches or exceeds' Orin Nano throughput is explicitly limited to batch sizes 1 and 4. For clarity, state what happens at batch 16, where Fig. 5 suggests the Orin Nano may overtake for some models, to avoid an over-general reading.
  2. [§3.3 (Energy measurement)] Power sampling rates differ (5 Hz external meter on RPi 5 vs 1 Hz tegrastats on Orin Nano). Please discuss the potential impact of sampling rate on energy estimates, particularly for very short training samples, and consider reporting confidence intervals.
  3. [§4.2, first sentence] The phrase 'upstream gradients' is slightly confusing because gradients are not computed through the Hailo-executed backbone; the concern is about the quality of features feeding the head. Consider rewording to 'feature quality' or 'input to the host-side head'.
  4. [Table 3 caption] The parenthetical notation like '(#4, #4)' is not explicitly defined in the caption. Add a sentence such as '#' refers to the strategy numbering in Table 1, with the first/second value for CIFAR-100/Oxford-IIIT Pet.'
  5. [References] Reference [20] is the authors' own prior work; it is used for motivation, which is fine, but the novelty of the current paper relative to [20] should be stated more explicitly in the introduction.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity; self-citations are motivational and the measured results are externally benchmarked.

full rationale

This paper is an empirical systems benchmark, not a derivation. The central claims—wall-clock speedup, throughput, and energy per sample—are measured against independent external baselines (Raspberry Pi 5 CPU and NVIDIA Jetson Orin Nano) and are not the output of a fitted model or an equation-level reduction. The heterogeneous pipeline is defined as a graph partition (Eq. 1) but its performance is measured, not derived. Post-training quantization restoration uses standard external methods (channel equalization [15], iterative bias correction [5], knowledge-distillation fine-tuning [4], AdaRound [17]) applied through Hailo's compiler; no parameter is fitted to the reported accuracy numbers. The only self-citation, [20], appears once as motivational context ('operational contexts [20]') and carries no argumentative weight. The author-maintained ONNX Runtime fork [16] is tooling, not an evidential premise. There is no import of a uniqueness theorem, no ansatz smuggled via self-citation, and no renaming of a known result. The paper explicitly limits its claims to architectures whose backbones are quantization-resilient and acknowledges unquantified peak memory, which reinforces that the results are empirical findings rather than a self-contained derivation. The practice of reporting the best performance-restoration strategy per dataset in Table 3 is a selective-reporting concern, but it does not reduce the measured outcome to the input by construction, and therefore does not constitute circularity under the stated rules.

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

The paper introduces no new mathematical entities, forces, or parameters. It relies on established hardware, standard quantization-restoration methods, and a convenience fork of ONNX Runtime. The main uncharged assumptions are that head-only fine-tuning is sufficient for adaptation and that INT8 features are good enough for training, both of which are partially contradicted by the paper's own accuracy tables.

free parameters (3)
  • Best PTQ restoration strategy per dataset = #3/#4 depending on dataset
    Table 3 reports results using the best-performing of the five restoration strategies chosen per dataset after seeing the outcomes, which is a post-hoc model selection rather than a fixed protocol.
  • Learning rate = 1e-3
    Fixed AdamW learning rate chosen in Section 3.3; hand-set, not fitted, but a configuration choice that affects all results.
  • Number of training epochs = 5
    All runs are evaluated after exactly five epochs; this fixed horizon favors fast-converging head-only updates and was not chosen by a convergence criterion.
assumptions (4)
  • domain assumption Frozen-backbone, head-only fine-tuning is a valid model-adaptation setting
    The entire pipeline restricts updates to the classification head; this is asserted in Section 1 and 3.3 and is not compared with full fine-tuning or more expressive parameter-efficient methods.
  • domain assumption INT8 quantization with PTQ restoration preserves feature quality sufficiently for head training
    This is the central premise behind using the Hailo-8L, but Table 3 shows it fails for MobileNetV3 and FastViT on CIFAR-100, where accuracy drops by 12.7 and 21.0 points even after restoration.
  • domain assumption The frozen backbone forward pass is the dominant training-time cost
    The speedup story depends on this. The authors themselves note in Section 4.1 that MobileNetV3's host-side head limits the speedup, so this assumption is architecture-dependent.
  • domain assumption Energy measurements at 1-5 Hz sampling without idle-power subtraction capture true per-sample training energy
    Section 3.3 describes the measurement setup; low sampling rates and short five-epoch runs make the reported mJ/sample numbers potentially noisy, although the direction of the energy savings is consistent.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Empowering On-Device Model Adaptation with an Edge AI Inference Accelerator." pith.science (2026). https://pith.science/paper/K7KSVAPY

@misc{pith2026260718101,
  author       = {Pith},
  title        = {Pith review of: Empowering On-Device Model Adaptation with an Edge AI Inference Accelerator},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/K7KSVAPY}},
  note         = {Machine review of arXiv:2607.18101}
}
read the original abstract

On-device model adaptation is essential to enable lifelong personalization on resource-constrained hardware, but compute, power, and memory limitations of such devices make end-to-end backpropagation impractical for modern deep neural networks. This work proposes a heterogeneous adaptation pipeline that repurposes a commercial edge AI inference accelerator, Hailo-8L, for frozen-backbone feature extraction during on-device training. The computational graph is partitioned so that the pre-trained backbone is quantized to INT8 and run on the accelerator, while only a lightweight FP32 classification head is fine-tuned on the host CPU, enabling frequent, energy-efficient in-field updates with most weights remaining fixed. Across multiple architectures and datasets, this pipeline achieves up to 15.4x faster wall-clock training time compared to a Raspberry Pi 5 CPU baseline, offers competitive throughput in favorable settings, and consistently reduces energy per sample. Post-training quantization restoration is shown to be crucial for preserving the quality of accelerator-generated features and mitigating accuracy loss in quantization-sensitive architectures. Overall, the results demonstrate a practical approach to efficient on-device adaptation using inference-oriented edge accelerators. The implementation is available at https://github.com/MatPiech/accelerator-training.

Figures

Figures reproduced from arXiv: 2607.18101 by the authors.

Figure 1
Figure 1. Micro-architecture of the heterogeneous on-device adaptation pipeline, detailing graph partitioning, data formats, and gradient flow. Backpropagation is truncated at the accelerator boundary, so only the top adaptive layers receive gradient updates. performance and enabling personalization to specific users [12] or operational contexts [20]. Training near the data source reduces reliance on network con￾nectivity and… view at source ↗
Figure 2
Figure 2. The proposed ONNX-based toolchain for Hailo-accelerated adaptation. Py￾Torch models are exported to ONNX, then the Hailo Dataflow Compiler applies 8-bit quantization and restoration to generate the hardware delegate (HailoOp). The ONNX Runtime Training API then processes this hybrid graph to produce training artifacts. mentally divides the learning process into two distinct hardware domains: an INT8 hardware acceler… view at source ↗
Figure 3
Figure 3. Time-to-accuracy convergence profiles for the evaluated architectures and datasets. Curves denote training accuracy over time; markers indicate the values for subsequent training epochs; horizontal dashed lines represent final test accuracy. GPU configuration (NVIDIA Jetson Orin Nano at 13.70 ms/sample), while using 3.3× less energy per trained sample. Nevertheless, it is important to note the variation in accelerat… view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Impact of INT8 post-training quantization and subsequent performance recov￾ery strategies on upstream gradient stability and final test accuracy, assessed following five epochs of on-device training on the CIFAR-100 and Oxford-IIIT Pet datasets. models, simple equaliza…
Figure 5
Figure 5. Figure 5: Empirical training throughput on the Oxford-IIIT Pet dataset, measured in images per second, across varying batch sizes (1, 4, and 16). throughput at batch sizes 1 and 4, while consuming much less power. This is due to its inference-centric architectural design, which …

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

28 extracted references · 4 canonical work pages

  1. [1]

    et al.: Fastvit: A fast hybrid vision trans- former using structural reparameterization

    Anasosalu Vasu, P.K. et al.: Fastvit: A fast hybrid vision trans- former using structural reparameterization. In: 2023 IEEE/CVF Inter- national Conference on Computer Vision (ICCV). pp. 5762–5772 (2023). https://doi.org/10.1109/ICCV51070.2023.00532

    arXiv 2023

  2. [2]

    et al.: Enabling on-device smartphone gpu based training: Lessons learned

    Das, A. et al.: Enabling on-device smartphone gpu based training: Lessons learned. In: 2022 IEEE International Conference on Pervasive Computing and Communi- cations Workshops and other Affiliated Events (PerCom Workshops). pp. 533–538 (2022). https://doi.org/10.1109/PerComWorkshops53856.2022.9767442

    arXiv 2022

  3. [3]

    et al.: Imagenet: A large-scale hierarchical image database

    Deng, J. et al.: Imagenet: A large-scale hierarchical image database. In: 2009 IEEE Conference on Computer Vision and Pattern Recognition. pp. 248–255 (2009). https://doi.org/10.1109/CVPR.2009.5206848

    arXiv 2009

  4. [4]

    et al.: Qft: Post-training quantization via fast joint finetuning of all degrees of freedom

    Finkelstein, A. et al.: Qft: Post-training quantization via fast joint finetuning of all degrees of freedom. In: Computer Vision – ECCV 2022 Workshops. pp. 115–129 (2023). https://doi.org/10.1007/978-3-031-25082-8_8

    work page doi:10.1007/978-3-031-25082-8_8 2022

  5. [5]

    arXiv preprint arXiv:1906.03193 (2019)

    Finkelstein, A., Almog, U., Grobman, M.: Fighting quantization bias with bias. arXiv preprint arXiv:1906.03193 (2019)

    arXiv 1906

  6. [7]

    Accessed: 31-05-2026

    HAILO: Hailo Dataflow Compiler 3.31.0,https://hailo.ai, [Online]. Accessed: 31-05-2026

    2026

  7. [8]

    4.23.0,https://hailo.ai, [Online]

    HAILO: HailoRT. 4.23.0,https://hailo.ai, [Online]. Accessed: 31-05-2026

    2026

  8. [9]

    HAILO: Hailo-8L M.2 AI Acceleration Module (3 2024),https://hailo.ai/ files/hailo-8l-m-2-et-product-brief-en/, rev. 1

    2024

Show all 28 references
  1. [10]

    et al.: Deep residual learning for image recognition

    He, K. et al.: Deep residual learning for image recognition. In: 2016 IEEE Confer- ence on Computer Vision and Pattern Recognition (CVPR). pp. 770–778 (2016). https://doi.org/10.1109/CVPR.2016.90

    2016 doi

  2. [11]

    et al.: Searching for mobilenetv3

    Howard, A. et al.: Searching for mobilenetv3. In: 2019 IEEE/CVF Inter- national Conference on Computer Vision (ICCV). pp. 1314–1324 (2019). https://doi.org/10.1109/ICCV.2019.00140

    2019

  3. [12]

    et al.: On-device learning for human activity recogni- tion on low-power microcontrollers

    Karagül, M.T. et al.: On-device learning for human activity recogni- tion on low-power microcontrollers. In: Machine Learning and Principles and Practice of Knowledge Discovery in Databases. pp. 148–160 (2026). https://doi.org/10.1007/978-3-032-19099-4_11 12 M. Piechocki et al

    2026 doi

  4. [13]

    Krizhevsky, A.: Learning multiple layers of features from tiny images. Tech. rep., University of Toronto (2009)

    2009

  5. [14]

    et al.: On-device training under 256kb memory

    Lin, J. et al.: On-device training under 256kb memory. In: Proceedings of the 36th International Conference on Neural Information Processing Systems (2022)

    2022

  6. [15]

    et al.: Same, same but different: Recovering neural network quantiza- tion error through weight factorization

    Meller, E. et al.: Same, same but different: Recovering neural network quantiza- tion error through weight factorization. In: Chaudhuri, K., Salakhutdinov, R. (eds.) Proceedings of the 36th International Conference on Machine Learning. Proceed- ings of Machine Learning Researc...

    2019

  7. [16]

    1.22.1-hailo,https://github.com/MatPiech/onnxruntime, [Online]

    Microsoft, Piechocki, M.: ONNX Runtime On-Device Training with HailoRT support. 1.22.1-hailo,https://github.com/MatPiech/onnxruntime, [Online]. Ac- cessed: 31-05-2026

    2026

  8. [17]

    et al.: Up or down? adaptive rounding for post-training quantization

    Nagel, M. et al.: Up or down? adaptive rounding for post-training quantization. In: Proceedings of the 37th International Conference on Machine Learning. ICML’20, JMLR.org (2020)

    2020

  9. [18]

    NVIDIA Corporation: Jetson Orin Nano Developer Kit Carrier Board (4 2024), sP-11324-001 v1.2

    2024

  10. [19]

    et al.: Cats and dogs

    Parkhi, O.M. et al.: Cats and dogs. In: 2012 IEEE Conference on Computer Vision and Pattern Recognition. pp. 3498–3505 (2012). https://doi.org/10.1109/CVPR.2012.6248092

    2012

  11. [20]

    In: Advanced Concepts for Intelligent Vision Systems

    Piechocki, M., Kraft, M., Capotondi, A.: On-device continual adaptation for re- liable solar irradiance forecasting. In: Advanced Concepts for Intelligent Vision Systems. pp. 353–364 (2026). https://doi.org/10.1007/978-3-032-07343-3_28

    2026 doi

  12. [21]

    et al.: Computationally budgeted continual learning: What does mat- ter? In: 2023 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)

    Prabhu, A. et al.: Computationally budgeted continual learning: What does mat- ter? In: 2023 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). pp. 3698–3707 (2023). https://doi.org/10.1109/CVPR52729.2023.00360

    2023

  13. [22]

    Journal of King Saud University - Computer and Information Sciences34(4), 1595–1623 (2022)

    Ray, P.P.: A review on tinyml: State-of-the-art and prospects. Journal of King Saud University - Computer and Information Sciences34(4), 1595–1623 (2022). https://doi.org/10.1016/j.jksuci.2021.11.019

    2022 doi

  14. [23]

    In: Chaudhuri, K., Salakhutdinov, R

    Tan, M., Le, Q.: EfficientNet: Rethinking model scaling for convolutional neural networks. In: Chaudhuri, K., Salakhutdinov, R. (eds.) Proceedings of the 36th International Conference on Machine Learning. Proceedings of Machine Learning Research, vol. 97, pp. 6105–6114. PMLR (...

    2019

  15. [24]

    et al.: Hardware-accelerated on-device learning: Training, parti- tioning, and compilation for constrained edge ai

    Topko, I. et al.: Hardware-accelerated on-device learning: Training, parti- tioning, and compilation for constrained edge ai. In: 2025 IEEE Com- puter Society Annual Symposium on VLSI (ISVLSI). vol. 1, pp. 1–6 (2025). https://doi.org/10.1109/ISVLSI65124.2025.11130214

    2025

  16. [25]

    et al.: Continual learning: Applications and the road forward

    Verwimp, E. et al.: Continual learning: Applications and the road forward. Trans- actions on Machine Learning Research (2024)

    2024

  17. [26]

    et al.: A comprehensive survey of continual learning: Theory, method and application

    Wang, L. et al.: A comprehensive survey of continual learning: Theory, method and application. IEEE Transactions on Pattern Analysis and Machine Intelligence pp. 1–20 (2024). https://doi.org/10.1109/TPAMI.2024.3367329

    2024

  18. [27]

    https://doi.org/10.5281/zenodo.4414861

    Wightman, R.: Pytorch image models (2019). https://doi.org/10.5281/zenodo.4414861

    2019 doi

  19. [28]

    IEEE Transactions on Network Science and Engineering13, 6571–6588 (2026)

    Wu, B., Ding, Z., Huang, J.: A review of continual learning in edge ai. IEEE Transactions on Network Science and Engineering13, 6571–6588 (2026). https://doi.org/10.1109/TNSE.2026.3657652

    2026

  20. [29]

    et al.: On-device training: A first overview on existing systems

    Zhu, S. et al.: On-device training: A first overview on existing systems. ACM Trans. Sen. Netw.20(6) (2024). https://doi.org/10.1145/3696003

    2024 doi

Pith tools

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