TensorFlow Lite 实战：手把手教你在 Android/iOS 上部署 AI 模型 – wiki大全

作者： /

TensorFlow Lite 实战：手把手教你在 Android/iOS 上部署 AI 模型

随着移动设备算力的不断增强，将人工智能 (AI) directly 部署到用户设备端已成为主流趋势。设备端 AI 不仅可以有效降低服务器成本，还能提供更低延迟的实时响应、保障用户数据隐私，并且在离线状态下依然可用。TensorFlow Lite (TFLite) 正是 Google 为此目标推出的轻量级、跨平台的设备端 AI 推理框架。

本文将作为一篇详尽的实战指南，手把手带你完成从模型转换到最终在 Android 和 iOS 应用中成功部署的全过程。

核心流程概览

无论是在 Android 还是 iOS 上部署，核心流程都可以归纳为以下几个步骤：
1. 获取模型: 选择一个预训练好的模型或训练自己的模型。
2. 模型转换: 使用 TensorFlow Lite Converter 将模型转换为 .tflite 格式，并进行可选的量化优化。
3. 集成到项目: 将 .tflite 模型和 TFLite 依赖库集成到你的移动应用项目中。
4. 编写推理代码:
* 加载模型文件。
* 对输入数据进行预处理（如图像缩放、归一化）。
* 执行模型推理。
* 对模型的输出结果进行后处理，并呈现给用户。

Part 1: 模型准备

在部署之前，我们需要一个 TensorFlow Lite 格式的模型。

1.1 获取 TensorFlow 模型

你可以从多种渠道获取模型：
* TensorFlow Hub: 这是一个由 Google 官方维护的模型仓库，提供了大量针对不同任务（如图像分类、目标检测、文本嵌入等）的预训练模型，其中很多都有对应的 TFLite 版本。
* 自己训练: 使用 TensorFlow 或 Keras 从头开始训练，或者在一个预训练模型的基础上进行迁移学习。完成后，你会得到一个 SavedModel、HDF5 或 Keras 格式的模型。

对于本文的示例，我们将以一个经典的图像分类模型 MobileNetV2 为例。

1.2 转换为 TensorFlow Lite 格式

假设你已经有了一个 TensorFlow SavedModel 格式的模型，接下来的步骤将展示如何将其转换为 .tflite 文件。这个过程通常在你的开发机上用 Python 完成。

首先，确保你安装了 TensorFlow：
bash
pip install tensorflow

然后，使用以下 Python 脚本进行转换：

“`python
import tensorflow as tf

SavedModel 路径

saved_model_dir = “path/to/your/saved_model”

初始化 TFLiteConverter

converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)

[可选] 应用优化 (例如：动态范围量化)

量化可以显著减小模型大小并加速推理，但可能会有微小的精度损失

converter.optimizations = [tf.lite.Optimize.DEFAULT]

执行转换

tflite_model = converter.convert()

将转换后的模型保存为 .tflite 文件

with open(“model.tflite”, “wb”) as f:
f.write(tflite_model)

print(“模型已成功转换为 model.tflite”)
“`

关于量化 (Quantization):
* tf.lite.Optimize.DEFAULT: 这是推荐的默认选项，它会进行动态范围量化，可将模型大小减小约 4 倍。
* FP16 量化: 将权重从 32 位浮点数转换为 16 位浮点数，大小减半，在 GPU 上尤其高效。
* INT8 全整型量化: 将所有权重和计算都转换为 8 位整数，模型大小可减小 4 倍，CPU 推理速度显著提升。但这需要一个代表性的数据集来校准量化参数。

转换完成后，你就得到了部署所需的 model.tflite 文件。

Part 2: Android 部署实战 (Kotlin)

2.1 项目设置

  1. 创建项目: 在 Android Studio 中创建一个新的空项目，选择 Kotlin 作为开发语言。

  2. 添加 TFLite 依赖: 打开 build.gradle (Module :app) 文件，在 dependencies 代码块中添加 TensorFlow Lite 的依赖。

    groovy
    dependencies {
    // ... 其他依赖
    implementation 'org.tensorflow:tensorflow-lite:2.11.0'
    // TFLite Support Library 提供了许多便捷的 API，简化输入/输出处理
    implementation 'org.tensorflow:tensorflow-lite-support:0.4.3'
    }

    注意: 请随时检查并使用最新版本的库。

  3. 关闭 aaptOptions 压缩: 为了防止模型文件在打包时被压缩，同样在 build.gradle (Module :app) 的 android 代码块中添加以下配置：

    groovy
    android {
    // ...
    aaptOptions {
    noCompress "tflite"
    }
    }

2.2 集成模型

  1. 在 src/main 目录下创建一个 assets 文件夹。
  2. 将之前生成的 model.tflite 文件（以及一个用于分类的标签文件，如 labels.txt）复制到这个 assets 文件夹中。

2.3 编写推理代码

以下是一个简化的图像分类流程。

1. 加载模型和标签

