Detecta objetos en imágenes con un modelo entrenado por AutoML en plataformas de Apple

Después de entrenar tu propio modelo con AutoML Vision Edge, puedes usarlo en tu app para detectar objetos en imágenes.

Hay dos formas de integrar modelos entrenados desde AutoML Vision Edge. Para empaquetar el modelo, copia los archivos del modelo en tu proyecto de Xcode o descárgalos de forma dinámica desde Firebase.

Opciones de empaquetado de modelos
Empaquetados en tu app	El modelo es parte del paquete El modelo está disponible de inmediato, incluso cuando el dispositivo Apple está sin conexión No se necesita un proyecto de Firebase
Alojado en Firebase	El modelo se sube al aprendizaje automático de Firebase para alojarlo Se reduce el tamaño del paquete de app El modelo se descarga a pedido El modelo de envío se actualiza sin volver a publicar la app Pruebas A/B sencillas con Firebase Remote Config Se requiere un proyecto de Firebase

Antes de comenzar

Si quieres descargar un modelo, asegúrate de agregar Firebase a tu proyecto de Apple, en caso de que aún no lo hayas hecho. Esto no es obligatorio cuando se agrupa un modelo.
Incluye las bibliotecas de TensorFlow y Firebase en tu Podfile:

Para empaquetar un modelo con tu app, sigue estos pasos:
Swift
```
pod 'TensorFlowLiteSwift'
```
Objective-C
```
pod 'TensorFlowLiteObjC'
```
Para descargar un modelo de Firebase de forma dinámica, agrega la dependencia Firebase/MLModelInterpreter:
Swift
```
pod 'TensorFlowLiteSwift'
pod 'Firebase/MLModelInterpreter'
```
Objective-C
```
pod 'TensorFlowLiteObjC'
pod 'Firebase/MLModelInterpreter'
```
Después de instalar o actualizar los Pods de tu proyecto, abre el proyecto de Xcode con su .xcworkspace.

1. Carga el modelo

Configura una fuente de modelo local

Para empaquetar el modelo con tu app, copia el modelo y el archivo de etiquetas en tu proyecto de Xcode y asegúrate de seleccionar Create folder references cuando lo hagas. El archivo del modelo y las etiquetas se incluirán en el conjunto de la app.

Además, presta atención al archivo tflite_metadata.json que se creó junto con el modelo. Necesitas dos valores:

Las dimensiones de entrada del modelo. El valor predeterminado es 320 × 320.
La cantidad máxima de detecciones del modelo. Es 40 de forma predeterminada.

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:

Swift

let remoteModel = CustomRemoteModel(
    name: "your_remote_model"  // The name you assigned in the Google Cloud console.
)

Objective-C

FIRCustomRemoteModel *remoteModel = [[FIRCustomRemoteModel alloc]
                                     initWithName:@"your_remote_model"];

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:

Swift

let downloadProgress = ModelManager.modelManager().download(
    remoteModel,
    conditions: ModelDownloadConditions(
        allowsCellularAccess: true,
        allowsBackgroundDownloading: true
    )
)

Objective-C

FIRModelDownloadConditions *conditions =
        [[FIRModelDownloadConditions alloc] initWithAllowsCellularAccess:YES
                                             allowsBackgroundDownloading:YES];
NSProgress *progress = [[FIRModelManager modelManager] downloadModel:remoteModel
                                                          conditions:conditions];

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.

Crea un detector de objetos a partir de tu modelo

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

Si solo tienes un modelo empaquetado a nivel local, crea un intérprete a partir del archivo de modelo:

Swift

guard let modelPath = Bundle.main.path(
    forResource: "model",
    ofType: "tflite"
) else {
  print("Failed to load the model file.")
  return true
}
let interpreter = try Interpreter(modelPath: modelPath)
try interpreter.allocateTensors()

Objective-C

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

NSError *error;
TFLInterpreter *interpreter = [[TFLInterpreter alloc] initWithModelPath:modelPath
                                                                  error:&error];
if (error != NULL) { return; }

[interpreter allocateTensorsWithError:&error];
if (error != NULL) { return; }

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 debes confirmarlo antes de ejecutar el intérprete, 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 Interpreter: crea un intérprete desde el modelo remoto si se descargó o, en su defecto, desde el modelo local.

Swift

var modelPath: String?
if ModelManager.modelManager().isModelDownloaded(remoteModel) {
    ModelManager.modelManager().getLatestModelFilePath(remoteModel) { path, error in
        guard error == nil else { return }
        guard let path = path else { return }
        modelPath = path
    }
} else {
    modelPath = Bundle.main.path(
        forResource: "model",
        ofType: "tflite"
    )
}

