跳至主要內容

边缘AI部署：在IoT设备上运行轻量化AI模型

老张2026/8/1大约 17 分钟边缘AIIoT轻量化模型ONNXJava边缘计算

边缘AI部署：在IoT设备上运行轻量化AI模型

3秒与50毫秒的差距

2025年8月，广东某汽车零部件工厂的总工程师刘伟坐在质检车间里，盯着一块屏幕上的延迟数字：3,247ms。

这是他们用云端AI做零件表面缺陷检测的平均响应时间。生产线的节拍是每8秒一个零件，3秒多的检测延迟意味着什么？意味着检测结果出来时，生产线已经走了3-4个零件，一旦发现问题，需要回溯排查。

更糟糕的是，工厂的网络并不稳定。连接到云端的专线有时会出现500ms甚至数秒的抖动，导致检测服务时断时续。有一次因为网络中断，30分钟内流出了约200个可能存在缺陷的零件，损失了一批高精度航空件订单，价值约87万元。

刘伟的团队做了一个决定：把AI模型"搬"到工厂的边缘设备上。

6周后，部署在工控机上的轻量化AI模型上线了。检测延迟：47ms。网络问题：不再依赖网络。准确率：从云端的94.2%提升到96.8%（因为边缘模型是在工厂自己的数据上专门训练的）。

这篇文章，带你完整实现一套边缘AI部署方案。

边缘AI vs 云端AI：延迟/隐私/成本的权衡

全景对比

维度云端AI边缘AI
延迟50ms - 数秒（含网络）5-100ms（本地推理）
网络依赖强依赖不依赖（可完全离线）
数据隐私数据上传云端数据不离开设备
模型更新实时（API调用最新版本）需要推送更新
计算成本按调用付费一次性硬件投入
模型能力无限（服务器算力）受设备算力限制
维护复杂度低较高

适合边缘AI的场景

轻量化模型：MobileNet、DistilBERT、TinyLlama

在边缘设备上，不可能直接运行GPT-4这样的大模型。需要选择专门为边缘设计的轻量化模型。

视觉模型（适合图像/视频任务）

模型大小Top-1精度(ImageNet)推理速度(RPi4)
MobileNetV3-Small2.5MB67.4%12ms
MobileNetV3-Large5.4MB75.2%25ms
EfficientNet-B020MB77.1%55ms
EfficientNet-Lite014MB75.1%35ms
YOLOv8n（检测）6MBmAP50 37.3%40ms

文本模型（适合NLP任务）

模型大小性能（相对BERT）推理速度(CPU)
DistilBERT-base65MB97%60ms
TinyBERT-4L14MB96.8%25ms
MobileBERT25MB99.2%40ms
TinyLlama-1.1B-Q4637MB-500ms(CPU)

工厂质检场景的模型选择

刘伟团队最终选择了EfficientNet-Lite0 + ONNX Runtime的方案：

选择理由：
1. 模型大小14MB，适合工控机存储限制
2. EfficientNet在工业缺陷检测上精度优于MobileNet
3. ONNX Runtime支持Java调用，与现有Java工控系统集成
4. 在工控机（Intel Atom x7）上推理延迟约35ms，满足要求

模型量化：INT8/INT4压缩模型体积

量化（Quantization）是将模型权重从32位浮点（FP32）压缩到更低精度（INT8/INT4）的技术。

量化效果对比

精度模型大小精度损失推理速度提升
FP32（原始）100%0%1×
FP16（半精度）50%<0.1%1.5-2×
INT8（8位整数）25%0.5-1%2-4×
INT4（4位整数）12.5%1-3%3-5×

使用ONNX量化

# quantize_model.py - 将模型量化为INT8
import onnx
from onnxruntime.quantization import quantize_dynamic, QuantType

# 原始ONNX模型
input_model_path = "efficientnet_lite0.onnx"

# INT8动态量化
output_model_path = "efficientnet_lite0_int8.onnx"
quantize_dynamic(
    model_input=input_model_path,
    model_output=output_model_path,
    weight_type=QuantType.QInt8,
    per_channel=False,  # 工控CPU建议False，性能更好
    reduce_range=False
)

