Detecta, haz un seguimiento y clasifica objetos con un modelo de clasificación personalizado en iOS

Puedes usar ML Kit para detectar objetos y hacerles seguimiento en fotogramas de video sucesivos.

Cuando pasas una imagen a ML Kit, este detecta hasta cinco objetos en la imagen junto con la posición de cada objeto en ella. Cuando detectas objetos en transmisiones de video por Internet, cada uno de ellos tiene un ID único que puedes usar para seguirlo de un fotograma a otro.

Puedes usar un modelo de clasificación de imágenes personalizado para clasificar los objetos que se detectan. Consulta Modelos personalizados con ML Kit para obtener orientación sobre los requisitos de compatibilidad de modelos, dónde encontrar modelos previamente entrenados, y cómo entrenar tus propios modelos.

Existen dos maneras de integrar un modelo personalizado. Puedes empaquetar el modelo colocándolo dentro de la carpeta de recursos de tu app o descargarlo de forma dinámica desde Cloud Storage. En la siguiente tabla, se comparan las dos opciones.

Modelo empaquetado Modelo alojado
El modelo forma parte del archivo .ipa de tu app, lo que aumenta su tamaño. El modelo no forma parte del archivo .ipa de tu app. Se aloja subiéndolo a Cloud Storage. Te recomendamos usar Cloud Storage para Firebase.
El modelo está disponible de inmediato, incluso cuando el dispositivo Android está sin conexión Tu app debe incluir código para descargar el modelo a pedido
No se necesita un proyecto de Firebase Se requiere un proyecto de Firebase (si se usa Cloud Storage para Firebase).
Debes volver a publicar tu app para actualizar el modelo El modelo de envío se actualiza sin volver a publicar la app
No hay pruebas A/B integradas Pruebas A/B con Firebase Remote Config

Probar

Antes de comenzar

  1. Incluye las bibliotecas de ML Kit en el Podfile:

    pod 'GoogleMLKit/ObjectDetectionCustom', '8.0.0'

  2. Después de instalar o actualizar los Pods de tu proyecto, abre el proyecto de Xcode con su .xcworkspace. ML Kit es compatible con Xcode 13.2.1 o versiones posteriores.

  3. Si quieres descargar un modelo con Cloud Storage para Firebase, asegúrate de agregar Firebase a tu proyecto de iOS, en caso de que aún no lo hayas hecho. Esto no es obligatorio cuando se agrupa un modelo.

1. Carga el modelo

Configura una fuente de modelo local

Sigue estos pasos para empaquetar el modelo con tu app:

  1. Copia el archivo del modelo (por lo general, tiene la extensión .tflite o .lite) a tu proyecto de Xcode. Cuando lo hagas, asegúrate de seleccionar Copy bundle resources. El archivo del modelo se incluirá en el paquete de aplicación y estará disponible para ML Kit.

  2. Crea un objeto LocalModel y especifica la ruta de acceso al archivo del modelo:

    Swift

    let localModel = LocalModel(path: localModelFilePath)

    Objective-C

    MLKLocalModel *localModel =
    [[MLKLocalModel alloc] initWithPath:localModelFilePath];

Configura una fuente de modelo alojada de forma remota

Para usar el modelo alojado de forma remota, debes descargar el archivo del modelo al almacenamiento local del dispositivo con tu propia lógica de la app y, luego, cargarlo como un modelo local. Te recomendamos usar Cloud Storage para Firebase para alojar un modelo. Para obtener detalles de la implementación, consulta la guía de migración de Firebase ML a Cloud Storage.

2. Configura el detector de objetos

Después de configurar las fuentes de tu modelo, configura el detector de objetos para tu caso práctico con un objeto CustomObjectDetectorOptions. Puedes cambiar la siguiente configuración:

Configuración del detector de objetos
Modo de detección STREAM_MODE (predeterminado) | SINGLE_IMAGE_MODE

En STREAM_MODE (predeterminado), el detector de objetos se ejecuta con baja latencia, pero podría generar resultados incompletos (como cuadros de límite o etiquetas de categoría no especificados) en las primeras invocaciones del detector. Además, en STREAM_MODE, el detector asigna ID de seguimiento a los objetos, que puedes usar para hacer seguimiento de objetos en los fotogramas. Usa este modo cuando quieras hacer seguimiento de objetos o cuando la baja latencia sea importante, como cuando procesas transmisiones de video en tiempo real.

