边缘计算：客户端 + 人工智能

àì夳堔傛蜴生んèń 2022-09-05 05:59 286阅读 0赞

![e4938e5b60bdce7f79c0be5b71cbbd38.png][]

有人说人工智能会是继互联网之后的下一次工业革命，不可否认，大到汽车、小到手表，AI技术已经广泛应用在我们周围，随便一个APP都试图跟AI发生点关系以证明自己的与时俱进。

AI的普及为客户端开发带来了挑战，同时也是机遇。挑战在于客户端技术相对于AI等新兴技术正被逐渐边缘化；机遇在于移动设备仍将长期作为连接AI与用户的重要载体，随着硬件能力逐升级，移动端甚至可以自主完成一些机器学习和推理，让用户更快捷地享受到AI的带来的便利。

# 边缘计算（Edge AI）的意义 #

“模型” 是对一组训练数据应用机器学习算法而得到的结果。使用模型对一些输入的数据进行预测的过程叫“推理”。有很多依靠编写代码仅能低效甚至很难完成的任务，使用模型推理能更好地完成。例如，可以训练模型来归类照片，或者识别照片内的特定对象等。

长久以来，模型推理大多运行在服务端，客户端只作为结果展示的载体。但随着移动端的硬件性能越来越高，很多深度学习的数据模型可以以二进制形式下载到手机上，基于这些模型可以进行端上的AI处理，“边缘计算”的概念由此诞生，边缘计算有以下好处

*  数据本地化，解决云端存储及隐私问题；
 *  计算本地化，解决云端计算过载问题；
 *  低通信成本，解决交互和体验问题；
 *  去中心化计算，故障规避与极致个性化。

![a4ce46c810148b4f379dfa8f75c53bf8.png][]

#### 边缘计算的技术现状 ####

严格来说，边缘AI（Edge AI）是边缘计算的一个方向，边缘AI等能力主要借助移动端的机器学习（Machine Learning，后文简称ML）库实现。

移动端的KL库主要服务于模型下发和移动端推理引擎的执行，由于移动端的计算能力相对较弱，模型文件不宜过大，需要进行一些裁剪和压缩。目前主流的ML库有**Tensorflow Lite**、**PyTorch Mobile**、**MediaPipe**、**Firebase ML Kit**等，本文就这些技术做一个简单的介绍，帮大家扩大技术视野。

# TensorFlow Lite #

> https://www.tensorflow.org/lite/guide

TensorFlow Lite 是将 TensorFlow 用于移动设备和嵌入式设备的轻量级解决方案，可以在Android、iOS以及其他嵌入式系统上使用。 借由 **TensorFlow Lite Converter** 将模型转化的压缩后的格式`.tflite`。**TFLite Converter** 提供 Python和 CLI 工具，推荐使用Python API。

下面代码是通过 TFLite Converter 将 `tensorflow` 和 `tf.keras` 的模型文件转换为 TFLite 格式的模型

import tensorflow as tf
    
    # 转换 saved_model
    converter = tf.lite.TFLiteConverter.from_saved_model(export_dir)
    tflite_model = converter.convert()
    with open('model.tflite', 'wb') as f:
        f.write(tflite_model)
    
    # 转换 keras_model
    keras_model = tf.keras.models.load_model(filepath)
    converter = tf.lite.TFLiteConverter.from_keras_model(keras_model)
    keras_tflite_model = converter.convert()
    with open('keras_model.tflite', 'wb') as f:
        f.write(keras_tflite_model)

![f4e3fcffec61424f34c600f9a861ad2a.png][]

转换后的模型文件可以通过 TFLite 下载到手机上使用。 以 Android 为例，代码如下：

class TFLiteActivity : AppCompatActivity() { 
        /* 模型下载 */
        private fun initializeTFLite(device: String = "NNAPI", numThreads: Int = 4) { 
            val delegate = when (device) { 
                "NNAPI" -> NnApiDelegate()
                "GPU" -> GpuDelegate()
                "CPU" -> "" }
            if (delegate != "") tfliteOptions.addDelegate(delegate)
    
            tfliteOptions.setNumThreads(numThreads)
            tfliteModel = FileUtil.loadMappedFile(this, tflite_model_path)
            tfliteInterpreter = Interpreter(tfliteModel, tfliteOptions)
            inputImageBuffer = TensorImage(tfliteInterpreter.getInputTensor(0).dataType())
            outputProbabilityBuffer = TensorBuffer.createFixedSize(
                tfliteInterpreter.getOutputTensor(0).shape(),
                tfliteInterpreter.getInputTensor(0).dataType())
    
            probabilityProcessor = TensorProcessor .Builder()
                .add(NormalizeOp(0.0f, 1.0f))
                .build()
        }
    
