企业官网建设流程全解析

想自己动手训练一个大模型，但看到动辄需要几十张A100、几个月训练时间的新闻就望而却步？觉得微调一个模型听起来很酷，但打开教程就被复杂的分布式训练、数据清洗和超参调优劝退？

别急着关掉页面。这篇文章要解决的问题，恰恰是让你在一台普通的个人电脑（甚至配置好环境的云端笔记本）上，用Jupyter Notebook，完整地走一遍大模型从“预训练”到“微调”的核心流程。我们不会去从头训练一个千亿参数的GPT-4，那不现实。但我们会做一件更有实操价值的事：理解并亲手实践大模型训练的两个最关键阶段——预训练（Pre-training）与基于LoRA的微调（Fine-tuning）——并最终得到一个可以在消费级硬件（比如你的手机）上推理运行的轻量级模型。

这背后的核心判断是：对于绝大多数开发者和研究者，真正重要的不是重复造轮子，而是深入理解“轮子”是如何被制造和适配的。掌握全流程的实操能力，远比空洞地背诵Transformer原理更有价值。通过本文，你将能清晰地回答：预训练到底在“预”什么？LoRA微调为何能如此省资源？以及如何将一个大模型“压缩”到手机可用的状态。

读完本文，你将获得：

1. 一套完整的、可复现的Jupyter Notebook代码，覆盖数据准备、模型定义、预训练、LoRA微调、模型导出与量化。
2. 对“预训练”和“微调”本质的透彻理解，明白它们各自解决了什么问题，以及如何衔接。
3. 一个实实在在能跑起来的、经过微调的微型大模型，并了解如何将其转换为手机端（如通过ONNX、MNN等框架）可部署的格式。
4. 绕过主流教程“坑点”的实战经验，包括环境配置、显存优化、数据格式处理等。

我们摒弃华而不实的理论堆砌，聚焦于“手撕”代码和流程。现在，打开你的Jupyter Notebook，我们开始。

1. 重新理解“预训练”与“微调”：为何LoRA是游戏规则改变者？

在深入代码之前，我们必须建立正确的认知框架。很多人将“预训练”和“微调”理解为先后顺序的两个独立步骤，这并不完全准确。

预训练（Pre-training）的本质是让模型学习“世界的通用表示”。它通过在海量无标注文本（如网页、书籍、代码）上完成“掩码语言模型”（MLM）或“下一个词预测”任务，让模型掌握语言的语法、常识、逻辑和部分事实。这个过程极其耗费资源，可以理解为铸造一个具有强大通用理解能力的“大脑基座”。像GPT、LLaMA、Qwen等都属于预训练模型。

微调（Fine-tuning）的目标是让这个“通用大脑”适应特定的“专业领域”或“任务格式”。传统全参数微调会更新模型的所有权重，虽然效果好，但成本高昂，且容易导致“灾难性遗忘”——模型可能忘记了之前学到的通用知识。

而LoRA（Low-Rank Adaptation，低秩适配）的出现，彻底改变了微调的成本与效率。它的核心思想非常巧妙：不直接修改原始模型那巨大的参数矩阵（比如有70亿参数），而是为其中一些关键层（通常是注意力层的QKV矩阵）注入一对小小的、低秩的“适配器”矩阵。在微调时，我们“冻结”原始大模型的参数，只训练这些新增的、参数量极少的适配器。

可以做一个类比：预训练模型好比一台功能强大的通用电脑（大脑基座）。传统微调相当于把电脑的主板、CPU都换了，风险高、成本大。而LoRA则像是外接了一个专用的“任务扩展卡”（适配器），电脑本身不动，通过这个扩展卡来获得处理特定任务（如法律文书、医疗问答）的超能力。训练完成后，只需要保存这个很小的“扩展卡”（通常只有几MB到几十MB），与原始模型组合即可使用。

正是LoRA的这种特性，使得我们在个人电脑上微调大模型成为可能。本文的实战部分也将围绕LoRA展开。

2. 环境准备：打造你的大模型实验工作台

工欲善其事，必先利其器。我们的目标是在Jupyter环境中完成所有操作，因此需要一个集成度较高的深度学习环境。