En SINGLE_IMAGE_MODE, el detector de objetos muestra el resultado después de que se determina el cuadro delimitador del objeto. Si también habilitas la clasificación, muestra el resultado después de que estén disponibles el cuadro de límite y la etiqueta de categoría. En consecuencia, la latencia de detección es más alta potencialmente. Además, en SINGLE_IMAGE_MODE, no se asignan ID de seguimiento. Usa este modo si la latencia no es importante y no quieres lidiar con resultados parciales.
Detecta varios objetos y hazles seguimiento false (predeterminado) | true

Ya sea para detectar y hacer seguimiento de hasta cinco objetos o solo al más prominente (predeterminado).
Clasifica objetos false (predeterminado) | true

Ya sea para clasificar o no objetos detectados con el modelo de clasificador personalizado proporcionado. Para usar tu modelo de clasificación personalizado, debes establecerlo en true.

Umbral de confianza de la clasificación

Puntuación de confianza mínima de las etiquetas detectadas. Si no se establece, se usará cualquier umbral de clasificador especificado por los metadatos del modelo. Si el modelo no contiene metadatos o si estos no especifican un umbral de clasificador, se usará un umbral predeterminado de 0.0.
Cantidad máxima de etiquetas por objeto

Cantidad máxima de etiquetas por objeto que mostrará el detector. Si no se establece, se usará el valor predeterminado de 10.

Si solo tienes un modelo empaquetado a nivel local, crea un detector de objetos a partir del objeto LocalModel:

Swift

let options = CustomObjectDetectorOptions(localModel: localModel)
options.detectorMode = .singleImage
options.shouldEnableClassification = true
options.shouldEnableMultipleObjects = true
options.classificationConfidenceThreshold = NSNumber(value: 0.5)
options.maxPerObjectLabelCount = 3

Objective-C

MLKCustomObjectDetectorOptions *options =
    [[MLKCustomObjectDetectorOptions alloc] initWithLocalModel:localModel];
options.detectorMode = MLKObjectDetectorModeSingleImage;
options.shouldEnableClassification = YES;
options.shouldEnableMultipleObjects = YES;
options.classificationConfidenceThreshold = @(0.5);
options.maxPerObjectLabelCount = 3;

Si tienes un modelo alojado de forma remota, comprueba si se descargó antes de ejecutarlo.

Aunque solo debes confirmarlo antes de ejecutar el detector de objetos, si tienes un modelo alojado de forma remota y uno empaquetado localmente, sería acertado realizar esta verificación cuando se crea una instancia de ObjectDetector: crea un detector desde el modelo remoto si se descargó o, en su defecto, desde el modelo local.

Swift

// Path where your download logic saves the model
let documentDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
let localModelURL = documentDirectory.appendingPathComponent("my_remote_model.tflite")

let model: LocalModel
if FileManager.default.fileExists(atPath: localModelURL.path) {
  // Use the downloaded model
  model = LocalModel(path: localModelURL.path)
} else {
  // Fall back to bundled model
  guard let bundledModelPath = Bundle.main.path(forResource: "model", ofType: "tflite") else { return }
  model = LocalModel(path: bundledModelPath)
}

let options = CustomObjectDetectorOptions(localModel: model)
options.detectorMode = .singleImage
options.shouldEnableClassification = true
options.shouldEnableMultipleObjects = true
options.classificationConfidenceThreshold = NSNumber(value: 0.5)
options.maxPerObjectLabelCount = 3
let objectDetector = ObjectDetector.objectDetector(options: options)

Objective-C

NSString *documentsDirectory = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
NSString *localModelPath = [documentsDirectory stringByAppendingPathComponent:@"my_remote_model.tflite"];

MLKLocalModel *model;
if ([NSFileManager.defaultManager fileExistsAtPath:localModelPath]) {
  // Use the downloaded model
  model = [[MLKLocalModel alloc] initWithPath:localModelPath];
} else {
  // Fall back to bundled model
  NSString *bundledModelPath = [NSBundle.mainBundle pathForResource:@"model" ofType:@"tflite"];
  model = [[MLKLocalModel alloc] initWithPath:bundledModelPath];
}