# 对比模型大小
import os
original_size = os.path.getsize(input_model_path) / 1024 / 1024
quantized_size = os.path.getsize(output_model_path) / 1024 / 1024
print(f"原始模型: {original_size:.1f} MB")
print(f"量化模型: {quantized_size:.1f} MB")
print(f"压缩比: {original_size/quantized_size:.1f}x")

# 输出示例：
# 原始模型: 18.3 MB
# 量化模型: 4.7 MB
# 压缩比: 3.9x

ONNX格式：模型的跨平台部署标准

ONNX（Open Neural Network Exchange）是微软和Facebook共同推出的开放式神经网络交换格式，支持PyTorch/TensorFlow/Keras等主流框架导出，并通过ONNX Runtime在几乎所有平台上高效运行。

模型转换流程

PyTorch模型转ONNX

# export_to_onnx.py
import torch
import torchvision.models as models

# 加载你的自定义模型（或使用预训练模型）
model = models.efficientnet_b0(pretrained=False)
model.classifier[1] = torch.nn.Linear(1280, 2)  # 二分类：良品/缺陷品
model.load_state_dict(torch.load("defect_detector.pth"))
model.eval()

# 创建示例输入
dummy_input = torch.randn(1, 3, 224, 224)  # batch=1, RGB, 224×224

# 导出为ONNX
torch.onnx.export(
    model,
    dummy_input,
    "defect_detector.onnx",
    export_params=True,
    opset_version=17,          # 使用较新的opset，兼容性更好
    do_constant_folding=True,  # 常量折叠优化
    input_names=["input"],
    output_names=["output"],
    dynamic_axes={
        "input": {0: "batch_size"},    # 支持动态批次
        "output": {0: "batch_size"}
    }
)

# 验证导出的模型
import onnx
model_onnx = onnx.load("defect_detector.onnx")
onnx.checker.check_model(model_onnx)
print("ONNX模型验证通过")
print(f"模型大小: {os.path.getsize('defect_detector.onnx')/1024/1024:.1f} MB")

Java调用ONNX模型：ONNX Runtime Java API

这是本文的核心代码部分——如何在Java中高效调用ONNX模型。

Maven依赖

<dependencies>
    <!-- ONNX Runtime Java API -->
    <dependency>
        <groupId>com.microsoft.onnxruntime</groupId>
        <artifactId>onnxruntime</artifactId>
        <version>1.19.2</version>
    </dependency>

    <!-- 图像处理 -->
    <dependency>
        <groupId>org.openpnp</groupId>
        <artifactId>opencv</artifactId>
        <version>4.9.0-0</version>
    </dependency>

    <!-- Spring Boot -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

核心推理引擎

package com.laozhang.edge.inference;

import ai.onnxruntime.*;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.nio.FloatBuffer;
import java.nio.file.Path;
import java.util.*;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * ONNX推理引擎
 * 线程安全，支持会话池化以提高并发推理能力
 */
@Component
public class OnnxInferenceEngine {

    private static final int SESSION_POOL_SIZE = 4;  // 并发推理会话数
    private static final String MODEL_PATH = "/opt/edge-ai/models/defect_detector_int8.onnx";

    private OrtEnvironment environment;
    private final ConcurrentLinkedQueue<OrtSession> sessionPool = new ConcurrentLinkedQueue<>();
    private OrtSession.SessionOptions sessionOptions;

    @PostConstruct
    public void initialize() throws OrtException {
        environment = OrtEnvironment.getEnvironment();

        sessionOptions = new OrtSession.SessionOptions();

        // 性能优化选项
        sessionOptions.setIntraOpNumThreads(2);         // 单个推理使用的线程数
        sessionOptions.setInterOpNumThreads(1);         // 算子间并行线程数
        sessionOptions.setOptimizationLevel(
            OrtSession.SessionOptions.OptLevel.ALL_OPT  // 最大优化
        );

        // 如果有GPU，启用CUDA（工控机通常没有GPU，用CPU）
        // sessionOptions.addCUDA(0);

        // 针对Intel CPU的OpenVINO加速（工控机常见）
        // sessionOptions.addOpenVINO("CPU");

        // 创建会话池
        for (int i = 0; i < SESSION_POOL_SIZE; i++) {
            sessionPool.add(environment.createSession(MODEL_PATH, sessionOptions));
        }

        System.out.println("ONNX推理引擎初始化完成，会话池大小：" + SESSION_POOL_SIZE);
        printModelInfo();
    }

