MobileFineTuner: A Mobile-Native Framework for On-Device LLM Fine-Tuning in Real-World Embedded AI Applications

Bing Luo; Jiaxiang Geng; Lunyu Zhao; Yiyi Lu

REVIEW 3 major objections 4 minor 1 cited by

MobileFineTuner: A Mobile-Native Framework for On-Device LLM Fine-Tuning in Real-World Embedded AI Applications

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

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

Pith's one-line read A new C++ framework enables practical on-device fine-tuning of LLMs on commodity mobile phones, reproducing server-grade training results while keeping user data on the device.

desk verdict Real open-source C++ fine-tuning stack with honest PyTorch fidelity checks, but 'practical' is unbacked — the only timing data implies multi-day runs and no energy measurement. read the letter →

arxiv 2512.08211 v2 pith:OBH5FZRE submitted 2025-12-09 cs.LG

Jiaxiang Geng , Lunyu Zhao , Yiyi Lu , Bing Luo This is my paper

classification cs.LG

keywords on-devicefine-tuningmobileLLMtrainingparametershardinggradientaccumulationenergy-awareschedulinglow-rankadaptation(LoRA)privacy-preservingpersonalizationembeddedAI

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 MobileFineTuner is the first unified open-source framework that lets developers fine-tune large language models directly on commodity Android phones, where Python-based training stacks cannot run. It argues that a fully C++ implementation with parameter sharding, gradient accumulation, and energy-aware scheduling makes on-device Full-FT and LoRA training feasible under phone memory and battery limits. The authors show that fine-tuned models reach loss, perplexity, and MMLU accuracy close to those from standard server-side training, while memory usage drops substantially, and they demonstrate a privacy-preserving health-agent use case where a local model is personalized with wearable-sensing data. If correct, the framework closes an infrastructure gap and makes private, on-device model personalization practical.

What carries the argument

The load-bearing mechanism is the framework's four-layer C++ stack (basic tensor/autodiff layer, intermediate layer with attention/MLP/embedding and LoRA adapters, abstract layer with optimizers, and application layer with transformer blocks and KV-cache), together with the memory optimizations: parameter sharding (partitioning model parameters into contiguous segments, loading only the active segment for the current forward/backward pass, offloading inactive segments to disk) and gradient accumulation (micro-batches per forward/backward with gradient accumulation and a single optimizer step). An energy-aware computation scheduler introduces sleep delays when battery percentage falls below a

What would settle it

Take the paper's Qwen2.5-0.5B LoRA fine-tuning configuration on a 12GB Android phone, run it until convergence, and record total wall-clock time and battery percentage consumed; if the run exceeds a reasonable duration (e.g., an overnight charge) or the battery fails before convergence, the 'practical' claim is falsified.

Watch

Extended reading notes

Core claim

MobileFineTuner is presented as the first unified open-source framework that performs full parameter fine-tuning (Full-FT) and low-rank adaptation (LoRA) directly on commodity Android phones, implemented natively in C++ without a Python runtime or virtual machine. The authors claim that two system-level mechanisms — parameter sharding, which partitions model parameters into segments and swaps only active segments into RAM while offloading inactive ones to disk, and gradient accumulation, which splits large batches into memory-sized micro-batches — bring backpropagation through transformer blocks within phone memory limits, while an energy-aware scheduler slows computation as battery drops. E

Load-bearing premise

The load-bearing premise is that 'practical' means a full fine-tuning run finishes within acceptable time and battery budget; the paper only reports step-level times of roughly 5-10 minutes per step and no end-to-end runtime or energy measurement, so if a complete run must finish in a user-acceptable duration, that premise is not yet demonstrated.

Editorial extensions

If this is right

Developers can fine-tune small language models (roughly up to 0.5B parameters) on 8-12GB phones, enabling private personalization without transmitting user data.
The framework supports both Full-FT and LoRA with a familiar high-level train loop, and exports models in standard formats, so on-device training can be integrated into existing LLM pipelines.
Because parameter sharding and gradient accumulation do not alter convergence, users can trade RAM for wall-clock time and still get the same model quality.
The energy-aware scheduler makes sustained training feasible on battery power, at the cost of slower progress when the battery is low.
The framework is open-source and designed to be extended, providing a base for future work on federated or split fine-tuning across multiple phones.

Reading between the lines

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

