跳至主要內容

第1976篇：边缘计算与端侧AI——在用户设备上运行小模型的应用场景

老张2026/4/30大约 10 分钟

第1976篇：边缘计算与端侧AI——在用户设备上运行小模型的应用场景

有次参加一个 AI 产品的演示，对方产品经理说"我们的 AI 助手可以离线使用"。在场的工程师们互相交换了一个眼神——这句话背后涉及的技术栈，和"需要联网的 AI 助手"差距相当大。

端侧 AI 不是噱头，在某些场景下是刚需。今天把这个话题从工程角度讲清楚。

端侧 AI 的真实需求场景

我见过几类真实需求：

场景一：工厂质检。流水线上的相机实时检测产品缺陷，要求延迟在 50ms 以内，且工厂内网不通外网。用云端 AI 根本行不通。

场景二：医疗设备。某些医疗影像分析设备，数据不允许出设备（HIPAA 合规）。必须在设备本地跑模型。

场景三：军工/政府离线场景。物理隔离网络，根本没有互联网可用。

场景四：弱网/无网环境。农村地区、地铁隧道、出海船只。应用需要在无网络时也能提供 AI 能力。

场景五：隐私优先的消费产品。用户数据不想离开设备，比如手机上的私人日记 AI 助手。

理解清楚场景，才能选对技术方案。

端侧 AI 的技术栈全貌

模型选型：端侧能跑什么

端侧最核心的约束是内存和计算能力。我整理了一张实用的选型表：

设备类型可用内存推荐模型推理速度（tokens/s）
高端手机（骁龙8Gen3）8GB 可用约4GBQwen2.5-1.5B INT430-50
中端手机4GB 可用约2GBQwen2.5-0.5B INT415-25
M1/M2 MacBook8-16GB 统一内存Qwen2.5-7B INT480-120
工业边缘计算盒子（嵌入式）4-8GBQwen2.5-1.5B INT85-15
浏览器（WebAssembly）2-4GB 受限Phi-3-mini INT43-8

手机上 30-50 tokens/s 是什么概念？每秒输出 30-50 个汉字，用户阅读速度大概是 200-400 字/分钟，换算下来大约是 3-7 字/秒。所以 30 tokens/s 已经可以实时流式显示，用户感受不错。

量化技术：让大模型跑进小盒子

量化是端侧 AI 的核心技术。简单说就是把模型的浮点数精度降低，换取内存和计算量的大幅减少。

FP32：1个参数 4字节
FP16：1个参数 2字节  → 内存减半，精度轻微损失
INT8：1个参数 1字节  → 内存减75%，精度有损但可接受
INT4：1个参数 0.5字节→ 内存减87.5%，精度有损但小模型仍可用

Qwen2.5-7B 模型：

  • FP16：约 14GB
  • INT8：约 7GB
  • INT4：约 3.5GB → 可以在 MacBook M2 8GB 上跑了

用 llama.cpp 进行量化：

# 安装 llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make

# 将 HuggingFace 格式转为 GGUF
python convert_hf_to_gguf.py \
    /path/to/qwen2.5-7b-instruct \
    --outfile qwen2.5-7b.gguf \
    --outtype f16

# INT4 量化
./llama-quantize qwen2.5-7b.gguf qwen2.5-7b-q4_k_m.gguf Q4_K_M

# 测试推理
./llama-cli -m qwen2.5-7b-q4_k_m.gguf -p "你好" -n 100

Q4_K_M 是比较均衡的量化方案，比纯 Q4 质量好，又比 Q5 小。

Java 后端如何与端侧 AI 协作

等等，这里要转换一下思维。端侧 AI 运行在用户设备上，Java 后端服务怎么参与？

主要有两种模式：

模式一：端侧独立运行，后端仅同步数据

模式二：端云协同，按能力分工

Java 后端在这里的角色是：知识库管理、模型更新分发、用户数据同步、降级兜底。

Android 端侧 AI 接入实战

目前 Android 上跑本地 LLM，主流方案是 MLC-LLM 或 llama.cpp 的 JNI 绑定：

// Android 端的本地模型管理
public class LocalLLMManager {

