边缘计算：客户端 + 人工智能
有人说人工智能会是继互联网之后的下一次工业革命，不可否认，大到汽车、小到手表，AI技术已经广泛应用在我们周围，随便一个APP都试图跟AI发生点关系以证明自己的与时俱进。
AI的普及为客户端开发带来了挑战，同时也是机遇。挑战在于客户端技术相对于AI等新兴技术正被逐渐边缘化；机遇在于移动设备仍将长期作为连接AI与用户的重要载体，随着硬件能力逐升级，移动端甚至可以自主完成一些机器学习和推理，让用户更快捷地享受到AI的带来的便利。
边缘计算（Edge AI）的意义
“模型” 是对一组训练数据应用机器学习算法而得到的结果。使用模型对一些输入的数据进行预测的过程叫“推理”。有很多依靠编写代码仅能低效甚至很难完成的任务，使用模型推理能更好地完成。例如，可以训练模型来归类照片，或者识别照片内的特定对象等。
长久以来，模型推理大多运行在服务端，客户端只作为结果展示的载体。但随着移动端的硬件性能越来越高，很多深度学习的数据模型可以以二进制形式下载到手机上，基于这些模型可以进行端上的AI处理，“边缘计算”的概念由此诞生，边缘计算有以下好处
- 数据本地化，解决云端存储及隐私问题；
- 计算本地化，解决云端计算过载问题；
- 低通信成本，解决交互和体验问题；
- 去中心化计算，故障规避与极致个性化。
边缘计算的技术现状
严格来说，边缘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)
转换后的模型文件可以通过 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。
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")
经转换的模型可以在 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)
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"
}
上面是人脸识别的处理过程， 经历了图像输入、人脸检测、特征点绘制等一系列过程，这也正好是 MediaPipe 的特点，不只是简单的ML推理，而是可以将输入、前处理、推理、后处理，输出等一系列流程进行组合编排。
Firebase ML Kit
https://firebase.google.com/docs/ml
Firebase 由 Google 提供支持，基于 Google Mobile Service 的移动开放平台，为移动开发这提供了 APM、埋点等功能，ML Kit 是 Firebase 功能的面向移动端的机器学习库， 面向 Android/iOS 提供模型的分发、推理、学习、日志收集等能力。目前只支持 Tensorflow Lite 格式的模型。
例如使用 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是一个好选择。
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 执行。
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 中使用，代码如下：
<script src="https://cdn.jsdelivr.net/npm/@tensorflow/[email protected]"> script>
<script src="https://cdn.jsdelivr.net/npm/@tensorflow-models/[email protected]"> script>
<img id="img" src="cat.jpg">img>
<script>
const img = document.getElementById('img');
// Load the model.
mobilenet.load().then(model => {
// Classify the image.
model.classify(img).then(predictions => {
console.log('Predictions: ');
console.log(predictions);
});
});
script>
当然也可以在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）。通过减少模型体积降低了计算量。当然量化会导致精度的劣化，有可能使计算产生偏差，这也是一种面向性能的妥协。
剪枝（Pruning）
神经网络中的一些冗余的权重和神经元是可以被剪枝的，因为这些权重较低或者神经元的输出大多数时候为零。通过删除这些内容可以减轻模型的重量。另外通过共享的手段，在多个节点之间共享权重，也可以减少模型的容量。跟量化一样，删除一些权重可能导致精读劣化。
蒸馏（Distillation）
蒸馏是通过在学习方法上下功夫来提高压缩模型精度的方法。
蒸馏现以高精度的大容量模型进行学习，以大容量模型的推理结果作为特征参考，参与轻量模型的计算中，以提高准确率。由于大容量模型的推理结果是一个标签的概率分布，所以轻量模型从标签的概率中学习各个数据标签的相似性。例如，有一张猫的画像，分布在猫60%、狗30%、兔子10%的情况下，猫的图像是猫：狗：兔子=6:3:1的特征。
总结
我们在学习计算机组成原理的时候知道一个常识是，CPU 的运力是过剩的，但硬件的性能瓶颈受制于内存和主线的速度。如果把 Cloud 比作CPU，那么连接云/端的网络就是内存和总线。4G网络条件下，云/端巨大的通信开销使得计算的实时性较差。即使到了5G时代，传输速度虽然大大提升，但是过多的链接又会造成“CPU”的高负荷。因此人们急需找到一种适合云端协同环境下的AI处理方案。