    /**
     * 执行推理
     *
     * @param inputData  预处理后的输入张量数据（归一化后的float数组）
     * @param inputShape 输入形状 [batch, channels, height, width]
     * @return 推理结果
     */
    public InferenceResult infer(float[] inputData, long[] inputShape) throws OrtException {
        OrtSession session = borrowSession();
        try {
            long startNano = System.nanoTime();

            // 创建输入张量
            OnnxTensor inputTensor = OnnxTensor.createTensor(
                environment,
                FloatBuffer.wrap(inputData),
                inputShape
            );

            // 执行推理
            try (OrtSession.Result result = session.run(
                    Map.of("input", inputTensor))) {

                // 获取输出（分类概率）
                float[][] outputData = (float[][]) result.get(0).getValue();
                float[] probabilities = outputData[0];

                long endNano = System.nanoTime();
                long latencyMs = (endNano - startNano) / 1_000_000;

                return new InferenceResult(probabilities, latencyMs);
            } finally {
                inputTensor.close();
            }
        } finally {
            returnSession(session);
        }
    }

    /**
     * 批量推理（提高吞吐量）
     */
    public List<InferenceResult> inferBatch(List<float[]> inputBatch,
                                             long[] singleInputShape) throws OrtException {
        if (inputBatch.isEmpty()) return Collections.emptyList();

        int batchSize = inputBatch.size();
        int singleSize = inputBatch.get(0).length;

        // 合并为批量输入
        float[] batchData = new float[batchSize * singleSize];
        for (int i = 0; i < batchSize; i++) {
            System.arraycopy(inputBatch.get(i), 0, batchData, i * singleSize, singleSize);
        }

        // 构建批量shape
        long[] batchShape = new long[singleInputShape.length];
        batchShape[0] = batchSize;
        System.arraycopy(singleInputShape, 1, batchShape, 1, singleInputShape.length - 1);

        OrtSession session = borrowSession();
        try {
            long startNano = System.nanoTime();

            OnnxTensor inputTensor = OnnxTensor.createTensor(
                environment, FloatBuffer.wrap(batchData), batchShape);

            try (OrtSession.Result result = session.run(
                    Map.of("input", inputTensor))) {

                float[][] allProbabilities = (float[][]) result.get(0).getValue();
                long latencyMs = (System.nanoTime() - startNano) / 1_000_000;

                List<InferenceResult> results = new ArrayList<>();
                for (float[] probs : allProbabilities) {
                    results.add(new InferenceResult(probs, latencyMs / batchSize));
                }
                return results;
            } finally {
                inputTensor.close();
            }
        } finally {
            returnSession(session);
        }
    }

    private OrtSession borrowSession() {
        OrtSession session = sessionPool.poll();
        if (session == null) {
            // 池耗尽时等待（实际生产中应该有超时和告警）
            while ((session = sessionPool.poll()) == null) {
                Thread.yield();
            }
        }
        return session;
    }

    private void returnSession(OrtSession session) {
        sessionPool.offer(session);
    }

    private void printModelInfo() throws OrtException {
        OrtSession session = borrowSession();
        try {
            System.out.println("=== 模型信息 ===");
            session.getInputInfo().forEach((name, info) ->
                System.out.println("输入: " + name + " -> " + info));
            session.getOutputInfo().forEach((name, info) ->
                System.out.println("输出: " + name + " -> " + info));
        } finally {
            returnSession(session);
        }
    }

    @PreDestroy
    public void shutdown() {
        sessionPool.forEach(session -> {
            try { session.close(); } catch (OrtException e) { /* ignore */ }
        });
        try {
            if (sessionOptions != null) sessionOptions.close();
            if (environment != null) environment.close();
        } catch (OrtException e) { /* ignore */ }
        System.out.println("ONNX推理引擎已关闭");
    }

    /**
     * 推理结果
     */
    public record InferenceResult(float[] probabilities, long latencyMs) {
        public int predictedClass() {
            int maxIdx = 0;
            for (int i = 1; i < probabilities.length; i++) {
                if (probabilities[i] > probabilities[maxIdx]) maxIdx = i;
            }
            return maxIdx;
        }

        public float confidence() {
            return probabilities[predictedClass()];
        }
    }
}