    private static final String MODEL_FILE = "qwen2.5-1.5b-q4.bin";
    private long nativeHandle = 0;

    static {
        System.loadLibrary("llama");  // llama.cpp JNI 库
    }

    // JNI native 方法
    private native long initModel(String modelPath, int nThreads, int nCtx);
    private native String generateText(long handle, String prompt, int maxTokens, float temp);
    private native void destroyModel(long handle);

    public void initialize(Context context) throws IOException {
        // 从 assets 复制模型文件到内部存储
        File modelFile = new File(context.getFilesDir(), MODEL_FILE);
        if (!modelFile.exists()) {
            copyFromAssets(context, MODEL_FILE, modelFile);
        }

        // 初始化模型
        // nThreads: 推理线程数，建议设为 CPU 核数的一半
        // nCtx: 上下文窗口，越大越占内存
        nativeHandle = initModel(modelFile.getAbsolutePath(), 4, 2048);
        if (nativeHandle == 0) {
            throw new RuntimeException("模型加载失败");
        }
    }

    public String generate(String prompt, GenerateConfig config) {
        if (nativeHandle == 0) throw new IllegalStateException("模型未初始化");

        // 构建符合 Qwen 格式的 prompt
        String formattedPrompt = formatQwenPrompt(prompt, config.getSystemPrompt());

        return generateText(nativeHandle, formattedPrompt, config.getMaxTokens(), config.getTemperature());
    }

    private String formatQwenPrompt(String userMessage, String systemPrompt) {
        StringBuilder sb = new StringBuilder();
        sb.append("<|im_start|>system\n").append(systemPrompt).append("<|im_end|>\n");
        sb.append("<|im_start|>user\n").append(userMessage).append("<|im_end|>\n");
        sb.append("<|im_start|>assistant\n");
        return sb.toString();
    }

    private void copyFromAssets(Context context, String assetName, File dest) throws IOException {
        try (InputStream in = context.getAssets().open(assetName);
             FileOutputStream out = new FileOutputStream(dest)) {
            byte[] buffer = new byte[8192];
            int len;
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }
        }
    }

    @Override
    protected void finalize() {
        if (nativeHandle != 0) destroyModel(nativeHandle);
    }
}

流式推理（Android 上必须在后台线程）：

public class LocalChatViewModel extends ViewModel {

    private final LocalLLMManager llmManager;
    private final MutableLiveData<String> streamingOutput = new MutableLiveData<>();
    private final MutableLiveData<Boolean> isGenerating = new MutableLiveData<>(false);

    public void chat(String userMessage) {
        isGenerating.postValue(true);
        streamingOutput.postValue("");

        // 在 IO 线程推理
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(() -> {
            StringBuilder fullResponse = new StringBuilder();

            try {
                // 流式生成
                llmManager.generateStreaming(
                        userMessage,
                        token -> {
                            fullResponse.append(token);
                            // 实时更新 UI
                            streamingOutput.postValue(fullResponse.toString());
                        },
                        () -> {
                            // 生成完成
                            isGenerating.postValue(false);
                            saveToHistory(userMessage, fullResponse.toString());
                        }
                );
            } catch (Exception e) {
                isGenerating.postValue(false);
                // 降级到云端
                fallbackToCloud(userMessage);
            }
        });
    }

    private void fallbackToCloud(String message) {
        // 端侧推理失败，走云端 API
        cloudService.chat(message)
                .subscribe(
                        response -> streamingOutput.postValue(response),
                        error -> streamingOutput.postValue("服务暂时不可用，请稍后重试")
                );
    }
}

iOS 端侧 AI：Core ML 和 Metal 加速

iOS 上有 Apple Neural Engine 加持，推理速度比纯 CPU 快很多。主流方案是 Core ML：

虽然 iOS 原生用 Swift/ObjC 开发，但 Java 后端提供的 API 设计要配合它：

// Java 后端提供的模型分发 API
@RestController
@RequestMapping("/api/edge-model")
public class EdgeModelController {

    @Autowired
    private ModelVersionService modelVersionService;

