इस पेज का अनुवाद Cloud Translation API से किया गया है.

Apple प्लैटफ़ॉर्म पर पसंद के मुताबिक TensorFlow Lite मॉडल का इस्तेमाल करना

अगर आपका ऐप्लिकेशन, TensorFlow Lite मॉडल, तो अपने मॉडल डिप्लॉय करने के लिए Firebase ML का इस्तेमाल किया जा सकता है. इन्होंने बदलाव किया है मॉडल को Firebase के साथ डिप्लॉय करने पर, और अपने ऐप्लिकेशन के एमएल मॉडल को अपडेट करें, लेकिन आपका ऐप्लिकेशन. और Remote Config और A/B Testing के साथ, आप डाइनैमिक तौर पर उपयोगकर्ताओं के अलग-अलग सेट को अलग-अलग मॉडल दिखाने के लिए करते हैं.

MLModelInterpreter लाइब्रेरी, जो मॉडल डाउनलोड करने वाला एपीआई और TensorFlow Lite का इंटरफ़ेस, दोनों अनुवादक, अब काम नहीं करता है. इस पेज पर बताया गया है कि TensorFlow Lite के साथ MLModelDownloader लाइब्रेरी नेटिव अनुवादक इंटरफ़ेस.

ज़रूरी शर्तें

MLModelDownloader लाइब्रेरी सिर्फ़ Swift के लिए उपलब्ध है.
TensorFlow Lite, सिर्फ़ iOS 9 और उसके बाद के वर्शन इस्तेमाल करने वाले डिवाइसों पर चलता है.

TensorFlow Lite के मॉडल

TensorFlow Lite मॉडल, ऐसे एमएल मॉडल हैं जिन्हें मोबाइल पर चलाने के लिए ऑप्टिमाइज़ किया गया है डिवाइस. TensorFlow Lite का मॉडल पाने के लिए:

पहले से बने हुए मॉडल का इस्तेमाल करें, जैसे कि आधिकारिक TensorFlow Lite के मॉडल.
बदलें TensorFlow मॉडल, Keras मॉडल या TensorFlow के लिए कंक्रीट फ़ंक्शन लाइट.

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

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

इंस्टॉल हो जाने के बाद, Firebase और TensorFlowLite का इस्तेमाल करने के लिए उन्हें इंपोर्ट करें.

Swift

import FirebaseMLModelDownloader
import TensorFlowLite

1. अपना मॉडल डिप्लॉय करना

Firebase कंसोल या Firebase एडमिन Python और Node.js SDK टूल. यहां जाएं: कस्टम मॉडल डिप्लॉय और मैनेज करना.

अपने Firebase प्रोजेक्ट में कोई कस्टम मॉडल जोड़ने के बाद, आपके ऐप्लिकेशन के मॉडल को, आपके बताए गए नाम से इस्तेमाल करके. किसी भी समय, इन्हें डिप्लॉय किया जा सकता है TensorFlow Lite का नया मॉडल और उपयोगकर्ताओं इसके हिसाब से डिवाइस getModel() पर कॉल किया जा रहा है (नीचे देखें).

2. मॉडल को डिवाइस पर डाउनलोड करें और TensorFlow Lite का अनुवादक मोड शुरू करें

अपने ऐप्लिकेशन में TensorFlow Lite मॉडल का इस्तेमाल करने के लिए, पहले Firebase ML SDK टूल का इस्तेमाल करें डिवाइस पर मॉडल का नया वर्शन डाउनलोड करने के लिए.

मॉडल डाउनलोड करने के लिए, मॉडल डाउनलोड करने वाले के getModel() तरीके को कॉल करें, उस नाम को दर्ज करते हुए जो आपने मॉडल को अपलोड करते समय असाइन किया था, चाहे आप हमेशा नया मॉडल डाउनलोड करना चाहते हैं और उन स्थितियों को को डाउनलोड करने की अनुमति देनी है.

डाउनलोड करने के इन तीन तरीकों में से कोई एक चुनें:

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

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

Swift

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

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

3. इनपुट डेटा के आधार पर अनुमान लगाएं

अपने मॉडल के इनपुट और आउटपुट आकार पाना

TensorFlow Lite मॉडल अनुवादक, इनपुट के तौर पर इनपुट लेता है और आउटपुट के तौर पर जनरेट करता है एक या ज़्यादा बहु-आयामी सरणियां. इन अरे में, byte, int, long या float वैल्यू. डेटा को किसी मॉडल को पास करने या उसके नतीजे का इस्तेमाल करने से पहले, आपको यह जानना ज़रूरी है आपके मॉडल में इस्तेमाल की जाने वाली सरणियों की संख्या और डाइमेंशन ("साइज़").

यदि आपने मॉडल खुद बनाया हो या मॉडल का इनपुट और आउटपुट प्रारूप हो सकता है कि आपके पास यह जानकारी पहले से मौजूद हो. अगर आपको यह नहीं पता कि आपके मॉडल के इनपुट और आउटपुट का आकार और डेटा टाइप, तो आप TensorFlow Lite का अनुवाद करने वाला टूल, आपके मॉडल की जांच करता है. उदाहरण के लिए:

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

आउटपुट का उदाहरण:

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

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

अनुवादक चलाएं

अपने मॉडल के इनपुट और आउटपुट का फ़ॉर्मैट तय करने के बाद, डेटा डालना और डेटा हासिल करने के लिए ज़रूरी डेटा में कोई बदलाव करना आपके मॉडल के लिए सही आकार का इनपुट.

उदाहरण के लिए, अगर आपका मॉडल इमेज को प्रोसेस करता है और आपके मॉडल में इनपुट डाइमेंशन हैं [1, 224, 224, 3] फ़्लोटिंग-पॉइंट वैल्यू में से, आपको नीचे दिए गए उदाहरण की तरह, इमेज के रंग की वैल्यू फ़्लोटिंग-पॉइंट की रेंज पर सेट की गई हैं:

Swift

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

इसके बाद, अनुवादक में अपने इनपुट NSData को कॉपी करें और इसे चलाएं:

Swift

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

अनुवादक के output(at:) तरीके को कॉल करके, मॉडल का आउटपुट देखा जा सकता है. आउटपुट का इस्तेमाल करने का तरीका, इस्तेमाल किए जा रहे मॉडल पर निर्भर करता है.

उदाहरण के लिए, अगर डेटा को कैटगरी में बांटा जा रहा है, तो अगले चरण के तौर पर नतीजों के इंडेक्स को उन लेबल के साथ मैप करें जो वे दिखाते हैं:

Swift

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

अपेंडिक्स: मॉडल की सुरक्षा

भले ही, आप TensorFlow Lite के मॉडल Firebase ML, Firebase ML उन्हें मानक क्रमिक प्रोटोबफ़ फ़ॉर्मैट में इसमें सेव करता है लोकल स्टोरेज.

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