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

Cuando pasas una imagen al Kit de AA, se detectan hasta cinco objetos en ella, junto con la posición de cada uno. Cuando se detectan objetos en transmisiones de video por Internet, cada uno de ellos tiene un ID único que puedes usar para seguirlo de fotograma a fotograma.

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

Hay dos formas de integrar un modelo personalizado. Para empaquetar el modelo, puedes colocarlo en la carpeta de elementos de tu app o descargarlo de forma dinámica desde Firebase. En la siguiente tabla, se comparan las dos opciones.

Probarlo

• Consulta la app de la guía de inicio rápido de Vision para ver un uso de ejemplo del modelo empaquetado y la app de inicio rápido de AutoML para ver un ejemplo de uso del modelo alojado.
• Consulta la app de muestra de material design para ver una implementación de extremo a extremo de esta API.

Antes de comenzar

1. Incluye las bibliotecas del Kit de AA en tu Podfile:

   Para empaquetar un modelo con tu app, haz lo siguiente:

   pod 'GoogleMLKit/ObjectDetectionCustom', '3.2.0'
   

   Para descargar un modelo de Firebase de forma dinámica, agrega la dependencia LinkFirebase:

   pod 'GoogleMLKit/ObjectDetectionCustom', '3.2.0'
   pod 'GoogleMLKit/LinkFirebase', '3.2.0'
   

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

3. Si quieres descargar un modelo, 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

Para empaquetar el modelo con tu app, haz lo siguiente:

1. Copia el archivo del modelo (por lo general, termina en .tflite o .lite) a tu proyecto de Xcode. Asegúrate de seleccionar Copy bundle resources cuando lo hagas. El archivo del modelo se incluirá en el paquete de la app y estará disponible para el Kit de AA.

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

   Swift

   let localModel = LocalModel(path: localModelFilePath)

   Objective‑C

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

Configura una fuente de modelo alojada en Firebase

Para usar el modelo alojado de forma remota, crea un objeto CustomRemoteModel y especifica el nombre que le asignaste al modelo cuando lo publicaste:

let firebaseModelSource = FirebaseModelSource(
    name: "your_remote_model") // The name you assigned in
                               // the Firebase console.
let remoteModel = CustomRemoteModel(remoteModelSource: firebaseModelSource)

MLKFirebaseModelSource *firebaseModelSource =
    [[MLKFirebaseModelSource alloc]
        initWithName:@"your_remote_model"]; // The name you assigned in
                                            // the Firebase console.
MLKCustomRemoteModel *remoteModel =
    [[MLKCustomRemoteModel alloc]
        initWithRemoteModelSource:firebaseModelSource];

Luego, inicia la tarea de descarga del modelo y especifica las condiciones en las que deseas permitir la descarga. Si el modelo no está en el dispositivo o si hay una versión más reciente de este, la tarea descargará el modelo de Firebase de forma asíncrona:

let downloadConditions = ModelDownloadConditions(
  allowsCellularAccess: true,
  allowsBackgroundDownloading: true
)

let downloadProgress = ModelManager.modelManager().download(
  remoteModel,
  conditions: downloadConditions
)

MLKModelDownloadConditions *downloadConditions =
    [[MLKModelDownloadConditions alloc] initWithAllowsCellularAccess:YES
                                         allowsBackgroundDownloading:YES];

NSProgress *downloadProgress =
    [[MLKModelManager modelManager] downloadModel:remoteModel
                                       conditions:downloadConditions];

Muchas apps comienzan la tarea de descarga en su código de inicialización, pero puedes hacerlo en cualquier momento antes de usar el modelo.

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 las siguientes opciones de configuración:

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

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

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. Puedes verificar el estado de la tarea de descarga del modelo con el método isModelDownloaded(remoteModel:) del administrador del modelo.

Aunque solo tienes que confirmar esto antes de ejecutar el detector de objetos, si tienes un modelo alojado de forma remota y uno empaquetado localmente, tendría sentido 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.

var options: CustomObjectDetectorOptions!
if (ModelManager.modelManager().isModelDownloaded(remoteModel)) {
  options = CustomObjectDetectorOptions(remoteModel: remoteModel)
} else {
  options = CustomObjectDetectorOptions(localModel: localModel)
}
options.detectorMode = .singleImage
options.shouldEnableClassification = true
options.shouldEnableMultipleObjects = true
options.classificationConfidenceThreshold = NSNumber(value: 0.5)
options.maxPerObjectLabelCount = 3

