InterpreterApi

पब्लिक इंटरफ़ेस InterpreterApi
जानी-पहचानी इंडायरेक्ट सब-क्लास

TensorFlow Lite के मॉडल इंटरप्रेटर का इंटरफ़ेस. इसमें एक्सपेरिमेंटल तरीके शामिल नहीं हैं.

InterpreterApi इंस्टेंस में, पहले से ट्रेनिंग दिए गए TensorFlow Lite मॉडल को शामिल किया जाता है, जिसमें मॉडल अनुमान के लिए कार्रवाइयां की जाती हैं.

उदाहरण के लिए, अगर कोई मॉडल सिर्फ़ एक इनपुट लेता है और सिर्फ़ एक आउटपुट दिखाता है, तो: 

try (InterpreterApi interpreter =
     new InterpreterApi.create(file_of_a_tensorflowlite_model)) {
   interpreter.run(input, output);
 }

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

Object[] inputs = {input0, input1, ...};
 Map<Integer, Object> map_of_indices_to_outputs = new HashMap<>();
 FloatBuffer ith_output = FloatBuffer.allocateDirect(3 * 2 * 4);  // Float tensor, shape 3x2x4.
 ith_output.order(ByteOrder.nativeOrder());
 map_of_indices_to_outputs.put(i, ith_output);
 try (InterpreterApi interpreter =
     new InterpreterApi.create(file_of_a_tensorflowlite_model)) {
   interpreter.runForMultipleInputsOutputs(inputs, map_of_indices_to_outputs);
 }

अगर कोई मॉडल, स्ट्रिंग टेंसर लेता या बनाता है: 

String[] input = {"foo", "bar"};  // Input tensor shape is [2].
 String[][] output = new String[3][2];  // Output tensor shape is [3, 2].
 try (InterpreterApi interpreter =
     new InterpreterApi.create(file_of_a_tensorflowlite_model)) {
   interpreter.runForMultipleInputsOutputs(input, output);
 }

ध्यान दें कि आकार [] और आकृति[1] के बीच अंतर होता है. स्केलर स्ट्रिंग टेंसर आउटपुट के लिए: 

String[] input = {"foo"};  // Input tensor shape is [1].
 ByteBuffer outputBuffer = ByteBuffer.allocate(OUTPUT_BYTES_SIZE);  // Output tensor shape is [].
 try (Interpreter interpreter = new Interpreter(file_of_a_tensorflowlite_model)) {
   interpreter.runForMultipleInputsOutputs(input, outputBuffer);
 }
 byte[] outputBytes = new byte[outputBuffer.remaining()];
 outputBuffer.get(outputBytes);
 // Below, the `charset` can be StandardCharsets.UTF_8.
 String output = new String(outputBytes, charset);

इनपुट और आउटपुट के क्रम तब तय किए जाते हैं, जब TensorFlow के मॉडल को Toco के साथ TensorFlowLite मॉडल में बदला जाता है. इनपुट के डिफ़ॉल्ट आकार भी इस तरह से तय किए जाते हैं.

जब इनपुट को (मल्टी-डाइमेंशन) सरणियों के रूप में दिया जाता है, तो संबंधित इनपुट टेंसर(दिमागी) का आकार उस अरे के आकार के हिसाब से तय किया जाएगा. जब इनपुट Buffer टाइप के तौर पर दिए जाते हैं, तो कोई इंप्लिसिट साइज़ नहीं बदला जाता. कॉलर को यह पक्का करना होगा कि Buffer बाइट का साइज़ या तो उससे जुड़े टेंसर के बराबर हो या वह पहले resizeInput(int, int[]) के ज़रिए टेंसर का साइज़ बदले. टेन्सर के आकार और टाइप की जानकारी, Tensor क्लास से ली जा सकती है. यह क्लास getInputTensor(int) और getOutputTensor(int) से उपलब्ध है.

चेतावनी:InterpreterApi इंस्टेंस, थ्रेड की सुविधा वाले नहीं हैं.