2.1 基础环境配置

我们推荐使用Miniconda/Anaconda来管理Python环境，避免包冲突。

# 1. 创建并激活一个专用的Python 3.10环境（3.8-3.11均可） conda create -n handson-llm python=3.10 -y conda activate handson-llm # 2. 安装Jupyter Lab或Notebook pip install jupyterlab # 或者 pip install notebook # 3. 安装PyTorch（请根据你的CUDA版本到官网获取对应命令） # 例如，对于CUDA 11.8： pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 如果没有GPU或使用CPU，安装CPU版本： # pip install torch torchvision torchaudio

2.2 核心依赖库安装

接下来，安装我们实战所需的机器学习框架和工具库。

# 进入你的项目目录，然后安装 pip install transformers datasets accelerate peft bitsandbytes scikit-learn pandas tqdm matplotlib # 使用清华镜像加速：-i https://pypi.tuna.tsinghua.edu.cn/simple

关键库说明：

• transformers(Hugging Face)：模型、分词器、训练管道的核心库，是我们的“瑞士军刀”。
• datasets：轻松加载和处理数据集。
• accelerate：统一分布式训练接口，简化单机多卡或多机训练代码。
• peft：实现LoRA等参数高效微调方法的官方库，本文的核心。
• bitsandbytes：提供8-bit优化器、4-bit量化等功能，极大降低显存消耗。
• scikit-learn：用于简单的数据评估。

2.3 验证环境与启动Jupyter

# 验证关键库是否安装成功 python -c "import torch; print(f'PyTorch版本: {torch.__version__}, CUDA可用: {torch.cuda.is_available()}')" python -c "import transformers; print(f'Transformers版本: {transformers.__version__}')" python -c "import peft; print(f'PEFT版本: {peft.__version__}')" # 启动Jupyter Lab jupyter lab # 或启动经典Notebook # jupyter notebook

启动后，在浏览器中打开显示的本地链接（通常是http://localhost:8888），新建一个Python Notebook，我们的实战就正式开始了。

3. 实战第一步：选择一个“小巧”的预训练模型基座

既然目标是手撕全流程并在个人设备上运行，我们必须选择一个参数量较小的预训练模型。这里我们选择microsoft/phi-2，这是一个27亿参数的“小”模型，但能力出众，非常适合教育演示和轻量级部署。当然，你也可以选择TinyLlama、Qwen1.5-1.8B或Gemma-2B等。

在Jupyter的第一个Cell中，我们加载模型和分词器。

# cell 1: 导入库并加载预训练模型 import torch from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer from datasets import load_dataset import pandas as pd from peft import LoraConfig, get_peft_model, TaskType # 设置设备 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print(f"使用设备: {device}") # 指定模型名称 model_name = "microsoft/phi-2" # 你也可以尝试 "TinyLlama/TinyLlama-1.1B-Chat-v1.0" # 加载分词器（Tokenization） tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) # 注意：phi-2没有默认的pad_token，需要设置 if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token # 通常用eos_token作为pad_token # 加载预训练模型（Causal LM，用于文本生成） model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, # 使用半精度减少显存占用 device_map="auto", # 自动将模型层分配到可用设备（GPU/CPU） trust_remote_code=True ) print(f"模型 '{model_name}' 加载完成。") print(f"模型参数量: {sum(p.numel() for p in model.parameters()):,}")

关键点解析：

• trust_remote_code=True：某些模型（如phi-2）需要此参数来运行自定义代码。
• torch_dtype=torch.float16：半精度（FP16）训练/推理，是节省显存的关键操作，对精度影响通常很小。
• device_map=”auto”：让accelerate库自动处理模型在GPU和CPU间的分布，对大于显存的模型非常有用。
• 重要：分词器的pad_token必须设置，否则在批处理数据时会出错。

4. 模拟“预训练”：理解数据与任务构建

真正的预训练需要TB级数据和数月时间。为了演示流程，我们用一个极简的“继续预训练”或“领域适应”任务来模拟：让模型学习一种特定的文本风格或知识片段。我们使用一个微型数据集。

