使用自定义分类模型检测、跟踪和分类对象 (Android)

您可以使用机器学习套件检测和跟踪连续视频帧中的对象。

当您将图片传递给机器学习套件时,机器学习套件最多可检测图片中的 5 个对象 以及图像中每个对象的位置。当在 视频流,每个对象都有一个唯一 ID,可用于跟踪 帧的呈现方式

您可以使用自定义图片分类模型来对 。如需了解更多详情,请参阅使用机器学习套件的自定义模型 模型兼容性要求方面的指南、在哪里可以找到预训练模型, 以及如何训练自己的模型。

您可以通过两种方式集成自定义模型。你可以通过以下方式捆绑模型: 将其放入应用的资源文件夹中,也可以动态下载 。下表对这两个选项进行了比较。

捆绑模型 托管的模型
该模型是应用 APK 的一部分,这会增加其大小。 该模型不是 APK 的一部分。它通过上传到 Firebase 机器学习
即使 Android 设备处于离线状态,模型也可立即使用 按需下载模型
无需 Firebase 项目 需要 Firebase 项目
您必须重新发布应用才能更新模型 无需重新发布应用即可推送模型更新
没有内置 A/B 测试 使用 Firebase Remote Config 轻松进行 A/B 测试

试试看

准备工作

  1. 在项目级 build.gradle 文件中,请务必包含 buildscript 和 Google 的 Maven 制品库 allprojects 个版块。

  2. 将 Android 版机器学习套件库的依赖项添加到模块的 应用级 Gradle 文件,通常为 app/build.gradle

    如需将模型与应用捆绑,请执行以下操作:

    dependencies {
      // ...
      // Object detection & tracking feature with custom bundled model
      implementation 'com.google.mlkit:object-detection-custom:17.0.2'
    }
    

    如需从 Firebase 动态下载模型,请添加 linkFirebase 依赖项:

    dependencies {
      // ...
      // Object detection & tracking feature with model downloaded
      // from firebase
      implementation 'com.google.mlkit:object-detection-custom:17.0.2'
      implementation 'com.google.mlkit:linkfirebase:17.0.0'
    }
    
  3. 如果您想下载模型,请确保 将 Firebase 添加到您的 Android 项目, (如果您尚未这样做)。捆绑模型时不需要这样做。

1. 加载模型

配置本地模型来源

如需将模型与您的应用捆绑在一起,请执行以下操作:

  1. 将模型文件(通常以 .tflite.lite 结尾)复制到应用的 assets/ 文件夹。(您可能需要先创建文件夹, 右键点击 app/ 文件夹,然后点击 新建 >文件夹 >Assets 文件夹。)

  2. 然后,将以下内容添加到应用的 build.gradle 文件中,以确保 Gradle 在构建应用时不会压缩模型文件:

    android {
        // ...
        aaptOptions {
            noCompress "tflite"
            // or noCompress "lite"
        }
    }
    

    模型文件将包含在应用软件包中,并提供给机器学习套件使用 原始资源

  3. 创建 LocalModel 对象,指定模型文件的路径:

    Kotlin

    val localModel = LocalModel.Builder()
            .setAssetFilePath("model.tflite")
            // or .setAbsoluteFilePath(absolute file path to model file)
            // or .setUri(URI to model file)
            .build()

    Java

    LocalModel localModel =
        new LocalModel.Builder()
            .setAssetFilePath("model.tflite")
            // or .setAbsoluteFilePath(absolute file path to model file)
            // or .setUri(URI to model file)
            .build();

配置 Firebase 托管的模型来源

如需使用远程托管的模型,请通过以下方法创建一个 CustomRemoteModel 对象: FirebaseModelSource,指定您在创建模型时 发布时间:

Kotlin

// Specify the name you assigned in the Firebase console.
val remoteModel =
    CustomRemoteModel
        .Builder(FirebaseModelSource.Builder("your_model_name").build())
        .build()

Java

// Specify the name you assigned in the Firebase console.
CustomRemoteModel remoteModel =
    new CustomRemoteModel
        .Builder(new FirebaseModelSource.Builder("your_model_name").build())
        .build();

然后,启动模型下载任务,指定 来允许下载如果该设备上没有该型号,或者版本较新的 模型可用时,任务会异步下载 模型:

Kotlin

