Apple प्लैटफ़ॉर्म पर AutoML के ट्रेनिंग वाले मॉडल की मदद से, इमेज में मौजूद ऑब्जेक्ट पहचानें

AutoML Vision Edge का इस्तेमाल करके, अपना मॉडल ट्रेन करने के बाद, इमेज में ऑब्जेक्ट का पता लगाने के लिए, अपने ऐप्लिकेशन में इसका इस्तेमाल किया जा सकता है.

Firebase ML की AutoML Vision Edge सुविधाएं बंद कर दी गई हैं. एमएल मॉडल को अपने-आप ट्रेन करने के लिए, Vertex AI का इस्तेमाल करें. इन मॉडल को डिवाइस पर इस्तेमाल करने के लिए, TensorFlow Lite मॉडल के तौर पर एक्सपोर्ट किया जा सकता है. इसके अलावा, क्लाउड-आधारित अनुमान लगाने के लिए डिप्लॉय भी किया जा सकता है.

AutoML Vision Edge से ट्रेन किए गए मॉडल को इंटिग्रेट करने के दो तरीके हैं. मॉडल की फ़ाइलों को अपने Xcode प्रोजेक्ट में कॉपी करके, मॉडल को बंडल किया जा सकता है. इसके अलावा, Firebase से इसे डाइनैमिक तौर पर डाउनलोड भी किया जा सकता है.

मॉडल को बंडल करने के विकल्प
आपके ऐप्लिकेशन में बंडल किया गया	मॉडल, बंडल का हिस्सा है मॉडल तुरंत उपलब्ध हो जाता है. भले ही, Apple डिवाइस ऑफ़लाइन हो Firebase प्रोजेक्ट की ज़रूरत नहीं है
Firebase की मदद से होस्ट किया गया	मॉडल को Firebase मशीन लर्निंग पर अपलोड करके होस्ट करें ऐप्लिकेशन बंडल का साइज़ कम करता है मॉडल को मांग पर डाउनलोड किया जाता है अपने ऐप्लिकेशन को फिर से पब्लिश किए बिना, मॉडल के अपडेट को पुश करना Firebase रिमोट कॉन्फ़िगरेशन की मदद से आसानी से A/B टेस्टिंग करना इसके लिए, Firebase प्रोजेक्ट की ज़रूरत होती है

शुरू करने से पहले

1. अगर आपको कोई मॉडल डाउनलोड करना है, तो पक्का करें कि आपने अपने Apple प्रोजेक्ट में Firebase जोड़ा हो. अगर आपने ऐसा पहले नहीं किया है, तो अब करें. मॉडल को बंडल करने के लिए, ऐसा करना ज़रूरी नहीं है.

2. अपनी Podfile में TensorFlow और Firebase लाइब्रेरी शामिल करें:

   अपने ऐप्लिकेशन के साथ मॉडल को बंडल करने के लिए:

   Swift

   pod 'TensorFlowLiteSwift'
   

   Objective-C

   pod 'TensorFlowLiteObjC'
   

   Firebase से मॉडल को डाइनैमिक तौर पर डाउनलोड करने के लिए, Firebase/MLModelInterpreter डिपेंडेंसी जोड़ें:

   Swift

   pod 'TensorFlowLiteSwift'
   pod 'Firebase/MLModelInterpreter'
   

   Objective-C

   pod 'TensorFlowLiteObjC'
   pod 'Firebase/MLModelInterpreter'
   

3. अपने प्रोजेक्ट के Pods इंस्टॉल या अपडेट करने के बाद, .xcworkspace का इस्तेमाल करके अपना Xcode प्रोजेक्ट खोलें.

1. मॉडल लोड करना

लोकल मॉडल सोर्स कॉन्फ़िगर करना

मॉडल को अपने ऐप्लिकेशन के साथ बंडल करने के लिए, मॉडल और लेबल फ़ाइल को अपने Xcode प्रोजेक्ट में कॉपी करें. ऐसा करते समय, फ़ोल्डर रेफ़रंस बनाएं को चुनना न भूलें. मॉडल फ़ाइल और लेबल को ऐप्लिकेशन बंडल में शामिल किया जाएगा.

साथ ही, मॉडल के साथ बनाई गई tflite_metadata.json फ़ाइल भी देखें. आपको दो वैल्यू की ज़रूरत होगी:

• मॉडल के इनपुट डाइमेंशन. यह डिफ़ॉल्ट रूप से 320x320 होती है.
• मॉडल की ज़्यादा से ज़्यादा पहचानें. यह डिफ़ॉल्ट रूप से 40 होती है.

Firebase पर होस्ट किए गए मॉडल सोर्स को कॉन्फ़िगर करना

रिमोट तौर पर होस्ट किए गए मॉडल का इस्तेमाल करने के लिए, CustomRemoteModel ऑब्जेक्ट बनाएं. इसमें वह नाम डालें जो आपने मॉडल को पब्लिश करते समय असाइन किया था:

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"];

इसके बाद, मॉडल डाउनलोड करने का टास्क शुरू करें. साथ ही, उन शर्तों के बारे में बताएं जिनके तहत आपको डाउनलोड करने की अनुमति देनी है. अगर मॉडल डिवाइस पर मौजूद नहीं है या मॉडल का नया वर्शन उपलब्ध है, तो टास्क, Firebase से मॉडल को असिंक्रोनस तरीके से डाउनलोड करेगा:

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];

कई ऐप्लिकेशन, अपने शुरू करने वाले कोड में डाउनलोड करने का टास्क शुरू करते हैं. हालांकि, मॉडल का इस्तेमाल करने से पहले, किसी भी समय ऐसा किया जा सकता है.

