企业官网建设流程全解析

在探索大语言模型（LLM）落地的过程中，许多开发者和研究者都面临一个共同的困境：网上资料虽多，但往往聚焦于某个单一环节，如“如何微调”、“如何量化”，缺乏一个从零开始、贯通全流程的实战指南。这使得想要亲手构建一个可实际运行、甚至能在资源受限设备（如手机）上部署的模型变得异常困难。本文将彻底解决这个问题，为你呈现一份“手撕”级别的LLM训练全流程实战教程。

我们将从最基础的预训练开始，一步步经历监督微调（SFT）、基于人类反馈的强化学习（RLHF），最终通过量化与蒸馏技术，将一个“庞然大物”压缩成能在手机上运行的轻量级模型。整个过程将包含完整的代码示例、可复现的配置以及每个环节的“避坑”指南。无论你是希望深入理解大模型训练内在机制的研究者，还是寻求在业务中落地私有化模型的工程师，这篇文章都将提供一条清晰的路径。

1. 大模型训练全流程核心概念解析

在动手之前，我们必须理解贯穿整个流程的四大核心阶段及其目标。这并非简单的概念罗列，而是理解我们每一步“为何而做”的关键。

1.1 预训练：构建模型的“世界知识库”

预训练是大模型学习的起点，其目标是通过海量无标注文本，让模型学会语言的统计规律、语法结构和基础的事实知识。你可以把它想象成让一个学生通读整个互联网的文本，从而建立起对世界的基本认知。

• 核心任务：通常采用“掩码语言建模”（MLM）或“自回归语言建模”（如GPT系列）等自监督学习目标。例如，在MLM中，我们会随机遮盖输入句子中的一些词，然后让模型预测被遮盖的词是什么。
• 输入与输出：输入是原始的、清洗过的文本数据（如网页、书籍、代码）。输出是一个具备强大语言理解和生成能力的基础模型，例如类似BERT、GPT的架构。这个模型虽然“博学”，但还不擅长遵循具体的人类指令。
• 关键挑战：计算资源消耗巨大（需要成千上万的GPU时）、数据质量要求高、训练过程不稳定。对于大多数个人或中小团队，从头预训练一个百亿参数模型是不现实的。因此，实践中我们常基于开源的基础模型（如LLaMA、Qwen、BLOOM）开始，这相当于站在了巨人的肩膀上。

1.2 监督微调：教会模型“听话”

基础模型知识渊博，但回答可能冗长、不符合格式、甚至有害。监督微调的目标就是将这个“通才”模型，培养成能完成特定任务（如对话、编程、文案生成）的“专才”。

• 核心任务：使用高质量的、成对的指令-回答数据对模型进行有监督训练。数据格式如：{“instruction”: “写一首关于春天的诗”， “output”: “春风吹绿柳枝条...”}。
• 输入与输出：输入是基础模型和SFT数据集。输出是一个指令遵循模型。经过SFT后，模型能更好地理解人类意图，并以更安全、更有用的方式回应。
• 关键挑战：构建高质量、多样化的SFT数据成本高昂；容易发生过拟合（模型只记住了训练数据，丧失了泛化能力）；微调策略（如全参数微调、LoRA等参数高效微调）的选择直接影响效果和资源消耗。

1.3 基于人类反馈的强化学习：对齐人类偏好

SFT让模型能执行指令，但哪个回答更好、更无害、更有帮助？RLHF旨在让模型的输出与人类复杂、主观的价值观和偏好对齐。

• 核心任务：它分为三步：
  1. 收集偏好数据：人类标注员对同一个提示词的多个模型输出进行排序，形成偏好对(回答A， 回答B)，其中A优于B。
  2. 训练奖励模型：用一个单独的模型（奖励模型）来学习人类的偏好，即学会给更好的回答打更高的分数。
  3. 强化学习优化：使用PPO等强化学习算法，以奖励模型的分数为引导，优化SFT后的模型，使其生成能获得高奖励（即更符合人类偏好）的回答。
• 输入与输出：输入是SFT模型和人类偏好数据。输出是一个与人类价值观更对齐的模型。RLHF能显著提升模型回答的有用性、安全性和流畅度。
• 关键挑战：流程复杂，需要训练多个模型；奖励模型可能被“欺骗”；训练不稳定，容易导致模型退化或输出异常。