चेतावनी: InterpreterApi इंस्टेंस में ऐसे संसाधनों का मालिकाना हक है जिन्हें close() का इस्तेमाल करके, साफ़ तौर पर खाली किया जाना ज़रूरी है

TFLite लाइब्रेरी को NDK API 19 के हिसाब से बनाया गया है. यह Android एपीआई के 19 से पहले के लेवल पर काम कर सकता है. हालांकि, इसकी कोई गारंटी नहीं है.

नेस्ट की गई क्लास

क्लास InterpreterApi.Options रनटाइम के दौरान अनुवादक के व्यवहार को कंट्रोल करने के लिए, विकल्प क्लास. 

सार्वजनिक तरीके

ऐब्स्ट्रैक्ट शून्य
allocateTensors()
अगर ज़रूरी हो, तो सभी टेन्सर के लिए आवंटन को साफ़ तौर पर अपडेट करता है.
ऐब्स्ट्रैक्ट शून्य
close() (बंद करें)
InterpreterApi इंस्टेंस से जुड़े संसाधन रिलीज़ करें.
स्टैटिक InterpreterApi
create(फ़ाइल ModelFile, InterpreterApi.Options के विकल्प)
दिए गए मॉडल और विकल्पों का इस्तेमाल करके, InterpreterApi इंस्टेंस बनाता है.
स्टैटिक InterpreterApi
create(ByteBuffer byteBuffer, InterpreterApi.Options के विकल्प)
दिए गए मॉडल और विकल्पों का इस्तेमाल करके, InterpreterApi इंस्टेंस बनाता है.
ऐब्स्ट्रैक्ट int
getInputIndex(स्ट्रिंग opName)
इनपुट के ऑपरेटर के नाम के आधार पर, उस इनपुट के इंडेक्स की जानकारी देता है.
ऐब्सट्रैक्ट टेन्सर
getInputTensor(int inputIndex)
दिए गए इनपुट इंडेक्स से जुड़े Tensor की जानकारी देता है.
ऐब्स्ट्रैक्ट int
getInputTensorCount()
इनपुट टेंसर की संख्या का पता लगाता है.
ऐब्सट्रैक्ट लॉन्ग
getLastNativeInferenceDurationNanoseconds()
नेटिव अनुमान का समय दिखाता है.
ऐब्स्ट्रैक्ट int
getOutputIndex(स्ट्रिंग opName)
आउटपुट के ऑपरेटर के नाम के आधार पर, आउटपुट के इंडेक्स की जानकारी देता है.
ऐब्सट्रैक्ट टेन्सर
getOutputTensor(इंट आउटपुट इंडेक्स)
दिए गए आउटपुट इंडेक्स से जुड़े Tensor की जानकारी देता है.
ऐब्स्ट्रैक्ट int
getOutputTensorCount()
आउटपुट टेन्सर की संख्या की जानकारी देता है.
ऐब्स्ट्रैक्ट शून्य
resizeInput(int idx, int[] dims, boolean strict)
दिए गए डिम में, नेटिव मॉडल के idx-वें इनपुट का साइज़ बदलता है.
ऐब्स्ट्रैक्ट शून्य
resizeInput(int idx, int[] डिम)
दिए गए डिम में, नेटिव मॉडल के idx-वें इनपुट का साइज़ बदलता है.
ऐब्स्ट्रैक्ट शून्य
run(ऑब्जेक्ट इनपुट, ऑब्जेक्ट आउटपुट)
अगर मॉडल सिर्फ़ एक इनपुट लेता है और सिर्फ़ एक आउटपुट देता है, तो मॉडल अनुमान चलाता है.
ऐब्स्ट्रैक्ट शून्य
runForMultipleInputsOutputs(Object[] इनपुट, मैप<इंटिजर, ऑब्जेक्ट> आउटपुट)
अगर मॉडल एक से ज़्यादा इनपुट लेता है या एक से ज़्यादा आउटपुट देता है, तो मॉडल अनुमान चलाता है.

