استنتاج TensorFlow Lite

يشير مصطلح استنتاج إلى عملية تنفيذ نموذج TensorFlow Lite على الجهاز لإجراء تنبؤات استنادًا إلى بيانات الإدخال. لإجراء استنتاج باستخدام نموذج TensorFlow Lite، يجب استخدامه من خلال مترجم. تم تصميم برنامج TensorFlow Lite الفوري ليكون سريعًا وبطيء. ويستخدم المترجم الفوري ترتيبًا ثابتًا للرسم البياني ومُحدِّد ذاكرة مخصصًا (أقل ديناميكية) لضمان توفير الحد الأدنى من التحميل والإعداد ووقت استجابة التنفيذ.

توضّح هذه الصفحة كيفية الوصول إلى مترجِم TensorFlow Lite وإجراء استنتاج باستخدام C++ وJava وPython، بالإضافة إلى روابط تؤدي إلى موارد أخرى لكل نظام أساسي متوافق.

المفاهيم المهمة

يتبع استنتاج TensorFlow Lite عادةً الخطوات التالية:

1. تحميل نموذج

   يجب تحميل نموذج .tflite في الذاكرة التي تحتوي على الرسم البياني لتنفيذ النموذج.

2. تحويل البيانات

   لا تتطابق البيانات الأولية للنموذج بشكل عام مع تنسيق بيانات الإدخال الذي يتوقعه النموذج. على سبيل المثال، قد تحتاج إلى تغيير حجم الصورة أو تغيير تنسيق الصورة لتصبح متوافقة مع النموذج.

3. إجراء الاستنتاج

   تتضمن هذه الخطوة استخدام واجهة برمجة تطبيقات TensorFlow Lite لتنفيذ النموذج. وهي تتضمن بضع خطوات مثل إنشاء مترجم، وتخصيص الموتّرات، كما هو موضّح في الأقسام التالية.

4. تفسير المخرجات

   عندما تحصل على نتائج من استنتاج النموذج، ينبغي لك تفسير المضغوط بطريقة هادفة تكون مفيدة في تطبيقك.

   فعلى سبيل المثال، قد يعرض نموذج قائمة من الاحتمالات فقط. الأمر متروك لك لتعيين الاحتمالات للفئات ذات الصلة وتقديمها للمستخدم النهائي.

المنصّات المعتمدة

يتم توفير واجهات برمجة تطبيقات الاستنتاج من TensorFlow لمعظم الأنظمة الأساسية الشائعة للأجهزة الجوّالة/الأنظمة الأساسية المضمّنة، مثل Android وiOS وLinux، بعدة لغات برمجة.

في معظم الحالات، يعكس تصميم واجهة برمجة التطبيقات تفضيل الأداء على سهولة الاستخدام. تم تصميم TensorFlow Lite للاستنتاج السريع على الأجهزة الصغيرة، لذا ليس من المستغرب أن تحاول واجهات برمجة التطبيقات تجنب النُسخ غير الضرورية سعيًا إلى توفير الراحة. وبالمثل، لم يكن الاتساق مع واجهات برمجة تطبيقات TensorFlow هدفًا صريحًا ومن المتوقع حدوث بعض التباين بين اللغات.

في جميع المكتبات، تتيح لك واجهة برمجة تطبيقات TensorFlow Lite تحميل النماذج وإدخالات الخلاصة واسترداد مخرجات الاستنتاج.

النظام الأساسي Android

على نظام التشغيل Android، يمكن إجراء استنتاج TensorFlow Lite باستخدام واجهات برمجة تطبيقات Java أو C++. توفر واجهات برمجة تطبيقات Java سهولة الاستخدام ويمكن استخدامها مباشرةً ضمن فئات نشاط Android. توفّر واجهات برمجة التطبيقات C++ المزيد من المرونة والسرعة، ولكنها قد تتطلّب كتابة برامج تضمين JNI لنقل البيانات بين طبقتَي Java وC++.

انظر أدناه للاطّلاع على تفاصيل حول استخدام لغة C++ وJava، أو اتّباع دليل Android السريع للبدء للاطّلاع على برنامج تعليمي ومثال على التعليمات البرمجية.

أداة إنشاء رمز برنامج تضمين لنظام التشغيل Android من TensorFlow Lite