        /* 处理处理 */
        @WorkerThread
        override fun analyzeImage(image: ImageProxy, rotationDegrees: Int): Map<String, Float> { 
            val bitmap = Utils.imageToBitmap(image)
            val cropSize = Math.min(bitmap.width, bitmap.height)
            inputImageBuffer.load(bitmap)
            val inputImage = ImageProcessor .Builder()
                .add(ResizeWithCropOrPadOp(cropSize, cropSize))
                .add(ResizeOp(224, 224, ResizeMethod.NEAREST_NEIGHBOR))
                .add(NormalizeOp(127.5f, 127.5f))
                .build()
                .process(inputImageBuffer)
    
            tfliteInterpreter.run(inputImage!!.buffer, outputProbabilityBuffer.buffer.rewind())
            val labeledProbability: Map<String, Float> = TensorLabel(
                labelsList, probabilityProcessor.process(outputProbabilityBuffer)
            ).mapWithFloatValue
            return labeledProbability
        }
    }

TFLite 的 API 非常易用，即使没有太多的客户端开发经验也可以驾驭。

# PyTorch Mobile #

> https://pytorch.org/mobile/home/

Facebook 于 19 年底发布了 PyTorch Mobile， 以 PyTorch 的移动端解决方案。PyTorch Mobile将 Pytorchscript 的模型进行 JIT 编译为 `.pt` 格式的文件。2020年，PyTorch Developer Day 宣布开始支持 Android 的 NNAPI 和 iOS 的 MetalAPI。

![c9a8566ae25c127ce24b5cab676b7166.png][]

PyTorch 中使用 `torch.jit.trace` 处理模型转换

import torch
    import torchvision
    
    model = torchvision.models.resnet18(pretrained=True)
    model.eval()
    example = torch.rand(1, 3, 224, 224)
    traced_script_module = torch.jit.trace(model, example)
    traced_script_module.save("model.pt")

![35a84f6e88d526ffdea0e8dbd262b2eb.png][]

经转换的模型可以在 Android 和 iOS 中加载。 以 Android 为例，代码如下：

class PyTorchActivity : AppCompatActivity() { 
        /* 模型下载 */
        private fun initializePyTorch() { 
            val pytorchModule = Module.load(Utils.assetFilePath(
                this,
                pytorch_mobile_model_path))
            val mInputTensorBuffer = Tensor.allocateFloatBuffer(3 * 224 * 224)
            val mInputTensor = Tensor.fromBlob(
                mInputTensorBuffer,
                longArrayOf(1, 3, 224L, 224L)
            )
        }
    
        /* 模型处理 */
        @WorkerThread
        override fun analyzeImage(image: ImageProxy, rotationDegrees: Int): Map<String, Float> { 
            TensorImageUtils.imageYUV420CenterCropToFloatBuffer(
                image.image,
                rotationDegrees,
                224,
                224,
                TensorImageUtils.TORCHVISION_NORM_MEAN_RGB,
                TensorImageUtils.TORCHVISION_NORM_STD_RGB,
                mInputTensorBuffer,
                0
            )
            val outputModule = pytorchModule.forward(IValue.from(mInputTensor)).toTensor()
            val scores = outputModule.dataAsFloatArray
            val labeledProbability: MutableMap<String, Float> = mutableMapOf()
            for (i in 0 until labelsList.size - 1) { 
                labeledProbability[labelsList[i + 1]] = score[i]
            }
            return labeledProbability
        }
    }

# MediaPipe #

> https://google.github.io/mediapipe/

MediaPipe 与 Tensorflow Lite 和 PyTorch Mobile 不同，并不是从已有的深度学习库派生出来的。MediaPipe 专注于计算机视觉和多媒体处理的 ML管道框架，在2019年6月举行的 CVPR 大会，MeidaPipe 正式开源，版本是v0.5.0。自那以后，谷歌陆续发布了一系列的ML管道示例。MediaPipe 为 Android 、 iOS 等多平台提供了人脸、物体检测、动作捕捉等能力。

MediaPipe 图形库可以通过 bazel 编译成供 Androd端使用的 `.aar` 或者 iOS 的 `.ipa`