MLKCustomObjectDetectorOptions *options = [[MLKCustomObjectDetectorOptions alloc] initWithLocalModel:model];
options.detectorMode = MLKObjectDetectorModeSingleImage;
options.shouldEnableClassification = YES;
options.shouldEnableMultipleObjects = YES;
options.classificationConfidenceThreshold = @(0.5);
options.maxPerObjectLabelCount = 3;
MLKObjectDetector *objectDetector = [MLKObjectDetector objectDetectorWithOptions:options];

Si solo tienes un modelo alojado de forma remota, debes inhabilitar la funcionalidad relacionada con el modelo, por ejemplo, oculta o inhabilita parte de tu IU, hasta que confirmes que el modelo se descargó.

Swift

let documentDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
let localModelURL = documentDirectory.appendingPathComponent("my_remote_model.tflite")
if FileManager.default.fileExists(atPath: localModelURL.path) {
  // Model is already cached, initialize immediately
  self.initializeDetector(with: localModelURL)
} else {
  // Model is not yet available, show loading UI and start download
  self.showLoadingUI()
  let storage = Storage.storage()
  let modelRef = storage.reference(forURL: "gs://YOUR_BUCKET/path/to/model.tflite")
  modelRef.write(toFile: localModelURL) { url, error in
    self.hideLoadingUI()
    if let error = error {
      // Handle download error
      self.showErrorUI()
    } else if let modelURL = url {
      // Download success, initialize detector
      self.initializeDetector(with: modelURL)
    }
  }
}

func initializeDetector(with modelURL: URL) {
  let localModel = LocalModel(path: modelURL.path)
  let options = CustomObjectDetectorOptions(localModel: localModel)
  options.detectorMode = .singleImage
  options.shouldEnableClassification = true
  options.shouldEnableMultipleObjects = true
  self.objectDetector = ObjectDetector.objectDetector(options: options)
  // Enable ML features in UI
  self.enableMLFeatures()
}

Objective-C

NSString *documentsDirectory = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
NSString *localModelPath = [documentsDirectory stringByAppendingPathComponent:@"my_remote_model.tflite"];
NSURL *localModelURL = [NSURL fileURLWithPath:localModelPath];

if ([NSFileManager.defaultManager fileExistsAtPath:localModelPath]) {
  // Model is already cached, initialize immediately
  [self initializeDetectorWithURL:localModelURL];
} else {
  // Model is not yet available, show loading UI and start download
  [self showLoadingUI];

  FIRStorage *storage = [FIRStorage storage];
  FIRStorageReference *modelRef = [storage referenceForURL:@"gs://YOUR_BUCKET/path/to/model.tflite"];

  [modelRef writeToFile:localModelURL
             completion:^(NSURL * _Nullable URL, NSError * _Nullable error) {
               [self hideLoadingUI];
               if (error != nil) {
                 // Handle download error
                 [self showErrorUI];
               } else {
                 // Download success, initialize detector
                 [self initializeDetectorWithURL:URL];
               }
             }];
}

- (void)initializeDetectorWithURL:(NSURL *)modelURL {
  MLKLocalModel *localModel = [[MLKLocalModel alloc] initWithPath:modelURL.path];
  MLKCustomObjectDetectorOptions *options = [[MLKCustomObjectDetectorOptions alloc] initWithLocalModel:localModel];
  options.detectorMode = MLKObjectDetectorModeSingleImage;
  options.shouldEnableClassification = YES;
  options.shouldEnableMultipleObjects = YES;
  self.objectDetector = [MLKObjectDetector objectDetectorWithOptions:options];

  // Enable ML features in UI
  [self enableMLFeatures];
}

La API de detección y seguimiento de objetos está optimizada para estos dos casos prácticos principales:

  • Detección y seguimiento en vivo del objeto más prominente en el visor de la cámara.
  • Detección de múltiples objetos de una imagen estática.

Si deseas configurar la API para estos casos de uso, utiliza este código:

Swift

// Live detection and tracking
let options = CustomObjectDetectorOptions(localModel: localModel)
options.shouldEnableClassification = true
options.maxPerObjectLabelCount = 3