بالنسبة إلى نموذج TensorFlow Lite المُحسَّن بالبيانات الوصفية، يمكن للمطوّرين استخدام منشئ رموز برنامج تضمين TensorFlow Lite لنظام التشغيل Android لإنشاء رمز برنامج تضمين خاص بالنظام الأساسي. يزيل رمز برنامج التضمين الحاجة إلى التفاعل مباشرةً مع ByteBuffer على Android. بدلاً من ذلك، يمكن للمطورين التفاعل مع نموذج TensorFlow Lite مع الكائنات المكتوبة مثل Bitmap وRect. للحصول على مزيد من المعلومات، يُرجى الرجوع إلى منشئ رمز برنامج تضمين Android TensorFlow Lite.

نظام iOS الأساسي

على iOS، يتوفّر TensorFlow Lite مع مكتبات iOS الأصلية المكتوبة باللغتَين Swift وObjective-C. يمكنك أيضًا استخدام C API مباشرةً في رموز Objective-C.

يمكنك الاطّلاع أدناه على تفاصيل حول استخدام Swift وObjective-C وC API، أو يمكنك اتّباع دليل التشغيل السريع لنظام التشغيل iOS للاطّلاع على برنامج تعليمي ومثال على رمز برمجي.

نظام Linux الأساسي

على أنظمة Linux الأساسية (بما في ذلك Raspberry Pi)، يمكنك تنفيذ الاستنتاجات باستخدام واجهات برمجة تطبيقات TensorFlow Lite المتاحة في C++ وPython، كما هو موضَّح في الأقسام التالية.

تشغيل نموذج

يتضمن تشغيل نموذج TensorFlow Lite بضع خطوات بسيطة:

1. حمِّل النموذج في الذاكرة.
2. يمكنك إنشاء Interpreter استنادًا إلى نموذج حالي.
3. ضبط قيم موصّل الإدخال (يمكنك اختياريًا تغيير حجم موترات الإدخال إذا كانت الأحجام المحددة مسبقًا غير مطلوبة.)
4. عليك استدعاء الاستنتاج.
5. قراءة قيم متعدّد الإخراج

توضح الأقسام التالية كيفية تنفيذ هذه الخطوات بكل لغة.

تحميل نموذج وتشغيله في Java

النظام الأساسي: Android

إنّ واجهة برمجة تطبيقات Java لإجراء الاستنتاج باستخدام TensorFlow Lite مصمّمة في المقام الأول للاستخدام مع Android، لذا فهي متاحة كتبعية لمكتبة Android: org.tensorflow:tensorflow-lite.

في Java، ستستخدم الفئة Interpreter لتحميل نموذج واستنتاج استنتاج النموذج. وفي كثير من الحالات، قد تكون هذه هي واجهة برمجة التطبيقات الوحيدة التي تحتاجها.

يمكنك إعداد Interpreter باستخدام ملف .tflite:

public Interpreter(@NotNull File modelFile);

أو باستخدام MappedByteBuffer:

public Interpreter(@NotNull MappedByteBuffer mappedByteBuffer);

وفي كلتا الحالتين، يجب تقديم نموذج TensorFlow Lite أو واجهة برمجة التطبيقات التي تعرض IllegalArgumentException. إذا كنت تستخدم السمة MappedByteBuffer لإعداد Interpreter، يجب ألّا يتم تغيير أي تغيير طوال فترة بقاء Interpreter.

إنّ الطريقة المفضّلة لإجراء استنتاج في نموذج معيّن هي استخدام التوقيعات - هذه الطريقة مناسبة للنماذج التي تم تحويلها بدءًا من Tensorflow 2.5.

try (Interpreter interpreter = new Interpreter(file_of_tensorflowlite_model)) {
  Map<String, Object> inputs = new HashMap<>();
  inputs.put("input_1", input1);
  inputs.put("input_2", input2);
  Map<String, Object> outputs = new HashMap<>();
  outputs.put("output_1", output1);
  interpreter.runSignature(inputs, outputs, "mySignature");
}

تستخدم الطريقة runSignature ثلاث وسيطات:

• الإدخالات : لتحديد المدخلات من اسم الإدخال في التوقيع إلى كائن إدخال.

• المخرجات : تعيين لتعيين الإخراج من اسم الإخراج في التوقيع إلى بيانات الإخراج.