1.4 量化与蒸馏：让模型“瘦身”并提速

经过上述步骤，我们得到了一个强大但笨重的模型（通常为FP16或BF16精度），无法在手机等边缘设备部署。量化与蒸馏就是模型的“减肥”和“知识提炼”过程。

• 量化：降低模型权重和激活值的数值精度，例如从16位浮点数（FP16）降至8位整数（INT8）甚至4位整数（INT4）。这能大幅减少模型存储空间和内存占用，并利用硬件加速推理。
• 蒸馏：用一个庞大的“教师模型”来指导一个较小的“学生模型”进行学习，目标是让学生模型在性能上逼近教师模型，同时体积更小、速度更快。
• 目标：输入是对齐后的大模型，输出是一个轻量级、可部署的模型，在精度损失可控的前提下，满足终端设备的资源约束。

2. 环境准备与工具链搭建

工欲善其事，必先利其器。我们将基于PyTorch和Hugging Face生态系统来构建我们的训练流水线，这是目前社区最活跃、资源最丰富的选择。

2.1 硬件与基础软件环境

• 操作系统：Linux（Ubuntu 20.04/22.04 LTS推荐）或 macOS。Windows可通过WSL2获得近似体验。
• GPU：这是核心资源。至少需要一张显存 >= 24GB 的GPU（如RTX 4090）用于SFT和RLHF的实验阶段。预训练和全参数微调则需要多卡或A100/H100等专业卡。手机部署阶段则不需要强GPU。
• Python：版本 3.8 - 3.10。
• CUDA：根据你的GPU型号安装对应版本的CUDA工具包（如11.8, 12.1）。

2.2 核心Python库安装

创建一个新的虚拟环境（如conda create -n llm-train python=3.10），然后安装以下核心包：

# 基础深度学习框架 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 请根据你的CUDA版本调整 # Hugging Face 核心库，提供模型、数据集、训练器 pip install transformers datasets accelerate # 用于参数高效微调 (LoRA) pip install peft # 用于RLHF训练（例如，使用TRL库） pip install trl # 用于模型评估 pip install evaluate # 用于量化（以bitsandbytes为例） pip install bitsandbytes # 用于知识蒸馏（可选，根据具体方法选择库，如text-generation-webui或自定义） # pip install ... # 工具库 pip install scipy sentencepiece protobuf

版本兼容性提示：PyTorch、CUDA、bitsandbytes之间的版本有严格对应关系，安装失败时请优先检查版本匹配问题。

2.3 项目结构规划

清晰的目录结构有助于管理复杂的流程。建议如下：

llm_full_pipeline/ ├── configs/ # 存放各阶段的配置文件（YAML/JSON） ├── data/ # 数据集目录 │ ├── pretrain/ # 预训练数据 │ ├── sft/ # SFT数据 │ └── rlhf/ # RLHF偏好数据 ├── scripts/ # 各阶段的启动脚本 ├── src/ # 核心源代码 │ ├── pretrain.py │ ├── sft.py │ ├── rlhf_train.py # 训练奖励模型和PPO │ └── quantize_distill.py ├── models/ # 保存的模型检查点 │ ├── base_model/ # 下载的基础模型 │ ├── sft_model/ │ ├── rlhf_model/ │ └── final_mobile_model/ ├── outputs/ # 训练日志、输出结果 └── requirements.txt

3. 实战第一阶段：从零开始的理解与数据准备

由于从头预训练成本极高，我们采用更实际的路径：选择一个开源基础模型，并为其准备下游任务数据。

3.1 选择与加载基础模型

我们以较小规模的模型为例，便于实验。例如，选择meta-llama/Llama-2-7b-hf（需申请许可）或Qwen/Qwen-1_8B。这里使用Qwen-1.8B作为演示。

# src/load_base_model.py from transformers import AutoTokenizer, AutoModelForCausalLM import torch model_name = "Qwen/Qwen-1_8B" # 确保你有足够的显存，否则使用 `device_map="auto"` 或量化加载 model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, # 半精度节省显存 device_map="auto", # 自动分配多GPU trust_remote_code=True # Qwen需要此参数 ) tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) # 测试模型加载成功 print(f"模型 {model_name} 加载成功，参数量：{sum(p.numel() for p in model.parameters()):,}")

