端侧大模型实践 - 生成预测模型&模型轻量化&端侧部署

为避免模型训练中出现内存异常，先临时增加交换内存：

1. # 1. 先关闭旧的交换文件（如果之前创建过1GB的）
2. swapoff /swapfile || true
3. rm -rf /swapfile || true
5. # 2. 创建4GB交换文件（bs=1M表示每个块1MB，count=4096表示4096个块=4GB）
6. dd if=/dev/zero of=/swapfile bs=1M count=4096
8. # 3. 设置文件权限（仅root可访问，安全要求）
9. chmod 600 /swapfile
11. # 4. 格式化交换文件
12. mkswap /swapfile
14. # 5. 启用交换文件
15. swapon /swapfile
17. # 6. 验证是否生效（查看Swap列，应该显示4.0Gi）
18. free -h

复制代码

编写模型训练代码：

1. import paddle
2. import os
3. import random
4. from paddlenlp.transformers import ErnieTokenizer, ErnieForSequenceClassification
5. from paddlenlp.data import Stack, Tuple, Pad
6. from paddle.io import DataLoader, BatchSampler, Dataset
8. # 核心配置：强制CPU + 最小化内存占用
9. paddle.set_device("cpu")
10. paddle.disable_static()
11. paddle.set_default_dtype("float32")  # 降低精度减少内存
13. # 1. 极简数据集类（降低内存波动）
14. class SimpleDataset(Dataset):
15.     def __init__(self, data):
16.         self.data = data
17.    
18.     def __getitem__(self, idx):
19.         return self.data[idx]
20.    
21.     def __len__(self):
22.         return len(self.data)
24. # 仅保留3条核心数据，避免内存占用
25. raw_data = [
26.     ("我的订单怎么还没发货", 0),
27.     ("申请退款多久到账", 1),
28.     ("产品保质期多久", 2)
29. ]
30. train_dataset = SimpleDataset(raw_data)
31. print(f"加载极简训练数据，共 {len(train_dataset)} 条")
33. # 2. 初始化模型和分词器（忽略权重警告）
34. tokenizer = ErnieTokenizer.from_pretrained("ernie-3.0-mini-zh")
35. model = ErnieForSequenceClassification.from_pretrained(
36.     "ernie-3.0-mini-zh",
37.     num_classes=3,
38.     ignore_mismatched_sizes=True  # 关闭权重不匹配警告
39. )
41. # 3. 数据预处理（最短文本长度，减少张量大小）
42. def convert_example(example):
43.     text, label = example
44.     inputs = tokenizer(
45.         text,
46.         max_len=16,  # 最短文本长度
47.         padding="max_length",
48.         truncation=True,
49.         return_length=False
50.     )
51.     return inputs["input_ids"], inputs["token_type_ids"], label
53. # 提前预处理所有数据，避免加载器中重复计算
54. processed_data = [convert_example(example) for example in train_dataset]
55. train_dataset = SimpleDataset(processed_data)
57. # 4. 数据加载器（批量大小=1，关闭多线程）
58. batchify_fn = lambda samples, fn=Tuple(
59.     Pad(axis=0, pad_val=tokenizer.pad_token_id),
60.     Pad(axis=0, pad_val=tokenizer.pad_token_type_id),
61.     Stack(dtype="int64")
62. ): fn(samples)
64. # 精细化批次控制，最低内存占用
65. sampler = BatchSampler(train_dataset, batch_size=1, shuffle=True)
66. train_loader = DataLoader(
67.     dataset=train_dataset,
68.     batch_sampler=sampler,
69.     collate_fn=batchify_fn,
70.     num_workers=0  # 关闭多线程，避免内存泄漏
71. )
73. # 5. 训练配置（极简优化器，降低内存）
74. model.train()
75. # SGD优化器内存占用远低于Adam
76. optimizer = paddle.optimizer.SGD(learning_rate=1e-3, parameters=model.parameters())
77. loss_fn = paddle.nn.CrossEntropyLoss()
79. # 6. 训练循环（修复no_grad错误，极简逻辑）
80. epochs = 1
81. total_loss = 0.0
82. batch_count = 0
84. print(f"开始训练 Epoch 1/{epochs}")
85. for batch in train_loader:
86.     input_ids, token_type_ids, labels = batch
87.    
88.     # 核心修复：删除错误的paddle.no_grad(False)，训练需要梯度
89.     logits = model(input_ids, token_type_ids)
90.     loss = loss_fn(logits, labels)
91.    
92.     # 反向传播 + 优化
93.     loss.backward()
94.     optimizer.step()
95.     optimizer.clear_grad()
96.    
97.     # 记录损失
98.     total_loss += loss.numpy()[0]
99.     batch_count += 1
100.     print(f"Batch {batch_count} 训练完成，损失：{loss.numpy()[0]:.4f}")
102. # 7. 保存模型（仅保存必要文件）
103. model_dir = "./ernie_demo_model_light"
104. os.makedirs(model_dir, exist_ok=True)
105. model.save_pretrained(model_dir, save_config=False)
106. tokenizer.save_pretrained(model_dir)
108. # 最终输出
109. avg_loss = total_loss / batch_count if batch_count > 0 else 0
110. print("\n==== 训练完全完成 ====")
111. print(f"模型保存路径：{os.path.abspath(model_dir)}")
112. print(f"总训练批次：{batch_count}，平均损失：{avg_loss:.4f}")
113. print("提示：权重警告是正常现象，模型已成功训练并保存！")