• اسم التوقيع (اختياري): اسم التوقيع (يمكن تركه فارغًا إذا كان النموذج يحتوي على توقيع واحد).

هناك طريقة أخرى لإجراء استنتاج عندما لا يحتوي النموذج على توقيعات محددة. ما عليك سوى الاتصال بالرقم Interpreter.run(). مثلاً:

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

تستخدم الطريقة run() إدخالاً واحدًا فقط وتعرض ناتجًا واحدًا فقط. لذلك إذا كان نموذجك يحتوي على مدخلات متعددة أو مخرجات متعددة، استخدم بدلاً من ذلك ما يلي:

interpreter.runForMultipleInputsOutputs(inputs, map_of_indices_to_outputs);

في هذه الحالة، يتجاوب كل إدخال في inputs مع موقد إدخال ويربط map_of_indices_to_outputs مؤشرات شدات الإخراج ببيانات الإخراج المقابلة.

في كلتا الحالتين، يجب أن تتوافق مؤشرات المتوتر مع القيم التي أدخلتها في محوّل TensorFlow Lite عند إنشاء النموذج. يُرجى العلم أنّ ترتيب الموترات في input يجب أن يتطابق مع الترتيب المعيَّن لمحوّل TensorFlow Lite.

توفّر الفئة Interpreter أيضًا دوال ملائمة للحصول على فهرس لأي إدخال أو إخراج نموذج باستخدام اسم عملية:

public int getInputIndex(String opName);
public int getOutputIndex(String opName);

إذا لم تكن opName عملية صالحة في النموذج، ستعرض IllegalArgumentException.

يُرجى أيضًا الانتباه إلى أنّ Interpreter يملك الموارد. لتجنب تسرُّب الذاكرة، يجب تحرير الموارد بعد الاستخدام من خلال:

interpreter.close();

للحصول على مثال على مشروع باستخدام Java، راجِع نموذج تصنيف صور Android.

أنواع البيانات المتوافقة (في Java)

لاستخدام TensorFlow Lite، يجب أن تكون أنواع بيانات المداخل والمخرجات أحد الأنواع الأساسية التالية:

• float
• int
• long
• byte

يُسمح أيضًا باستخدام أنواع String، ولكن يتم ترميزها بشكل مختلف عن الأنواع الأساسية. على وجه الخصوص، يحدد شكل سلسلة Tensor عدد السلاسل وترتيبها في Tensor، بحيث يكون كل عنصر نفسه سلسلة متغيرة الطول. بتعبير آخر، لا يمكن حساب حجم (بايت) Tensor من الشكل والنوع وحدهما، وبالتالي لا يمكن تقديم السلاسل كوسيطة ByteBuffer واحدة مسطحة.

في حال استخدام أنواع بيانات أخرى، بما في ذلك أنواع البيانات المجمّعة في علبة مثل Integer وFloat، سيتم استخدام IllegalArgumentException.

مدخلات

يجب أن يكون كل إدخال عبارة عن مصفوفة أو مصفوفة متعددة الأبعاد من الأنواع الأساسية المتوافقة، أو عبارة عن قيمة ByteBuffer أولية بالحجم المناسب. إذا كان المدخل صفيفًا أو صفيفًا متعدد الأبعاد، فسيتم ضمنيًا تغيير مشد الإدخال المرتبط إلى أبعاد الصفيفة في وقت الاستنتاج. إذا كان الإدخال هو ByteBuffer، فيجب على المتصل أولاً تغيير حجم موصّل الإدخال المرتبط (عبر Interpreter.resizeInput()) قبل تنفيذ الاستنتاج.

عند استخدام ByteBuffer، يُفضَّل استخدام مخازن البايت الاحتياطية المباشرة، لأنّ ذلك يسمح لـ Interpreter بتجنّب النُسخ غير الضرورية. إذا كان ByteBuffer مخزنًا مؤقتًا مباشرًا للبايت، يجب أن يكون ترتيبه ByteOrder.nativeOrder(). بعد استخدامه لاستنتاج النموذج، يجب أن يظل دون تغيير حتى ينتهي استنتاج النموذج.

المُخرَجات