假设我们想让模型学习写“程序员风格的诗歌”。我们准备一个很小的数据集。

# cell 2: 创建并处理一个微型“预训练”数据集 # 模拟数据：一些包含“代码”和“诗意”的文本 pretrain_data = [ "def hello_world(): print('Hello, world of algorithms and beauty.')", "Binary trees dance in recursive harmony, leaves whispering in the wind of iteration.", "// A loop that never ends, like my love for clean code and elegant poetry.", "The compiler's silence is the poet's rhyme, both seeking perfection in their own time.", "Git commit -m 'feat: add stanza of logic, fix: metaphor overflow'", ] # 将数据转换为HF Dataset格式 from datasets import Dataset pretrain_dataset = Dataset.from_dict({"text": pretrain_data}) # 定义tokenization函数，对文本进行编码 def tokenize_function(examples): # 这里我们进行简单的拼接和截断，真实预训练会有更复杂的处理（如滑动窗口） return tokenizer( examples["text"], truncation=True, padding="max_length", max_length=128 # 设置一个固定的序列长度 ) # 应用tokenization tokenized_pretrain_dataset = pretrain_dataset.map(tokenize_function, batched=True, remove_columns=["text"]) # 设置标签，对于因果语言模型，标签就是输入本身（shifted） tokenized_pretrain_dataset = tokenized_pretrain_dataset.map( lambda examples: {"labels": examples["input_ids"].copy()}, batched=True ) print(f"数据集处理完成，样本数: {len(tokenized_pretrain_dataset)}") print(f"单个样本的键: {tokenized_pretrain_dataset[0].keys()}")

预训练任务的核心：对于因果语言模型（如GPT），预训练任务是“下一个词预测”。在数据格式上，这体现为将input_ids直接作为labels。模型的任务是根据前面的token预测下一个token。我们这里简化了流程，真实场景中数据量巨大，且会使用动态填充和更复杂的数据加载器。

5. LoRA微调实战：让模型学会“对话”

现在进入重头戏：LoRA微调。我们让上面加载的预训练模型学会遵循指令进行对话。我们将使用一个经典的指令微调数据集timdettmers/openassistant-guanaco的子集。

5.1 准备指令微调数据集

# cell 3: 加载并处理指令微调数据集 # 加载一个小的对话数据集 dataset_name = "timdettmers/openassistant-guanaco" # 实际使用时可以加载全部，这里为演示只取一小部分 finetune_dataset = load_dataset(dataset_name, split="train[:500]") # 取前500条 print(f"微调数据集加载完成，样本数: {len(finetune_dataset)}") print(f"数据集结构示例: {finetune_dataset[0]}") # 查看一条数据格式 sample = finetune_dataset[0] print(f"\n示例对话原文:\n{sample['text']}")

这个数据集的每条样本是一个字符串，格式通常为：

### Human: {用户指令} ### Assistant: {助手回答}

我们需要将其处理成模型能理解的“输入-输出”格式。

5.2 构建适用于对话的Tokenization流程

对于指令微调，我们需要明确区分哪些部分是输入（需要模型看到的上下文），哪些部分是输出（需要模型生成并计算损失的部分）。通常，我们将整个对话作为输入，但只在“助手回答”的部分计算损失。

# cell 4: 定义对话数据格式化与Tokenization函数 def format_conversation(example): # 假设数据格式是 Human/Assistant 交替 text = example["text"] # 这里我们简化处理：将整个文本作为模型输入。 # 更精细的做法是只对Assistant部分计算loss，这需要构建attention_mask。 return {"formatted_text": text} def tokenize_and_prepare_for_finetuning(examples): # 1. 对格式化后的文本进行编码 tokenized = tokenizer( examples["formatted_text"], truncation=True, padding="max_length", max_length=256, # 对话可以稍长一些 return_tensors="pt" # 返回PyTorch张量 ) # 2. 对于因果LM，labels就是input_ids的副本 tokenized["labels"] = tokenized["input_ids"].clone() return tokenized # 应用格式化 formatted_dataset = finetune_dataset.map(format_conversation, batched=False) # 应用tokenization tokenized_finetune_dataset = formatted_dataset.map( tokenize_and_prepare_for_finetuning, batched=True, remove_columns=finetune_dataset.column_names ) # 分割训练集和验证集 split_dataset = tokenized_finetune_dataset.train_test_split(test_size=0.1, seed=42) train_dataset = split_dataset["train"] eval_dataset = split_dataset["test"] print(f"训练集大小: {len(train_dataset)}， 验证集大小: {len(eval_dataset)}")

