iOS'ta ML Kit ile çıkarım yapmak için TensorFlow Lite modelini kullanma

TensorFlow Lite modeliyle cihaz üzerinde çıkarım gerçekleştirmek için ML Kit'i kullanabilirsiniz.

ML Kit, TensorFlow Lite modellerini yalnızca iOS 9 ve daha yenisini çalıştıran cihazlarda kullanabilir.

Sen başlamadan önce

  1. Firebase'i uygulamanıza henüz eklemediyseniz başlangıç ​​kılavuzundaki adımları izleyerek bunu yapın.
  2. ML Kit kitaplıklarını Pod dosyanıza ekleyin:
    pod 'Firebase/MLModelInterpreter', '6.25.0'
    
    Projenizin Pod'larını yükledikten veya güncelledikten sonra, Xcode projenizi .xcworkspace kullanarak açtığınızdan emin olun.
  3. Uygulamanızda Firebase'i içe aktarın:

    Süratli

    import Firebase

    Amaç-C

    @import Firebase;
  4. Kullanmak istediğiniz TensorFlow modelini TensorFlow Lite formatına dönüştürün. Bkz. TOCO: TensorFlow Lite Optimize Edici Dönüştürücü .

Modelinizi barındırın veya paketleyin

Uygulamanızda çıkarım amacıyla bir TensorFlow Lite modelini kullanabilmeniz için öncelikle modeli ML Kit'in kullanımına sunmanız gerekir. ML Kit, Firebase kullanılarak uzaktan barındırılan, uygulama ikili dosyasıyla birlikte verilen TensorFlow Lite modellerini veya her ikisini birden kullanabilir.

Firebase'de bir model barındırarak, yeni bir uygulama sürümü yayınlamadan modeli güncelleyebilir ve farklı kullanıcı gruplarına farklı modelleri dinamik olarak sunmak için Uzaktan Yapılandırma ve A/B Testini kullanabilirsiniz.

Modeli yalnızca Firebase'de barındırarak sağlamayı ve uygulamanızla birlikte paketlememeyi seçerseniz uygulamanızın ilk indirme boyutunu azaltabilirsiniz. Ancak, model uygulamanızla birlikte paketlenmemişse, uygulamanız modeli ilk kez indirene kadar modelle ilgili herhangi bir işlevin kullanılamayacağını unutmayın.

Modelinizi uygulamanızla birlikte paketleyerek, Firebase tarafından barındırılan model mevcut olmadığında uygulamanızın makine öğrenimi özelliklerinin çalışmaya devam etmesini sağlayabilirsiniz.

Firebase'de modelleri barındırın

TensorFlow Lite modelinizi Firebase'de barındırmak için:

  1. Firebase konsolunun ML Kiti bölümünde Özel sekmesini tıklayın.
  2. Özel model ekle'yi (veya Başka bir model ekle ) tıklayın.
  3. Firebase projenizde modelinizi tanımlamak için kullanılacak bir ad belirtin ve ardından TensorFlow Lite model dosyasını yükleyin (genellikle .tflite veya .lite ile biter).

Firebase projenize özel bir model ekledikten sonra, belirttiğiniz adı kullanarak uygulamalarınızda modele referans verebilirsiniz. İstediğiniz zaman yeni bir TensorFlow Lite modeli yükleyebilirsiniz; uygulamanız yeni modeli indirecek ve uygulama bir sonraki yeniden başlatıldığında kullanmaya başlayacaktır. Uygulamanızın modeli güncellemeye çalışması için gereken cihaz koşullarını tanımlayabilirsiniz (aşağıya bakın).

Modelleri bir uygulamayla paketleyin

TensorFlow Lite modelinizi uygulamanızla birlikte paketlemek için model dosyasını (genellikle .tflite veya .lite ile biter) Xcode projenize ekleyin ve bunu yaparken Paket kaynaklarını kopyala seçeneğini seçmeye dikkat edin. Model dosyası uygulama paketine dahil edilecek ve ML Kit'e sunulacak.

Modeli yükle