图像预处理

package com.laozhang.edge.preprocessing;

import org.opencv.core.*;
import org.opencv.imgproc.Imgproc;
import org.opencv.imgcodecs.Imgcodecs;
import org.springframework.stereotype.Component;

/**
 * 工业图像预处理器
 * 将工业相机采集的图像转换为模型输入格式
 */
@Component
public class ImagePreprocessor {

    private static final int TARGET_HEIGHT = 224;
    private static final int TARGET_WIDTH = 224;

    // ImageNet标准化参数
    private static final float[] MEAN = {0.485f, 0.456f, 0.406f};
    private static final float[] STD  = {0.229f, 0.224f, 0.225f};

    static {
        // 加载OpenCV本地库
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }

    /**
     * 从文件路径预处理图像
     */
    public float[] preprocessFromFile(String imagePath) {
        Mat image = Imgcodecs.imread(imagePath);
        return preprocess(image);
    }

    /**
     * 从字节数组预处理图像（相机直接输出）
     */
    public float[] preprocessFromBytes(byte[] imageBytes) {
        Mat mat = new MatOfByte(imageBytes);
        Mat image = Imgcodecs.imdecode(mat, Imgcodecs.IMREAD_COLOR);
        return preprocess(image);
    }

    /**
     * 核心预处理流程
     * 步骤：BGR→RGB → 调整大小 → 归一化 → HWC→CHW格式转换
     */
    public float[] preprocess(Mat bgrImage) {
        // 1. BGR转RGB（OpenCV默认BGR，PyTorch模型需要RGB）
        Mat rgbImage = new Mat();
        Imgproc.cvtColor(bgrImage, rgbImage, Imgproc.COLOR_BGR2RGB);

        // 2. 调整到目标尺寸
        Mat resized = new Mat();
        Imgproc.resize(rgbImage, resized,
            new Size(TARGET_WIDTH, TARGET_HEIGHT),
            0, 0, Imgproc.INTER_LINEAR);

        // 3. 转换为float并归一化到[0,1]
        Mat floatMat = new Mat();
        resized.convertTo(floatMat, CvType.CV_32F, 1.0 / 255.0);

        // 4. 提取像素值并做ImageNet标准化
        float[] floatData = new float[(int) floatMat.total() * floatMat.channels()];
        floatMat.get(0, 0, floatData);

        // 5. 格式转换：HWC（高×宽×通道）→ CHW（通道×高×宽）
        // ONNX Runtime期望的输入格式
        float[] chwData = new float[3 * TARGET_HEIGHT * TARGET_WIDTH];
        int pixelCount = TARGET_HEIGHT * TARGET_WIDTH;

        for (int i = 0; i < pixelCount; i++) {
            for (int c = 0; c < 3; c++) {
                // 标准化：(pixel - mean) / std
                chwData[c * pixelCount + i] =
                    (floatData[i * 3 + c] - MEAN[c]) / STD[c];
            }
        }

        // 释放Mat资源
        rgbImage.release();
        resized.release();
        floatMat.release();

        return chwData;
    }

    /**
     * 工业场景特殊预处理：增强对比度，减少光照影响
     */
    public float[] preprocessWithEnhancement(Mat image) {
        // CLAHE对比度限制自适应直方图均衡化
        Mat labImage = new Mat();
        Imgproc.cvtColor(image, labImage, Imgproc.COLOR_BGR2Lab);

        List<Mat> channels = new ArrayList<>();
        Core.split(labImage, channels);

        CLAHE clahe = Imgproc.createCLAHE(2.0,
            new Size(8, 8));
        clahe.apply(channels.get(0), channels.get(0));

        Core.merge(channels, labImage);
        Imgproc.cvtColor(labImage, image, Imgproc.COLOR_Lab2BGR);

        return preprocess(image);
    }
}

完整的工厂质检服务

package com.laozhang.edge.service;

import com.laozhang.edge.inference.OnnxInferenceEngine;
import com.laozhang.edge.preprocessing.ImagePreprocessor;
import org.springframework.stereotype.Service;

import java.time.Instant;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 工厂零件质检服务
 * 集成图像采集、预处理、推理、结果上报的完整流程
 */
@Service
public class DefectDetectionService {

