Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

Verwenden Sie ein benutzerdefiniertes TensorFlow Lite-Modell auf iOS

Wenn Ihre App benutzerdefinierte verwendet TensorFlow Lite Modelle, können Sie Firebase ML verwenden , um Ihre Modelle bereitstellen. Durch die Bereitstellung von Modellen mit Firebase können Sie die anfängliche Downloadgröße Ihrer App reduzieren und die ML-Modelle Ihrer App aktualisieren, ohne eine neue Version Ihrer App zu veröffentlichen. Und mit Remote Config und A/B-Tests können Sie verschiedene Modelle dynamisch für verschiedene Benutzergruppen bereitstellen.

Voraussetzungen

  • Die MLModelDownloader Bibliothek ist für Swift verfügbar.
  • TensorFlow Lite läuft nur auf Geräten mit iOS 9 und höher.

TensorFlow Lite-Modelle

TensorFlow Lite-Modelle sind ML-Modelle, die für die Ausführung auf mobilen Geräten optimiert sind. So erhalten Sie ein TensorFlow Lite-Modell:

Bevor Sie beginnen

  1. Wenn Sie nicht bereits Firebase zu Ihrer App, tun Sie dies , indem Sie die Schritte im Leitfaden zur Inbetriebnahme .
  2. Fügen Sie Firebase in Ihr Podfile ein:

    Schnell

    pod 'Firebase/MLModelDownloader'
    pod 'TensorFlowLiteSwift'
    
    Nachdem Sie Ihr Projekt Pods installieren oder aktualisieren, sollten Sie Ihre Xcode - Projekt mit seiner öffnen .xcworkspace .
  3. Importieren Sie Firebase in Ihre App:

    Schnell

    import Firebase
    import TensorFlowLite
    

1. Stellen Sie Ihr Modell bereit

Stellen Sie Ihre benutzerdefinierten TensorFlow-Modelle entweder über die Firebase-Konsole oder die Firebase Admin Python- und Node.js-SDKs bereit. Siehe Deploy und kundenspezifische Modelle verwalten .

Nachdem Sie Ihrem Firebase-Projekt ein benutzerdefiniertes Modell hinzugefügt haben, können Sie in Ihren Apps mit dem von Ihnen angegebenen Namen auf das Modell verweisen. Zu jeder Zeit können Sie ein neues TensorFlow Lite Modell einsetzen und das neue Modell auf den Geräten der Benutzer herunterladen durch den Aufruf getModel() (siehe unten).

2. Laden Sie das Modell auf das Gerät herunter und initialisieren Sie einen TensorFlow Lite-Interpreter

Um Ihr TensorFlow Lite-Modell in Ihrer App zu verwenden, verwenden Sie zuerst das Firebase ML SDK, um die neueste Version des Modells auf das Gerät herunterzuladen.

Um das Modell Download zu starten, rufen Sie die Modell - Downloader getModel() Methode, Angabe des Namens Sie das Modell zugewiesen , wenn Sie es hochgeladen, ob Sie wollen immer das neueste Modell herunterzuladen, und die Bedingungen , unter denen Sie das Herunterladen ermöglichen.

Sie können aus drei Download-Verhalten wählen:

Download-Typ Beschreibung
localModel Rufen Sie das lokale Modell vom Gerät ab. Wenn es kein lokales Modell zur Verfügung, dies verhält sich wie latestModel . Verwenden Sie diesen Downloadtyp, wenn Sie nicht nach Modellaktualisierungen suchen möchten. Sie verwenden beispielsweise Remote Config zum Abrufen von Modellnamen und laden Modelle immer unter neuen Namen hoch (empfohlen).
localModelUpdateInBackground Holen Sie sich das lokale Modell vom Gerät und starten Sie die Aktualisierung des Modells im Hintergrund. Wenn es kein lokales Modell zur Verfügung, dies verhält sich wie latestModel .
latestModel Holen Sie sich das neueste Modell. Wenn das lokale Modell die neueste Version ist, wird das lokale Modell zurückgegeben. Laden Sie andernfalls das neueste Modell herunter. Dieses Verhalten wird blockiert, bis die neueste Version heruntergeladen wurde (nicht empfohlen). Verwenden Sie dieses Verhalten nur in Fällen, in denen Sie explizit die neueste Version benötigen.

Sie sollten modellbezogene Funktionen deaktivieren, z. B. einen Teil Ihrer Benutzeroberfläche ausblenden oder ausblenden, bis Sie bestätigen, dass das Modell heruntergeladen wurde.

Schnell

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

Viele Apps starten die Download-Aufgabe in ihrem Initialisierungscode, aber Sie können dies jederzeit tun, bevor Sie das Modell verwenden müssen.

3. Führen Sie eine Inferenz auf Eingabedaten durch

Rufen Sie die Eingabe- und Ausgabeformen Ihres Modells ab

Der Modellinterpreter von TensorFlow Lite verwendet als Eingabe und erzeugt als Ausgabe ein oder mehrere mehrdimensionale Arrays. Diese Arrays enthalten entweder byte , int , long oder float Werte. Bevor Sie Daten an ein Modell übergeben oder dessen Ergebnis verwenden können, müssen Sie die Anzahl und Dimensionen ("Form") der von Ihrem Modell verwendeten Arrays kennen.

Wenn Sie das Modell selbst erstellt haben oder das Eingabe- und Ausgabeformat des Modells dokumentiert ist, verfügen Sie möglicherweise bereits über diese Informationen. Wenn Sie die Form und den Datentyp der Ein- und Ausgabe Ihres Modells nicht kennen, können Sie Ihr Modell mit dem TensorFlow Lite-Interpreter überprüfen. Zum Beispiel:

Python

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

Beispielausgabe:

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

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

Führen Sie den Dolmetscher aus

Nachdem Sie das Format der Eingabe und Ausgabe Ihres Modells bestimmt haben, rufen Sie Ihre Eingabedaten ab und führen Sie alle Transformationen an den Daten durch, die erforderlich sind, um eine Eingabe mit der richtigen Form für Ihr Modell zu erhalten.

Zum Beispiel, wenn Ihr Modell Bilder verarbeitet, und Ihr Modell hat Eingangsabmaße von [1, 224, 224, 3] Gleitkommawerte, können Sie das Bild der Farbwerte auf einen Floating-Point - Bereich wie im folgenden Beispiel skalieren müssen :

Schnell

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

Kopieren Sie dann Ihre Eingabe NSData dem Dolmetscher und führen Sie es:

Schnell

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

Sie können das ouput Modell erhalten , indem die Dolmetscher Aufruf output(at:) Methode. Wie Sie die Ausgabe verwenden, hängt vom verwendeten Modell ab.

Wenn Sie beispielsweise eine Klassifizierung durchführen, können Sie im nächsten Schritt die Indizes des Ergebnisses den Bezeichnungen zuordnen, die sie darstellen:

Schnell

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

Anhang: Modellsicherheit

Unabhängig davon, wie Sie Ihre TensorFlow Lite-Modelle für Firebase ML verfügbar machen, speichert Firebase ML sie im standardmäßigen serialisierten Protobuf-Format im lokalen Speicher.

Theoretisch bedeutet dies, dass jeder Ihr Modell kopieren kann. In der Praxis sind die meisten Modelle jedoch so anwendungsspezifisch und durch Optimierungen verschleiert, dass das Risiko ähnlich ist wie bei Konkurrenten, die Ihren Code zerlegen und wiederverwenden. Sie sollten sich dieses Risikos jedoch bewusst sein, bevor Sie ein benutzerdefiniertes Modell in Ihrer App verwenden.