LiteRT CompiledModel API, Python में उपलब्ध है. यह LiteRT रनटाइम के साथ TFLite मॉडल को कंपाइल और चलाने के लिए, हाई-लेवल इंटरफ़ेस उपलब्ध कराता है.
यहां दी गई गाइड में, CompiledModel Python API की मदद से सीपीयू इन्फ़रेंस के बारे में बुनियादी जानकारी दी गई है.
pip पैकेज इंस्टॉल करना
अपने Python एनवायरमेंट में LiteRT pip पैकेज इंस्टॉल करें:
pip install ai-edge-litert
बुनियादी अनुमान
CompiledModel बनाएं
.tflite फ़ाइल से कंपाइल किया गया मॉडल बनाएं. मौजूदा Python रैपर, डिफ़ॉल्ट रूप से सीपीयू के लिए कंपाइल होता है.
from ai_edge_litert.compiled_model import CompiledModel
model = CompiledModel.from_file("mymodel.tflite")
मेमोरी में मौजूद बफ़र से भी कंपाइल किया गया मॉडल बनाया जा सकता है:
from ai_edge_litert.compiled_model import CompiledModel
with open("mymodel.tflite", "rb") as f:
model = CompiledModel.from_buffer(f.read())
इनपुट और आउटपुट बफ़र बनाना
इनपुट डेटा को सेव करने के लिए ज़रूरी डेटा स्ट्रक्चर (बफ़र) बनाएं. इस डेटा को मॉडल में इनफ़रेंस के लिए डाला जाएगा. साथ ही, आउटपुट डेटा को सेव करने के लिए ज़रूरी डेटा स्ट्रक्चर (बफ़र) बनाएं. यह डेटा, मॉडल में इनफ़रेंस चलाने के बाद जनरेट होगा.
signature_index = 0
input_buffers = model.create_input_buffers(signature_index)
output_buffers = model.create_output_buffers(signature_index)
0 की signature_index वैल्यू, मॉडल में पहले सिग्नेचर को चुनती है.
अगर सीपीयू मेमोरी का इस्तेमाल किया जा रहा है, तो इनपुट बफ़र में सीधे तौर पर NumPy ऐरे लिखकर इनपुट भरें.
import numpy as np
input_data = np.array([[1.0, 2.0, 3.0, 4.0]], dtype=np.float32)
input_buffers[0].write(input_data)
मॉडल को चालू करना
इनपुट और आउटपुट बफ़र उपलब्ध कराकर, मॉडल को चलाएं.
model.run_by_index(signature_index, input_buffers, output_buffers)
आउटपुट वापस पाएं
मेमोरी से मॉडल के आउटपुट को सीधे तौर पर पढ़कर, आउटपुट वापस पाना.
import numpy as np
# Replace num_elements with the size of your model's output tensor.
num_elements = 4
output_array = output_buffers[0].read(num_elements, np.float32)
TensorBuffer का इस्तेमाल करें
LiteRT, TensorBuffer एपीआई के ज़रिए I/O बफ़र इंटरऑपरेबिलिटी के लिए, पहले से मौजूद सहायता उपलब्ध कराता है. यह एपीआई, NumPy ऐरे (write) लिखने और NumPy ऐरे (read) पढ़ने की सुविधा देता है. इस्तेमाल किए जा सकने वाले dtypes np.float32, np.int32, और np.int8 हैं.
मौजूदा होस्ट मेमोरी के साथ बफ़र भी बनाया जा सकता है:
import numpy as np
from ai_edge_litert.tensor_buffer import TensorBuffer
input_array = np.array([[1.0, 2.0, 3.0, 4.0]], dtype=np.float32)
input_buffer = TensorBuffer.create_from_host_memory(input_array)
हस्ताक्षर के नाम से चलाने के लिए, पहले मॉडल के हस्ताक्षर की जांच करें. इसके बाद, इनपुट/आउटपुट के नामों से TensorBuffer इंस्टेंस तक मैप उपलब्ध कराएं:
from ai_edge_litert.tensor_buffer import TensorBuffer
signatures = model.get_signature_list()
# Example signature structure:
# {"serving_default": {"inputs": ["input_0"], "outputs": ["output_0"]}}
input_buffer = TensorBuffer.create_from_host_memory(input_array)
output_buffer = model.create_output_buffer_by_name("serving_default", "output_0")
model.run_by_name(
"serving_default",
{"input_0": input_buffer},
{"output_0": output_buffer},
)
TensorBuffer API को लागू करने के तरीके के बारे में ज़्यादा जानकारी के लिए, TensorBuffer पर जाकर सोर्स कोड देखें.
GPU ऐक्सेलरेटर का इस्तेमाल करें
अगर आपके पास GPU है, तो CompiledModel बनाने वाले एपीआई में HardwareAccelerator.GPU विकल्प जोड़कर इसका इस्तेमाल किया जा सकता है.
from ai_edge_litert.compiled_model import CompiledModel
from ai_edge_litert.compiled_model import HardwareAccelerator
model = CompiledModel.from_file("mymodel.tflite", HardwareAccelerator.GPU)
यह देखने के लिए कि आपके प्लैटफ़ॉर्म के लिए कौनसे बैकएंड का इस्तेमाल किया जा सकता है, यह लेख पढ़ें.