// Multiple object detection in static images
let options = CustomObjectDetectorOptions(localModel: localModel)
options.detectorMode = .singleImage
options.shouldEnableMultipleObjects = true
options.shouldEnableClassification = true
options.maxPerObjectLabelCount = 3

Objective-C

// Live detection and tracking
MLKCustomObjectDetectorOptions *options =
    [[MLKCustomObjectDetectorOptions alloc] initWithLocalModel:localModel];
options.shouldEnableClassification = YES;
options.maxPerObjectLabelCount = 3;

// Multiple object detection in static images
MLKCustomObjectDetectorOptions *options =
    [[MLKCustomObjectDetectorOptions alloc] initWithLocalModel:localModel];
options.detectorMode = MLKObjectDetectorModeSingleImage;
options.shouldEnableMultipleObjects = YES;
options.shouldEnableClassification = YES;
options.maxPerObjectLabelCount = 3;

3. Prepara la imagen de entrada

Crea un objeto VisionImage con un UIImage o un CMSampleBuffer.

Si usas un UIImage, sigue estos pasos:

  • Crea un objeto VisionImage con el UIImage. Asegúrate de especificar el .orientation correcto.

    Swift

    let image = VisionImage(image: UIImage)
visionImage.orientation = image.imageOrientation

    Objective-C

    MLKVisionImage *visionImage = [[MLKVisionImage alloc] initWithImage:image];
visionImage.orientation = image.imageOrientation;

Si usas un CMSampleBuffer, sigue estos pasos:

  • Especifica la orientación de los datos de imagen contenidos en el CMSampleBuffer.

    Para obtener la orientación de la imagen, haz lo siguiente:

    Swift

    func imageOrientation(
  deviceOrientation: UIDeviceOrientation,
  cameraPosition: AVCaptureDevice.Position
) -> UIImage.Orientation {
  switch deviceOrientation {
  case .portrait:
    return cameraPosition == .front ? .leftMirrored : .right
  case .landscapeLeft:
    return cameraPosition == .front ? .downMirrored : .up
  case .portraitUpsideDown:
    return cameraPosition == .front ? .rightMirrored : .left
  case .landscapeRight:
    return cameraPosition == .front ? .upMirrored : .down
  case .faceDown, .faceUp, .unknown:
    return .up
  }
}

    Objective-C

    - (UIImageOrientation)
  imageOrientationFromDeviceOrientation:(UIDeviceOrientation)deviceOrientation
                         cameraPosition:(AVCaptureDevicePosition)cameraPosition {
  switch (deviceOrientation) {
    case UIDeviceOrientationPortrait:
      return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationLeftMirrored
                                                            : UIImageOrientationRight;

    case UIDeviceOrientationLandscapeLeft:
      return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationDownMirrored
                                                            : UIImageOrientationUp;
    case UIDeviceOrientationPortraitUpsideDown:
      return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationRightMirrored
                                                            : UIImageOrientationLeft;
    case UIDeviceOrientationLandscapeRight:
      return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationUpMirrored
                                                            : UIImageOrientationDown;
    case UIDeviceOrientationUnknown:
    case UIDeviceOrientationFaceUp:
    case UIDeviceOrientationFaceDown:
      return UIImageOrientationUp;
  }
}
  • Crea un objeto VisionImage con el CMSampleBuffer objeto y la orientación:

    Swift

    let image = VisionImage(buffer: sampleBuffer)
image.orientation = imageOrientation(
  deviceOrientation: UIDevice.current.orientation,
  cameraPosition: cameraPosition)

    Objective-C

     MLKVisionImage *image = [[MLKVisionImage alloc] initWithBuffer:sampleBuffer];
 image.orientation =
   [self imageOrientationFromDeviceOrientation:UIDevice.currentDevice.orientation
                                cameraPosition:cameraPosition];

4. Crea y ejecuta el detector de objetos

  1. Crea un detector de objetos nuevo:

    Swift

    let objectDetector = ObjectDetector.objectDetector(options: options)

    Objective-C

    MLKObjectDetector *objectDetector = [MLKObjectDetector objectDetectorWithOptions:options];

  2. Luego, usa el detector:

    De forma asíncrona:

    Swift

    objectDetector.process(image) { objects, error in
    guard error == nil, let objects = objects, !objects.isEmpty else {
        // Handle the error.
        return
    }
    // Show results.
}

    Objective-C

    [objectDetector
    processImage:image
      completion:^(NSArray *_Nullable objects,
                   NSError *_Nullable error) {
        if (objects.count == 0) {
            // Handle the error.
            return;
        }
        // Show results.
     }];

    De forma síncrona:

    Swift

    var objects: [Object]