    private static final String[] CLASS_NAMES = {"良品", "缺陷品"};
    private static final float DEFECT_THRESHOLD = 0.85f;  // 缺陷判定阈值
    private static final long[] INPUT_SHAPE = {1, 3, 224, 224};

    private final OnnxInferenceEngine inferenceEngine;
    private final ImagePreprocessor imagePreprocessor;
    private final DefectAlertService alertService;
    private final MetricsCollector metricsCollector;

    // 统计数据
    private final AtomicLong totalInspected = new AtomicLong(0);
    private final AtomicLong totalDefects = new AtomicLong(0);
    private final AtomicLong totalLatencyMs = new AtomicLong(0);

    public DefectDetectionService(
            OnnxInferenceEngine inferenceEngine,
            ImagePreprocessor imagePreprocessor,
            DefectAlertService alertService,
            MetricsCollector metricsCollector) {
        this.inferenceEngine = inferenceEngine;
        this.imagePreprocessor = imagePreprocessor;
        this.alertService = alertService;
        this.metricsCollector = metricsCollector;
    }

    /**
     * 单件检测（同步，适合低速生产线）
     */
    public DetectionResult detectSingle(String imageSource, String partId) {
        long start = System.currentTimeMillis();

        try {
            // 1. 图像预处理
            float[] inputData = imagePreprocessor.preprocessFromFile(imageSource);

            // 2. ONNX推理
            OnnxInferenceEngine.InferenceResult inferResult =
                inferenceEngine.infer(inputData, INPUT_SHAPE);

            // 3. 解析结果
            int predictedClass = inferResult.predictedClass();
            float confidence = inferResult.confidence();
            boolean isDefect = (predictedClass == 1) && (confidence >= DEFECT_THRESHOLD);

            long latencyMs = System.currentTimeMillis() - start;

            // 4. 更新统计
            totalInspected.incrementAndGet();
            if (isDefect) totalDefects.incrementAndGet();
            totalLatencyMs.addAndGet(latencyMs);

            // 5. 缺陷告警
            if (isDefect) {
                alertService.sendDefectAlert(partId, confidence, imageSource);
            }

            // 6. 上报监控指标
            metricsCollector.record("detection.latency_ms", latencyMs);
            metricsCollector.record("detection.confidence", confidence);

            DetectionResult result = new DetectionResult(
                partId,
                isDefect ? DetectionStatus.DEFECT : DetectionStatus.OK,
                CLASS_NAMES[predictedClass],
                confidence,
                latencyMs,
                Instant.now()
            );

            System.out.printf("[质检] 零件=%s, 结果=%s, 置信度=%.1f%%, 耗时=%dms%n",
                partId, result.status(), confidence * 100, latencyMs);

            return result;

        } catch (Exception e) {
            long latencyMs = System.currentTimeMillis() - start;
            System.err.println("检测失败，零件=" + partId + ": " + e.getMessage());
            return new DetectionResult(partId, DetectionStatus.ERROR,
                "ERROR", 0, latencyMs, Instant.now());
        }
    }

    /**
     * 批量检测（异步，适合高速生产线）
     */
    public CompletableFuture<List<DetectionResult>> detectBatch(
            List<String> imageSources, List<String> partIds) {

        return CompletableFuture.supplyAsync(() -> {
            try {
                // 批量预处理
                List<float[]> batchInputs = new ArrayList<>();
                for (String source : imageSources) {
                    batchInputs.add(imagePreprocessor.preprocessFromFile(source));
                }

                // 批量推理
                List<OnnxInferenceEngine.InferenceResult> inferResults =
                    inferenceEngine.inferBatch(batchInputs, new long[]{3, 224, 224});

                // 解析批量结果
                List<DetectionResult> results = new ArrayList<>();
                for (int i = 0; i < inferResults.size(); i++) {
                    OnnxInferenceEngine.InferenceResult ir = inferResults.get(i);
                    boolean isDefect = ir.predictedClass() == 1
                        && ir.confidence() >= DEFECT_THRESHOLD;

                    results.add(new DetectionResult(
                        partIds.get(i),
                        isDefect ? DetectionStatus.DEFECT : DetectionStatus.OK,
                        CLASS_NAMES[ir.predictedClass()],
                        ir.confidence(),
                        ir.latencyMs(),
                        Instant.now()
                    ));
                }
                return results;

            } catch (Exception e) {
                throw new RuntimeException("批量检测失败", e);
            }
        });
    }

