Etiqueta imágenes con un modelo personalizado en iOS

Puedes usar el Kit de AA para reconocer entidades en una imagen y etiquetarlas. Esta API admite una amplia variedad de modelos personalizados de clasificación de imágenes. Por favor, consulta Modelos personalizados con el Kit de AA para obtener orientación sobre 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. Puedes empaquetar el modelo colocarla dentro de la carpeta de recursos de la app, o bien puedes descargarla de forma dinámica desde Firebase. En la siguiente tabla, se comparan las dos opciones.

Modelo empaquetado Modelo alojado
El modelo es parte del APK de tu app, que aumenta su tamaño. El modelo no forma parte de tu APK. Se aloja subiendo a Aprendizaje automático de Firebase.
El modelo está disponible de inmediato, incluso cuando el dispositivo Android está sin conexión El modelo se descarga a pedido
No se necesita un proyecto de Firebase Requiere un proyecto de Firebase
Debes volver a publicar tu app para actualizar el modelo Envía actualizaciones del modelo sin volver a publicar tu app
Sin pruebas A/B integradas Pruebas A/B sencillas con Firebase Remote Config

Probar

Antes de comenzar

  1. Incluye las bibliotecas del ML Kit en tu Podfile:

    Para empaquetar un modelo con tu app, sigue estos pasos:

    pod 'GoogleMLKit/ImageLabelingCustom', '8.0.0'

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

    pod 'GoogleMLKit/ImageLabelingCustom', '8.0.0'
pod 'GoogleMLKit/LinkFirebase', '8.0.0'

  2. Después de instalar o actualizar los Pods de tu proyecto, abre tu proyecto de Xcode. con su .xcworkspace. El Kit de AA es compatible con la versión 13.2.1 de Xcode. o una superior.

  3. Si quieres descargar un modelo, asegúrate de agregar Firebase a tu proyecto de iOS si aún no lo has hecho. Esto no es necesario cuando agrupas los un modelo de responsabilidad compartida.

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 (que generalmente termina en .tflite o .lite) en tu Xcode y asegúrate de seleccionar Copy bundle resources cuando lo hagas. El 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 de acceso 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 RemoteModel y especifica la nombre que le asignaste al modelo cuando lo publicaste:

Swift

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

Objective-C

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 que deseas permitir la descarga. Si el modelo no está en el dispositivo o si es del modelo está disponible, la tarea descargará de forma asíncrona la de Firebase:

Swift

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

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

Objective-C

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 tú puedes hacerlo en cualquier momento antes de usar el modelo.

Configura el etiquetador de imágenes

Después de configurar las fuentes de tu modelo, crea un objeto ImageLabeler a partir de una. de ellas.

Están disponibles las siguientes opciones:

Opciones
confidenceThreshold

Puntuación de confianza mínima de las etiquetas detectadas. Si no se establece, de clasificación especificado por los metadatos del modelo. Si el modelo no contiene metadatos o si estos no especificas un umbral del clasificador, se establecerá un umbral predeterminado de 0.0 que se usan.
maxResultCount

Cantidad máxima de etiquetas que se mostrarán. Si no está establecido, el valor predeterminado de Se usará 10.

Si solo tienes un modelo empaquetado a nivel local, crea un etiquetador desde tu Objeto LocalModel:

Swift

let options = CustomImageLabelerOptions(localModel: localModel)
options.confidenceThreshold = NSNumber(value: 0.0)
let imageLabeler = ImageLabeler.imageLabeler(options: options)

Objective-C

MLKCustomImageLabelerOptions *options =
    [[MLKCustomImageLabelerOptions alloc] initWithLocalModel:localModel];
options.confidenceThreshold = @(0.0);
MLKImageLabeler *imageLabeler =
    [MLKImageLabeler imageLabelerWithOptions:options];

Si tienes un modelo alojado de forma remota, deberás verificar que se haya descargado antes de ejecutarlo. Puedes verificar el estado de la descarga del modelo tarea con el método isModelDownloaded(remoteModel:) del administrador de modelos.

Aunque solo tienes que confirmarlo antes de ejecutar el etiquetador, si tener un modelo alojado de forma remota y uno empaquetado localmente, podría hacer sentido realizar esta verificación cuando se cree una instancia de ImageLabeler: crea un del etiquetador del modelo remoto, si se descargó, y del modelo local de lo contrario.