3.2 准备SFT数据

SFT数据质量至关重要。我们创建一个简单的指令数据集示例。

# scripts/prepare_sft_data.py from datasets import Dataset import json # 示例数据：格式为指令-输出对 sft_examples = [ { "instruction": "写一首关于秋天的五言绝句。", "output": "秋风扫落叶，寒露凝为霜。孤雁南飞去，山川尽染黄。" }, { "instruction": "用Python写一个函数，计算斐波那契数列的第n项。", "output": "def fibonacci(n):\n if n <= 1:\n return n\n a, b = 0, 1\n for _ in range(2, n+1):\n a, b = b, a + b\n return b" }, { "instruction": "解释什么是机器学习。", "output": "机器学习是人工智能的一个分支，它使计算机系统能够从数据中学习和改进，而无需进行明确的编程。核心思想是通过算法识别数据中的模式，并利用这些模式进行预测或决策。" } ] # 将数据转换为Hugging Face Dataset格式 dataset = Dataset.from_list(sft_examples) # 保存到磁盘 dataset.save_to_disk("./data/sft/example_dataset") print(f"SFT示例数据已保存，共 {len(dataset)} 条样本。") # 实际项目中，你需要准备成千上万条这样的高质量数据，可以从Alpaca、ShareGPT等开源数据集入手并清洗。

3.3 准备RLHF偏好数据

RLHF需要格式为(chosen, rejected)的偏好对。

# scripts/prepare_rlhf_data.py from datasets import Dataset # 示例：对于同一个问题，chosen是更好的回答 preference_examples = [ { "prompt": "如何泡一杯好喝的茶？", "chosen": "泡一杯好茶需要注意水温、茶具和冲泡时间。例如，绿茶宜用80-85℃的水，冲泡1-2分钟；红茶可用沸水，冲泡3-5分钟。首先温杯，然后投茶，注水后等待适当时间即可品饮。", "rejected": "把茶叶扔进杯子里，倒上开水就行了。" }, { "prompt": "简述太阳系的结构。", "chosen": "太阳系以太阳为中心，包括八大行星、它们的卫星、矮行星、小行星带、柯伊伯带和奥尔特云等。行星按离太阳从近到远依次为水星、金星、地球、火星、木星、土星、天王星、海王星。", "rejected": "太阳系就是太阳和一堆石头围着它转，有火星、木星什么的，可能还有冥王星。" } ] preference_dataset = Dataset.from_list(preference_examples) preference_dataset.save_to_disk("./data/rlhf/preference_dataset") print(f"RLHF偏好数据已保存，共 {len(preference_dataset)} 条样本。")

4. 实战第二阶段：监督微调

我们将使用参数高效微调技术LoRA来微调模型，这能极大减少可训练参数量和显存消耗。

4.1 配置LoRA微调参数

# configs/sft_lora_config.json { "model_name": "Qwen/Qwen-1_8B", "dataset_path": "./data/sft/example_dataset", "output_dir": "./models/sft_lora_model", "num_train_epochs": 3, "per_device_train_batch_size": 4, "gradient_accumulation_steps": 4, "learning_rate": 2e-4, "warmup_steps": 100, "logging_steps": 10, "save_steps": 200, "lora_r": 8, # LoRA秩 "lora_alpha": 32, # LoRA缩放参数 "lora_dropout": 0.1, "lora_target_modules": ["q_proj", "v_proj"] # 对哪些模块应用LoRA }

4.2 编写SFT训练脚本