    /**
     * 获取实时统计数据
     */
    public InspectionStats getStats() {
        long total = totalInspected.get();
        long defects = totalDefects.get();
        double defectRate = total > 0 ? (double) defects / total : 0;
        double avgLatency = total > 0 ? (double) totalLatencyMs.get() / total : 0;

        return new InspectionStats(total, defects, defectRate, avgLatency);
    }

    public enum DetectionStatus { OK, DEFECT, ERROR }

    public record DetectionResult(
            String partId,
            DetectionStatus status,
            String className,
            float confidence,
            long latencyMs,
            Instant timestamp
    ) {}

    public record InspectionStats(
            long totalInspected,
            long totalDefects,
            double defectRate,
            double avgLatencyMs
    ) {}
}

REST API接口

package com.laozhang.edge.controller;

import com.laozhang.edge.service.DefectDetectionService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;

/**
 * 质检服务REST API
 * 供工控系统调用
 */
@RestController
@RequestMapping("/api/v1/detection")
public class DefectDetectionController {

    private final DefectDetectionService detectionService;

    public DefectDetectionController(DefectDetectionService detectionService) {
        this.detectionService = detectionService;
    }

    /**
     * 上传图片进行质检
     */
    @PostMapping("/inspect")
    public ResponseEntity<DefectDetectionService.DetectionResult> inspect(
            @RequestParam("image") MultipartFile imageFile,
            @RequestParam("partId") String partId) throws Exception {

        // 保存临时文件
        Path tempFile = Files.createTempFile("inspection_", ".jpg");
        imageFile.transferTo(tempFile);

        try {
            DefectDetectionService.DetectionResult result =
                detectionService.detectSingle(tempFile.toString(), partId);
            return ResponseEntity.ok(result);
        } finally {
            Files.deleteIfExists(tempFile);
        }
    }

    /**
     * 获取实时统计数据
     */
    @GetMapping("/stats")
    public ResponseEntity<DefectDetectionService.InspectionStats> getStats() {
        return ResponseEntity.ok(detectionService.getStats());
    }

    /**
     * 健康检查
     */
    @GetMapping("/health")
    public ResponseEntity<Map<String, Object>> health() {
        return ResponseEntity.ok(Map.of(
            "status", "UP",
            "model", "defect_detector_int8.onnx",
            "stats", detectionService.getStats()
        ));
    }
}

边缘设备选型

设备CPU内存价格推理延迟(EfficientNet)适用场景
树莓派4BCortex-A72 4核8GB¥500~150ms教学/低速场景
树莓派5Cortex-A76 4核8GB¥800~80ms轻量级工业
NVIDIA Jetson NanoARM+128-core GPU4GB¥1200~25msAI推理首选
NVIDIA Jetson OrinARM+1792-core GPU16GB¥8000~5ms高性能工业
工控机 Intel Atom x74核 2.0GHz8GB¥3000~45ms刘伟团队选择
工控机 Intel Core i56核 3.5GHz16GB¥6000~20ms高吞吐工业

刘伟团队的选择：工控机（Intel Atom x7），原因：

  1. 工厂已有工控机，无需额外采购
  2. 工业级可靠性（IP67防护，宽温工作）
  3. 45ms延迟满足要求
  4. Java生态成熟，与现有SCADA系统集成简单

云边协同：简单任务边缘处理，复杂任务上云

不是所有任务都适合在边缘处理。好的云边协同设计能让你在成本和性能之间找到最佳平衡。

package com.laozhang.edge.hybrid;

import org.springframework.stereotype.Service;

/**
 * 云边协同调度器
 * 根据任务复杂度和网络状态，智能路由到边缘或云端
 */
@Service
public class HybridInferenceRouter {

    private static final float EDGE_CONFIDENCE_THRESHOLD = 0.90f;
    private static final float CLOUD_CONFIDENCE_THRESHOLD = 0.60f;

    private final DefectDetectionService edgeService;     // 边缘推理
    private final CloudInferenceClient cloudClient;       // 云端推理
    private final NetworkMonitor networkMonitor;           // 网络状态监控
    private final LocalCacheQueue cacheQueue;              // 离线缓存队列