इनहेरिट किए गए तरीके

सार्वजनिक तरीके

सार्वजनिक ऐब्स्ट्रैक्ट शून्य allocateTensors ()

अगर ज़रूरी हो, तो सभी टेन्सर के लिए आवंटन को साफ़ तौर पर अपडेट करता है.

यह दिए गए इनपुट टेंसर आकार(आकारों) का इस्तेमाल करके, डिपेंडेंट टेंसर के लिए आकार और मेमोरी के बंटवारे को लागू करेगा.

ध्यान दें: यह कॉल *पूरी तरह से वैकल्पिक* है. अगर किसी इनपुट टेन्सर का साइज़ बदला गया है, तो एक्ज़ीक्यूट करने के दौरान टेन्सर का बंटवारा अपने-आप हो जाएगा. यह कॉल, ग्राफ़ को चलाने से पहले किसी भी आउटपुट टेन्सर के लिए आकार तय करने में सबसे ज़्यादा काम आता है, उदाहरण के लिए, 

 interpreter.resizeInput(0, new int[]{1, 4, 4, 3}));
 interpreter.allocateTensors();
 FloatBuffer input = FloatBuffer.allocate(interpreter.getInputTensor(0).numElements());
 // Populate inputs...
 FloatBuffer output = FloatBuffer.allocate(interpreter.getOutputTensor(0).numElements());
 interpreter.run(input, output)
 // Process outputs...

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

थ्रो
IllegalStateException अगर ग्राफ़ के टेंसर का बंटवारा नहीं हो पाता.

सार्वजनिक ऐब्स्ट्रैक्ट शून्य बंद करें ()

InterpreterApi इंस्टेंस से जुड़े संसाधन रिलीज़ करें.

सार्वजनिक स्टैटिक InterpreterApi बनाएं (फ़ाइल मॉडल फ़ाइल, InterpreterApi.Options के विकल्प)

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

पैरामीटर
modelFile ऐसी फ़ाइल जिसमें पहले से ट्रेन किया गया TF Lite मॉडल होता है.
विकल्प अनुवादक के व्यवहार को पसंद के मुताबिक बनाने के लिए विकल्पों का सेट.
थ्रो
IllegalArgumentException अगर modelFile, मान्य TensorFlow Lite मॉडल को कोड में नहीं बदलता.

सार्वजनिक स्टैटिक InterpreterApi बनाएं (ByteBuffer byteBuffer, InterpreterApi.Options विकल्प)

दिए गए मॉडल और विकल्पों का इस्तेमाल करके, InterpreterApi इंस्टेंस बनाता है. इस मॉडल को ByteBuffer से पढ़ा जाएगा.

पैरामीटर
byteBuffer पहले से ट्रेनिंग वाला TF Lite मॉडल, जो बाइनरी सीरियल के तौर पर है. InterpreterApi इंस्टेंस बनने के बाद, ByteBuffer में बदलाव नहीं करना चाहिए. ByteBuffer या तो एक MappedByteBuffer हो सकता है जो किसी मॉडल फ़ाइल को मेमोरी-मैप करता है. इसके अलावा, NativeOrder() का वह ByteBuffer भी हो सकता है जिसमें किसी मॉडल का बाइट कॉन्टेंट शामिल हो.
विकल्प अनुवादक के व्यवहार को पसंद के मुताबिक बनाने के लिए विकल्पों का सेट.
थ्रो
IllegalArgumentException अगर byteBuffer, localOrder का MappedByteBuffer या डायरेक्ट ByteBuffer नहीं है.

सार्वजनिक ऐब्स्ट्रैक्ट int getInputIndex (स्ट्रिंग opName)

इनपुट के ऑपरेटर के नाम के आधार पर, उस इनपुट के इंडेक्स की जानकारी देता है.

पैरामीटर
opName
थ्रो
IllegalArgumentException अगर opName, अनुवादक को शुरू करने के लिए इस्तेमाल किए गए मॉडल के किसी भी इनपुट से मेल नहीं खाता है.