5.3 配置LoRA并应用到模型

这是PEFT库发挥威力的地方。

# cell 5: 配置LoRA参数并包装模型 from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training # 首先，为某些模型（如量化模型）进行预处理（非必须，但推荐） model = prepare_model_for_kbit_training(model) # 定义LoRA配置 lora_config = LoraConfig( r=8, # LoRA的秩（rank），越小参数量越少，但能力可能下降。常用8, 16, 32。 lora_alpha=32, # 缩放参数，通常设置为r的倍数。 target_modules=["q_proj", "k_proj", "v_proj", "dense"], # 针对Transformer的哪些层应用LoRA。不同模型结构名称不同，需要查阅。 lora_dropout=0.1, # Dropout概率，防止过拟合。 bias="none", # 是否训练偏置。 task_type=TaskType.CAUSAL_LM # 任务类型：因果语言模型。 ) # 将LoRA适配器应用到原模型上 model = get_peft_model(model, lora_config) model.print_trainable_parameters() # 打印可训练参数量

执行model.print_trainable_parameters()后，你会看到类似输出：

trainable params: 4,194,304 || all params: 2,776,381,952 || trainable%: 0.1510

这就是LoRA的魔力：一个近28亿参数的模型，只需要训练约419万个参数（占比0.15%），显存和计算需求骤降。

5.4 配置训练参数并启动微调

我们使用Hugging Face的TrainerAPI来简化训练循环。

# cell 6: 设置训练参数并创建Trainer from transformers import DataCollatorForLanguageModeling, TrainingArguments, Trainer # 数据收集器，用于动态padding（如果我们之前没用`padding='max_length'`，这个更有用） data_collator = DataCollatorForLanguageModeling( tokenizer=tokenizer, mlm=False, # 不是掩码语言模型，是因果LM ) # 定义训练参数 training_args = TrainingArguments( output_dir="./phi-2-lora-guanaco", # 输出目录 overwrite_output_dir=True, num_train_epochs=3, # 训练轮数，小数据集可适当增加 per_device_train_batch_size=2, # 根据你的GPU显存调整 per_device_eval_batch_size=2, gradient_accumulation_steps=4, # 梯度累积，模拟更大batch size warmup_steps=50, # 学习率预热步数 logging_steps=10, # 每10步打印一次日志 eval_steps=50, # 每50步评估一次 save_steps=200, # 每200步保存一次 evaluation_strategy="steps", # 按步评估 save_strategy="steps", load_best_model_at_end=True, # 训练结束后加载最佳模型 metric_for_best_model="eval_loss", greater_is_better=False, learning_rate=2e-4, # LoRA学习率通常可以设大一点 fp16=True, # 使用混合精度训练，节省显存 report_to="none", # 不报告给wandb等，本地运行 save_total_limit=2, # 只保留最后2个检查点 ) # 创建Trainer trainer = Trainer( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=eval_dataset, data_collator=data_collator, tokenizer=tokenizer, ) # 开始训练！ print("开始LoRA微调训练...") trainer.train() print("训练完成！")

训练过程会在Jupyter中输出日志，显示训练损失和评估损失下降。由于数据集很小，训练会很快完成。

6. 模型保存、加载与推理测试

训练完成后，我们需要保存LoRA权重，并学习如何加载它进行推理。

6.1 保存与加载LoRA适配器