    public HybridInferenceRouter(
            DefectDetectionService edgeService,
            CloudInferenceClient cloudClient,
            NetworkMonitor networkMonitor,
            LocalCacheQueue cacheQueue) {
        this.edgeService = edgeService;
        this.cloudClient = cloudClient;
        this.networkMonitor = networkMonitor;
        this.cacheQueue = cacheQueue;
    }

    /**
     * 智能路由推理
     */
    public InferenceDecision route(String imageSource, String partId) {
        // Step 1: 先跑边缘推理（总是要跑）
        DefectDetectionService.DetectionResult edgeResult =
            edgeService.detectSingle(imageSource, partId);

        float confidence = edgeResult.confidence();
        InferenceRoute route;
        String finalDecision;

        if (confidence >= EDGE_CONFIDENCE_THRESHOLD) {
            // 高置信度：直接使用边缘结果
            route = InferenceRoute.EDGE_ONLY;
            finalDecision = edgeResult.className();

        } else if (confidence >= CLOUD_CONFIDENCE_THRESHOLD) {
            // 中等置信度：上传云端二次确认
            if (networkMonitor.isAvailable()) {
                CloudInferenceResult cloudResult = cloudClient.infer(imageSource);
                route = InferenceRoute.CLOUD_CONFIRMED;
                finalDecision = cloudResult.className();
            } else {
                // 网络不可用，暂用边缘结果并加入待确认队列
                cacheQueue.add(new PendingItem(imageSource, partId, edgeResult));
                route = InferenceRoute.EDGE_CACHED;
                finalDecision = edgeResult.className() + "[待云端确认]";
            }

        } else {
            // 低置信度：需要人工+云端联合判断
            if (networkMonitor.isAvailable()) {
                cloudClient.uploadForExpertReview(imageSource, partId, edgeResult);
            } else {
                cacheQueue.add(new PendingItem(imageSource, partId, edgeResult));
            }
            route = InferenceRoute.EXPERT_REVIEW;
            finalDecision = "待专家确认";
        }

        return new InferenceDecision(partId, finalDecision, confidence,
            edgeResult.latencyMs(), route);
    }

    public enum InferenceRoute {
        EDGE_ONLY,        // 仅边缘（高置信度）
        CLOUD_CONFIRMED,  // 云端确认（中等置信度+网络可用）
        EDGE_CACHED,      // 边缘缓存（中等置信度+网络不可用）
        EXPERT_REVIEW     // 专家审核（低置信度）
    }

    public record InferenceDecision(String partId, String decision,
                                     float confidence, long latencyMs,
                                     InferenceRoute route) {}
}

模型更新：如何远程更新边缘设备上的模型

package com.laozhang.edge.update;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.nio.file.*;
import java.security.MessageDigest;
import java.util.HexFormat;

/**
 * 边缘模型更新服务
 * 支持热更新，不中断生产线
 */
@Service
public class ModelUpdateService {

    private static final String MODEL_DIR = "/opt/edge-ai/models/";
    private static final String MODEL_FILENAME = "defect_detector_int8.onnx";
    private static final String UPDATE_SERVER = "http://model-registry.factory.local";

    private final OnnxInferenceEngine inferenceEngine;
    private final ModelRegistryClient registryClient;

    public ModelUpdateService(OnnxInferenceEngine inferenceEngine,
                               ModelRegistryClient registryClient) {
        this.inferenceEngine = inferenceEngine;
        this.registryClient = registryClient;
    }

    /**
     * 每小时检查模型更新
     */
    @Scheduled(fixedDelay = 3600_000)
    public void checkAndUpdate() {
        try {
            ModelMetadata remote = registryClient.getLatestModelMetadata("defect-detector");
            ModelMetadata local = getLocalModelMetadata();

            if (!remote.version().equals(local.version())) {
                System.out.println("发现新版本模型: " + remote.version() +
                    "（当前: " + local.version() + "）");
                performHotUpdate(remote);
            }
        } catch (Exception e) {
            System.err.println("模型更新检查失败: " + e.getMessage());
            // 不影响正常推理，只是跳过本次更新
        }
    }