val downloadConditions = DownloadConditions.Builder()
    .requireWifi()
    .build()
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
    .addOnSuccessListener {
        // Success.
    }

Java

DownloadConditions downloadConditions = new DownloadConditions.Builder()
        .requireWifi()
        .build();
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(@NonNull Task task) {
                // Success.
            }
        });

许多应用会通过其初始化代码启动下载任务,但 可以在需要使用该模型之前随时执行此操作。

2. 配置对象检测器

配置模型来源后,请为模型配置对象检测器 具有 CustomObjectDetectorOptions 对象的用例。您可以将 以下设置:

对象检测器设置
检测模式 STREAM_MODE(默认值)|SINGLE_IMAGE_MODE

STREAM_MODE(默认)下,对象检测器会运行 但可能会生成不完整的结果(例如 未指定的边界框或类别标签) 检测器的调用。此外,在 STREAM_MODE 中, 检测器会为对象分配跟踪 ID,供您用来 跨帧跟踪对象。当您想要追踪活动时,可以使用此模式 或者对低延迟很重要,例如在处理 实时流式传输视频。

SINGLE_IMAGE_MODE 中,对象检测器会返回 确定对象的边界框后的结果。如果您 也会启用分类,它会返回 框和类别标签均可使用。因此 检测延迟时间可能更长。此外,在 SINGLE_IMAGE_MODE,未分配跟踪 ID。使用 如果延迟时间不重要,并且您不希望处理 部分结果。

检测和跟踪多个对象 false(默认值)|true

是检测和跟踪最多五个对象,还是仅检测和跟踪最多五个对象 醒目对象(默认)。

对对象进行分类 false(默认值)|true

是否使用提供的 自定义分类器模型。要使用自定义分类 模型,则需要将其设为 true

分类置信度阈值

已检测到的标签的最低置信度分数。如果未设置,任何 系统将使用模型元数据指定的分类器阈值。 如果模型不包含任何元数据或元数据不包含 则默认阈值为 0.0, 。

每个对象的标签数上限

检测器将为每个对象设置的标签数量上限 return。如果未设置,系统将使用默认值 10。

对象检测和跟踪 API 针对这两种核心用途进行了优化 用例:

  • 实时检测和跟踪相机中最突出的对象 取景器
  • 检测静态图片中的多个对象。

如需使用本地捆绑的模型为这些用例配置 API,请执行以下操作:

Kotlin

// Live detection and tracking
val customObjectDetectorOptions =
        CustomObjectDetectorOptions.Builder(localModel)
        .setDetectorMode(CustomObjectDetectorOptions.STREAM_MODE)
        .enableClassification()
        .setClassificationConfidenceThreshold(0.5f)
        .setMaxPerObjectLabelCount(3)
        .build()

// Multiple object detection in static images
val customObjectDetectorOptions =
        CustomObjectDetectorOptions.Builder(localModel)
        .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
        .enableMultipleObjects()
        .enableClassification()
        .setClassificationConfidenceThreshold(0.5f)
        .setMaxPerObjectLabelCount(3)
        .build()

val objectDetector =
        ObjectDetection.getClient(customObjectDetectorOptions)

Java

// Live detection and tracking
CustomObjectDetectorOptions customObjectDetectorOptions =
        new CustomObjectDetectorOptions.Builder(localModel)
                .setDetectorMode(CustomObjectDetectorOptions.STREAM_MODE)
                .enableClassification()
                .setClassificationConfidenceThreshold(0.5f)
                .setMaxPerObjectLabelCount(3)
                .build();

// Multiple object detection in static images
CustomObjectDetectorOptions customObjectDetectorOptions =
        new CustomObjectDetectorOptions.Builder(localModel)
                .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
                .enableMultipleObjects()
                .enableClassification()
                .setClassificationConfidenceThreshold(0.5f)
                .setMaxPerObjectLabelCount(3)
                .build();

ObjectDetector objectDetector =
    ObjectDetection.getClient(customObjectDetectorOptions);

如果您有远程托管的模型,则必须检查该模型 下载应用您可以检查模型下载的状态 使用模型管理器的 isModelDownloaded() 方法完成任务。

虽然您只需在运行检测器之前确认这一点,但如果您 同时具有远程托管的模型和本地捆绑的模型, 在实例化图片检测器时执行此检查: 从远程模型检索该检测器(如果已下载),而从本地 模型。