# cell 7: 保存模型和LoRA适配器 # 保存完整的模型（包含基础模型和LoRA权重，便于直接加载推理） trainer.save_model("./phi-2-lora-guanaco-final") # 也可以单独保存LoRA适配器权重（更小，便于分享） model.save_pretrained("./phi-2-lora-adapters") print("模型已保存。") # 加载推理演示 print("\n--- 加载模型进行推理测试 ---") # 方法1：加载完整保存的模型 from peft import PeftModel # 重新加载基础模型（注意：要与训练时精度一致） base_model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, device_map="auto", trust_remote_code=True ) # 加载LoRA适配器并合并 lora_model = PeftModel.from_pretrained(base_model, "./phi-2-lora-adapters") lora_model = lora_model.merge_and_unload() # 将适配器权重合并到基础模型，提升推理速度 lora_model.to(device)

6.2 进行推理测试

让我们测试一下微调后的模型是否学会了对话格式。

# cell 8: 编写一个简单的对话生成函数 def generate_response(prompt, model, tokenizer, max_length=150): inputs = tokenizer(prompt, return_tensors="pt").to(device) with torch.no_grad(): outputs = model.generate( **inputs, max_new_tokens=max_length, do_sample=True, # 使用采样，使生成更丰富 temperature=0.7, # 温度参数，控制随机性 top_p=0.9, # 核采样参数 pad_token_id=tokenizer.eos_token_id ) response = tokenizer.decode(outputs[0], skip_special_tokens=True) # 只截取模型生成的部分（去掉输入提示） response = response[len(prompt):].strip() return response # 测试几个问题 test_prompts = [ "### Human: What is the capital of France?\n### Assistant:", "### Human: Explain the concept of recursion in programming.\n### Assistant:", "### Human: Write a short poem about coding.\n### Assistant:", ] print("微调后模型回答测试：") for prompt in test_prompts: print(f"\n输入: {prompt}") answer = generate_response(prompt, lora_model, tokenizer) print(f"回答: {answer}") print("-" * 50)

观察输出，你会发现模型已经能够按照### Human:和### Assistant:的格式进行回答，并且答案的质量相比原始预训练模型（如果直接问，可能不会遵循指令格式）有所提升。这就是指令微调的效果。

7. 模型量化与手机端部署前瞻

让模型能在手机端运行的关键一步是模型量化。量化将模型参数的精度从FP16降低到INT8甚至INT4，大幅减少模型体积和内存占用，同时推理速度也能提升。

7.1 使用bitsandbytes进行4-bit量化加载

我们可以在加载基础模型时就进行量化，这样LoRA微调和推理都能在量化模型上进行，极大节省显存。

# cell 9: 使用4-bit量化重新加载基础模型并进行LoRA微调（可选，资源紧张时使用） from transformers import BitsAndBytesConfig # 配置4-bit量化 bnb_config = BitsAndBytesConfig( load_in_4bit=True, # 加载4-bit量化模型 bnb_4bit_quant_type="nf4", # 量化类型 bnb_4bit_compute_dtype=torch.float16, # 计算时仍用FP16 bnb_4bit_use_double_quant=True, # 双重量化，进一步压缩 ) # 加载量化后的基础模型 quantized_base_model = AutoModelForCausalLM.from_pretrained( model_name, quantization_config=bnb_config, device_map="auto", trust_remote_code=True ) # 同样应用LoRA配置 quantized_model = get_peft_model(quantized_base_model, lora_config) quantized_model.print_trainable_parameters() # 之后可以用quantized_model替换之前的model进行训练，步骤完全一样。 # 注意：量化训练对超参更敏感，学习率可能需要调整。

7.2 模型导出为手机端可用的格式

要将模型部署到手机（iOS/Android），通常需要将其转换为特定框架的格式。ONNX和MNN是常见的选择。这里以导出到ONNX为例：