“`kotlin
import org.tensorflow.lite.Interpreter
import java.io.FileInputStream
import java.nio.MappedByteBuffer
import java.nio.channels.FileChannel

// … 在你的 Activity 或 ViewModel 中 …

private lateinit var tflite: Interpreter
private lateinit var labels: List

private fun loadModelAndLabels() {
val modelFileDescriptor = assets.openFd(“model.tflite”)
val inputStream = FileInputStream(modelFileDescriptor.fileDescriptor)
val fileChannel = inputStream.channel
val startOffset = modelFileDescriptor.startOffset
val declaredLength = modelFileDescriptor.declaredLength
val tfliteModel: MappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declaredLength)

val options = Interpreter.Options()
// 可选：使用 NNAPI 或 GPU 代理加速
// options.addDelegate(NnApiDelegate()) 
// options.addDelegate(GpuDelegate())
tflite = Interpreter(tfliteModel, options)

// 加载标签
labels = assets.open("labels.txt").bufferedReader().readLines()

}
“`

2. 预处理输入图像

模型需要特定尺寸和格式的输入。例如，MobileNetV2 通常需要 224x224 的 RGB 图像，并且像素值需要归一化到 [-1, 1] 或 [0, 1] 的范围。

“`kotlin
import android.graphics.Bitmap
import org.tensorflow.lite.support.image.ImageProcessor
import org.tensorflow.lite.support.image.TensorImage
import org.tensorflow.lite.support.image.ops.ResizeOp
import org.tensorflow.lite.support.image.ops.NormalizeOp

private fun preprocessImage(bitmap: Bitmap): TensorImage {
// 假设模型输入尺寸为 224×224
val imageProcessor = ImageProcessor.Builder()
.add(ResizeOp(224, 224, ResizeOp.ResizeMethod.BILINEAR))
// 根据你的模型要求进行归一化
// .add(NormalizeOp(0f, 255f)) // 归一化到 [0, 1]
.add(NormalizeOp(127.5f, 127.5f)) // 归一化到 [-1, 1]
.build()

var tensorImage = TensorImage.fromBitmap(bitmap)
tensorImage = imageProcessor.process(tensorImage)
return tensorImage

}
“`

3. 执行推理和后处理

“`kotlin
import org.tensorflow.lite.support.tensorbuffer.TensorBuffer

fun classifyImage(bitmap: Bitmap): String {
val tensorImage = preprocessImage(bitmap)

// 假设模型输出是一个形状为 [1, 1001] 的浮点数数组，代表 1001 个分类的概率
val outputBuffer = TensorBuffer.createFixedSize(intArrayOf(1, 1001), org.tensorflow.lite.DataType.FLOAT32)

// 执行推理
tflite.run(tensorImage.buffer, outputBuffer.buffer)

// 后处理：找到概率最高的分类
val probabilities = outputBuffer.floatArray
var maxProbability = -1f
var maxIndex = -1
for (i in probabilities.indices) {
    if (probabilities[i] > maxProbability) {
        maxProbability = probabilities[i]
        maxIndex = i
    }
}

return if (maxIndex != -1) {
    "结果: ${labels[maxIndex]}, 置信度: ${maxProbability}"
} else {
    "无法识别"
}

}
“`

现在，你只需要在你的应用中获取一个 Bitmap 对象（例如从相机或图库），调用 classifyImage 方法，即可在 Android 设备上看到 AI 模型的工作成果。

Part 3: iOS 部署实战 (Swift)

3.1 项目设置

  1. 创建项目: 在 Xcode 中创建一个新的 App 项目，选择 Swift 作为开发语言。

  2. 添加 TFLite 依赖 (CocoaPods):

    • 在你的项目根目录下，如果还没有 Podfile，运行 pod init。

    • 打开 Podfile，添加 TensorFlow Lite Swift 库：
      “`ruby
      platform :ios, ‘14.0’

      target ‘YourAppName’ do
      use_frameworks!

      # 添加 TensorFlow Lite Swift 库
      pod ‘TensorFlowLiteSwift’
      end
      ``
      * 在终端中运行      pod install。
      * 完成后，关闭      .xcodeproj文件，并打开新生成的.xcworkspace` 文件来继续开发。

3.2 集成模型

  1. 将 model.tflite 和 labels.txt 文件直接拖拽到 Xcode 的项目导航器中。
  2. 在弹出的对话框中，确保 “Add to targets” 已勾选你的主应用 Target。

3.3 编写推理代码

1. 加载模型和初始化 Interpreter

“`swift
import TensorFlowLite

class ModelDataHandler {

private var interpreter: Interpreter?
private var labels: [String] = []

init?() {
    guard let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite") else {
        print("Failed to load the model file.")
        return nil
    }

    do {
        // 初始化 Interpreter
        var options = Interpreter.Options()
        // options.threadCount = 2 // 可选：设置线程数
        interpreter = try Interpreter(modelPath: modelPath, options: options)

        // 为输入张量分配内存
        try interpreter?.allocateTensors()

        loadLabels()

    } catch {
        print("Failed to create the interpreter with error: \(error.localizedDescription)")
        return nil
    }
}

private func loadLabels() {
    guard let labelsPath = Bundle.main.path(forResource: "labels", ofType: "txt") else {
        return
    }
    do {
        let content = try String(contentsOfFile: labelsPath, encoding: .utf8)
        labels = content.components(separatedBy: .newlines)
    } catch {
        print("Failed to load labels: \(error.localizedDescription)")
    }
}
// ... 后续代码

}
“`