    /**
     * 客户端检查是否有模型更新
     */
    @GetMapping("/check-update")
    public ModelVersionInfo checkUpdate(
            @RequestParam String deviceType,      // ios/android/embedded
            @RequestParam String currentVersion,
            @RequestHeader("X-Device-RAM") int deviceRam  // 设备可用内存(MB)
    ) {
        return modelVersionService.getRecommendedVersion(
                deviceType, currentVersion, deviceRam
        );
    }

    /**
     * 下载模型（支持断点续传）
     */
    @GetMapping("/download/{modelId}")
    public ResponseEntity<StreamingResponseBody> downloadModel(
            @PathVariable String modelId,
            @RequestHeader(value = "Range", required = false) String range
    ) {
        ModelFile modelFile = modelVersionService.getModelFile(modelId);

        StreamingResponseBody body = outputStream -> {
            try (InputStream in = modelFile.openStream()) {
                byte[] buffer = new byte[64 * 1024];  // 64KB chunks
                int len;
                while ((len = in.read(buffer)) != -1) {
                    outputStream.write(buffer, 0, len);
                    outputStream.flush();
                }
            }
        };

        return ResponseEntity.ok()
                .header("Content-Type", "application/octet-stream")
                .header("Content-Length", String.valueOf(modelFile.getSize()))
                .header("Accept-Ranges", "bytes")
                .body(body);
    }
}

模型更新分发的策略设计：

@Service
public class ModelVersionService {

    /**
     * 根据设备类型和内存，推荐合适的模型版本
     */
    public ModelVersionInfo getRecommendedVersion(
            String deviceType, String currentVersion, int availableRamMB) {

        // 根据内存选量化级别
        String quantization;
        if (availableRamMB >= 6000) {
            quantization = "Q8_0";    // 高质量
        } else if (availableRamMB >= 3000) {
            quantization = "Q4_K_M";  // 均衡
        } else {
            quantization = "Q4_0";    // 最小
        }

        // 根据设备类型选模型规模
        String modelSize = switch (deviceType) {
            case "ios", "android_high" -> "1.5b";
            case "android_mid" -> "0.5b";
            case "embedded" -> "0.5b";
            default -> "1.5b";
        };

        String recommendedVersion = "qwen2.5-" + modelSize + "-" + quantization;

        return ModelVersionInfo.builder()
                .currentVersion(currentVersion)
                .recommendedVersion(recommendedVersion)
                .hasUpdate(!currentVersion.equals(recommendedVersion))
                .downloadUrl("/api/edge-model/download/" + recommendedVersion)
                .fileSize(calculateFileSize(modelSize, quantization))
                .build();
    }
}

端云协同：离线优先架构

离线优先（Offline First）是端侧 AI 应用的核心设计理念：

// 这是 Android 端的逻辑，展示协同思路
public class OfflineFirstChatService {

    private final LocalLLMManager localLLM;
    private final RemoteChatApi remoteApi;
    private final NetworkStateMonitor networkMonitor;
    private final LocalDatabase localDb;

    public void chat(String message, ChatCallback callback) {
        boolean isOnline = networkMonitor.isConnected();

        if (!isOnline) {
            // 完全离线模式
            handleOfflineChat(message, callback);
            return;
        }

        // 在线时：根据任务复杂度决定
        if (isSimpleQuery(message)) {
            // 简单问题：本地模型，快速响应
            handleOfflineChat(message, callback);
            // 后台同步到服务器（用于历史记录）
            syncToServerAsync(message, null);
        } else {
            // 复杂问题：云端模型，质量更好
            remoteApi.chat(message)
                    .subscribe(
                            response -> {
                                callback.onComplete(response);
                                localDb.saveChat(message, response);
                            },
                            error -> {
                                // 云端失败，降级到本地
                                handleOfflineChat(message, callback);
                            }
                    );
        }
    }

    private boolean isSimpleQuery(String message) {
        return message.length() < 50
                || message.contains("你好")
                || message.contains("什么是")  // 简单定义类问题
                ;
    }

    private void handleOfflineChat(String message, ChatCallback callback) {
        // 先检查本地对话历史缓存
        Optional<String> cached = localDb.findSimilarAnswer(message);
        if (cached.isPresent()) {
            callback.onComplete(cached.get() + "\n（来自本地缓存）");
            return;
        }

        // 调用本地模型
        localLLM.generateStreaming(message,
                token -> callback.onToken(token),
                () -> callback.onDone()
        );
    }
}