# MediaPipe graph that performs face mesh with TensorFlow Lite on GPU.
    
    # GPU buffer. (GpuBuffer)
    input_stream: "input_video"
    
    # Output image with rendered results. (GpuBuffer)
    output_stream: "output_video"
    # Detected faces. (std::vector<Detection>)
    output_stream: "face_detections"
    
    # Throttles the images flowing downstream for flow control. It passes through
    # the very first incoming image unaltered, and waits for downstream nodes
    # (calculators and subgraphs) in the graph to finish their tasks before it
    # passes through another image. All images that come in while waiting are
    # dropped, limiting the number of in-flight images in most part of the graph to
    # 1. This prevents the downstream nodes from queuing up incoming images and data
    # excessively, which leads to increased latency and memory usage, unwanted in
    # real-time mobile applications. It also eliminates unnecessarily computation,
    # e.g., the output produced by a node may get dropped downstream if the
    # subsequent nodes are still busy processing previous inputs.
    node { 
      calculator: "FlowLimiterCalculator"
      input_stream: "input_video"
      input_stream: "FINISHED:output_video"
      input_stream_info: { 
        tag_index: "FINISHED"
        back_edge: true
      }
      output_stream: "throttled_input_video"
    }
    
    # Subgraph that detects faces.
    node { 
      calculator: "FaceDetectionFrontGpu"
      input_stream: "IMAGE:throttled_input_video"
      output_stream: "DETECTIONS:face_detections"
    }
    
    # Converts the detections to drawing primitives for annotation overlay.
    node { 
      calculator: "DetectionsToRenderDataCalculator"
      input_stream: "DETECTIONS:face_detections"
      output_stream: "RENDER_DATA:render_data"
      node_options: { 
        [type.googleapis.com/mediapipe.DetectionsToRenderDataCalculatorOptions] { 
          thickness: 4.0
          color {  r: 255 g: 0 b: 0 }
        }
      }
    }
    
    # Draws annotations and overlays them on top of the input images.
    node { 
      calculator: "AnnotationOverlayCalculator"
      input_stream: "IMAGE_GPU:throttled_input_video"
      input_stream: "render_data"
      output_stream: "IMAGE_GPU:output_video"
    }

![a9e1b751c6af43a7dfbe571223115895.png][]

上面是人脸识别的处理过程， 经历了图像输入、人脸检测、特征点绘制等一系列过程，这也正好是 MediaPipe 的特点，不只是简单的ML推理，而是可以将输入、前处理、推理、后处理，输出等一系列流程进行组合编排。

# Firebase ML Kit #

> https://firebase.google.com/docs/ml

Firebase 由 Google 提供支持，基于 Google Mobile Service 的移动开放平台，为移动开发这提供了 APM、埋点等功能，ML Kit 是 Firebase 功能的面向移动端的机器学习库， 面向 Android/iOS 提供模型的分发、推理、学习、日志收集等能力。目前只支持 Tensorflow Lite 格式的模型。

![1ac1068c0b3e8b199bdbc5ddd2067864.png][]

例如使用 ML Kit 识别图片中的物体，代码如下：

private class ObjectDetection : ImageAnalysis.Analyzer { 
        val options = FirebaseVisionObjectDetectorOptions.Builder()
            .setDetectorMode(FirebaseVisionObjectDetectorOptions.STREAM_MODE)
            .enableClassification()
            .build()
        val objectDetector = FirebaseVision.getInstance().getOnDeviceObjectDetector(options)
    
        private fun degreesToFirebaseRotation(degrees: Int): Int = when(degrees) { 
            0 -> FirebaseVisionImageMetadata.ROTATION_0
            90 -> FirebaseVisionImageMetadata.ROTATION_90
            180 -> FirebaseVisionImageMetadata.ROTATION_180
            270 -> FirebaseVisionImageMetadata.ROTATION_270
            else -> throw Exception("Rotation must be 0, 90, 180, or 270.")
        }
    
        override fun analyze(imageProxy: ImageProxy?, degrees: Int) { 
            val mediaImage = imageProxy?.image
            val imageRotation = degreesToFirebaseRotation(degrees)
            if (mediaImage != null) { 
                val image = FirebaseVisionImage.fromMediaImage(mediaImage, imageRotation)
                objectDetector.processImage(image)
                        .addOnSuccessListener {  detectedObjects ->
                            for (obj in detectedObjects) { 
                                val id = obj.trackingId
                                val bounds = obj.boundingBox
                                val category = obj.classificationCategory
                                val confidence = obj.classificationConfidence
                                // Do Something
                            }
                        }
                        .addOnFailureListener {  e ->
                            // Do Something
                        }
            }
        }
    }