# src/sft.py import json from transformers import ( AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer, DataCollatorForLanguageModeling ) from datasets import load_from_disk from peft import LoraConfig, get_peft_model, TaskType import torch # 1. 加载配置 with open('./configs/sft_lora_config.json', 'r') as f: config = json.load(f) # 2. 加载模型和分词器 model = AutoModelForCausalLM.from_pretrained( config['model_name'], torch_dtype=torch.float16, device_map="auto", trust_remote_code=True ) tokenizer = AutoTokenizer.from_pretrained(config['model_name'], trust_remote_code=True) # 设置padding token（如果tokenizer没有） if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token # 3. 配置LoRA lora_config = LoraConfig( task_type=TaskType.CAUSAL_LM, r=config['lora_r'], lora_alpha=config['lora_alpha'], lora_dropout=config['lora_dropout'], target_modules=config['lora_target_modules'] ) model = get_peft_model(model, lora_config) model.print_trainable_parameters() # 查看可训练参数量，通常只有原模型的0.1%-1% # 4. 加载并预处理数据集 dataset = load_from_disk(config['dataset_path']) def format_instruction(example): # 将指令和输出组合成模型训练的文本格式 text = f"### Instruction:\n{example['instruction']}\n\n### Response:\n{example['output']}{tokenizer.eos_token}" return {'text': text} formatted_dataset = dataset.map(format_instruction) tokenized_dataset = formatted_dataset.map( lambda x: tokenizer(x['text'], truncation=True, max_length=512), batched=True ) # 5. 定义训练参数 training_args = TrainingArguments( output_dir=config['output_dir'], num_train_epochs=config['num_train_epochs'], per_device_train_batch_size=config['per_device_train_batch_size'], gradient_accumulation_steps=config['gradient_accumulation_steps'], learning_rate=config['learning_rate'], warmup_steps=config['warmup_steps'], logging_steps=config['logging_steps'], save_steps=config['save_steps'], fp16=True, # 使用混合精度训练 remove_unused_columns=False, ) # 6. 初始化Trainer并训练 trainer = Trainer( model=model, args=training_args, train_dataset=tokenized_dataset, data_collator=DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False), ) trainer.train() trainer.save_model() tokenizer.save_pretrained(config['output_dir']) print(f"SFT-LoRA模型已保存至 {config['output_dir']}")

4.3 运行与验证

在终端执行：

cd /path/to/llm_full_pipeline python src/sft.py

训练完成后，你可以加载微调后的模型进行测试：

from peft import PeftModel model = AutoModelForCausalLM.from_pretrained(config['model_name'], device_map="auto", trust_remote_code=True) model = PeftModel.from_pretrained(model, config['output_dir']) inputs = tokenizer("### Instruction:\n写一句励志的话。\n\n### Response:\n", return_tensors="pt").to(model.device) outputs = model.generate(**inputs, max_new_tokens=50) print(tokenizer.decode(outputs[0], skip_special_tokens=True))

5. 实战第三阶段：RLHF训练

RLHF流程复杂，我们使用Hugging Face的trl库来简化奖励模型训练和PPO优化。

5.1 训练奖励模型

奖励模型是一个分类模型，学习区分好的回答和坏的回答。

# src/train_reward_model.py (简化示例) from transformers import AutoModelForSequenceClassification, AutoTokenizer from trl import RewardTrainer, RewardConfig from datasets import load_from_disk import torch # 加载偏好数据集 dataset = load_from_disk("./data/rlhf/preference_dataset") # 需要将数据集转换为特定格式：每个样本包含 `input_ids_chosen`, `attention_mask_chosen`, `input_ids_rejected`, `attention_mask_rejected` # 此处省略数据预处理细节... # 加载一个基础模型作为奖励模型 backbone model_name = "Qwen/Qwen-1_8B" reward_model = AutoModelForSequenceClassification.from_pretrained( model_name, num_labels=1, torch_dtype=torch.float16, trust_remote_code=True ) tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token # 定义训练参数 training_args = RewardConfig( output_dir="./models/reward_model", num_train_epochs=1, per_device_train_batch_size=2, gradient_accumulation_steps=4, learning_rate=1e-5, logging_steps=10, remove_unused_columns=False, ) # 初始化Trainer trainer = RewardTrainer( model=reward_model, args=training_args, train_dataset=dataset, # 假设dataset已处理好 tokenizer=tokenizer, ) trainer.train()

5.2 使用PPO进行强化学习优化

这一步使用训练好的奖励模型来优化我们之前SFT得到的模型。