The paper's step times (5-10 minutes per step for Qwen2.5-0.5B) imply that a full fine-tuning run would take many hours to days; the authors never report end-to-end completion time or battery drain, so 'practical' should be read as feasible in controlled or overnight scenarios, not as a fast operation.
A direct energy accounting (total joules to convergence vs. server training) is not given; this is the logical next experiment to test the energy-aware scheduler's real-world benefit.
The framework's design could naturally extend to federated learning across phones since it already supports local training and server-side training with the same API; the paper lists this as future work.
If adopted broadly, on-device fine-tuning could move personalization workloads off data centers, but the current experiments are limited to models below about 1B parameters, so scaling to larger models will likely require quantization and hardware acceleration, which the paper lists as ongoing.

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.

Desk Editor's Note

read the letter

Read this if you work on on-device LLM training. MobileFineTuner is a genuine open-source C++ framework that runs LoRA fine-tuning of small LLMs on stock Android phones and reports loss/PPL numbers close to PyTorch on the same settings. That's a real artifact — the first unified, open stack of its kind, as far as I can tell. The integration of parameter sharding, gradient accumulation, and an energy-aware scheduler into one C++ codebase with HF-format checkpoint I/O is useful plumbing the community has been missing.

What's solid: the PEFT evaluation covers 10 model-task pairs across GPT-2, Qwen2.5-0.5B, and Gemma3-270M/1B, and final loss/PPL mostly line up with PyTorch (e.g., GPT2-124M MMLU 23.53 vs 25.45 accuracy, Qwen PPL 20.10 vs 20.50). They don't claim to beat PyTorch; they use it as a correctness baseline, which is the right frame. Gradient accumulation results show stable convergence across micro-batch splits. The ablation tables are clearly presented.

Where it wobbles: the word “practical” and the conclusion that fine-tuning “can be performed efficiently” are not supported by the data in the paper. The only wall-clock evidence is Fig. 9: Qwen2.5-0.5B on a Pixel 8 Pro at 0.081 h/step before the battery threshold drops to 50% speed (0.164 h/step). Their own Table 7 shows ~1,218 convergence steps for a similar training setup. That's roughly 4–7 days of continuous computation on a flagship phone for a 0.5B model. There is no end-to-end completion time, no battery drain measurement, no energy reading — even though a PowerMonitor is described in §5.1.2. The energy scheduler's only demonstrated effect is making each step slower; there's no measured energy reduction. Also, device coverage is overstated: Gemma3-1B runs only on the MacBook, Gemma3-270M only on the MacBook in the WikiText experiments, and Full-FT is a single GPT2-124M run on one device. Parameter sharding savings are modest (16% for GPT2-small, ~4–6% for others) and no disk-I/O overhead is reported. I couldn't verify the code from the text; the repo link exists but I didn't inspect it.

None of this is fatal to the artifact. The framework likely works as advertised for small models and privacy-sensitive personalization where you can train overnight while plugged in. But the claims need to be scaled back to match the evidence, or the authors need to add wall-clock and energy measurements for a realistic end-to-end personalization task.

Who it's for: systems researchers working on on-device training, mobile ML, and federated/personalized LLMs. It should go to peer review — a serious referee can push for the missing measurements and a more careful reading of “practical.” I'd want to see a revised version with the claims tightened.

Referee Report

3 major / 4 minor

Summary. The paper introduces MobileFineTuner, an open-source C++ framework for fine-tuning LLMs directly on Android phones. It supports full-parameter fine-tuning and LoRA, and contributes system-level optimizations: ZeRO-inspired parameter sharding to disk, gradient accumulation, and an energy-aware computation scheduler. Evaluation covers GPT-2, Qwen2.5, and Gemma3 models on Pixel phones and a MacBook Air, comparing training loss/PPL/accuracy against a PyTorch baseline and reporting memory (RSS) reductions. The paper claims that this is the first unified open-source framework enabling practical on-device LLM fine-tuning on commodity phones.

Significance. If substantiated, MobileFineTuner would fill a real infrastructure gap: it is implemented natively in C++, ships with an open-source repository, uses actual mobile hardware rather than simulation, and compares against an external PyTorch baseline. The memory-sharding and gradient-accumulation ablations provide concrete system measurements. These are meaningful strengths. However, the central 'practical' claim currently rests on incomplete evidence: the only wall-clock data implies multi-day training runs, no battery/energy measurement is reported, and several model/device combinations run only on a laptop. The claim that MobileFineTuner 'reproduces standard Full-FT and LoRA fine-tuning behavior' is also not uniformly supported by the reported numbers, which show large unexplained discrepancies for GPT-2 on WikiText-2.

