获取我们在 Firebase 峰会上发布的所有信息,了解 Firebase 可如何帮助您加快应用开发速度并满怀信心地运行应用。了解详情

Use un modelo TensorFlow Lite personalizado en plataformas Apple

Si su aplicación usa modelos TensorFlow Lite personalizados, puede usar Firebase ML para implementar sus modelos. Al implementar modelos con Firebase, puede reducir el tamaño de descarga inicial de su aplicación y actualizar los modelos ML de su aplicación sin lanzar una nueva versión de su 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 usan iOS 9 y versiones posteriores.

Modelos de TensorFlow Lite

Los modelos TensorFlow Lite son modelos ML que están optimizados para ejecutarse en dispositivos móviles. Para obtener un modelo 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, importa Firebase y TensorFlowLite para usarlos.

Rápido

import FirebaseMLModelDownloader
import TensorFlowLite

1. Implementa tu modelo

Implemente sus modelos personalizados de TensorFlow con Firebase console o Firebase Admin Python y Node.js SDK. Consulte Implementar y administrar modelos personalizados .

Después de agregar un modelo personalizado a su proyecto de Firebase, puede hacer referencia al modelo en sus aplicaciones con el nombre que especificó. En cualquier momento, puede implementar un nuevo modelo de TensorFlow Lite y descargar el nuevo modelo en los dispositivos de los usuarios llamando a getModel() (consulte a continuación).

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

Para usar su modelo de TensorFlow Lite en su aplicación, primero use el SDK de Firebase ML para descargar la última versión del modelo en el dispositivo.

Para iniciar la descarga del modelo, llame al método getModel() del descargador de modelos, especificando el nombre que 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:

Tipo de descarga Descripción
localModel Obtenga el modelo local del dispositivo. Si no hay un modelo local disponible, se comporta como latestModel . Use este tipo de descarga si no está interesado en buscar actualizaciones de modelos. Por ejemplo, está utilizando Remote Config para recuperar nombres de modelos y siempre carga modelos con nuevos nombres (recomendado).
localModelUpdateInBackground Obtenga el modelo local del dispositivo y comience a actualizar el modelo en segundo plano. Si no hay un modelo local disponible, se comporta como latestModel .
latestModel Consigue el último modelo. Si el modelo local es la última versión, devuelve el modelo local. De lo contrario, descargue el último modelo. Este comportamiento se bloqueará hasta que se descargue la última versión (no recomendado). Use este comportamiento solo en los casos en que necesite explícitamente la última versión.

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

Rápido

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 que necesite usar el modelo.

3. Realizar inferencias sobre los datos de entrada

Obtenga las formas de entrada y salida de su modelo

El intérprete de modelos 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 que pueda pasar datos a un modelo o usar su resultado, debe conocer el número y las dimensiones ("forma") de las matrices que usa 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 la salida de su modelo, puede usar el intérprete de TensorFlow Lite para inspeccionar su modelo. Por ejemplo:

Pitón

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']))

Salida de ejemplo:

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

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

Ejecutar el intérprete

Una vez que haya determinado el formato de entrada y salida de su modelo, obtenga sus datos de entrada y realice las transformaciones en los datos que sean necesarias para obtener una entrada con la forma correcta para su modelo.

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 deba escalar los valores de color de la imagen a un rango de punto flotante como en el siguiente ejemplo :

Rápido

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 ..&lt; 224 {
  for col in 0 ..&lt; 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(&amp;bytes, &amp;normalizedRed, elementSize)
    inputData.append(&amp;bytes, count: elementSize)
    memcpy(&amp;bytes, &amp;normalizedGreen, elementSize)
    inputData.append(&amp;bytes, count: elementSize)
    memcpy(&ammp;bytes, &amp;normalizedBlue, elementSize)
    inputData.append(&amp;bytes, count: elementSize)
  }
}

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

Rápido

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

Puede obtener la salida del modelo llamando al método output(at:) del intérprete. La forma en que utilice 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:

Rápido

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: Modelo de seguridad

Independientemente de cómo haga que sus 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 ofuscados por las optimizaciones que el riesgo es similar al de los competidores que desensamblan y reutilizan su código. No obstante, debe tener en cuenta este riesgo antes de utilizar un modelo personalizado en su aplicación.