# src/train_with_ppo.py (概念性代码，实际更复杂) from trl import PPOConfig, PPOTrainer, AutoModelForCausalLMWithValueHead from transformers import AutoTokenizer import torch # 1. 加载SFT模型（作为策略模型） sft_model_path = "./models/sft_lora_model" policy_model = AutoModelForCausalLMWithValueHead.from_pretrained(sft_model_path, torch_dtype=torch.float16) policy_tokenizer = AutoTokenizer.from_pretrained(sft_model_path) # 2. 加载奖励模型 reward_model = AutoModelForSequenceClassification.from_pretrained("./models/reward_model", torch_dtype=torch.float16) reward_tokenizer = AutoTokenizer.from_pretrained("./models/reward_model") # 3. 配置PPO参数 ppo_config = PPOConfig( batch_size=8, mini_batch_size=4, learning_rate=1e-5, log_with="wandb", # 可选，用于日志记录 ) # 4. 初始化PPO Trainer ppo_trainer = PPOTrainer( config=ppo_config, model=policy_model, ref_model=None, # 可以使用原始SFT模型作为参考模型以防止退化 tokenizer=policy_tokenizer, ) # 5. 训练循环（简化） # for epoch in range(ppo_config.total_epochs): # for batch in dataloader: # # 生成回答 # response_tensors = ppo_trainer.generate(batch['query'], ...) # # 使用奖励模型评分 # rewards = reward_model_score(response_tensors, ...) # # PPO优化步骤 # stats = ppo_trainer.step(response_tensors, rewards) # ... 实际实现需要构建prompt数据集和完整的训练循环

注意：完整的RLHF/PPO实现代码量较大，涉及多个循环和细节处理。强烈建议深入研究trl库的官方示例和文档。

6. 实战第四阶段：量化与蒸馏

假设我们经过SFT和RLHF得到了一个对齐后的模型./models/aligned_model。现在目标是将其部署到手机。

6.1 动态量化（以8位为例）

使用bitsandbytes库进行加载时量化，这是最简单的方法。

# src/quantize_dynamic.py from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig import torch model_path = "./models/aligned_model" tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) # 配置4位或8位量化加载 bnb_config = BitsAndBytesConfig( load_in_8bit=True, # 使用8位整数量化 # load_in_4bit=True, # 或者使用4位量化，更激进 bnb_4bit_compute_dtype=torch.float16, ) # 以量化方式加载模型 quantized_model = AutoModelForCausalLM.from_pretrained( model_path, quantization_config=bnb_config, device_map="auto", trust_remote_code=True ) # 保存量化后的模型（注意：有些量化方式保存的是适配器，有些可以保存完整模型） save_path = "./models/quantized_8bit_model" quantized_model.save_pretrained(save_path) tokenizer.save_pretrained(save_path) print(f"8位量化模型已保存至 {save_path}")

6.2 知识蒸馏（概念与步骤）

蒸馏需要一个小型的学生模型和一个教师模型。这里概述关键步骤：

1. 选择学生模型：选择一个参数量小得多的模型架构，如TinyLlama-1.1B。
2. 准备蒸馏数据：使用未标注的文本或指令数据。
3. 定义蒸馏损失：通常结合：
   • 软目标损失：让学生模型的输出概率分布逼近教师模型的输出概率分布（使用KL散度）。
   • 硬目标损失：传统的交叉熵损失，让学生预测真实的标签（如果数据有标签）。
   • 隐藏状态损失：让学生中间层的表示逼近教师层。
4. 训练学生模型。

# 伪代码，展示核心思想 # teacher_model = 加载对齐后的大模型 # student_model = 初始化小模型 # distillation_criterion = KLDivLoss() # for data in dataloader: # with torch.no_grad(): # teacher_logits = teacher_model(data).logits # student_logits = student_model(data).logits # loss = distillation_criterion(F.log_softmax(student_logits/T, dim=-1), # F.softmax(teacher_logits/T, dim=-1)) * (T*T) # loss.backward() # optimizer.step()

6.3 转换为移动端格式（以ONNX为例）

最后，将PyTorch模型转换为手机端推理引擎（如ONNX Runtime, TFLite）支持的格式。