复制代码

训练记录如下：

验证模型训练结果，创建 validate_model.py 文件，命令：

1. nano /root/validate_model.py

复制代码

代码：

1. import paddle
2. from paddlenlp.transformers import ErnieTokenizer
4. # 核心配置：和训练时保持一致
5. paddle.set_device("cpu")
6. paddle.disable_static()
8. # 1. 加载训练好的模型和分词器
9. # 模型路径：和训练时保存的路径一致（ernie_demo_model_light）
10. model_path = "./ernie_demo_model_light"
11. # 加载分词器
12. tokenizer = ErnieTokenizer.from_pretrained(model_path)
13. # 加载模型（和训练时的模型结构一致）
14. from paddlenlp.transformers import ErnieForSequenceClassification
15. model = ErnieForSequenceClassification.from_pretrained(
16.     model_path,
17.     num_classes=3,
18.     ignore_mismatched_sizes=True
19. )
20. # 切换到评估模式（禁用Dropout等训练层）
21. model.eval()
23. # 2. 定义标签映射（数字→中文，方便查看）
24. label_map = {0: "物流咨询", 1: "退款咨询", 2: "产品咨询"}
26. # 3. 定义验证函数（输入文本，输出分类结果）
27. def predict(text):
28.     # 预处理文本（和训练时的逻辑完全一致）
29.     inputs = tokenizer(
30.         text,
31.         max_len=16,
32.         padding="max_length",
33.         truncation=True,
34.         return_length=False
35.     )
36.     # 转换为Paddle张量
37.     input_ids = paddle.to_tensor([inputs["input_ids"]], dtype="int64")
38.     token_type_ids = paddle.to_tensor([inputs["token_type_ids"]], dtype="int64")
39.    
40.     # 模型推理（禁用梯度计算，节省内存）
41.     with paddle.no_grad():
42.         logits = model(input_ids, token_type_ids)
43.         # 获取概率最大的标签
44.         pred_label = paddle.argmax(logits, axis=1).numpy()[0]
45.    
46.     # 返回直观结果
47.     return label_map[pred_label]
49. # 4. 验证新文本（选3条未参与训练的文本）
50. test_texts = [
51.     "快递到哪了？",       # 预期：物流咨询
52.     "退款多久能到账？",   # 预期：退款咨询
53.     "产品怎么使用？"      # 预期：产品咨询
54. ]
56. # 5. 执行验证并打印结果
57. print("==== 模型验证结果 ====")
58. for text in test_texts:
59.     result = predict(text)
60.     print(f"输入文本：{text}")
61.     print(f"模型分类结果：{result}\n"):