Kotlin

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded ->
    val optionsBuilder =
        if (isDownloaded) {
            CustomObjectDetectorOptions.Builder(remoteModel)
        } else {
            CustomObjectDetectorOptions.Builder(localModel)
        }
    val customObjectDetectorOptions = optionsBuilder
            .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
            .enableClassification()
            .setClassificationConfidenceThreshold(0.5f)
            .setMaxPerObjectLabelCount(3)
            .build()
    val objectDetector =
        ObjectDetection.getClient(customObjectDetectorOptions)
}

Java

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener(new OnSuccessListener() {
        @Override
        public void onSuccess(Boolean isDownloaded) {
            CustomObjectDetectorOptions.Builder optionsBuilder;
            if (isDownloaded) {
                optionsBuilder = new CustomObjectDetectorOptions.Builder(remoteModel);
            } else {
                optionsBuilder = new CustomObjectDetectorOptions.Builder(localModel);
            }
            CustomObjectDetectorOptions customObjectDetectorOptions = optionsBuilder
                .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
                .enableClassification()
                .setClassificationConfidenceThreshold(0.5f)
                .setMaxPerObjectLabelCount(3)
                .build();
            ObjectDetector objectDetector =
                ObjectDetection.getClient(customObjectDetectorOptions);
        }
});

如果您只有远程托管的模型,则应停用与模型相关的 部分功能(如灰显或隐藏界面的某一部分), 您可以确认模型已下载。为此,你可以将一个监听器附加到 添加到模型管理器的 download() 方法:

Kotlin

RemoteModelManager.getInstance().download(remoteModel, conditions)
    .addOnSuccessListener {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.
    }

Java

RemoteModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Void v) {
              // Download complete. Depending on your app, you could enable
              // the ML feature, or switch from the local model to the remote
              // model, etc.
            }
        });

3. 准备输入图片

基于图片创建 InputImage 对象。 对象检测器直接从 Bitmap、NV21 ByteBuffer 或 YUV_420_888 media.Image。根据这些来源构建 InputImage 的步骤如下: 我们建议您:如果您构建一个 来自其他来源的 InputImage,我们将在内部处理转换, 而且效率可能会降低

您可以创建 InputImage 对象,下文对每种方法进行了说明。

使用 media.Image

如需创建 InputImage,请执行以下操作: 对象(例如从 media.Image 对象中捕获图片时) 请传递 media.Image 对象和图片的 旋转为 InputImage.fromMediaImage()

如果您使用 <ph type="x-smartling-placeholder"></ph> CameraX 库、OnImageCapturedListenerImageAnalysis.Analyzer 类计算旋转角度值 。

Kotlin

private class YourImageAnalyzer : ImageAnalysis.Analyzer {

    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        Image mediaImage = imageProxy.getImage();
        if (mediaImage != null) {
          InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
          // Pass image to an ML Kit Vision API
          // ...
        }
    }
}

如果您不使用可提供图片旋转角度的相机库, 可以根据设备的旋转角度和镜头方向来计算 设备传感器:

Kotlin

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 0)
    ORIENTATIONS.append(Surface.ROTATION_90, 90)
    ORIENTATIONS.append(Surface.ROTATION_180, 180)
    ORIENTATIONS.append(Surface.ROTATION_270, 270)
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Throws(CameraAccessException::class)
private fun getRotationCompensation(cameraId: String, activity: Activity, isFrontFacing: Boolean): Int {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    val deviceRotation = activity.windowManager.defaultDisplay.rotation
    var rotationCompensation = ORIENTATIONS.get(deviceRotation)

    // Get the device's sensor orientation.
    val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360
    }
    return rotationCompensation
}

Java

private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 0);
    ORIENTATIONS.append(Surface.ROTATION_90, 90);
    ORIENTATIONS.append(Surface.ROTATION_180, 180);
    ORIENTATIONS.append(Surface.ROTATION_270, 270);
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private int getRotationCompensation(String cameraId, Activity activity, boolean isFrontFacing)
        throws CameraAccessException {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
    int rotationCompensation = ORIENTATIONS.get(deviceRotation);

    // Get the device's sensor orientation.
    CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360;
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360;
    }
    return rotationCompensation;
}

然后,传递 media.Image 对象和 将旋转角度值设为 InputImage.fromMediaImage()

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

Java

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

使用文件 URI