يجب أن يكون كل ناتج صفيفًا أو مصفوفة متعددة الأبعاد من الأنواع الأساسية المتوافقة، أو متغير ByteBuffer بالحجم المناسب. لاحظ أن بعض النماذج لها مخرجات ديناميكية، حيث يمكن أن يختلف شكل متوترات الإخراج حسب المدخلات. لا توجد طريقة مباشرة للتعامل مع هذا الأمر باستخدام واجهة برمجة تطبيقات الاستنتاج Java الحالية، لكن الإضافات المخطط لها ستجعل ذلك ممكنًا.

تحميل نموذج وتشغيله في Swift

النظام الأساسي: iOS

تتوفّر Swift API في TensorFlowLiteSwift Pod من Cocoapods.

أولاً، عليك استيراد الوحدة النمطية TensorFlowLite.

import TensorFlowLite

// Getting model path
guard
  let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite")
else {
  // Error handling...
}

do {
  // Initialize an interpreter with the model.
  let interpreter = try Interpreter(modelPath: modelPath)

  // Allocate memory for the model's input `Tensor`s.
  try interpreter.allocateTensors()

  let inputData: Data  // Should be initialized

  // input data preparation...

  // Copy the input data to the input `Tensor`.
  try self.interpreter.copy(inputData, toInputAt: 0)

  // Run inference by invoking the `Interpreter`.
  try self.interpreter.invoke()

  // Get the output `Tensor`
  let outputTensor = try self.interpreter.output(at: 0)

  // Copy output to `Data` to process the inference results.
  let outputSize = outputTensor.shape.dimensions.reduce(1, {x, y in x * y})
  let outputData =
        UnsafeMutableBufferPointer<Float32>.allocate(capacity: outputSize)
  outputTensor.data.copyBytes(to: outputData)

  if (error != nil) { /* Error handling... */ }
} catch error {
  // Error handling...
}

تحميل وتشغيل نموذج بلغة Objective-C

النظام الأساسي: iOS

تتوفر واجهة برمجة التطبيقات Objective-C في TensorFlowLiteObjC مجموعة من Cocoapods.

أولاً، عليك استيراد الوحدة النمطية TensorFlowLite.

@import TensorFlowLite;

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];
NSError *error;

// Initialize an interpreter with the model.
TFLInterpreter *interpreter = [[TFLInterpreter alloc] initWithModelPath:modelPath
                                                                  error:&error];
if (error != nil) { /* Error handling... */ }

// Allocate memory for the model's input `TFLTensor`s.
[interpreter allocateTensorsWithError:&error];
if (error != nil) { /* Error handling... */ }

NSMutableData *inputData;  // Should be initialized
// input data preparation...

// Get the input `TFLTensor`
TFLTensor *inputTensor = [interpreter inputTensorAtIndex:0 error:&error];
if (error != nil) { /* Error handling... */ }

// Copy the input data to the input `TFLTensor`.
[inputTensor copyData:inputData error:&error];
if (error != nil) { /* Error handling... */ }

// Run inference by invoking the `TFLInterpreter`.
[interpreter invokeWithError:&error];
if (error != nil) { /* Error handling... */ }

// Get the output `TFLTensor`
TFLTensor *outputTensor = [interpreter outputTensorAtIndex:0 error:&error];
if (error != nil) { /* Error handling... */ }

// Copy output to `NSData` to process the inference results.
NSData *outputData = [outputTensor dataWithError:&error];
if (error != nil) { /* Error handling... */ }

استخدام C API في رمز Objective-C

لا تتوافق واجهة برمجة التطبيقات Objective-C API حاليًا مع المفوَّضين. لاستخدام المفوَّضين مع رمز Objective-C، عليك طلب C API مباشرةً.

#include "tensorflow/lite/c/c_api.h"

TfLiteModel* model = TfLiteModelCreateFromFile([modelPath UTF8String]);
TfLiteInterpreterOptions* options = TfLiteInterpreterOptionsCreate();

// Create the interpreter.
TfLiteInterpreter* interpreter = TfLiteInterpreterCreate(model, options);

// Allocate tensors and populate the input tensor data.
TfLiteInterpreterAllocateTensors(interpreter);
TfLiteTensor* input_tensor =
    TfLiteInterpreterGetInputTensor(interpreter, 0);