major comments (3)

[§6.2.3, Fig. 9; Abstract; §7] The 'practical' claim is not supported by the reported timing and energy evidence. The only wall-clock measurement, in §6.2.3, shows Qwen2.5-0.5B on the Pixel 8 Pro taking 0.081 h/step (~4.9 min/step) before the battery threshold and 0.164 h/step (~9.8 min/step) after the scheduler engages. For a run of roughly 1,200 steps (the convergence scale reported for Gemma3-270M in Table 7), this implies multiple days of continuous training. No end-to-end completion time, total battery drain, or total energy consumption is reported anywhere, despite the PowerMonitor described in §5.1.2. The energy-aware scheduler's only measured effect is an increase in per-step wall-clock time, not a measured reduction in energy. The authors should either add end-to-end time and battery/energy measurements, or temper the 'practical' claim to 'executable on-device fine-tuning.'
[Tables 4–6; §6.1.2; Abstract; §7] The device-coverage claim overstates what was actually run on phones. In Table 4, Gemma3-1B runs only on the MacBook Air for WikiText-2, and Gemma3-270M runs only on the MacBook Air as well. In Table 5, Gemma3-1B again runs only on the MacBook Air. Nevertheless, Table 6 reports MobileFineTuner fine-tuning metrics for these model/task combinations, and the abstract and conclusion state that 'GPT-2, Gemma 3, and Qwen 2.5' were fine-tuned on 'real mobile phones.' The reported Gemma3-1B results, and the Gemma3-270M WikiText-2 result, appear to come from a laptop, not a phone. The authors should clearly separate phone-executable configurations from laptop-only configurations and qualify the corresponding claims.
[§6.1.2, Table 6] The claim that MobileFineTuner 'reproduces standard LoRA fine-tuning behavior' is not supported by the WikiText-2 GPT-2 results. For GPT2-124M, MobileFineTuner reports final loss 2.62 ± 0.2 versus PyTorch 3.54 ± 0.3, and PPL 11.79 versus 25.77. For GPT2-355M, the numbers are 2.27 versus 3.25 for loss and 8.20 versus 18.08 for PPL. These are large, unexplained discrepancies, not 'comparable' outcomes. The authors need to explain the discrepancy (e.g., different convergence criteria, tokenization, or evaluation protocol), or restrict the 'reproduces' claim to the configurations where agreement is actually close.

minor comments (4)

[Throughout] There are numerous typos and inconsistent capitalizations: 'MobilefineTuner' vs 'MobileFineTuner', 'opensourse', 'Framemwork', 'parametern', 'Gradients accumulation' (section title), and the duplicated heading '5.1.4 Device specifications for our common evaluation.' These should be fixed.
[§6.2.3, Fig. 9] The caption 'Loss with Computation Scheduling' does not match the text, which discusses wall-clock time per step. Clarify what the figure actually plots, and report the loss curve separately if it is intended.
[§6.2.1, Fig. 7] The memory reduction from parameter sharding is modest for the larger models: GPT2-medium drops from 3,603 MB to 3,462 MB (~4%), Gemma3-270M from 5,060 to 4,719 (~7%), and Gemma3-1B from 11,448 to 10,782 (~6%). The text calls this a 'substantial' reduction; consider reporting the relative reduction quantitatively and discussing disk I/O overhead.
[Table 6] The table header says metrics are averaged across 'all devices that were able to complete the full fine-tuning process,' but the set of devices differs per model. Please state explicitly, for each row, which devices are included in the average.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: MobileFineTuner's central claims are validated against an external PyTorch baseline, and self-citations are peripheral.

full rationale

This is a systems/engineering paper, not a derivation paper; there is no claimed derivation chain whose predictions reduce to inputs. The central correctness claim — that MobileFineTuner reproduces standard Full-FT/LoRA behavior — is checked against PyTorch as an external baseline (Table 6, Figures 4–6), and the memory claims are measured via RSS (Section 6.2.1). The only self-citations ([9], [41]) appear in the related-work survey and in a background statement about privacy-preserving on-device training; they are not used to justify any load-bearing technical result. The energy-aware scheduler (§4.2, §6.2.3) is evaluated with wall-clock time reported by the framework's own metrics observer, and no total-energy measurement is given; this is an evidentiary weakness in the 'practical' claim, but not a circularity: the scheduler's effect is not defined in terms of the claimed outcome. The framework is open-source and the hardware/RSS numbers are externally checkable. Hence no step reduces by construction to its own inputs.

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