TensorFlow Lite modelinizi uygulamanızda kullanmak için öncelikle ML Kit'i modelinizin mevcut olduğu konumlarla yapılandırın: Firebase'i kullanarak uzaktan, yerel depolamada veya her ikisinde birden. Hem yerel hem de uzak modeli belirtirseniz, varsa uzak modeli kullanabilir, uzak model yoksa yerel olarak depolanan modele geri dönebilirsiniz.

Firebase tarafından barındırılan bir modeli yapılandırma

Modelinizi Firebase'de barındırdıysanız, modeli yayınlarken atadığınız adı belirterek bir CustomRemoteModel nesnesi oluşturun:

Süratli

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

Amaç-C

// Initialize using the name you assigned in the Firebase console.
FIRCustomRemoteModel *remoteModel =
    [[FIRCustomRemoteModel alloc] initWithName:@"your_remote_model"];

Ardından, indirmeye izin vermek istediğiniz koşulları belirterek model indirme görevini başlatın. Model cihazda yoksa veya modelin daha yeni bir sürümü mevcutsa görev, modeli Firebase'den eşzamansız olarak indirir:

Süratli

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

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

Amaç-C

FIRModelDownloadConditions *downloadConditions =
    [[FIRModelDownloadConditions alloc] initWithAllowsCellularAccess:YES
                                         allowsBackgroundDownloading:YES];

NSProgress *downloadProgress =
    [[FIRModelManager modelManager] downloadRemoteModel:remoteModel
                                             conditions:downloadConditions];

Çoğu uygulama, indirme görevini kendi başlatma kodunda başlatır, ancak bunu, modeli kullanmanız gerekmeden önce herhangi bir noktada yapabilirsiniz.

Yerel bir model yapılandırma

Modeli uygulamanızla birlikte paketlediyseniz TensorFlow Lite modelinin dosya adını belirterek bir CustomLocalModel nesnesi oluşturun:

Süratli

guard let modelPath = Bundle.main.path(
  forResource: "your_model",
  ofType: "tflite",
  inDirectory: "your_model_directory"
) else { /* Handle error. */ }
let localModel = CustomLocalModel(modelPath: modelPath)

Amaç-C

NSString *modelPath = [NSBundle.mainBundle pathForResource:@"your_model"
                                                    ofType:@"tflite"
                                               inDirectory:@"your_model_directory"];
FIRCustomLocalModel *localModel =
    [[FIRCustomLocalModel alloc] initWithModelPath:modelPath];

Modelinizden bir tercüman oluşturun

Model kaynaklarınızı yapılandırdıktan sonra bunlardan birinden bir ModelInterpreter nesnesi oluşturun.

Yalnızca yerel olarak paketlenmiş bir modeliniz varsa, CustomLocalModel nesnesini modelInterpreter(localModel:) öğesine iletmeniz yeterlidir:

Süratli

let interpreter = ModelInterpreter.modelInterpreter(localModel: localModel)

Amaç-C

FIRModelInterpreter *interpreter =
    [FIRModelInterpreter modelInterpreterForLocalModel:localModel];

Uzaktan barındırılan bir modeliniz varsa, çalıştırmadan önce indirilip indirilmediğini kontrol etmeniz gerekecektir. Model yöneticisinin isModelDownloaded(remoteModel:) yöntemini kullanarak model indirme görevinin durumunu kontrol edebilirsiniz.

Her ne kadar yorumlayıcıyı çalıştırmadan önce bunu yalnızca onaylamanız gerekse de, hem uzaktan barındırılan bir modeliniz hem de yerel olarak paketlenmiş bir modeliniz varsa, ModelInterpreter başlatırken bu kontrolü gerçekleştirmek mantıklı olabilir: eğer uzak modelden bir yorumlayıcı oluşturun indirilmiş ve aksi takdirde yerel modelden.

Süratli

var interpreter: ModelInterpreter
if ModelManager.modelManager().isModelDownloaded(remoteModel) {
  interpreter = ModelInterpreter.modelInterpreter(remoteModel: remoteModel)
} else {
  interpreter = ModelInterpreter.modelInterpreter(localModel: localModel)
}

Amaç-C

FIRModelInterpreter *interpreter;
if ([[FIRModelManager modelManager] isModelDownloaded:remoteModel]) {
  interpreter = [FIRModelInterpreter modelInterpreterForRemoteModel:remoteModel];
} else {
  interpreter = [FIRModelInterpreter modelInterpreterForLocalModel:localModel];
}