guard modelPath != nil else { return }
let interpreter = try Interpreter(modelPath: modelPath)
try interpreter.allocateTensors()

Objective-C

__block NSString *modelPath;
if ([[FIRModelManager modelManager] isModelDownloaded:remoteModel]) {
    [[FIRModelManager modelManager] getLatestModelFilePath:remoteModel
                                                completion:^(NSString * _Nullable filePath,
                                                             NSError * _Nullable error) {
        if (error != NULL) { return; }
        if (filePath == NULL) { return; }
        modelPath = filePath;
    }];
} else {
    modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                ofType:@"tflite"];
}

NSError *error;
TFLInterpreter *interpreter = [[TFLInterpreter alloc] initWithModelPath:modelPath
                                                                  error:&error];
if (error != NULL) { return; }

[interpreter allocateTensorsWithError:&error];
if (error != NULL) { return; }

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:

Swift

NotificationCenter.default.addObserver(
    forName: .firebaseMLModelDownloadDidSucceed,
    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: .firebaseMLModelDownloadDidFail,
    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:FIRModelDownloadDidSucceedNotification
                object:nil
                 queue:nil
            usingBlock:^(NSNotification *_Nonnull note) {
              if (weakSelf == nil | note.userInfo == nil) {
                return;
              }
              __strong typeof(self) strongSelf = weakSelf;

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

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

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

2. Prepara la imagen de entrada

A continuación, debes preparar tus imágenes para el intérprete de TensorFlow Lite.

Recorta y escala la imagen a las dimensiones de entrada del modelo, como se especifica en el archivo tflite_metadata.json (de forma predeterminada, 320 × 320 píxeles). Puedes hacerlo con Core Image o con una biblioteca de terceros.

Copia los datos de imagen en un Data (objeto NSData):

Swift

guard let image: CGImage = // Your input image
guard let context = CGContext(
  data: nil,
  width: image.width, height: image.height,
  bitsPerComponent: 8, bytesPerRow: image.width * 4,
  space: CGColorSpaceCreateDeviceRGB(),
  bitmapInfo: CGImageAlphaInfo.noneSkipFirst.rawValue
) else {
  return nil
}

context.draw(image, in: CGRect(x: 0, y: 0, width: image.width, height: image.height))
guard let imageData = context.data else { return nil }

var inputData = Data()
for row in 0 ..< 320 {    // Model takes 320x320 pixel images as input
  for col in 0 ..< 320 {
    let offset = 4 * (col * context.width + row)
    // (Ignore offset 0, the unused alpha channel)
    var red = imageData.load(fromByteOffset: offset+1, as: UInt8.self)
    var green = imageData.load(fromByteOffset: offset+2, as: UInt8.self)
    var blue = imageData.load(fromByteOffset: offset+3, as: UInt8.self)

    inputData.append(&red, count: 1)
    inputData.append(&green, count: 1)
    inputData.append(&blue, count: 1)
  }
}

Objective-C

CGImageRef image = // Your input image
long imageWidth = CGImageGetWidth(image);
long imageHeight = CGImageGetHeight(image);
CGContextRef context = CGBitmapContextCreate(nil,
                                             imageWidth, imageHeight,
                                             8,
                                             imageWidth * 4,
                                             CGColorSpaceCreateDeviceRGB(),
                                             kCGImageAlphaNoneSkipFirst);
CGContextDrawImage(context, CGRectMake(0, 0, imageWidth, imageHeight), image);
UInt8 *imageData = CGBitmapContextGetData(context);

NSMutableData *inputData = [[NSMutableData alloc] initWithCapacity:0];

for (int row = 0; row < 300; row++) {
  for (int col = 0; col < 300; col++) {
    long offset = 4 * (row * imageWidth + col);
    // (Ignore offset 0, the unused alpha channel)
    UInt8 red = imageData[offset+1];
    UInt8 green = imageData[offset+2];
    UInt8 blue = imageData[offset+3];

    [inputData appendBytes:&red length:1];
    [inputData appendBytes:&green length:1];
    [inputData appendBytes:&blue length:1];
  }
}

3. Ejecuta el detector de objetos

A continuación, pasa la entrada preparada al intérprete:

Swift

try interpreter.copy(inputData, toInputAt: 0)
try interpreter.invoke()

Objective-C

TFLTensor *input = [interpreter inputTensorAtIndex:0 error:&error];
if (error != nil) { return; }

[input copyData:inputData error:&error];
if (error != nil) { return; }

[interpreter invokeWithError:&error];
if (error != nil) { return; }

4. Obtén información sobre los objetos detectados

Si la detección de objetos se realiza de forma correcta, el modelo muestra como resultado tres arreglos de 40 elementos cada uno (o lo que se haya especificado en el archivo tflite_metadata.json). Cada elemento corresponde a un posible objeto. El primer array es un conjunto de cuadros de límite; el segundo, uno de etiquetas, y el tercero es uno de valores de confianza. Para obtener los resultados del modelo, sigue estos pasos:

Swift

var output = try interpreter.output(at: 0)
let boundingBoxes =
    UnsafeMutableBufferPointer<Float32>.allocate(capacity: 4 * 40)
output.data.copyBytes(to: boundingBoxes)

output = try interpreter.output(at: 1)
let labels =
    UnsafeMutableBufferPointer<Float32>.allocate(capacity: 40)
output.data.copyBytes(to: labels)

output = try interpreter.output(at: 2)
let probabilities =
    UnsafeMutableBufferPointer<Float32>.allocate(capacity: 40)
output.data.copyBytes(to: probabilities)

Objective-C

TFLTensor *output = [interpreter outputTensorAtIndex:0 error:&error];
if (error != nil) { return; }
NSData *boundingBoxes = [output dataWithError:&error];
if (error != nil) { return; }

output = [interpreter outputTensorAtIndex:1 error:&error];
if (error != nil) { return; }
NSData *labels = [output dataWithError:&error];
if (error != nil) { return; }

output = [interpreter outputTensorAtIndex:2 error:&error];
if (error != nil) { return; }
NSData *probabilities = [output dataWithError:&error];
if (error != nil) { return; }

Luego, puedes combinar los resultados de las etiquetas con tu diccionario de etiquetas:

Swift

guard let labelPath = Bundle.main.path(
    forResource: "dict",
    ofType: "txt"
) else { return true }
let fileContents = try? String(contentsOfFile: labelPath)
guard let labelText = fileContents?.components(separatedBy: "\n") else { return true }

for i in 0 ..< 40 {
    let top = boundingBoxes[0 * i]
    let left = boundingBoxes[1 * i]
    let bottom = boundingBoxes[2 * i]
    let right = boundingBoxes[3 * i]

    let labelIdx = Int(labels[i])
    let label = labelText[labelIdx]
    let confidence = probabilities[i]

    if confidence > 0.66 {
        print("Object found: \(label) (confidence: \(confidence))")
        print("  Top-left: (\(left),\(top))")
        print("  Bottom-right: (\(right),\(bottom))")
    }
}

Objective-C

NSString *labelPath = [NSBundle.mainBundle pathForResource:@"dict"
                                                    ofType:@"txt"];
NSString *fileContents = [NSString stringWithContentsOfFile:labelPath
                                                   encoding:NSUTF8StringEncoding
                                                      error:&error];
if (error != nil || fileContents == NULL) { return; }
NSArray<NSString*> *labelText = [fileContents componentsSeparatedByString:@"\n"];

for (int i = 0; i < 40; i++) {
    Float32 top, right, bottom, left;
    Float32 labelIdx;
    Float32 confidence;

    [boundingBoxes getBytes:&top range:NSMakeRange(16 * i + 0, 4)];
    [boundingBoxes getBytes:&left range:NSMakeRange(16 * i + 4, 4)];
    [boundingBoxes getBytes:&bottom range:NSMakeRange(16 * i + 8, 4)];
    [boundingBoxes getBytes:&right range:NSMakeRange(16 * i + 12, 4)];

    [labels getBytes:&labelIdx range:NSMakeRange(4 * i, 4)];
    [probabilities getBytes:&confidence range:NSMakeRange(4 * i, 4)];

    if (confidence > 0.5f) {
        NSString *label = labelText[(int)labelIdx];
        NSLog(@"Object detected: %@", label);
        NSLog(@"  Confidence: %f", confidence);
        NSLog(@"  Top-left: (%f,%f)", left, top);
        NSLog(@"  Bottom-right: (%f,%f)", right, bottom);
    }
}

Sugerencias para mejorar el rendimiento en tiempo real

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

Regula las llamadas al detector. Si hay un fotograma de video nuevo disponible mientras se ejecuta el detector, ignora ese fotograma.
Si estás usando la salida del detector para superponer gráficos en la imagen de entrada, primero obtén el resultado 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. Consulta las clases previewOverlayView y FIRDetectionOverlayView en la app de muestra para ver un ejemplo.