The framework is an engineering artifact rather than a mathematical derivation, so the ledger contains experimental hyperparameters and unverified engineering assumptions rather than invented physical entities. The main uncharged cost is the assumption that disk sharding and battery throttling do not make training impractically slow, plus the premise that Python cannot provide a reasonable mobile fine-tuning path.

free parameters (4)

Sequence length and batch size = seq_len=128, batch=8
Chosen uniformly for all runs to match the PyTorch baseline; not justified by data or an ablation.
LoRA rank / alpha / dropout = r=8, alpha=32 (16 in ablations), dropout=0.1
Standard LoRA defaults; they affect PEFT quality but are not fitted to the reported claims.
Learning rates = 1e-5 (Full-FT), 2e-4 (LoRA)
Chosen by hand; no learning-rate sweep is reported, so sensitivity is unknown.
Energy scheduler K, mu, rho = K=1, mu=60%, rho=50%
User-defined hyperparameters for the energy demo; the choice of mu=60% directly triggers the reported throttling event, so the result is illustrative rather than optimized.

assumptions (3)

domain assumption Android does not natively support Python, so Python-based fine-tuning frameworks cannot be practically deployed on phones
Central premise for the claimed gap in §2. The paper dismisses Termux and ONNX-based phone attempts as inefficient or inconvenient, but does not benchmark against them.
domain assumption Disk-offloading inactive parameter shards reduces memory without prohibitive runtime cost
§4.1.1 and Fig. 7 report RSS reductions only; no wall-clock time or energy comparison with/without sharding is given, so the speed cost of disk offloading is assumed acceptable.
domain assumption Identical hyperparameters on PyTorch and MobileFineTuner give a valid correctness comparison
§6.1.2 uses a unified configuration across frameworks and devices, but numerical implementations, hardware, and memory management differ; no hyperparameter sensitivity analysis is shown.

how reviews work

0 comments

Cite this review

Pith. "Pith review of MobileFineTuner: A Mobile-Native Framework for On-Device LLM Fine-Tuning in Real-World Embedded AI Applications." pith.science (2026). https://pith.science/paper/OBH5FZRE

@misc{pith2026251208211,
  author       = {Pith},
  title        = {Pith review of: MobileFineTuner: A Mobile-Native Framework for On-Device LLM Fine-Tuning in Real-World Embedded AI Applications},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/OBH5FZRE}},
  note         = {Machine review of arXiv:2512.08211}
}

read the original abstract

Large language models (LLMs) are moving from cloud-centric services toward on-device embedded AI, where models interact with private, longitudinal signals sensed from users and their physical environments. Mobile phones are a natural platform for such applications because they are continuously carried by users, connected to wearable sensors, and deeply integrated with daily mobile applications. However, practical LLM fine-tuning on commodity phones remains difficult. Existing fine-tuning frameworks are largely Python-based and server-oriented, making them hard to deploy inside mobile applications. We present MobileFineTuner, a mobile-native open-source framework for end-to-end LLM fine-tuning on commodity mobile phones. MobileFineTuner is implemented in C++ and provides a reusable training stack. To make fine-tuning feasible under mobile resource constraints, MobileFineTuner integrates a resource-aware training runtime with memory-efficient attention, activation checkpointing, gradient accumulation, parameter sharding, and energy-aware scheduling. We evaluate MobileFineTuner on real mobile phones using GPT-2, Gemma 3, and Qwen2.5 models across multiple fine-tuning tasks. The results show that MobileFineTuner reproduces standard Full-FT and LoRA fine-tuning behavior, substantially reduces memory pressure and improves executability on memory-constrained phones. We further demonstrate MobileFineTuner through a private campus health-agent application, where a local LLM is fine-tuned on user-specific wearable-sensing records to provide more personalized responses while keeping raw records on the phone. These results establish MobileFineTuner as a practical toolkit for studying and building on-device LLM fine-tuning applications in embedded AI and sensing systems.

Figures

Figures reproduced from arXiv: 2512.08211 by the authors.

**Figure 1.** MobileFineTuner overview. why they do not typically adopt mobile phones as target platforms. Second, we review recent efforts that attempt to enable LLM fine-tuning on mobile phones, analyzing their implementation strategies and inherent limitations. 2.1 Leveraging Private-Domain Data for on-device LLM Fine-Tuning To leverage private-domain data for LLM fine-tuning, recent works have proposed several approaches that… view at source ↗