do {
    objects = try objectDetector.results(in: image)
} catch let error {
    // Handle the error.
    return
}
// Show results.

    Objective-C

    NSError *error;
NSArray *objects =
    [objectDetector resultsInImage:image error:&error];
// Show results or handle the error.

5. Obtén información sobre los objetos etiquetados

Si la llamada al procesador de imágenes se ejecuta correctamente, este pasa una lista de Object al controlador de finalización o la muestra, dependiendo de si llamaste a un método asíncrono o a uno síncrono.

Cada Object contiene las siguientes propiedades:

frame Un CGRect que indica la posición del objeto en la imagen.
trackingID Un número entero que identifica el objeto en las imágenes o `nil` en SINGLE_IMAGE_MODE.
labels
label.text La descripción de texto de la etiqueta. Solo se muestra si los metadatos del modelo LiteRT contienen descripciones de etiquetas.
label.index El índice de la etiqueta entre todas las etiquetas compatibles con el clasificador.
label.confidence El valor de confianza de la clasificación del objeto.

Swift

// objects contains one item if multiple object detection wasn't enabled.
for object in objects {
  let frame = object.frame
  let trackingID = object.trackingID
  let description = object.labels.enumerated().map { (index, label) in
    "Label \(index): \(label.text), \(label.confidence), \(label.index)"
  }.joined(separator: "\n")
}

Objective-C

// The list of detected objects contains one item if multiple object detection
// wasn't enabled.
for (MLKObject *object in objects) {
  CGRect frame = object.frame;
  NSNumber *trackingID = object.trackingID;
  for (MLKObjectLabel *label in object.labels) {
    NSString *labelString =
        [NSString stringWithFormat:@"%@, %f, %lu",
                                   label.text,
                                   label.confidence,
                                   (unsigned long)label.index];
  }
}

Cómo garantizar una excelente experiencia del usuario

Para obtener la mejor experiencia del usuario, sigue estos lineamientos en tu app:

  • La detección exitosa de objetos depende de la complejidad visual del objeto. Para que se detecten, es posible que los objetos con una pequeña cantidad de características visuales deban ocupar un espacio mayor en la imagen. Debes proporcionar a los usuarios una orientación sobre cómo capturar entradas que funcionen bien con el tipo de objetos que deseas detectar.
  • Cuando uses la clasificación, si deseas detectar objetos que no se incluyen de forma clara en las categorías compatibles, implementa un manejo especial para objetos desconocidos.

Además, consulta la app de muestra de Material Design del ML Kit y la colección de patrones para las funciones con tecnología de aprendizaje automático de Material Design.

Cómo mejorar el rendimiento

Si quieres usar la detección de objetos en una aplicación en tiempo real, sigue estos lineamientos para lograr los mejores fotogramas por segundo:

  • Cuando uses el modo de transmisión en una aplicación en tiempo real, no utilices la detección de múltiples objetos, ya que la mayoría de los dispositivos no podrán producir fotogramas adecuados.

  • Para procesar fotogramas de video, usa la API síncrona results(in:) del detector. Llama a este método desde la AVCaptureVideoDataOutputSampleBufferDelegate's captureOutput(_, didOutput:from:) función para obtener de forma síncrona los resultados del fotograma de video determinado. Mantén AVCaptureVideoDataOutput de alwaysDiscardsLateVideoFrames como true para limitar las llamadas al detector. Si un fotograma de video nuevo está disponible mientras se ejecuta el detector, se descartará.
  • Si estás usando la salida del detector para superponer gráficos en la imagen de entrada, primero obtén el resultado de la detección de ML Kit y, luego, procesa la imagen y la superposición en un solo paso. De esta manera, procesas en la superficie de visualización solo una vez por cada fotograma de entrada procesado. Consulta updatePreviewOverlayViewWithLastFrame en la muestra de inicio rápido del ML Kit para ver un ejemplo.