Yalnızca uzaktan barındırılan bir modeliniz varsa, modelin indirildiğini onaylayana kadar modelle ilgili işlevleri devre dışı bırakmalısınız (örneğin, kullanıcı arayüzünüzün bir kısmını grileştirme veya gizleme).

Gözlemcileri varsayılan Bildirim Merkezine ekleyerek model indirme durumunu alabilirsiniz. İndirme işlemleri biraz zaman alabileceğinden ve indirme işlemi tamamlandığında kaynak nesne serbest bırakılabileceğinden, gözlemci bloğunda self zayıf bir referans kullandığınızdan emin olun. Örneğin:

Süratli

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

Amaç-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];
            }];

Modelin giriş ve çıkışını belirtin

Daha sonra model yorumlayıcının giriş ve çıkış formatlarını yapılandırın.

TensorFlow Lite modeli girdi olarak alır ve çıktı olarak bir veya daha fazla çok boyutlu dizi üretir. Bu diziler byte , int , long veya float değerlerini içerir. ML Kit'i, modelinizin kullandığı dizilerin sayısı ve boyutları ("şekli") ile yapılandırmanız gerekir.

Modelinizin giriş ve çıkışının şeklini ve veri türünü bilmiyorsanız modelinizi incelemek için TensorFlow Lite Python yorumlayıcısını kullanabilirsiniz. Örneğin:

import tensorflow as tf

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

# Print input shape and type
print(interpreter.get_input_details()[0]['shape'])  # Example: [1 224 224 3]
print(interpreter.get_input_details()[0]['dtype'])  # Example: <class 'numpy.float32'>

# Print output shape and type
print(interpreter.get_output_details()[0]['shape'])  # Example: [1 1000]
print(interpreter.get_output_details()[0]['dtype'])  # Example: <class 'numpy.float32'>

Modelinizin giriş ve çıkış biçimini belirledikten sonra bir ModelInputOutputOptions nesnesi oluşturarak uygulamanızın model yorumlayıcısını yapılandırın.

Örneğin, bir kayan noktalı görüntü sınıflandırma modeli, N adet 224x224 adet üç kanallı (RGB) görüntü grubunu temsil Float N adet x224x224x3 adet Float değeri dizisini girdi olarak alabilir ve çıktı olarak her biri, görüntünün modelin öngördüğü 1000 kategoriden birinin üyesi olma olasılığı.

Böyle bir model için model yorumlayıcısının giriş ve çıkışını aşağıda gösterildiği gibi yapılandırırsınız:

Süratli

let ioOptions = ModelInputOutputOptions()
do {
    try ioOptions.setInputFormat(index: 0, type: .float32, dimensions: [1, 224, 224, 3])
    try ioOptions.setOutputFormat(index: 0, type: .float32, dimensions: [1, 1000])
} catch let error as NSError {
    print("Failed to set input or output format with error: \(error.localizedDescription)")
}

Amaç-C

FIRModelInputOutputOptions *ioOptions = [[FIRModelInputOutputOptions alloc] init];
NSError *error;
[ioOptions setInputFormatForIndex:0
                             type:FIRModelElementTypeFloat32
                       dimensions:@[@1, @224, @224, @3]
                            error:&error];
if (error != nil) { return; }
[ioOptions setOutputFormatForIndex:0
                              type:FIRModelElementTypeFloat32
                        dimensions:@[@1, @1000]
                             error:&error];
if (error != nil) { return; }

Giriş verileri üzerinde çıkarım gerçekleştirin

Son olarak, modeli kullanarak çıkarım yapmak için giriş verilerinizi alın, veriler üzerinde modeliniz için gerekli olabilecek tüm dönüştürmeleri gerçekleştirin ve verileri içeren bir Data nesnesi oluşturun.

Örneğin, modeliniz görüntüleri işliyorsa ve modelinizde [BATCH_SIZE, 224, 224, 3] kayan nokta değerlerinin giriş boyutları varsa, aşağıdaki örnekte olduğu gibi görüntünün renk değerlerini kayan nokta aralığına ölçeklendirmeniz gerekebilir :

Süratli

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 }