Swift

var options: CustomImageLabelerOptions!
if (ModelManager.modelManager().isModelDownloaded(remoteModel)) {
  options = CustomImageLabelerOptions(remoteModel: remoteModel)
} else {
  options = CustomImageLabelerOptions(localModel: localModel)
}
options.confidenceThreshold = NSNumber(value: 0.0)
let imageLabeler = ImageLabeler.imageLabeler(options: options)

Objective-C

MLKCustomImageLabelerOptions *options;
if ([[MLKModelManager modelManager] isModelDownloaded:remoteModel]) {
  options = [[MLKCustomImageLabelerOptions alloc] initWithRemoteModel:remoteModel];
} else {
  options = [[MLKCustomImageLabelerOptions alloc] initWithLocalModel:localModel];
}
options.confidenceThreshold = @(0.0);
MLKImageLabeler *imageLabeler =
    [MLKImageLabeler imageLabelerWithOptions:options];

Si solo tienes un modelo alojado de forma remota, debes inhabilitar las funciones funcional, por ejemplo, ocultar o inhabilitar parte de tu IU, hasta que confirmas que el modelo se descargó.

Puedes obtener el estado de descarga del modelo adjuntando observadores al valor predeterminado Centro de notificaciones. Asegúrate de utilizar una referencia débil para self en el observador ya que las descargas pueden tardar un tiempo y el objeto de origen puede para cuando finalice la descarga. Por ejemplo:

Swift

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]
    // ...
}

Objective-C

__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];
            }];

2. Prepara la imagen de entrada

Crea un objeto VisionImage con un objeto UIImage o CMSampleBuffer

Si usas un UIImage, sigue estos pasos:

  • Crea un objeto VisionImage con 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:

  • Especificar la orientación de los datos de imagen que se incluyen en la 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 elemento Objeto CMSampleBuffer y 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];

3. Ejecuta el etiquetador de imágenes

Para etiquetar objetos de una imagen, pasa el objeto image al de ImageLabeler process().

De forma asíncrona:

Swift

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

Objective-C

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

De forma síncrona:

Swift

var labels: [ImageLabel]
do {
    labels = try imageLabeler.results(in: image)
} catch let error {
    // Handle the error.
    return
}
// Show results.

Objective-C

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

4. Obtén información sobre las entidades etiquetadas

Si la operación de etiquetado de imágenes se realiza correctamente, devuelve un array de ImageLabel Cada ImageLabel representa un elemento que se etiquetada en la imagen. Puedes obtener la descripción del texto de cada etiqueta (si está disponible en los metadatos del archivo del modelo de TensorFlow Lite, el índice y la puntuación de confianza. Por ejemplo:

Swift

for label in labels {
  let labelText = label.text
  let confidence = label.confidence
  let index = label.index
}

Objective-C

for (MLKImageLabel *label in labels) {
  NSString *labelText = label.text;
  float confidence = label.confidence;
  NSInteger index = label.index;
}

Sugerencias para mejorar el rendimiento en tiempo real

Si quieres etiquetar imágenes en una aplicación en tiempo real, sigue estos pasos: pautas para lograr la mejor velocidad de fotogramas:

  • Para procesar fotogramas de video, usa la API síncrona results(in:) del detector. Llamada este método desde De AVCaptureVideoDataOutputSampleBufferDelegate La función captureOutput(_, didOutput:from:) para obtener resultados de un video determinado de forma síncrona marco. Mantener de AVCaptureVideoDataOutput alwaysDiscardsLateVideoFrames como true para limitar las llamadas al detector Si un nuevo cliente El fotograma estará disponible mientras se ejecute el detector, que se descartará.
  • Si usas la salida del detector para superponer gráficos la imagen de entrada, primero obtén el resultado del ML Kit y, luego, renderiza la imagen y superponerla en un solo paso. De esta manera, renderizas en la superficie de visualización. solo una vez por cada trama de entrada procesada. Consulta updatePreviewOverlayViewWithLastFrame. en la muestra de inicio rápido del Kit de AA para ver un ejemplo.