Utilice un modelo personalizado de TensorFlow Lite en plataformas Apple

Si tu aplicación usa modelos personalizados de TensorFlow Lite , puedes usar Firebase ML para implementar tus modelos. Al implementar modelos con Firebase, puedes reducir el tamaño de descarga inicial de tu aplicación y actualizar los modelos de aprendizaje automático de tu aplicación sin lanzar una nueva versión de tu aplicación. Y, con Remote Config y A/B Testing, puede servir dinámicamente diferentes modelos a diferentes conjuntos de usuarios.

Requisitos previos

• La biblioteca MLModelDownloader solo está disponible para Swift.
• TensorFlow Lite solo se ejecuta en dispositivos que utilizan iOS 9 y versiones posteriores.

Modelos TensorFlow Lite

Los modelos TensorFlow Lite son modelos ML que están optimizados para ejecutarse en dispositivos móviles. Para obtener un modelo de TensorFlow Lite:

• Utilice un modelo prediseñado, como uno de los modelos oficiales de TensorFlow Lite .
• Convierta un modelo de TensorFlow, un modelo de Keras o una función concreta a TensorFlow Lite.

Antes de que empieces

Para usar TensorFlowLite con Firebase, debe usar CocoaPods ya que TensorFlowLite actualmente no admite la instalación con Swift Package Manager. Consulte la guía de instalación de CocoaPods para obtener instrucciones sobre cómo instalar MLModelDownloader .

Una vez instalado, importe Firebase y TensorFlowLite para poder usarlos.

import FirebaseMLModelDownloader
import TensorFlowLite

1. Implementa tu modelo

Implementa tus modelos personalizados de TensorFlow usando Firebase console o los SDK de Firebase Admin Python y Node.js. Consulte Implementar y administrar modelos personalizados .

Después de agregar un modelo personalizado a tu proyecto de Firebase, puedes hacer referencia al modelo en tus aplicaciones usando el nombre que especificaste. En cualquier momento, puedes implementar un nuevo modelo de TensorFlow Lite y descargarlo en los dispositivos de los usuarios llamando a getModel() (ver más abajo).

2. Descargue el modelo en el dispositivo e inicialice un intérprete de TensorFlow Lite.

Para iniciar la descarga del modelo, llame al método getModel() del descargador de modelos, especificando el nombre que le asignó al modelo cuando lo cargó, si desea descargar siempre el último modelo y las condiciones bajo las cuales desea permitir la descarga.

Puede elegir entre tres comportamientos de descarga:

Debe deshabilitar la funcionalidad relacionada con el modelo (por ejemplo, atenuar u ocultar parte de su interfaz de usuario) hasta que confirme que el modelo se ha descargado.

let conditions = ModelDownloadConditions(allowsCellularAccess: false)
ModelDownloader.modelDownloader()
    .getModel(name: "your_model",
              downloadType: .localModelUpdateInBackground,
              conditions: conditions) { result in
        switch (result) {
        case .success(let customModel):
            do {
                // Download complete. Depending on your app, you could enable the ML
                // feature, or switch from the local model to the remote model, etc.

                // The CustomModel object contains the local path of the model file,
                // which you can use to instantiate a TensorFlow Lite interpreter.
                let interpreter = try Interpreter(modelPath: customModel.path)
            } catch {
                // Error. Bad model file?
            }
        case .failure(let error):
            // Download was unsuccessful. Don't enable ML features.
            print(error)
        }
}

Muchas aplicaciones inician la tarea de descarga en su código de inicialización, pero puede hacerlo en cualquier momento antes de necesitar usar el modelo.

3. Realizar inferencias sobre los datos de entrada.

Obtenga las formas de entrada y salida de su modelo

El intérprete del modelo TensorFlow Lite toma como entrada y produce como salida una o más matrices multidimensionales. Estas matrices contienen valores byte , int , long o float . Antes de poder pasar datos a un modelo o utilizar su resultado, debe conocer el número y las dimensiones ("forma") de las matrices que utiliza su modelo.

Si creó el modelo usted mismo, o si el formato de entrada y salida del modelo está documentado, es posible que ya tenga esta información. Si no conoce la forma y el tipo de datos de la entrada y salida de su modelo, puede usar el intérprete de TensorFlow Lite para inspeccionar su modelo. Por ejemplo:

import tensorflow as tf

interpreter = tf.lite.Interpreter(model_path="your_model.tflite")
interpreter.allocate_tensors()

# Print input shape and type
inputs = interpreter.get_input_details()
print('{} input(s):'.format(len(inputs)))
for i in range(0, len(inputs)):
    print('{} {}'.format(inputs[i]['shape'], inputs[i]['dtype']))

# Print output shape and type
outputs = interpreter.get_output_details()
print('\n{} output(s):'.format(len(outputs)))
for i in range(0, len(outputs)):
    print('{} {}'.format(outputs[i]['shape'], outputs[i]['dtype']))

1 input(s):
[  1 224 224   3] <class 'numpy.float32'>

1 output(s):
[1 1000] <class 'numpy.float32'>

Ejecute el intérprete

Por ejemplo, si su modelo procesa imágenes y su modelo tiene dimensiones de entrada de [1, 224, 224, 3] valores de punto flotante, es posible que tenga que escalar los valores de color de la imagen a un rango de punto flotante como en el siguiente ejemplo. :

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 false
}

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

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

    // Normalize channel values to [0.0, 1.0]. This requirement varies
    // by model. For example, some models might require values to be
    // normalized to the range [-1.0, 1.0] instead, and others might
    // require fixed-point values or the original bytes.
    var normalizedRed = Float32(red) / 255.0
    var normalizedGreen = Float32(green) / 255.0
    var normalizedBlue = Float32(blue) / 255.0

    // Append normalized values to Data object in RGB order.
    let elementSize = MemoryLayout.size(ofValue: normalizedRed)
    var bytes = [UInt8](repeating: 0, count: elementSize)
    memcpy(&bytes, &normalizedRed, elementSize)
    inputData.append(&bytes, count: elementSize)
    memcpy(&bytes, &normalizedGreen, elementSize)
    inputData.append(&bytes, count: elementSize)
    memcpy(&ammp;bytes, &normalizedBlue, elementSize)
    inputData.append(&bytes, count: elementSize)
  }
}

Luego, copie su entrada NSData al intérprete y ejecútelo:

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

Puede obtener el resultado del modelo llamando al método output(at:) del intérprete. La forma de utilizar la salida depende del modelo que esté utilizando.

Por ejemplo, si está realizando una clasificación, como siguiente paso, puede asignar los índices del resultado a las etiquetas que representan:

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

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

for i in labels.indices {
    print("\(labels[i]): \(probabilities[i])")
}

Apéndice: Seguridad del modelo

Independientemente de cómo hagas que tus modelos de TensorFlow Lite estén disponibles para Firebase ML, Firebase ML los almacena en el formato protobuf serializado estándar en el almacenamiento local.

En teoría, esto significa que cualquiera puede copiar su modelo. Sin embargo, en la práctica, la mayoría de los modelos son tan específicos de la aplicación y están tan confusos por las optimizaciones que el riesgo es similar al de que los competidores desensamblen y reutilicen su código. Sin embargo, debes ser consciente de este riesgo antes de utilizar un modelo personalizado en tu aplicación.