सार्वजनिक ऐब्स्ट्रैक्ट Tensor getInputTensor (intinputIndex)

दिए गए इनपुट इंडेक्स से जुड़े Tensor की जानकारी देता है.

पैरामीटर
inputIndex
थ्रो
IllegalArgumentException अगर inputIndex नेगेटिव है या मॉडल इनपुट की संख्या से छोटी नहीं है.

सार्वजनिक ऐब्स्ट्रैक्ट int getInputTensorCount ()

इनपुट टेंसर की संख्या का पता लगाता है.

सार्वजनिक ऐब्स्ट्रैक्ट लॉन्ग getLastNativeInferenceDurationNanoseconds ()

नेटिव अनुमान का समय दिखाता है.

थ्रो
IllegalArgumentException अगर अनुवादक ने मॉडल को शुरू नहीं किया है.

सार्वजनिक ऐब्स्ट्रैक्ट int getOutputIndex (स्ट्रिंग opName)

आउटपुट के ऑपरेटर के नाम के आधार पर, आउटपुट के इंडेक्स की जानकारी देता है.

पैरामीटर
opName
थ्रो
IllegalArgumentException अगर opName, अनुवादक को शुरू करने के लिए इस्तेमाल किए गए मॉडल के किसी भी आउटपुट से मेल नहीं खाता है.

सार्वजनिक ऐब्स्ट्रैक्ट Tensor getOutputTensor (इंट आउटपुट इंडेक्स)

दिए गए आउटपुट इंडेक्स से जुड़े Tensor की जानकारी देता है.

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

पैरामीटर
outputIndex
थ्रो
IllegalArgumentException अगर outputIndex नेगेटिव है या मॉडल आउटपुट की संख्या से कम नहीं है.

सार्वजनिक ऐब्स्ट्रैक्ट int getOutputTensorCount ()

आउटपुट टेन्सर की संख्या की जानकारी देता है.

सार्वजनिक ऐब्स्ट्रैक्ट शून्य resizeInput (int idx, int[] dims, boolean strict)

दिए गए डिम में, नेटिव मॉडल के idx-वें इनपुट का साइज़ बदलता है.

जब `स्ट्रिक्ट` 'सही' पर सेट होता है, तो सिर्फ़ अज्ञात डाइमेंशन का साइज़ बदला जा सकता है. `Tensor.shapeSignature()` से मिले अरे में, अज्ञात डाइमेंशन को `-1` के तौर पर दिखाया जाता है.

पैरामीटर
idx
dims
कठोर
थ्रो
IllegalArgumentException अगर idx नेगेटिव है या मॉडल इनपुट की संख्या से छोटा नहीं है. इसके अलावा, अगर आईडीx-वें इनपुट का साइज़ बदलते समय कोई गड़बड़ी होती है. इसके अलावा, गड़बड़ी तब होती है, जब `स्ट्रिक्ट` 'सही' होने पर, तय डाइमेंशन वाले टेंसर का साइज़ बदलने की कोशिश की जाती है.

public ऐब्स्ट्रैक्ट void resizeInput (int idx, int[] डिम)

दिए गए डिम में, नेटिव मॉडल के idx-वें इनपुट का साइज़ बदलता है.

पैरामीटर
idx
dims
थ्रो
IllegalArgumentException अगर idx नेगेटिव है या मॉडल इनपुट की संख्या से छोटा नहीं है. इसके अलावा, अगर आईडीx-वें इनपुट का साइज़ बदलते समय कोई गड़बड़ी होती है.

सार्वजनिक ऐब्स्ट्रैक्ट शून्य run (ऑब्जेक्ट इनपुट, ऑब्जेक्ट आउटपुट)

अगर मॉडल सिर्फ़ एक इनपुट लेता है और सिर्फ़ एक आउटपुट देता है, तो मॉडल अनुमान चलाता है.