复制代码

验证有问题，但至少跑通了（不过虽然结果不对，这里也先不做追究，因为是要跑通流程，针对细节暂时不关注）

因为默认训练后的模型是动态图模型，需要输出静态图模型和移动端模型：

1. import paddle
2. import os
3. from paddlelite.lite import *
4. from paddlenlp.transformers import ErnieForSequenceClassification
6. # ====================== 配置项（关键修正：匹配实际分类数）=====================
7. # 动态图模型路径（你的ernie_demo_model_light）
8. DYNAMIC_MODEL_PATH = "./ernie_demo_model_light"
9. # 静态图模型保存路径
10. STATIC_MODEL_PATH = "./ernie_demo_static/model"
11. # 移动端模型输出路径
12. MOBILE_MODEL_PATH = "./ernie_mobile_model"
13. # 关键修正：改为实际的分类数（从报错看是3分类）
14. NUM_CLASSES = 3  # 原代码是2，现在改成3，匹配模型参数
15. # ====================================================
17. def dynamic2static():
18.     """第一步：动态图转静态图"""
19.     # 1. 加载训练好的动态图模型
20.     # 关键：ignore_mismatched_sizes=True 兼容可能的维度问题（兜底）
21.     model = ErnieForSequenceClassification.from_pretrained(
22.         DYNAMIC_MODEL_PATH,
23.         num_classes=NUM_CLASSES,
24.         ignore_mismatched_sizes=True  # 新增：忽略参数维度不匹配（防止漏改分类数）
25.     )
26.     model.eval()  # 必须切换到评估模式
27.    
28.     # 2. 定义输入规格（和模型输入匹配）
29.     input_spec = [
30.         paddle.static.InputSpec(shape=[None, None], dtype="int64", name="input_ids"),
31.         paddle.static.InputSpec(shape=[None, None], dtype="int64", name="token_type_ids")
32.     ]
33.    
34.     # 3. 导出静态图模型（生成.pdmodel和.pdiparams）
35.     paddle.jit.save(
36.         layer=model,
37.         path=STATIC_MODEL_PATH,
38.         input_spec=input_spec
39.     )
40.     print(f"✅ 静态图模型已生成：")
41.     print(f"   - {STATIC_MODEL_PATH}.pdmodel")
42.     print(f"   - {STATIC_MODEL_PATH}.pdiparams")
44. def static2mobile():
45.     """第二步：静态图转移动端模型"""
46.     # 1. 检查静态图文件是否存在
47.     model_file = f"{STATIC_MODEL_PATH}.pdmodel"
48.     param_file = f"{STATIC_MODEL_PATH}.pdiparams"
49.     if not os.path.exists(model_file) or not os.path.exists(param_file):
50.         raise FileNotFoundError("静态图模型文件不存在，请先运行dynamic2static()")
51.    
52.     # 2. 初始化Paddle Lite优化器
53.     opt = Opt()
54.     opt.set_model_file(model_file)
55.     opt.set_param_file(param_file)
56.    
57.     # 3. 设置移动端适配参数（ARM架构，手机通用）
58.     opt.set_valid_places("arm")
59.     opt.set_model_type("naive_buffer")  # 移动端轻量化格式
60.    
61.     # 4. 设置输出路径并执行优化
62.     opt.set_optimize_out(MOBILE_MODEL_PATH)
63.     opt.run()
64.    
65.     print(f"\n✅ 移动端模型已生成：{MOBILE_MODEL_PATH}.nb")
66.     print("   该文件可直接用于Android/iOS端部署")
68. # 主执行逻辑
69. if __name__ == "__main__":
70.     # 动态图→静态图→移动端模型
71.     dynamic2static()
72.     static2mobile()