MLKCustomObjectDetectorOptions *options;
if ([[MLKModelManager modelManager] isModelDownloaded:remoteModel]) {
  options = [[MLKCustomObjectDetectorOptions alloc] initWithRemoteModel:remoteModel];
} else {
  options = [[MLKCustomObjectDetectorOptions alloc] initWithLocalModel:localModel];
}
options.detectorMode = MLKObjectDetectorModeSingleImage;
options.shouldEnableClassification = YES;
options.shouldEnableMultipleObjects = YES;
options.classificationConfidenceThreshold = @(0.5);
options.maxPerObjectLabelCount = 3;

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ó.

Puedes obtener el estado de descarga del modelo si adjuntas observadores al Centro de notificaciones predeterminado. Asegúrate de utilizar una referencia débil para self en el bloque de observador, ya que las descargas pueden demorar un tiempo y el objeto de origen se puede liberar antes de que finalice la descarga. Por ejemplo:

NotificationCenter.default.addObserver(
    forName: .mlkitModelDownloadDidSucceed,
    object: nil,
    queue: nil
) { [weak self] notification in
    guard let strongSelf = self,
        let userInfo = notification.userInfo,
        let model = userInfo[ModelDownloadUserInfoKey.remoteModel.rawValue]
            as? RemoteModel,
        model.name == "your_remote_model"
        else { return }
    // The model was downloaded and is available on the device
}

NotificationCenter.default.addObserver(
    forName: .mlkitModelDownloadDidFail,
    object: nil,
    queue: nil
) { [weak self] notification in
    guard let strongSelf = self,
        let userInfo = notification.userInfo,
        let model = userInfo[ModelDownloadUserInfoKey.remoteModel.rawValue]
            as? RemoteModel
        else { return }
    let error = userInfo[ModelDownloadUserInfoKey.error.rawValue]
    // ...
}

__weak typeof(self) weakSelf = self;

[NSNotificationCenter.defaultCenter
    addObserverForName:MLKModelDownloadDidSucceedNotification
                object:nil
                 queue:nil
            usingBlock:^(NSNotification *_Nonnull note) {
              if (weakSelf == nil | note.userInfo == nil) {
                return;
              }
              __strong typeof(self) strongSelf = weakSelf;

              MLKRemoteModel *model = note.userInfo[MLKModelDownloadUserInfoKeyRemoteModel];
              if ([model.name isEqualToString:@"your_remote_model"]) {
                // The model was downloaded and is available on the device
              }
            }];

[NSNotificationCenter.defaultCenter
    addObserverForName:MLKModelDownloadDidFailNotification
                object:nil
                 queue:nil
            usingBlock:^(NSNotification *_Nonnull note) {
              if (weakSelf == nil | note.userInfo == nil) {
                return;
              }
              __strong typeof(self) strongSelf = weakSelf;

              NSError *error = note.userInfo[MLKModelDownloadUserInfoKeyError];
            }];

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

• Detección en tiempo real y seguimiento del objeto más prominente en el visor de la cámara.
• La detección de varios objetos de una imagen estática.

A fin de configurar la API para estos casos prácticos, sigue estos pasos:

// 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

// 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 CMSampleBuffer.

Si usas un UIImage, sigue estos pasos:

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

  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 que se encuentran en 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 objeto y la orientación CMSampleBuffer:

  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:

// 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")
}

// 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 experiencia del usuario excelente

Para obtener la mejor experiencia del usuario, sigue estos lineamientos en tu aplicación:

• La detección correcta de objetos depende de la complejidad visual del objeto. Para que se puedan detectar, es posible que los objetos con una pequeña cantidad de características visuales deban ocupar una parte más grande de la imagen. Debes proporcionar a los usuarios orientación sobre la captura de entradas que funcione 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 admitidas, implementa un control especial para objetos desconocidos.

Además, consulta la [app escaparate de material design del Kit de AA][vínculo de la app escaparate]{: .external } y la colección de patrones para las funciones con tecnología de aprendizaje automático de material design.

Cómo mejorar el rendimiento

• Cuando uses el modo de transmisión en una aplicación en tiempo real, no uses la detección de varios 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 función captureOutput(_, didOutput:from:) de AVCaptureVideoDataOutputSampleBufferDelegate para obtener resultados de manera síncrona desde el marco de video determinado. Mantén el alwaysDiscardsLateVideoFrames de AVCaptureVideoDataOutput como true para regular las llamadas al detector. Si hay un fotograma de video nuevo disponible mientras se ejecuta el detector, se descartará.
• Si usas la salida del detector para superponer gráficos en la imagen de entrada, primero obtén el resultado del Kit de AA 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 la updatePreviewOverlayViewWithLastFrame en la muestra de inicio rápido del Kit de AA para ver un ejemplo.