चेतावनी: अगर इनपुट/आउटपुट डेटा टाइप के तौर पर Buffer (सीधे तौर पर, लेकिन ज़रूरी नहीं है) का इस्तेमाल किया जाता है, तो एपीआई बेहतर तरीके से काम करता है. बेहतर परफ़ॉर्मेंस के लिए, कृपया शुरुआती डेटा को फ़ीड और फ़ेच करने के लिए, Buffer का इस्तेमाल करें. इन कंक्रीट Buffer टाइप का इस्तेमाल किया जा सकता है:

  • ByteBuffer - यह पहले से मौजूद किसी भी तरह के प्राचीन Tensor के साथ काम करता है.
  • FloatBuffer - फ़्लोट टेन्सर के साथ काम करता है.
  • IntBuffer - int32 Tensors के साथ काम करता है.
  • LongBuffer - int64 Tensors के साथ काम करता है.
ध्यान दें कि बूलियन टाइप सिर्फ़ अरे के तौर पर काम करते हैं, Buffer के तौर पर या स्केलर इनपुट के तौर पर नहीं.

पैरामीटर
इनपुट कोई अरे या कई डाइमेंशन वाला अरे या प्रिमिटिव टाइप का Buffer. इसमें, int, फ्लोट, long, और बाइट शामिल हैं. प्रिमिटिव टाइप के लिए, बड़े इनपुट डेटा को पास करने का पसंदीदा तरीका Buffer है. वहीं, स्ट्रिंग टाइप के लिए (मल्टी-डाइमेंशन) अरे इनपुट पाथ का इस्तेमाल करना ज़रूरी है. जब Buffer का इस्तेमाल किया जाता है, तो इसके कॉन्टेंट में तब तक बदलाव नहीं होना चाहिए, जब तक मॉडल अनुमान नहीं मिल जाता. साथ ही, कॉलर को यह भी पक्का करना चाहिए कि Buffer सही पोज़िशन पर हो. null वैल्यू की अनुमति सिर्फ़ तब होती है, जब कॉलर Delegate का इस्तेमाल कर रहा हो, जो बफ़र हैंडल इंटरऑप की अनुमति देता हो और ऐसा बफ़र इनपुट Tensor से जुड़ा हो.
आउटपुट आउटपुट डेटा की कई डाइमेंशन वाली कलेक्शन या int, फ़्लोट, लंबे, और बाइट जैसे प्रिमिटिव टाइप का Buffer. जब Buffer का इस्तेमाल किया जाता है, तो कॉलर को यह पक्का करना चाहिए कि लिखने के लिए सही पोज़िशन सेट की गई हो. शून्य वैल्यू की अनुमति है और यह कुछ मामलों में फ़ायदेमंद होता है. उदाहरण के लिए, अगर कॉलर Delegate का इस्तेमाल कर रहा है, जो बफ़र हैंडल इंटरऑप की अनुमति देता है, और ऐसा बफ़र, आउटपुट Tensor तक बाइंड किया गया है (Interpreter.Options#setAllowBufferHandleOutput(boolean) भी देखें) या अगर ग्राफ़ ने आउटपुट को डाइनैमिक रूप से आकार दिया है (जैसे, आउटपुट को सीधे तौर पर जनरेट किया, तो कॉलर को आउटपुट के आधार पर डेटा का पता लगाना होगा), Tensor से डेटा फ़ेच किया जाएगा.Tensor.asReadOnlyBuffer()
थ्रो
IllegalArgumentException अगर input शून्य या खाली है या अनुमान चलाते समय कोई गड़बड़ी होती है.
IllegalArgumentException (एक्सपेरिमेंटल, इसमें बदलाव हो सकता है). अगर अनुमान में setCancelled(true) की वजह से रुकावट आ गई है, तो डेटा में बदलाव हो सकता है.

सार्वजनिक ऐब्स्ट्रैक्ट शून्य runForMultipleInputsOutputs (ऑब्जेक्ट[] इनपुट, मैप<इंटीजर, ऑब्जेक्ट> आउटपुट)

अगर मॉडल एक से ज़्यादा इनपुट लेता है या एक से ज़्यादा आउटपुट देता है, तो मॉडल अनुमान चलाता है.

चेतावनी: अगर Buffer (सीधे तौर पर, लेकिन ज़रूरी नहीं है) को इनपुट/आउटपुट डेटा टाइप के तौर पर इस्तेमाल किया जाता है, तो एपीआई बेहतर तरीके से काम करता है. बेहतर परफ़ॉर्मेंस के लिए, कृपया शुरुआती डेटा को फ़ीड और फ़ेच करने के लिए, Buffer का इस्तेमाल करें. इन कंक्रीट Buffer टाइप का इस्तेमाल किया जा सकता है:

  • ByteBuffer - यह पहले से मौजूद किसी भी तरह के प्राचीन Tensor के साथ काम करता है.
  • FloatBuffer - फ़्लोट टेन्सर के साथ काम करता है.
  • IntBuffer - int32 Tensors के साथ काम करता है.
  • LongBuffer - int64 Tensors के साथ काम करता है.
ध्यान दें कि बूलियन टाइप सिर्फ़ अरे के तौर पर काम करते हैं, Buffer के तौर पर या स्केलर इनपुट के तौर पर नहीं.

ध्यान दें: inputs और outputs के शामिल न होने वाले एलिमेंट के लिए null की वैल्यू सिर्फ़ तब इस्तेमाल की जा सकती है, जब कॉलर Delegate का इस्तेमाल कर रहा हो जो बफ़र हैंडल इंटरऑप की अनुमति देता हो. साथ ही, ऐसा बफ़र इनपुट या आउटपुट Tensor से जुड़ा हो.

पैरामीटर
इनपुट इनपुट डेटा का कलेक्शन. इनपुट उसी क्रम में होने चाहिए जिसमें मॉडल के इनपुट हैं. हर इनपुट, कोई अरे या कई डाइमेंशन वाला अरे या फिर, कोई Buffer प्रिमिटिव टाइप हो सकता है. जैसे, int, फ़्लोट, लंबा, और बाइट. बड़े इनपुट डेटा को पास करने के लिए, Buffer सबसे बेहतर तरीका है. वहीं, स्ट्रिंग टाइप के लिए (कई डाइमेंशन वाले) कलेक्शन इनपुट पाथ का इस्तेमाल करना ज़रूरी है. जब Buffer का इस्तेमाल किया जाता है, तो इसके कॉन्टेंट में तब तक कोई बदलाव नहीं होना चाहिए, जब तक मॉडल का अनुमान नहीं लग जाता. साथ ही, कॉलर को यह भी पक्का करना चाहिए कि Buffer सही पोज़िशन पर हो.
आउटपुट यह आउटपुट डेटा के कई डाइमेंशन वाले अरे या इनट, फ़्लोट, लंबे, और बाइट जैसे प्रिमिटिव टाइप के Buffer से जुड़ा मैप मैपिंग आउटपुट इंडेक्स होता है. सिर्फ़ आउटपुट के इस्तेमाल के लिए, एंट्री सेव रखने की ज़रूरत होती है. जब Buffer का इस्तेमाल किया जाता है, तो कॉलर को यह पक्का करना चाहिए कि लिखने के लिए सही पोज़िशन सेट की गई हो. उन मामलों में मैप खाली हो सकता है जहां आउटपुट टेंसर डेटा के लिए या तो बफ़र हैंडल का इस्तेमाल किया जाता है या ऐसे मामलों में जहां आउटपुट डाइनैमिक आकार में होते हैं और अनुमान लागू होने के बाद, कॉलर को आउटपुट Tensor शेप में क्वेरी करनी चाहिए. साथ ही, डेटा को सीधे आउटपुट टेंसर से (Tensor.asReadOnlyBuffer() की मदद से) फ़ेच करना चाहिए.
थ्रो
IllegalArgumentException अगर inputs शून्य या खाली है, अगर outputs शून्य है या अनुमान लागू करते समय कोई गड़बड़ी होती है.