# cell 10: 将PyTorch模型导出为ONNX格式（简化示例） import os import onnx from pathlib import Path # 确保模型在eval模式且合并了LoRA权重 lora_model.eval() # 创建一个示例输入 dummy_input = tokenizer("Hello, how are you?", return_tensors="pt").input_ids.to(device) # 定义输出路径 onnx_path = Path("./onnx_model") onnx_path.mkdir(exist_ok=True) onnx_model_path = onnx_path / "phi2_lora.onnx" # 导出模型（这是一个简化示例，实际需要处理动态轴等复杂情况） torch.onnx.export( lora_model, (dummy_input,), onnx_model_path, input_names=["input_ids"], output_names=["logits"], dynamic_axes={ "input_ids": {0: "batch_size", 1: "sequence_length"}, "logits": {0: "batch_size", 1: "sequence_length"} }, opset_version=14, # 使用合适的ONNX opset do_constant_folding=True, ) print(f"模型已导出至: {onnx_model_path}") print(f"ONNX模型大小: {os.path.getsize(onnx_model_path) / (1024**2):.2f} MB") # 可以进行简单的正确性验证 import onnxruntime as ort import numpy as np ort_session = ort.InferenceSession(str(onnx_model_path)) onnx_inputs = {"input_ids": dummy_input.cpu().numpy()} onnx_outputs = ort_session.run(None, onnx_inputs) print("ONNX推理完成，输出shape:", onnx_outputs[0].shape)

注意：将大语言模型完整导出到移动端并实现高效推理是一个复杂的工程问题，涉及：

1. 序列生成逻辑：ONNX通常只导出单步前向计算，外层的token生成循环（如beam search）需要在端侧用C++/Java等实现。
2. 运行时优化：需要使用ONNX Runtime Mobile、MNN、TFLite等针对移动端优化的推理引擎。
3. 内存与速度权衡：需要测试不同量化精度（INT8, FP16）在目标设备上的表现。

本文完成了从PyTorch到ONNX的导出，为后续移动端集成提供了基础模型文件。完整的端到端部署需要结合具体的移动端推理框架进行开发。

8. 常见问题与排查思路（Q&A）

在实际操作中，你几乎一定会遇到下面这些问题。

9. 最佳实践与工程化建议

当你掌握了基本流程后，以下建议能帮助你做得更专业、更高效。

1. 数据质量高于数据数量：对于指令微调，1000条高质量、多样化的指令-回答对，远胜于10万条低质、重复的数据。精心设计和清洗你的数据集。
2. 超参数调优：LoRA的r（秩）和alpha是关键。从小开始（如r=8, alpha=32），如果欠拟合再增大。学习率通常比全参数微调大（1e-4到5e-4）。
3. 使用W&B或TensorBoard监控：将TrainingArguments中的report_to=”wandb”并登录，可以可视化训练过程，方便调试。
4. 分阶段训练：可以先在较大通用指令集上微调，再在垂直领域小数据集上进一步微调，这通常比一次性混合训练效果更好。
5. 模型评估：不要只看损失。设计一个小的测试集，用人眼或使用GPT-4等大模型作为裁判，评估生成结果的相关性、信息量和安全性。
6. 版本控制：对代码、数据集版本、模型检查点进行严格的版本控制。推荐使用DVC或MLflow管理数据和模型。
7. 安全与责任：微调后的模型可能继承或放大基座模型的偏见，也可能在指令遵循上产生意外输出。在部署前，务必进行全面的安全性和偏见测试。
8. 移动端部署优化：
   • 选择性量化：对模型的不同部分（如Embedding, LM Head）采用不同的量化策略。
   • 算子融合：利用推理引擎（如MNN）的图优化能力，融合操作以减少计算和内存访问。
   • 缓存(KV Cache)优化：对于自回归生成，有效管理Key-Value缓存是提升速度的关键。

通过本文的“手撕”流程，你不仅跑通了一个技术Demo，更重要的是建立了一套从预训练模型理解、LoRA微调实践到模型轻量化导出的完整认知框架和实操能力。这个流程是通用的，你可以轻松地将基座模型从phi-2替换为Llama-3-8B、Qwen-7B，将数据集从guanaco替换为你自己的业务数据，从而创造出满足特定需求的智能助手。

真正的价值不在于复现这个例子，而在于利用这个脚手架，去解决你实际遇到的数据、领域和部署问题。建议你下一步尝试使用更大的模型、更复杂的数据集，并深入研究移动端推理引擎（如ONNX Runtime, MNN, TFLite）的集成，最终打造出真正可用的端侧AI应用。