TfLiteTensorCopyFromBuffer(input_tensor, input.data(),
                           input.size() * sizeof(float));

// Execute inference.
TfLiteInterpreterInvoke(interpreter);

// Extract the output tensor data.
const TfLiteTensor* output_tensor =
    TfLiteInterpreterGetOutputTensor(interpreter, 0);
TfLiteTensorCopyToBuffer(output_tensor, output.data(),
                         output.size() * sizeof(float));

// Dispose of the model and interpreter objects.
TfLiteInterpreterDelete(interpreter);
TfLiteInterpreterOptionsDelete(options);
TfLiteModelDelete(model);

تحميل وتشغيل نموذج بلغة C++

الأنظمة الأساسية: Android وiOS وLinux

في C++ ، يتم تخزين النموذج في الفئة FlatBufferModel. وهي تضم نموذج TensorFlow Lite ويمكنك بناؤها بطريقتين مختلفتين، اعتمادًا على مكان تخزين النموذج:

class FlatBufferModel {
  // Build a model based on a file. Return a nullptr in case of failure.
  static std::unique_ptr<FlatBufferModel> BuildFromFile(
      const char* filename,
      ErrorReporter* error_reporter);

  // Build a model based on a pre-loaded flatbuffer. The caller retains
  // ownership of the buffer and should keep it alive until the returned object
  // is destroyed. Return a nullptr in case of failure.
  static std::unique_ptr<FlatBufferModel> BuildFromBuffer(
      const char* buffer,
      size_t buffer_size,
      ErrorReporter* error_reporter);
};

بعد أن أصبح لديك النموذج ككائن FlatBufferModel، يمكنك تنفيذه باستخدام Interpreter. يمكن استخدام عنصر FlatBufferModel واحد في الوقت نفسه من قِبل أكثر من عنصر Interpreter واحد.

يتم عرض الأجزاء المهمة من Interpreter API في مقتطف الرمز أدناه. تجدر الإشارة إلى ما يلي:

• يتم تمثيل الموتّرات بالأعداد الصحيحة لتجنّب مقارنات السلاسل (وأي تبعية ثابتة على مكتبات السلاسل).
• يجب عدم الوصول إلى مترجم من سلاسل المحادثات المتزامنة.
• يجب تشغيل تخصيص الذاكرة لشدات الإدخال والإخراج من خلال استدعاء AllocateTensors() مباشرةً بعد تغيير حجم موترات الإدخال.

تبدو أبسط طريقة لاستخدام TensorFlow Lite مع C++ على النحو التالي:

// Load the model
std::unique_ptr<tflite::FlatBufferModel> model =
    tflite::FlatBufferModel::BuildFromFile(filename);

// Build the interpreter
tflite::ops::builtin::BuiltinOpResolver resolver;
std::unique_ptr<tflite::Interpreter> interpreter;
tflite::InterpreterBuilder(*model, resolver)(&interpreter);

// Resize input tensors, if desired.
interpreter->AllocateTensors();

float* input = interpreter->typed_input_tensor<float>(0);
// Fill `input`.

interpreter->Invoke();

float* output = interpreter->typed_output_tensor<float>(0);

لمعرفة المزيد من الأمثلة على الرموز البرمجية، يمكنك الاطّلاع على minimal.cc وlabel_image.cc.

تحميل نموذج وتشغيله في بايثون

النظام الأساسي: Linux

غالبًا ما تحتاج واجهة برمجة تطبيقات Python لتنفيذ الاستنتاج إلى tf.lite.Interpreter فقط لتحميل نموذج وتنفيذ استنتاج.

يوضّح المثال التالي كيفية استخدام أداة "مترجم بايثون" لتحميل ملف .tflite وإجراء استنتاج باستخدام بيانات إدخال عشوائية:

ننصحك باستخدام هذا المثال إذا كنت تُجري عملية تحويل من SaveModel باستخدام SignatureDef محدّد. متوفّرة بدءًا من TensorFlow 2.5

class TestModel(tf.Module):
  def __init__(self):
    super(TestModel, self).__init__()

  @tf.function(input_signature=[tf.TensorSpec(shape=[1, 10], dtype=tf.float32)])
  def add(self, x):
    '''
    Simple method that accepts single input 'x' and returns 'x' + 4.
    '''
    # Name the output 'result' for convenience.
    return {'result' : x + 4}