let inputs = ModelInputs()
var inputData = Data()
do {
  for row in 0 ..< 224 {
    for col in 0 ..< 224 {
      let offset = 4 * (col * context.width + row)
      // (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)
    }
  }
  try inputs.addInput(inputData)
} catch let error {
  print("Failed to add input: \(error)")
}

Amaç-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);

FIRModelInputs *inputs = [[FIRModelInputs alloc] init];
NSMutableData *inputData = [[NSMutableData alloc] initWithCapacity:0];

for (int row = 0; row < 224; row++) {
  for (int col = 0; col < 224; col++) {
    long offset = 4 * (col * imageWidth + row);
    // 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.
    // (Ignore offset 0, the unused alpha channel)
    Float32 red = imageData[offset+1] / 255.0f;
    Float32 green = imageData[offset+2] / 255.0f;
    Float32 blue = imageData[offset+3] / 255.0f;

    [inputData appendBytes:&red length:sizeof(red)];
    [inputData appendBytes:&green length:sizeof(green)];
    [inputData appendBytes:&blue length:sizeof(blue)];
  }
}

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

Model girişinizi hazırladıktan sonra (ve modelin kullanılabilir olduğunu onayladıktan sonra), giriş ve giriş/çıkış seçeneklerini model yorumlayıcınızın run(inputs:options:completion:) yöntemine iletin.

Süratli

interpreter.run(inputs: inputs, options: ioOptions) { outputs, error in
    guard error == nil, let outputs = outputs else { return }
    // Process outputs
    // ...
}

Amaç-C

[interpreter runWithInputs:inputs
                   options:ioOptions
                completion:^(FIRModelOutputs * _Nullable outputs,
                             NSError * _Nullable error) {
  if (error != nil || outputs == nil) {
    return;
  }
  // Process outputs
  // ...
}];

Döndürülen nesnenin output(index:) yöntemini çağırarak çıktıyı alabilirsiniz. Örneğin:

Süratli

// Get first and only output of inference with a batch size of 1
let output = try? outputs.output(index: 0) as? [[NSNumber]]
let probabilities = output??[0]

Amaç-C

// Get first and only output of inference with a batch size of 1
NSError *outputError;
NSArray *probabilites = [outputs outputAtIndex:0 error:&outputError][0];

Çıktıyı nasıl kullanacağınız kullandığınız modele bağlıdır.

Örneğin, sınıflandırma yapıyorsanız bir sonraki adım olarak sonucun indekslerini temsil ettikleri etiketlerle eşleştirebilirsiniz. Modelinizin kategorilerinin her biri için etiket dizelerini içeren bir metin dosyanız olduğunu varsayalım; aşağıdakine benzer bir şey yaparak etiket dizelerini çıktı olasılıklarıyla eşleştirebilirsiniz:

Süratli

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 0 ..< labels.count {
  if let probability = probabilities?[i] {
    print("\(labels[i]): \(probability)")
  }
}

Amaç-C

NSError *labelReadError = nil;
NSString *labelPath = [NSBundle.mainBundle pathForResource:@"retrained_labels"
                                                    ofType:@"txt"];
NSString *fileContents = [NSString stringWithContentsOfFile:labelPath
                                                   encoding:NSUTF8StringEncoding
                                                      error:&labelReadError];
if (labelReadError != nil || fileContents == NULL) { return; }
NSArray<NSString *> *labels = [fileContents componentsSeparatedByString:@"\n"];
for (int i = 0; i < labels.count; i++) {
    NSString *label = labels[i];
    NSNumber *probability = probabilites[i];
    NSLog(@"%@: %f", label, probability.floatValue);
}

Ek: Model güvenliği

TensorFlow Lite modellerinizi ML Kit'e nasıl sunduğunuzdan bağımsız olarak, ML Kit bunları yerel depolamada standart serileştirilmiş protobuf formatında saklar.

Teorik olarak bu, herkesin modelinizi kopyalayabileceği anlamına gelir. Ancak uygulamada çoğu model, uygulamaya o kadar özeldir ve optimizasyonlar nedeniyle karartılmıştır ki, risk, rakiplerinizin kodunuzu parçalara ayırıp yeniden kullanması ile benzerdir. Ancak uygulamanızda özel bir model kullanmadan önce bu riskin farkında olmalısınız.