    /**
     * 热更新流程：下载→验证→替换→重载
     * 整个过程中推理服务不中断
     */
    private void performHotUpdate(ModelMetadata newModel) throws Exception {
        String tempPath = MODEL_DIR + MODEL_FILENAME + ".tmp";
        String activePath = MODEL_DIR + MODEL_FILENAME;
        String backupPath = MODEL_DIR + MODEL_FILENAME + ".backup";

        // Step 1: 下载新模型到临时文件
        System.out.println("下载新模型...");
        registryClient.downloadModel(newModel.downloadUrl(), tempPath);

        // Step 2: 校验MD5
        String actualMd5 = calculateMd5(tempPath);
        if (!actualMd5.equals(newModel.md5())) {
            Files.deleteIfExists(Path.of(tempPath));
            throw new RuntimeException("模型文件MD5校验失败！");
        }
        System.out.println("MD5校验通过");

        // Step 3: 备份当前模型
        Files.copy(Path.of(activePath), Path.of(backupPath),
            StandardCopyOption.REPLACE_EXISTING);

        // Step 4: 原子替换
        Files.move(Path.of(tempPath), Path.of(activePath),
            StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);

        // Step 5: 热重载推理引擎
        System.out.println("热重载推理引擎...");
        inferenceEngine.reload(activePath);

        System.out.printf("模型更新成功: %s → %s%n",
            getLocalModelMetadata().version(), newModel.version());

        // Step 6: 清理备份
        Files.deleteIfExists(Path.of(backupPath));
    }

    private String calculateMd5(String filePath) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        md.update(Files.readAllBytes(Path.of(filePath)));
        return HexFormat.of().formatHex(md.digest());
    }

    private ModelMetadata getLocalModelMetadata() {
        // 从本地元数据文件读取
        return registryClient.loadLocalMetadata(MODEL_DIR + "metadata.json");
    }
}

实战效果数据

部署6个月后，刘伟团队的完整数据：

指标云端AI（部署前）边缘AI（部署后）变化
平均检测延迟3,247ms47ms-98.6%
延迟P998,100ms89ms-98.9%
年度可用性97.8%（网络依赖）99.97%（本地）+2.2%
漏检率5.8%3.2%-44.8%
误检率8.3%4.7%-43.4%
月均AI成本¥12,000¥1,200-90%
投诉事件（质量问题）7次/年0次/年-100%

FAQ

Q1：边缘AI适合用Java吗？不是Python更主流？

Java完全可以用于边缘AI推理，特别是通过ONNX Runtime Java API。优势：

  1. Java工控系统存量大，集成方便
  2. JVM内存管理比C++更安全
  3. Spring Boot提供完整的服务框架

Python更适合训练阶段，Java更适合工业系统集成。

Q2：ONNX Runtime Java和Python版本性能差异大吗？

实测差异在5-15%以内，对大多数工业场景来说可接受。如果对性能有极致要求，可以用JNI调用C++ ONNX Runtime，或者用Java调用Python微服务。

Q3：模型精度下降超过预期怎么办？

检查以下环节：

  1. 图像预处理是否与训练时一致（归一化参数、色彩空间）
  2. 量化类型是否合适（INT8 vs INT4）
  3. 训练数据是否覆盖了边缘环境的光照、角度等条件

Q4：边缘设备存储空间不足怎么处理？

  1. 使用更激进的量化（INT4）
  2. 模型剪枝（去除不重要的神经元）
  3. 知识蒸馏（用大模型训练小模型）
  4. 只保留最近N个模型版本

Q5：如何保证边缘设备的安全性？

  1. 模型文件加密存储
  2. 推理服务只监听内网端口
  3. 模型更新走加密通道（HTTPS+MD5校验）
  4. 定期安全审计

总结

边缘AI不是"把云端AI搬到设备上"这么简单，它是一整套工程体系：

刘伟团队的47ms延迟，是这6个环节精心打磨的结果，每一步都不能马虎。

行动清单：

  1. 确认你的场景是否适合边缘AI（延迟/网络/隐私三要素）
  2. 选择合适的轻量化模型（视觉选MobileNet/EfficientNet，文本选DistilBERT）
  3. 用ONNX Runtime Java API实现推理引擎
  4. 设计云边协同策略，不是非此即彼
  5. 实现自动更新机制，让模型可以持续迭代
编辑此页
最近更新:
贡献者: xiaozhangge