अपने मॉडल से ऑब्जेक्ट डिटेक्टर बनाना

अपने मॉडल सोर्स कॉन्फ़िगर करने के बाद, उनमें से किसी एक से TensorFlow Lite Interpreter ऑब्जेक्ट बनाएं.

अगर आपके पास सिर्फ़ लोकल तौर पर बंडल किया गया मॉडल है, तो मॉडल फ़ाइल से इंटरप्रेटर बनाएं:

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

अगर आपके पास किसी दूसरे डिवाइस पर होस्ट किया गया मॉडल है, तो उसे चलाने से पहले आपको यह देखना होगा कि वह डाउनलोड हो गया है या नहीं. मॉडल मैनेजर के isModelDownloaded(remoteModel:) तरीके का इस्तेमाल करके, मॉडल डाउनलोड करने के टास्क की स्थिति देखी जा सकती है.

हालांकि, आपको इंटरप्रिटर को चलाने से पहले ही इसकी पुष्टि करनी होगी. अगर आपके पास रिमोट से होस्ट किया गया मॉडल और स्थानीय तौर पर बंडल किया गया मॉडल, दोनों हैं, तो Interpreter को इंस्टैंशिएट करते समय यह जांच करना सही रहेगा: अगर रिमोट मॉडल डाउनलोड किया गया है, तो उससे इंटरप्रिटर बनाएं और अगर नहीं, तो स्थानीय मॉडल से बनाएं.

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

अगर आपके पास सिर्फ़ रिमोट तौर पर होस्ट किया गया मॉडल है, तो आपको मॉडल से जुड़ी सुविधाओं को बंद कर देना चाहिए. उदाहरण के लिए, अपने यूज़र इंटरफ़ेस (यूआई) के कुछ हिस्से को धूसर कर दें या छिपा दें. ऐसा तब तक करें, जब तक मॉडल डाउनलोड होने की पुष्टि न हो जाए.

डिफ़ॉल्ट सूचना केंद्र में ऑब्ज़र्वर जोड़कर, मॉडल के डाउनलोड होने की स्थिति देखी जा सकती है. ऑब्ज़र्वर ब्लॉक में, self के लिए वेक रेफ़रंस का इस्तेमाल करना न भूलें. ऐसा इसलिए, क्योंकि डाउनलोड में कुछ समय लग सकता है और डाउनलोड पूरा होने तक, ऑरिजिन ऑब्जेक्ट को रिलीज़ किया जा सकता है. उदाहरण के लिए:

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. इनपुट इमेज तैयार करना

इसके बाद, आपको TensorFlow Lite इंटरप्रेटर के लिए अपनी इमेज तैयार करनी होंगी.

1. इमेज को काटकर, मॉडल के इनपुट डाइमेंशन के हिसाब से स्केल करें. इन डाइमेंशन के बारे में tflite_metadata.json फ़ाइल में बताया गया है. डिफ़ॉल्ट रूप से, इनपुट डाइमेंशन 320x320 पिक्सल होते हैं. ऐसा करने के लिए, Core Image या तीसरे पक्ष की लाइब्रेरी का इस्तेमाल किया जा सकता है

2. इमेज का डेटा किसी Data (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. ऑब्जेक्ट डिटेक्टर को चलाना

इसके बाद, तैयार किए गए इनपुट को अनुवादक को पास करें:

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. पहचाने गए ऑब्जेक्ट के बारे में जानकारी पाना

अगर ऑब्जेक्ट का पता चल जाता है, तो मॉडल आउटपुट के तौर पर, हर एक में 40 एलिमेंट (या tflite_metadata.json फ़ाइल में बताए गए एलिमेंट) के तीन ऐरे बनाता है. हर एलिमेंट, किसी संभावित ऑब्जेक्ट से जुड़ा होता है. पहला कलेक्शन, बॉउंडिंग बॉक्स का कलेक्शन होता है. दूसरा कलेक्शन, लेबल का कलेक्शन होता है. तीसरा कलेक्शन, कॉन्फ़िडेंस वैल्यू का कलेक्शन होता है. मॉडल के आउटपुट पाने के लिए:

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

इसके बाद, लेबल के आउटपुट को अपनी लेबल डिक्शनरी के साथ जोड़ा जा सकता है:

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

रीयल-टाइम परफ़ॉर्मेंस को बेहतर बनाने के लिए सलाह

अगर आपको रीयल-टाइम ऐप्लिकेशन में इमेज लेबल करनी हैं, तो सबसे अच्छा फ़्रेमरेट पाने के लिए, इन दिशा-निर्देशों का पालन करें:

• डिटेक्टर को कॉल को कम करता है. अगर डिटेक्टर चालू होने के दौरान कोई नया वीडियो फ़्रेम उपलब्ध हो जाता है, तो फ़्रेम को हटा दें.
• अगर इनपुट इमेज पर ग्राफ़िक ओवरले करने के लिए, डिटेक्टर के आउटपुट का इस्तेमाल किया जा रहा है, तो पहले नतीजा पाएं. इसके बाद, एक ही चरण में इमेज और ओवरले को रेंडर करें. ऐसा करने पर, हर इनपुट फ़्रेम के लिए डिसप्ले प्लैटफ़ॉर्म पर सिर्फ़ एक बार रेंडर किया जाता है. उदाहरण के लिए, शोकेस के सैंपल ऐप्लिकेशन में previewOverlayView और FIRDetectionOverlayView क्लास देखें.