SAVED_MODEL_PATH = 'content/saved_models/test_variable'
TFLITE_FILE_PATH = 'content/test_variable.tflite'

# Save the model
module = TestModel()
# You can omit the signatures argument and a default signature name will be
# created with name 'serving_default'.
tf.saved_model.save(
    module, SAVED_MODEL_PATH,
    signatures={'my_signature':module.add.get_concrete_function()})

# Convert the model using TFLiteConverter
converter = tf.lite.TFLiteConverter.from_saved_model(SAVED_MODEL_PATH)
tflite_model = converter.convert()
with open(TFLITE_FILE_PATH, 'wb') as f:
  f.write(tflite_model)

# Load the TFLite model in TFLite Interpreter
interpreter = tf.lite.Interpreter(TFLITE_FILE_PATH)
# There is only 1 signature defined in the model,
# so it will return it by default.
# If there are multiple signatures then we can pass the name.
my_signature = interpreter.get_signature_runner()

# my_signature is callable with input as arguments.
output = my_signature(x=tf.constant([1.0], shape=(1,10), dtype=tf.float32))
# 'output' is dictionary with all outputs from the inference.
# In this case we have single output 'result'.
print(output['result'])

مثال آخر إذا لم يتم تحديد SignatureDefs.

import numpy as np
import tensorflow as tf

# Load the TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_path="converted_model.tflite")
interpreter.allocate_tensors()

# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Test the model on random input data.
input_shape = input_details[0]['shape']
input_data = np.array(np.random.random_sample(input_shape), dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)

interpreter.invoke()

# The function `get_tensor()` returns a copy of the tensor data.
# Use `tensor()` in order to get a pointer to the tensor.
output_data = interpreter.get_tensor(output_details[0]['index'])
print(output_data)

بدلاً من تحميل النموذج كملف .tflite تم تحويله مسبقًا، يمكنك دمج الرمز الخاص بك مع TensorFlow Lite Converter Python API، ما يسمح لك بتحويل نموذج Keras إلى تنسيق TensorFlow Lite ثم الحصول على استنتاج:

import numpy as np
import tensorflow as tf

img = tf.keras.Input(shape=(64, 64, 3), name="img")
const = tf.constant([1., 2., 3.]) + tf.constant([1., 4., 4.])
val = img + const
out = tf.identity(val, name="out")

# Convert to TF Lite format
converter = tf.lite.TFLiteConverter.from_keras_model(tf.keras.models.Model(inputs=[img], outputs=[out]))
tflite_model = converter.convert()

# Load the TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()

# Continue to get tensors and so forth, as shown above...

للحصول على مزيد من نماذج رمز Python، يمكنك الاطّلاع على label_image.py.

تنفيذ الاستنتاج باستخدام نموذج شكل ديناميكي

إذا أردت تشغيل نموذج بشكل إدخال ديناميكي، عليك تغيير حجم شكل الإدخال قبل تنفيذ الاستنتاج. وبخلاف ذلك، سيتم استبدال شكل None في نماذج Tensorflow بعنصر نائب 1 في نماذج TFLite.

توضح الأمثلة التالية كيفية تغيير حجم شكل الإدخال قبل تشغيل الاستنتاج بلغات مختلفة. تفترض جميع الأمثلة أنّ شكل الإدخال محدّد على أنّه [1/None, 10]، ويجب تغيير حجمه ليصبح [3, 10].

مثال على C++:

// Resize input tensors before allocate tensors
interpreter->ResizeInputTensor(/*tensor_index=*/0, std::vector<int>{3,10});
interpreter->AllocateTensors();

مثال على لغة بايثون:

# Load the TFLite model in TFLite Interpreter
interpreter = tf.lite.Interpreter(model_path=TFLITE_FILE_PATH)

# Resize input shape for dynamic shape model and allocate tensor
interpreter.resize_tensor_input(interpreter.get_input_details()[0]['index'], [3, 10])
interpreter.allocate_tensors()

# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

العمليات المتاحة

يدعم TensorFlow Lite مجموعة فرعية من عمليات TensorFlow مع بعض القيود. للحصول على القائمة الكاملة للعمليات والقيود، يُرجى الاطّلاع على صفحة TF Lite Ops.