# src/export_to_onnx.py import torch from transformers import AutoModelForCausalLM, AutoTokenizer import onnx from onnxruntime.tools import float16_converter model_path = "./models/quantized_8bit_model" model = AutoModelForCausalLM.from_pretrained(model_path, device_map="cpu", trust_remote_code=True) # 放到CPU上导出 tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) model.eval() # 创建一个示例输入 dummy_input = tokenizer("Hello, how are you?", return_tensors="pt") input_ids = dummy_input["input_ids"] attention_mask = dummy_input["attention_mask"] # 导出模型为ONNX格式 torch.onnx.export( model, (input_ids, attention_mask), "./models/mobile_model.onnx", input_names=["input_ids", "attention_mask"], output_names=["logits"], dynamic_axes={ "input_ids": {0: "batch_size", 1: "sequence_length"}, "attention_mask": {0: "batch_size", 1: "sequence_length"}, "logits": {0: "batch_size", 1: "sequence_length"} }, opset_version=14, ) print("ONNX模型导出成功。") # 之后可以使用 onnxruntime 在移动端加载和推理此模型。

7. 常见问题与排查思路

在实践整个流程时，你几乎一定会遇到以下问题。

8. 最佳实践与工程建议

完成全流程只是第一步，要获得一个稳健、可用的模型，还需要遵循以下工程准则。

1. 数据为王，质量优先：

   • SFT数据：宁可要1000条高质量、多样化的指令-回答对，也不要10万条低质、重复的数据。人工审核一小部分数据至关重要。
   • RLHF数据：偏好标注的一致性比数量更重要。需要清晰的标注指南，并最好由多人交叉标注来评估一致性。

2. 迭代式训练与评估：

   • 不要一次性跑完所有epoch再评估。每训练一段时间（如每1000步）就在一个保留的验证集上评估生成质量。
   • 评估不应只看损失，更要进行人工评估或使用可靠的自动化指标（如BLEU, ROUGE用于翻译摘要，代码执行准确率用于编程）。

3. 资源管理策略：

   • 实验阶段：始终从LoRA等参数高效微调开始，快速验证想法。
   • 缩放阶段：想法验证有效后，再考虑进行全参数微调或扩大模型规模。
   • 使用混合精度训练：fp16或bf16能有效节省显存和加速训练。
   • 利用梯度累积：在显存有限的情况下，通过累积梯度来模拟更大的有效批次大小。

4. 模型安全与对齐：

   • RLHF是提升安全性的关键，但不是银弹。在部署前，必须进行红队测试，即主动尝试用各种 prompts 引导模型产生有害、偏见或泄露隐私的输出。
   • 考虑在系统层面添加后处理过滤器，对模型的输出进行关键词过滤或敏感内容检测。

5. 部署优化：

   • 量化选择：对于服务器部署，8-bit量化通常是精度和速度的良好平衡。对于端侧部署，4-bit量化或更激进的量化（如AWQ, GPTQ）是必须的。
   • 推理引擎：研究针对目标硬件（如手机CPU/NPU）优化的推理引擎，如ONNX Runtime, TensorFlow Lite, MNN, NCNN等，并进行充分的性能 profiling。
   • 缓存与批处理：对于自回归模型，使用KV缓存能极大加速生成过程。在服务端，对请求进行动态批处理可以提高吞吐量。

6. 版本控制与可复现性：

   • 对数据、代码、模型检查点、超参数配置进行严格的版本控制（如使用DVC, Git LFS）。
   • 记录每一次实验的完整环境（pip freeze > requirements.txt）、随机种子和硬件信息，确保任何结果都是可复现的。

从预训练到手机部署的完整链条，是现代大语言模型工程化的缩影。这个过程充满了挑战，从数据工程的复杂性，到训练过程的资源管理和稳定性，再到最终部署时的性能与精度权衡。通过本文拆解的四个核心阶段——预训练/SFT/RLHF/量化蒸馏，你不仅获得了一套可操作的代码方案，更重要的是建立起对LLM生命周期的系统性认知。

真正的掌握始于动手。建议你从一个超小模型（如1B参数）和一个小型高质量数据集开始，完整地走通这个流程。在遇到并解决每一个具体报错的过程中，你的理解会远比阅读十篇理论文章更加深刻。随后，你可以尝试替换不同的模型架构、尝试不同的微调方法（如QLoRA）、探索不同的RLHF算法变体，或是为特定的手机芯片（如高通、苹果芯）做深度优化。