Hello everyone! I've been recently diving into fine-tuning and deploying the LLaMA large model and am looking for a general workflow that covers data preparation, parameter selection, quantization and compression, as well as tips for cross-platform (CPU, GPU, mobile) execution. Are there any recommended script structures or commonly used open-source toolchains? In real-world projects, how do you balance model performance with resource consumption? I’d love to hear about your experiences and any potential pitfalls or solutions you’ve encountered.
Regarding common practices and considerations for fine-tuning, quantizing, and cross-platform deployment of the LLaMA large model, we look forward to everyone's experiences and suggestions.
👁️ 151 views💬 1 replies❤️ 0 likes
1 Replies
In real-world projects, I generally break down the fine-tuning, quantization, and cross-platform deployment of LLaMA into four stages: **data preparation → training script → quantization compression → multi-platform export**.
For data, I first use HuggingFace `datasets` to generate JSONL or Parquet files via `train_test_split`, ensuring each sample has the three fields `instruction`, `input`, and `output`. This allows downstream LoRA/PEFT code to directly call `DataCollatorForSeq2Seq`. During training, I prefer using `peft`'s LoRA (`lora_rank=8`, `lora_alpha=32`, `target_modules=["q_proj","v_proj"]`) combined with `bitsandbytes`' 4-bit AdamW. This setup lets me run 7B–13B parameter models on a single 24GB GPU with a learning rate of 2e-4, batch size 4–8, and 2–3 epochs of gradient accumulation.
After fine-tuning, I use `optimum`'s `quantize` interface to apply GPTQ/Auto-AWQ (`bits=4`, `group_size=128`), generating `.safetensors` files saved to `model_quantized/`. Next, I export the model to `torchscript` using `torch.compile` (or `onnxruntime`), then serve it with `torchserve` (CPU/GPU) and `torch2trt` (GPU). For mobile, I convert it to `onnx` and compile via `nnapi`/`coreml`.
During deployment, I ensure the `tokenizer` version is consistent, set `pad_token_id` to 0, and run baseline tests across hardware: **CPU: 1–2 tokens/ms**, **GPU: ~10 tokens/ms**, **Mobile: ~5 tokens/ms**. Common pitfalls include NaN after quantization (often due to not disabling `torch.nn.LayerNorm`'s fp16 computation) and serialization inconsistencies across platforms (I recommend calling `model.eval()` and manually `torch.save` before export to verify).
I encapsulate these steps into `run_finetune.sh`, `run_quant.sh`, and `run_deploy.sh`, adding `set -e` and log saving to ensure stable performance and resource balance across environments.