上面介绍的ML库都需要下发推理引擎到客户端，其实 Android、iOS 也有自带的推理引擎

# iOS (Core ML) #

> https://developer.apple.com/cn/documentation/coreml/  
> iOS提供了

iOS 提供 CoreML ，可以将各种机器学习模型集成到应用中，并进行推理。CoreML不仅支持TFLite格式的模型，还支持 ONNX、Pytorch、XGBoost、Scikit-learn 等其他模型格式。这些模型通过 coremltools 转换为 CoreML 专用格式后加载到本地。iPhone 搭载了专用的神经网络处理器，可以低功耗地进行模型推理。想用iOS进行机器学习的话，CoreML是一个好选择。

![83cc3c1474aa8f55a3d45906acf02563.png][]

![2b05dfcf837b57e9da08fb04cdadac7f.png][]

# Android (NNAPI) #

> https://developer.android.com/ndk/guides/neuralnetworks

Android 端提供了 NNAPI（Android Neural Networks API）用于模型推理。NNAPI 是 Android 8.1（API等级27）以后提供的专门处理机械学习的 Native 库。NNAPI 会根据手机当前的硬件性能、负荷状况等，将处理跑在特定设备上（GPU、DSP、专用处理器），当然也可以统一交由 CPU 执行。

![2f1ca92a3132c03a468ccc5be7abb7cc.png][]

# Web端 #

#### Tensorflow.js ####

> https://www.tensorflow.org/js

浏览器也可以进行机器学习和推理。Web浏览器中进行AI计算的主要语言是Javascript， 使用的ML库是Tensorflow.js。学习和推理都要在浏览器执行，相对于Android 、 iOS 来说性能不找优势，但是通过 WebGL 和 WASM 的辅助，也可以相对高效地完成计算，满足Web端需求

tf.keras 和 saved model 可以转换为 tensorflow.js 可处理的json格式，其中包含了神经网络结构和权重。整个转换通过 `tensorflowjs_converter` 进行

# saved_model转换
    tensorflowjs_converter \
        --input_format=tf_saved_model \
        --output_node_names='MobilenetV1/Predictions/Reshape_1' \
        --saved_model_tags=serve \
        /mobilenet/saved_model \
        /mobilenet/web_model
    
    # Keras_model変換
    tensorflowjs_converter \
        --input_format keras \
        path/to/my_model.h5 \
        path/to/tfjs_target_dir

tensorflow.js 可以嵌入到 html 中使用，代码如下：

当然也可以在js中使用

import * as tf from "@tensorflow/tfjs";
    
    import {  IMAGENET_CLASSES } from "./imagenet_classes";
    
    const MOBILENET_MODEL_PATH =
      "https://storage.googleapis.com/tfjs-models/tfjs/mobilenet_v1_0.25_224/model.json";
    
    const IMAGE_SIZE = 224;
    const TOPK_PREDICTIONS = 10;
    
    let mobilenet;
    const mobilenetDemo = async () => { 
      status("Loading model...");
    
      mobilenet = await tf.loadLayersModel(MOBILENET_MODEL_PATH);
      mobilenet.predict(tf.zeros([1, IMAGE_SIZE, IMAGE_SIZE, 3])).dispose();
    
      status("");
    
      const catElement = document.getElementById("cat");
      if (catElement.complete && catElement.naturalHeight !== 0) { 
        predict(catElement);
        catElement.style.display = "";
      } else { 
        catElement.onload = () => { 
          predict(catElement);
          catElement.style.display = "";
        };
      }
    };
    
    async function predict(imgElement) { 
      status("Predicting...");
      const logits = tf.tidy(() => { 
        const img = tf.browser.fromPixels(imgElement).toFloat();
    
        const offset = tf.scalar(127.5);
    
        const normalized = img.sub(offset).div(offset);
    
        const batched = normalized.reshape([1, IMAGE_SIZE, IMAGE_SIZE, 3]);
    
        return mobilenet.predict(batched);
      });
    }

#### ml5.js ####

> https://learn.ml5js.org/\#/

ml5.js 是对 tensorflow.js 的封装，它的 API 更加简单易懂，适合机器学习初学者使用。在ml5.js中 提供了图像、语言、声音等媒体中频繁使用的分类、转换API，API风格更加符合 Javascript 的习惯。

下面是使用 ml5.js 进行推理的代码示例：

