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 मॉडल को TensorFlowLite में बदलने पर, इनपुट और आउटपुट के ऑर्डर तय किए जाते हैं साथ ही, Toco मॉडल में इनपुट के डिफ़ॉल्ट आकार होते हैं.

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

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

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

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

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

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

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

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

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

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

सार्वजनिक ऐब्सट्रैक्ट अमान्य 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 बनाएं (फ़ाइल ModelFile, InterpreterApi.Options विकल्प)

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

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

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

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

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

सार्वजनिक ऐब्सट्रैक्ट आईएनटी getInputIndex (स्ट्रिंग opName)

इनपुट के ऑप का नाम दिए गए किसी इनपुट का इंडेक्स फ़ेच करता है.

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

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

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

पैरामीटर
inputIndex
थ्रो
IllegalArgumentException अगर inputIndex ऋणात्मक है या मॉडल इनपुट की संख्या.

सार्वजनिक ऐब्सट्रैक्ट आईएनटी getInputTensorCount ()

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

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

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

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

सार्वजनिक ऐब्सट्रैक्ट आईएनटी getOutputIndex (स्ट्रिंग opName)

आउटपुट के सेशन का नाम दिए जाने पर आउटपुट का इंडेक्स मिलता है.

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

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

यह फ़ंक्शन, दिए गए आउटपुट इंडेक्स से जुड़े Tensor को फ़ेच करता है.

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

पैरामीटर
outputIndex
थ्रो
IllegalArgumentException अगर outputIndex ऋणात्मक है या मॉडल आउटपुट की संख्या.

सार्वजनिक ऐब्सट्रैक्ट आईएनटी getOutputTensorCount ()

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

सार्वजनिक ऐब्सट्रैक्ट अमान्य resizeInput (int idx, int[] डिम, बूलियन स्ट्रिक्ट)

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

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

पैरामीटर
idx
डिम
कठोर
थ्रो
IllegalArgumentException अगर idx ऋणात्मक है या संख्या से छोटी नहीं है इनपुट का इस्तेमाल किया है; या अगर idx-th इनपुट का साइज़ बदलते समय गड़बड़ी होती है. इसके अलावा, गड़बड़ी की वजह से यह तब होता है, जब `स्ट्रिक्ट` सही पर होता है और तय डाइमेंशन वाले टेंसर का साइज़ बदलने की कोशिश करता है.

सार्वजनिक ऐब्सट्रैक्ट अमान्य resizeInput (int idx, int[] डिम)

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

पैरामीटर
idx
डिम
थ्रो
IllegalArgumentException अगर idx ऋणात्मक है या संख्या से छोटी नहीं है इनपुट का इस्तेमाल किया है; या अगर idx-th इनपुट का साइज़ बदलते समय गड़बड़ी होती है.

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

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

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

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

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

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

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

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

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

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

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