复制代码

使用paddle.lite执行端上模型预测：

1. package com.baidu.paddle.lite;
3. import android.content.Context;
4. import android.util.Log;
6. import com.baidu.paddle.lite.MobileConfig;
7. import com.baidu.paddle.lite.PaddlePredictor;
8. import com.baidu.paddle.lite.Tensor;
10. import java.io.File;
11. import java.io.FileOutputStream;
12. import java.io.InputStream;
13. import java.nio.FloatBuffer;
15. /**
16. * Paddle Lite 模型管理类
17. * 负责模型加载、预测、资源释放
18. */
19. public class PaddleLiteManager {
21.     private static final String TAG = "PaddleLiteManager";
22.     // 模型文件名（请确保与assets中的文件完全一致，包括.nb后缀）
23.     private static final String MODEL_FILE_NAME = "ernie_mobile_model.nb";
24.     // 输入张量名称（根据你的模型实际输入名修改，可通过Paddle Lite工具查看）
25.     private static final String INPUT_TENSOR_NAME = "input";
26.     // 输出张量名称（根据你的模型实际输出名修改）
27.     private static final String OUTPUT_TENSOR_NAME = "output";
29.     private Context mContext;
30.     private PaddlePredictor mPredictor; // 预测器实例
31.     private boolean isInitSuccess = false; // 初始化状态
33.     public PaddleLiteManager(Context context) {
34.         this.mContext = context.getApplicationContext();
35.     }
37.     /**
38.      * 初始化预测器（核心：解决模型文件找不到的问题）
39.      */
40.     public boolean initPredictor() {
41.         try {
42.             // 1. 将assets中的模型文件复制到应用内部存储（避免assets路径访问限制）
43.             File modelFile = copyAssetFileToInternalStorage(MODEL_FILE_NAME);
44.             if (modelFile == null || !modelFile.exists()) {
45.                 Log.e(TAG, "模型文件复制失败或不存在：" + (modelFile != null ? modelFile.getAbsolutePath() : "null"));
46.                 return false;
47.             }
48.             Log.d(TAG, "模型文件路径：" + modelFile.getAbsolutePath());
50.             // 2. 配置MobileConfig
51.             MobileConfig config = new MobileConfig();
52.             config.setModelFromFile(modelFile.getAbsolutePath()); // 使用绝对路径加载
53.             config.setThreads(4); // 设置线程数（根据设备调整）
54. //            config.setPowerMode(MobileConfig.PowerMode.LITE_POWER_HIGH); // 高性能模式
55.             // 可选：设置精度模式（根据需求选择）
56.             // config.setPrecisionMode(MobileConfig.PrecisionMode.LITE_PRECISION_FP32);
58.             // 3. 创建预测器
59.             mPredictor = PaddlePredictor.createPaddlePredictor(config);
60.             if (mPredictor == null) {
61.                 Log.e(TAG, "预测器创建失败");
62.                 return false;
63.             }
65.             isInitSuccess = true;
66.             Log.d(TAG, "模型初始化成功！");
67.             return true;
69.         } catch (Exception e) {
70.             Log.e(TAG, "初始化预测器异常：", e);
71.             isInitSuccess = false;
72.             return false;
73.         }
74.     }
76.     /**
77.      * 执行预测（示例：输入float数组，返回输出结果）
78.      * @param inputData 输入数据（需与模型输入形状匹配，示例：[1, 128]的float数组）
79.      * @param inputShape 输入形状（示例：new long[]{1, 128}）
80.      * @return 输出结果float数组，失败返回null
81.      */
82.     public float[] runPredict(float[] inputData, long[] inputShape) {
83.         if (!isInitSuccess || mPredictor == null) {
84.             Log.e(TAG, "预测器未初始化成功，无法执行预测");
85.             return null;
86.         }
88.         try {
89.             // 1. 获取输入张量
90.             Tensor inputTensor = mPredictor.getInput(0);
91.             if (inputTensor == null) {
92.                 Log.e(TAG, "获取输入张量失败，张量名：" + INPUT_TENSOR_NAME);
93.                 return null;
94.             }
96.             // 2. 设置输入形状和数据
97.             inputTensor.resize(inputShape);
98.             inputTensor.setData(inputData);
100.             // 3. 执行预测
101.             long startTime = System.currentTimeMillis();
102.             boolean predictResult = mPredictor.run();
103.             long endTime = System.currentTimeMillis();
104.             Log.d(TAG, "预测耗时：" + (endTime - startTime) + "ms");
106.             if (!predictResult) {
107.                 Log.e(TAG, "预测执行失败");
108.                 return null;
109.             }
111.             // 4. 获取输出张量
112.             Tensor outputTensor = mPredictor.getOutput(0);
113.             if (outputTensor == null) {
114.                 Log.e(TAG, "获取输出张量失败，张量名：" + OUTPUT_TENSOR_NAME);
115.                 return null;
116.             }
118.             // 5. 读取输出数据
119. //            float[] outputBuffer = outputTensor.getByteData();
120. //            float[] outputData = new float[outputBuffer.remaining()];
121. //            outputBuffer.get(outputData);
123.             Log.d(TAG, "预测成功，输出数据长度：" + outputTensor.getFloatData().length);
124.             return outputTensor.getFloatData();
126.         } catch (Exception e) {
127.             Log.e(TAG, "预测过程异常：", e);
128.             return null;
129.         }
130.     }
132.     /**
133.      * 释放资源
134.      */
135.     public void release() {
136.         if (mPredictor != null) {
137. //            mPredictor.close();
138.             mPredictor = null;
139.         }
140.         isInitSuccess = false;
141.         Log.d(TAG, "预测器资源已释放");
142.     }
144.     /**
145.      * 将assets中的文件复制到应用内部存储
146.      * @param fileName assets中的文件名
147.      * @return 复制后的文件，失败返回null
148.      */
149.     private File copyAssetFileToInternalStorage(String fileName) {
150.         InputStream inputStream = null;
151.         FileOutputStream outputStream = null;
152.         try {
153.             // 目标文件路径：/data/data/com.baidu.paddle.lite/files/xxx.nb
154.             File destFile = new File(mContext.getFilesDir(), fileName);
156.             // 如果文件已存在，直接返回
157.             if (destFile.exists()) {
158.                 Log.d(TAG, "模型文件已存在，无需重复复制：" + destFile.getAbsolutePath());
159.                 return destFile;
160.             }
162.             // 从assets读取文件
163.             inputStream = mContext.getAssets().open(fileName);
164.             outputStream = new FileOutputStream(destFile);
166.             // 复制文件
167.             byte[] buffer = new byte[1024 * 4]; // 4KB缓冲区
168.             int bytesRead;
169.             while ((bytesRead = inputStream.read(buffer)) != -1) {
170.                 outputStream.write(buffer, 0, bytesRead);
171.             }
173.             outputStream.flush();
174.             Log.d(TAG, "模型文件复制成功：" + destFile.getAbsolutePath());
175.             return destFile;
177.         } catch (Exception e) {
178.             Log.e(TAG, "复制assets文件失败：", e);
179.             return null;
180.         } finally {
181.             // 关闭流
182.             try {
183.                 if (inputStream != null) inputStream.close();
184.                 if (outputStream != null) outputStream.close();
185.             } catch (Exception e) {
186.                 Log.e(TAG, "关闭流异常：", e);
187.             }
188.         }
189.     }
191.     /**
192.      * 获取初始化状态
193.      */
194.     public boolean isInitSuccess() {
195.         return isInitSuccess;
196.     }
197. }

复制代码

至此，我们就跑完了从端模型的初步探索：跑通了 Hadoop → Spark → 大模型轻量化 → 端侧部署 全流程Demo

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

分享、互助 让互联网精神温暖你我

东西不错很实用谢谢分享