let classifier;
    
    let img;
    
    function preload() { 
      classifier = ml5.imageClassifier("MobileNet");
      img = loadImage("images/bird.png");
    }
    
    function setup() { 
      createCanvas(400, 400);
      classifier.classify(img, gotResult);
      image(img, 0, 0);
    }
    
    function gotResult(error, results) { 
      if (error) { 
        console.error(error);
      } else { 
        console.log(results);
        createDiv(`Label: ${ results[0].label}`);
        createDiv(`Confidence: ${ nf(results[0].confidence, 0, 2)}`);
      }
    }

# 模型压缩 #

前文提到过，模型压缩更利于端上进行推理，最后介绍几种常见的模型压缩方法：

*  参数量化（Parameter Quantization）
 *  网络剪枝（Network Pruning）
 *  知识蒸馏（Knowledge Distillation）

#### 量化（Quantization） ####

量化就是使用更少的bits来表示一个参数。例如在创建模型的时候使用32位浮点数进行学习，在进行推理之前，将其转化为16位、8位、甚至1位（boolean）。通过减少模型体积降低了计算量。当然量化会导致精度的劣化，有可能使计算产生偏差，这也是一种面向性能的妥协。

![f7c6395b801370652bfe3243c666e6ca.png][]

#### 剪枝（Pruning） ####

神经网络中的一些冗余的权重和神经元是可以被剪枝的，因为这些权重较低或者神经元的输出大多数时候为零。通过删除这些内容可以减轻模型的重量。另外通过共享的手段，在多个节点之间共享权重，也可以减少模型的容量。跟量化一样，删除一些权重可能导致精读劣化。

![8e097649e508ff369d4f7117a96286f3.png][]

#### 蒸馏（Distillation） ####

蒸馏是通过在学习方法上下功夫来提高压缩模型精度的方法。

蒸馏现以高精度的大容量模型进行学习，以大容量模型的推理结果作为特征参考，参与轻量模型的计算中，以提高准确率。由于大容量模型的推理结果是一个标签的概率分布，所以轻量模型从标签的概率中学习各个数据标签的相似性。例如，有一张猫的画像，分布在猫60%、狗30%、兔子10%的情况下，猫的图像是猫：狗：兔子=6:3:1的特征。

![4f7a746736be623ea131c7278e5436d9.png][]

# 总结 #

我们在学习计算机组成原理的时候知道一个常识是，CPU 的运力是过剩的，但硬件的性能瓶颈受制于内存和主线的速度。如果把 Cloud 比作CPU，那么连接云/端的网络就是内存和总线。4G网络条件下，云/端巨大的通信开销使得计算的实时性较差。即使到了5G时代，传输速度虽然大大提升，但是过多的链接又会造成“CPU”的高负荷。因此人们急需找到一种适合云端协同环境下的AI处理方案。

[e4938e5b60bdce7f79c0be5b71cbbd38.png]: /images/20220829/9d6e31f5f8ea44cb889112d794a4fcde.png
[a4ce46c810148b4f379dfa8f75c53bf8.png]: /images/20220829/073e9352637348e6ac0a0abc50e53d18.png
[f4e3fcffec61424f34c600f9a861ad2a.png]: /images/20220829/ce927c0a107f4fe8b2839325fd0f35aa.png
[c9a8566ae25c127ce24b5cab676b7166.png]: /images/20220829/6e50288c1805429fa7e4c591d902bc61.png
[35a84f6e88d526ffdea0e8dbd262b2eb.png]: /images/20220829/26b1fdb288504dc19a3d9e2cdecfb9ac.png
[a9e1b751c6af43a7dfbe571223115895.png]: /images/20220829/985b22b4755048a99789f6100795bc66.png
[1ac1068c0b3e8b199bdbc5ddd2067864.png]: /images/20220829/ce03cb4e9eee49ae9642e5fdaa5ab661.png
[83cc3c1474aa8f55a3d45906acf02563.png]: /images/20220829/94fc251cb070468b91ca44007e911183.png
[2b05dfcf837b57e9da08fb04cdadac7f.png]: /images/20220829/7e9cb8e6237f423183d8bb734cda47bb.png
[2f1ca92a3132c03a468ccc5be7abb7cc.png]: /images/20220829/3b941f78bf8147cd891c3f388b1059af.png
[f7c6395b801370652bfe3243c666e6ca.png]: /images/20220829/da994899b1b145b28c78846e1d0b7709.png
[8e097649e508ff369d4f7117a96286f3.png]: /images/20220829/1ca02ef042ea449bb351c7596601753a.png
[4f7a746736be623ea131c7278e5436d9.png]: /images/20220829/e2fbfc2dd97244478af70ac124a66fc2.png