**Figure 3.** Energy-aware dynamic computation schedul [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗

**Figure 4.** Loss of Full-FT on GPT2-127M@WikiText-2. [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗

Figures from the paper (5 more)

**Figure 5.** Figure 5: Loss of PEFT on Different Tasks. results serves to validate the correctness and reliability of our Full-FT implementation. 6.1.2 PEFT(LoRA). Settings. We evaluate PEFT performance on five models across two datasets, resulting in a total of ten tasks. For each task, we …

**Figure 6.** Figure 6: PPL of PEFT on Different Tasks. below the total physical memory, tasks may still fail. For instance, the Qwen2.5-0.5B model on WikiText-2 exhibits a Peak RSS of 6111 MB; however, this exceeds the available memory on the Pixel 8 (8 GB), causing the process to crash. In …

**Figure 7.** Figure 7: Average RSS w/ or w/o Parameters Sharding. [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]

**Figure 9.** Figure 9: Loss with Computation Scheduling. results demonstrate that gradient accumulation effectively mitigates memory pressure without compromising model performance or training efficiency on mobile devices. 6.2.3 Computation Scheduling. Settings. We perform PEFT to validate t…

**Figure 8.** Figure 8: Gradients Accumulation on Gemma3- 270M@WikiText-2. Gemma3-1B, both with and without parameters sharding. As shown, parameters sharding consistently reduces memory usage across all models. For instance, the average RSS for GPT2-small decreases from 1,945 MB without shar…

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

OpenJarvis: Personal AI, On Personal Devices
cs.LG 2026-05 unverdicted novelty 6.0 of 10

OpenJarvis decomposes personal AI into Intelligence, Engine, Agents, Tools & Memory, and Learning primitives and applies LLM-guided spec search to produce on-device configurations that reach within 3.2 pp of cloud bas...

Reference graph

Works this paper leans on

47 extracted references · 2 canonical work pages · cited by 1 Pith paper

[1]

Mario Almeida, Stefanos Laskaridis, Abhinav Mehrotra, Lukasz Dudziak, Ilias Leontiadis, and Nicholas D. Lane. 2021. Smart at what cost? characterising mobile deep neural networks in the wild. InPro- ceedings of the 21st ACM Internet Measurement Conference(Virtual Event)(IMC ’21). Association for Computing Machinery, New York, NY, USA, 658–672. doi:10.1145...

arXiv 2021
[2]

Jihwan Bang, Juntae Lee, Kyuhong Shim, Seunghan Yang, and Simyung Chang. 2024. Crayon: Customized On-Device LLM via Instant Adapter Blending and Edge-Server Hybrid Inference. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Lun-Wei Ku, Andre Martins, and Vivek Srikumar (Eds.). Association f...

2024
[3]

Daniel J Beutel, Taner Topal, Akhil Mathur, Xinchi Qiu, Javier Fernandez-Marques, Yan Gao, Lorenzo Sani, Kwing Hei Li, Titouan Par- collet, Pedro Porto Buarque De Gusmão, et al. 2020. Flower: A friendly federated learning research framework.arXiv preprint arXiv:2007.14390 (2020)

arXiv 2020
[4]

Xiaopei Chen, Liang Li, Fei Ji, and Wen Wu. 2025. Memory-Efficient Split Federated Learning for LLM Fine-Tuning on Heterogeneous Mo- bile Devices. InProceedings of IEEE INFOCOM 2025 - Workshop on Intelligent Edge for Large Models (IEILM). IEEE. to appear

2025
[5]

Yae Jee Cho, Luyang Liu, Zheng Xu, Aldi Fahrezi, and Gauri Joshi
[6]

Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova
[7]

2016.Reg- ulation (EU) 2016/679 of the European Parliament and of the Council

European Parliament and Council of the European Union. 2016.Reg- ulation (EU) 2016/679 of the European Parliament and of the Council. https://data.europa.eu/eli/reg/2016/679/oj

2016
[8]

Boyu Fan, Xiang Su, Sasu Tarkoma, and Pan Hui. 2025. HeLoRA: LoRA-heterogeneous Federated Fine-tuning for Foundation Models. ACM Trans. Internet Technol.25, 2, Article 11 (April 2025), 22 pages. doi:10.1145/3723877

work page doi:10.1145/3723877 2025

Show all 47 references

[9]

Tao Fan, Hanlin Gu, Xuemei Cao, Chee Seng Chan, Qian Chen, Yiqiang Chen, Yihui Feng, Yang Gu, Jiaxiang Geng, Bing Luo, Shuoling Liu, Win Kent Ong, Chao Ren, Jiaqi Shao, Chuan Sun, Xiaoli Tang, Hong Xi Tae, Yongxin Tong, Shuyue Wei, Fan Wu, Wei Xi, Mingcong Xu, He Yang, Xin Yan...
[11]

Georgi Gerganov and contributors. 2025. llama.cpp: LLM inference in C/C++. https://github.com/ggml-org/llama.cpp. https://github.com/ ggml-org/llama.cpp Accessed: 2025-10-02

2025
[12]

Tom Gunter, Zirui Wang, Chong Wang, Ruoming Pang, Andy Narayanan, Aonan Zhang, Bowen Zhang, Chen Chen, Chung-Cheng Chiu, David Qiu, Deepak Gopinath, Dian Ang Yap, Dong Yin, Feng Nan, Floris Weers, Guoli Yin, Haoshuo Huang, Jianyu Wang, Jiarui Lu, John Peebles, Ke Ye, Mark Lee,...

2026
[13]

Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. 2020. Measuring massive multitask language understanding.arXiv preprint arXiv:2009.03300 (2020)

2020 arXiv
[14]

Brown, Ben- jamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei

Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B. Brown, Ben- jamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. 2020. Scaling Laws for Neural Language Models.CoRR abs/2001.08361 (2020). arXiv:2001.08361 https://arxiv.org/abs/2001. 08361

2020 arXiv
[15]

Jaehee Kim, Yukyung Lee, and Pilsung Kang. 2024. A Gradient Ac- cumulation Method for Dense Retriever under Memory Constraint. InAdvances in Neural Information Processing Systems, A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang (Eds.), Vol. 37...

2024
[16]

Liang Li, Xingke Yang, Wen Wu, Hao Wang, Tomoaki Ohtsuki, Xin Fu, Miao Pan, and Xuemin Shen. 2025. MobiLLM: Enabling LLM Fine-Tuning on the Mobile Device via Server Assisted Side Tuning. arXiv:2502.20421 [cs.LG] https://arxiv.org/abs/2502.20421

2025 arXiv
[17]

Xiang Li, Zhenyan Lu, Dongqi Cai, Xiao Ma, and Mengwei Xu
[18]

Sourab Mangrulkar, Sylvain Gugger, Lysandre Debut, Younes Belkada, Sayak Paul, and Benjamin Bossan. 2022. PEFT: State-of-the- art Parameter-Efficient Fine-Tuning methods. https://github.com/ huggingface/peft

2022
[19]

Brendan McKeag. 2025. The Complete Guide to GPU Requirements for LLM Fine-Tuning. RunPod Blog. https://www.runpod.io/blog/llm- fine-tuning-gpu-guide

2025
[20]

OpenAI, Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ah- mad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, Red Avila, Igor Babuschkin, Suchir Balaji, Valerie Balcom, Paul Baltescu, Haiming Bao, Mohammad Bavarian, Jef...

2024 arXiv
[21]

Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Ed- ward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, L...

2019
[22]

InProceedings of the Workshop on Edge and Mobile Foundation Models(Minato-ku, Tokyo, Japan)(EdgeFM ’24)

Large Language Models on Mobile Devices: Measurements, Analysis, and Insights. InProceedings of the Workshop on Edge and Mobile Foundation Models(Minato-ku, Tokyo, Japan)(EdgeFM ’24). Association for Computing Machinery, New York, NY, USA, 1–6. doi:10.1145/3662006.3662059
[23]

Python Software Foundation. 2025. Python 3.13.7 Documentation. https://docs.python.org/3/index.html Accessed: 2025-10-03

2025
[24]

Ruiyang Qin, Jun Xia, Zhenge Jia, Meng Jiang, Ahmed Abbasi, Peipei Zhou, Jingtong Hu, and Yiyu Shi. 2024. Enabling On-Device Large Language Model Personalization with Self-Supervised Data Selec- tion and Synthesis. InProceedings of the 61st ACM/IEEE Design Au- tomation Confere...

2024
[25]

Alec Radford, Jeff Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language Models are Unsupervised Multitask Learners. (2019)

2019
[26]

Samyam Rajbhandari, Jeff Rasley, Olatunji Ruwase, and Yuxiong He
[27]

Dan Peng, Zhihui Fu, and Jun Wang. 2024. PocketLLM: Enabling On- Device Fine-Tuning for Personalized LLMs. InProceedings of the Fifth Workshop on Privacy in Natural Language Processing, Ivan Habernal, Sepideh Ghanavati, Abhilasha Ravichander, Vijayanta Jain, Patricia Thaine, T...

2024
[28]

Qwen Team. 2024. Qwen2.5: A Party of Foundation Models. https: //qwenlm.github.io/blog/qwen2.5/

2024
[29]

Arun James Thirunavukarasu, Darren Shu Jeng Ting, Kabilan Elango- van, Laura Gutierrez, Ting Fang Tan, and Daniel Shu Wei Ting. 2023. Large language models in medicine.Nature Medicine29, 8 (2023), 1930–1940. doi:10.1038/s41591-023-02448-8

2023 doi
[30]

Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie- Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, et al. 2023. Llama: Open and efficient foundation language models.arXiv preprint arXiv:2302.13971(2023)

2023 arXiv
[31]

Robert Triggs. 2025. How Much RAM Does Your Android Phone RE- ALLY Need? (2025). Android Authority. https://www.androidauthority. com/how-much-ram-do-i-need-phone-3086661/

2025
[32]

Pablo Villalobos, Anson Ho, Jaime Sevilla, Tamay Besiroglu, Lennart Heim, and Marius Hobbhahn. 2024. Position: will we run out of data? limits of LLM scaling based on human-generated data. InProceedings of the 41st International Conference on Machine Learning(Vienna, Austria) ...

2024
[33]

Gemma Team. 2025. Gemma 3. (2025). https://arxiv.org/abs/2503.19786

2025 arXiv
[34]

Haoming Wang, Boyuan Yang, Xiangyu Yin, and Wei Gao. 2025. Never Start from Scratch: Expediting On-Device LLM Personaliza- tion via Explainable Model Selection. InProceedings of the 23rd An- nual International Conference on Mobile Systems, Applications and Services(Hilton Anah...

2025
[35]

Smith, Iz Beltagy, and Hannaneh Hajishirzi

Yizhong Wang, Hamish Ivison, Pradeep Dasigi, Jack Hessel, Tushar Khot, Khyathi Raghavi Chandu, David Wadden, Kelsey MacMillan, Noah A. Smith, Iz Beltagy, and Hannaneh Hajishirzi. 2023. How far can camels go? exploring the state of instruction tuning on open resources. InProcee...

2023
[36]

Smith, Daniel Khashabi, and Hannaneh Hajishirzi

Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A. Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2023. Self-Instruct: Aligning Language Models with Self-Generated Instructions. InPro- ceedings of the 61st Annual Meeting of the Association for Computational Ling...

2023 doi
[37]

Ziyao Wang, Zheyu Shen, Yexiao He, Guoheng Sun, Hongyi Wang, Lingjuan Lyu, and Ang Li. 2024. FLoRA: Federated Fine-Tuning Large Language Models with Heterogeneous Low-Rank Adaptations. InThe Thirty-eighth Annual Conference on Neural Information Processing Sys- tems. https://op...

2024
[38]

Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, and Jamie Brew. 2019. HuggingFace’s Transformers: State-of-the-art Natural Language Processing.CoRR abs/1910.03771 (2019). arXiv:19...

2019 arXiv
[39]

Nicolas Wagner, Dongyang Fan, and Martin Jaggi. 2024. Personalized Collaborative Fine-Tuning for On-Device Large Language Models. In First Conference on Language Modeling. https://openreview.net/forum? id=bwo3GVsgOv

2024
[40]

Xingke Yang, Liang Li, Zhiyi Wan, Sicong Li, Xiaoqi Qi, Jiang Liu, Tomoaki Ohtsuki, Xin Fu, and Miao Pan. 2025. PAE MobiLLM: Privacy- Aware and Efficient LLM Fine-Tuning on the Mobile Device via Addi- tive Side-Tuning. arXiv:2507.01216 [cs.LG] https://arxiv.org/abs/2507. 01216

2025 arXiv
[41]

Tianjun Yuan, Jiaxiang Geng, Pengchao Han, Xianhao Chen, and Bing Luo. 2025. Flexible Personalized Split Federated Learning for On- Device Fine-Tuning of Foundation Models. arXiv:2508.10349 [cs.DC] https://arxiv.org/abs/2508.10349

2025 arXiv
[42]

Jianyi Zhang, Saeed Vahidian, Martin Kuo, Chunyuan Li, Ruiyi Zhang, Tong Yu, Guoyin Wang, and Yiran Chen. 2024. Towards Building The Federatedgpt: Federated Instruction Tuning. InICASSP 2024 - 2024 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASS...

2024
[45]

Shijie Wu, Ozan Irsoy, Steven Lu, Vadim Dabravolski, Mark Dredze, Sebastian Gehrmann, Prabhanjan Kambadur, David Rosenberg, and Gideon Mann. 2023. BloombergGPT: A Large Language Model for Finance. arXiv:2303.17564 [cs.LG] https://arxiv.org/abs/2303.17564

2023 arXiv
[2019]

InNorth American Chapter of the Association for Computational Linguistics

BERT: Pre-training of Deep Bidirectional Transformers for Lan- guage Understanding. InNorth American Chapter of the Association for Computational Linguistics. https://api.semanticscholar.org/CorpusID: 52967399
[2020]

InProceedings of the International Conference for High Perfor- mance Computing, Networking, Storage and Analysis(Atlanta, Georgia) (SC ’20)

ZeRO: memory optimizations toward training trillion parameter models. InProceedings of the International Conference for High Perfor- mance Computing, Networking, Storage and Analysis(Atlanta, Georgia) (SC ’20). IEEE Press, Article 20, 16 pages
[2024]

InProceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (Eds.)

Heterogeneous LoRA for Federated Fine-tuning of On-Device Foundation Models. InProceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (Eds.). Association for Computational Linguistics, Miami, Fl...

2024 doi
[2025]

IEEE Transactions on Knowledge and Data Engineering37, 7 (2025), 4314–4337

Ten Challenging Problems in Federated Foundation Models. IEEE Transactions on Knowledge and Data Engineering37, 7 (2025), 4314–4337. doi:10.1109/TKDE.2025.3555328

2025
[3731]

doi:10.18653/v1/2024.acl-long.204

2024 doi

Pith tools

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

[1] [1]

Mario Almeida, Stefanos Laskaridis, Abhinav Mehrotra, Lukasz Dudziak, Ilias Leontiadis, and Nicholas D. Lane. 2021. Smart at what cost? characterising mobile deep neural networks in the wild. InPro- ceedings of the 21st ACM Internet Measurement Conference(Virtual Event)(IMC ’21). Association for Computing Machinery, New York, NY, USA, 658–672. doi:10.1145...

arXiv 2021

[2] [2]

Jihwan Bang, Juntae Lee, Kyuhong Shim, Seunghan Yang, and Simyung Chang. 2024. Crayon: Customized On-Device LLM via Instant Adapter Blending and Edge-Server Hybrid Inference. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Lun-Wei Ku, Andre Martins, and Vivek Srikumar (Eds.). Association f...

2024

[3] [3]

Daniel J Beutel, Taner Topal, Akhil Mathur, Xinchi Qiu, Javier Fernandez-Marques, Yan Gao, Lorenzo Sani, Kwing Hei Li, Titouan Par- collet, Pedro Porto Buarque De Gusmão, et al. 2020. Flower: A friendly federated learning research framework.arXiv preprint arXiv:2007.14390 (2020)

arXiv 2020

[4] [4]

Xiaopei Chen, Liang Li, Fei Ji, and Wen Wu. 2025. Memory-Efficient Split Federated Learning for LLM Fine-Tuning on Heterogeneous Mo- bile Devices. InProceedings of IEEE INFOCOM 2025 - Workshop on Intelligent Edge for Large Models (IEILM). IEEE. to appear

2025

[5] [5]

Yae Jee Cho, Luyang Liu, Zheng Xu, Aldi Fahrezi, and Gauri Joshi

[6] [6]

Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova

[7] [7]

2016.Reg- ulation (EU) 2016/679 of the European Parliament and of the Council

European Parliament and Council of the European Union. 2016.Reg- ulation (EU) 2016/679 of the European Parliament and of the Council. https://data.europa.eu/eli/reg/2016/679/oj

2016

[8] [8]

Boyu Fan, Xiang Su, Sasu Tarkoma, and Pan Hui. 2025. HeLoRA: LoRA-heterogeneous Federated Fine-tuning for Foundation Models. ACM Trans. Internet Technol.25, 2, Article 11 (April 2025), 22 pages. doi:10.1145/3723877

work page doi:10.1145/3723877 2025