2. 预处理输入图像

与 Android 类似，图像需要被处理成模型所需的格式。这通常涉及缩放、裁剪和像素数据提取。

“`swift
import UIKit
import CoreGraphics

// … 在 ModelDataHandler 类中 …

// 将 UIImage 转换为模型所需的 Data
private func preprocessImage(image: UIImage) -> Data? {
guard let cgImage = image.cgImage else { return nil }

let width = 224
let height = 224

let bytesPerPixel = 4
let bytesPerRow = bytesPerPixel * width
let bitsPerComponent = 8

var imageData = Data(count: width * height * bytesPerPixel)

guard let context = CGContext(
    data: &imageData,
    width: width,
    height: height,
    bitsPerComponent: bitsPerComponent,
    bytesPerRow: bytesPerRow,
    space: CGColorSpaceCreateDeviceRGB(),
    bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Big.rawValue
) else {
    return nil
}

// 缩放图像并绘制到上下文中
context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))

// 提取像素数据并进行归一化
var floatArray = [Float32]()
for i in 0 ..< width * height {
    let R = Float32(imageData[i * 4 + 0])
    let G = Float32(imageData[i * 4 + 1])
    let B = Float32(imageData[i * 4 + 2])

    // 归一化到 [-1, 1]
    let normR = (R / 255.0 - 0.5) * 2.0
    let normG = (G / 255.0 - 0.5) * 2.0
    let normB = (B / 255.0 - 0.5) * 2.0

    floatArray.append(normR)
    floatArray.append(normG)
    floatArray.append(normB)
}

return Data(buffer: UnsafeBufferPointer(start: floatArray, count: floatArray.count))

}
“`

注意: 图像处理部分较为繁琐，可以封装成一个独立的工具类或使用第三方库来简化。TFLite 官方也提供了一些示例代码可供参考。

3. 执行推理和后处理

“`swift
// … 在 ModelDataHandler 类中 …

func classify(image: UIImage) -> String? {
guard let data = preprocessImage(image: image),
let interpreter = interpreter else {
return nil
}

do {
    // 将输入数据复制到模型的输入张量
    try interpreter.copy(data, toInputAt: 0)

    // 执行推理
    try interpreter.invoke()

    // 获取输出张量
    let outputTensor = try interpreter.output(at: 0)

    // 将输出数据转换为 Float 数组
    // 计算方式：outputTensor.data.count / MemoryLayout<Float>.size
    let results = [Float](unsafeData: outputTensor.data) ?? []

    // 后处理：找到概率最高的分类
    var maxConfidence: Float = 0.0
    var maxIndex = -1
    for i in 0..<results.count {
        if results[i] > maxConfidence {
            maxConfidence = results[i]
            maxIndex = i
        }
    }

    guard maxIndex != -1 && maxIndex < labels.count else {
        return "无法识别"
    }

    return "结果: \(labels[maxIndex]), 置信度: \(maxConfidence)"

} catch {
    print("Failed to invoke interpreter: \(error.localizedDescription)")
    return nil
}

}
“`

现在，你可以在你的 ViewController 中创建一个 ModelDataHandler 实例，并使用它来分析 UIImage。

Part 4: 性能优化与最佳实践

  • 使用硬件代理 (Delegates):
    • Android: 使用 NnApiDelegate 可以利用 Android 设备的神经处理单元 (NPU) 或 DSP；GpuDelegate 则使用 GPU。这是提升性能最直接有效的方式。
    • iOS: 使用 CoreMLDelegate 可以将 TFLite 模型转换为 Core ML 格式在苹果的硬件上高效运行。
  • 多线程: 在多核 CPU 上，适当增加推理线程数 (options.threadCount) 可以提升性能，但并非越多越好，需要根据具体设备和模型进行测试。
  • 选择合适的模型: 针对移动端，始终优先选择轻量级的模型架构，如 MobileNets、EfficientNets-Lite 等。
  • 异步执行: 模型推理可能是耗时操作，务必在后台线程执行，避免阻塞 UI 主线程。

结语

将 AI 模型部署到移动端，开启了无数创新的可能性。通过 TensorFlow Lite，开发者可以相对轻松地将强大的 AI 功能集成到自己的 Android 和 iOS 应用中。虽然初次接触时可能会在环境配置和数据处理上遇到一些挑战，但一旦你成功走通整个流程，你将能够为用户带来更智能、更即时、更具吸引力的移动体验。希望这篇指南能为你开启设备端 AI 之旅提供坚实的起点。

滚动至顶部