如需创建 InputImage,请执行以下操作: 对象时,请将应用上下文和文件 URI 传递给 InputImage.fromFilePath()。在需要满足特定条件时 使用 ACTION_GET_CONTENT intent 提示用户进行选择 从图库应用中获取图片

Kotlin

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}

Java

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

使用 ByteBufferByteArray

如需创建 InputImage,请执行以下操作: 对象ByteBufferByteArray时,首先计算图像 旋转角度。media.Image 然后,创建带有缓冲区或数组的 InputImage 对象以及图片的 高度、宽度、颜色编码格式和旋转角度:

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);

使用 Bitmap

如需创建 InputImage,请执行以下操作: 对象时,请进行以下声明:Bitmap

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);

图片由 Bitmap 对象和旋转角度表示。

4. 运行对象检测器

Kotlin

objectDetector
    .process(image)
    .addOnFailureListener(e -> {...})
    .addOnSuccessListener(results -> {
        for (detectedObject in results) {
          // ...
        }
    });

Java

objectDetector
    .process(image)
    .addOnFailureListener(e -> {...})
    .addOnSuccessListener(results -> {
        for (DetectedObject detectedObject : results) {
          // ...
        }
    });
<ph type="x-smartling-placeholder">

5. 获取已加标签的对象的相关信息

如果对 process() 的调用成功,则系统会将 DetectedObject 列表传递给 成功监听器

每个 DetectedObject 包含以下属性:

边界框 一个 Rect,指示对象在 图片。
跟踪 ID 一个整数,用于跨图片标识对象。以下时间内为 null: SINGLE_IMAGE_MODE。
标签
标签说明 标签的文本说明。仅当 TensorFlow 加载 精简版模型的元数据包含标签说明。
标签索引 标签在 分类器。
标签置信度 对象分类的置信度值。

Kotlin

// The list of detected objects contains one item if multiple
// object detection wasn't enabled.
for (detectedObject in results) {
    val boundingBox = detectedObject.boundingBox
    val trackingId = detectedObject.trackingId
    for (label in detectedObject.labels) {
      val text = label.text
      val index = label.index
      val confidence = label.confidence
    }
}

Java

// The list of detected objects contains one item if multiple
// object detection wasn't enabled.
for (DetectedObject detectedObject : results) {
  Rect boundingBox = detectedObject.getBoundingBox();
  Integer trackingId = detectedObject.getTrackingId();
  for (Label label : detectedObject.getLabels()) {
    String text = label.getText();
    int index = label.getIndex();
    float confidence = label.getConfidence();
  }
}

确保出色的用户体验

为了提供最佳用户体验,请在您的应用中遵循以下准则:

  • 对象检测成功与否取决于对象的视觉复杂性。在 视觉特征较少的物体可能需要 占据图片的较大部分您应该向用户提供有关 能够很好地满足待检测对象类型的输入。
  • 使用分类时,您想要检测未归入 彻底归类到支持的类别中,对未知状态执行特殊处理, 对象的操作。

另请访问 机器学习套件 Material Design 展示应用和 Material Design 适用于机器学习赋能的功能的模式集合。

提高性能

如果要在实时应用中使用对象检测,请遵循以下 实现最佳帧速率的准则:

  • 在实时应用中使用流处理模式时,请勿使用多个 对象检测,因为大多数设备都无法产生足够的帧速率。

  • 如果您使用 Cameracamera2 API、 限制对检测器的调用。如果新视频 当检测器运行时有可用的帧时,请丢弃该帧。请参阅 <ph type="x-smartling-placeholder"></ph> VisionProcessorBase 类。
  • 如果您使用 CameraX API, 确保将 backpressure 策略设置为默认值 ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST。 这可保证一次只传送一张图片进行分析。如果有更多图片 在分析器繁忙时生成,它们会被自动丢弃,不会排队等待 。通过调用 ImageProxy.close(),将传递下一张图片。
  • 如果您使用检测器的输出在图像上叠加显示 输入图片,首先从机器学习套件获取结果, 和叠加层。这会渲染到 每个输入帧只执行一次。请参阅 <ph type="x-smartling-placeholder"></ph> CameraSourcePreview GraphicOverlay 类。
  • 如果您使用 Camera2 API,请使用 ImageFormat.YUV_420_888 格式。如果您使用的是旧版 Camera API,请使用 ImageFormat.NV21 格式。