边缘服务器：介于手机和云之间

还有一类场景是"边缘服务器"——不在用户手机上，但也不在中心云，而是在工厂车间、门店、基站旁边的小型服务器。这种设备通常有比手机更强的算力。

// 边缘服务器的 Spring Boot 配置
@Configuration
@ConditionalOnProperty(name = "deploy.type", havingValue = "edge")
public class EdgeDeploymentConfig {

    @Bean
    public ChatClient edgeChatClient() {
        // 边缘服务器上用 Ollama 本地部署
        OpenAiApi api = OpenAiApi.builder()
                .baseUrl("http://localhost:11434/v1")  // Ollama 默认端口
                .apiKey("ollama")
                .build();

        return ChatClient.builder(
                new OpenAiChatModel(api, OpenAiChatOptions.builder()
                        .model("qwen2.5:14b")  // 边缘服务器资源更多，可以跑14B
                        .build())
        ).build();
    }

    /**
     * 边缘节点心跳，上报到中心管理平台
     */
    @Scheduled(fixedRate = 30000)
    public void heartbeat() {
        EdgeNodeStatus status = EdgeNodeStatus.builder()
                .nodeId(System.getenv("EDGE_NODE_ID"))
                .cpuUsage(getSystemCpuUsage())
                .memoryUsage(getSystemMemoryUsage())
                .modelLoaded("qwen2.5:14b")
                .requestsLastMinute(requestCounter.getAndSet(0))
                .build();

        // 上报到中心管理节点（非敏感的运维数据可以出境）
        centralManagementApi.reportHeartbeat(status);
    }
}

知识更新：OTA 模型热更新

端侧 AI 的一个难题是知识更新。模型文件动辄几百 MB 到几 GB，每次更新全量下载不现实。常用方案是 LoRA 增量更新：

@Service
public class EdgeModelUpdateService {

    /**
     * 检查并下载 LoRA 增量更新
     * LoRA 文件通常只有几十 MB，远小于全量模型
     */
    public void checkAndApplyLoRAUpdate(String deviceId, String baseModelVersion) {
        // 获取适用于当前设备的 LoRA 更新列表
        List<LoRAUpdate> updates = updateRepository.findAvailableUpdates(
                deviceId, baseModelVersion
        );

        if (updates.isEmpty()) {
            log.info("设备 {} 已是最新", deviceId);
            return;
        }

        for (LoRAUpdate update : updates) {
            // 下载 LoRA 权重（几十 MB）
            downloadLoRA(update);
            log.info("设备 {} 应用 LoRA 更新: {}", deviceId, update.getName());
        }
    }
}

踩过的坑

坑一：模型首次加载时间太长。7B INT4 模型在手机上冷启动要 10-30 秒，用户体验很差。解决方案是在应用启动时后台预热，或者只在 WiFi 下初始化模型。

坑二：推理时温度升高导致手机降频。持续推理几分钟后，手机发热，CPU/NPU 降频，推理速度掉一半。需要限制单次生成长度，避免连续长时间推理。

坑三：不同设备量化效果差异大。同样是 INT4 量化，在高端骁龙芯片上很流畅，在某些联发科芯片上因为 NPU 指令集不同，反而更慢。要对主流设备型号做专项测试。

坑四：知识截止日期问题。端侧模型的知识是固定的，对时效性要求高的问题必须提示用户"离线模式，信息可能过时"。

小结

端侧 AI 不是银弹，但在特定场景下是唯一选择。几个关键判断标准：

  • 如果业务有网络隔离要求，端侧是刚需
  • 如果需要极低延迟（< 100ms），考虑本地边缘推理
  • 如果业务有大量简单、重复的 AI 请求，端侧可以显著降低云端成本
  • 如果设备内存 < 2GB，目前技术上还比较勉强，等模型再小一点

Java 后端工程师在端侧 AI 体系里的角色，主要是：设计好端云协同协议、做好模型分发和版本管理、构建好降级和容错机制。

编辑此页
最近更新:
贡献者: xiaozhangge