این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.
Switch to English

استنباط TensorFlow Lite

اصطلاح استنباط به فرآیند اجرای مدل TensorFlow Lite روی دستگاه به منظور پیش بینی بر اساس داده های ورودی گفته می شود. برای انجام استنباط با مدل TensorFlow Lite ، باید آن را از طریق یک مفسر اجرا کنید. مفسر TensorFlow Lite سریع و لاغر طراحی شده است. مفسر برای اطمینان از کمترین بار ، مقداردهی اولیه و تأخیر اجرا ، از یک مرتبه گرافی استاتیک و یک تخصیص دهنده حافظه اختصاصی (با پویایی کمتر) استفاده می کند.

در این صفحه نحوه دستیابی به مفسر TensorFlow Lite و انجام استنباط با استفاده از C ++ ، Java و Python ، به علاوه پیوند به منابع دیگر برای هر سیستم عامل پشتیبانی شده ، توضیح داده شده است .

مفاهیم مهم

استنباط TensorFlow Lite به طور معمول مراحل زیر را دنبال می کند:

  1. بارگیری یک مدل

    شما باید مدل .tflite را در حافظه بارگذاری کنید که حاوی نمودار اجرای مدل است.

  2. تبدیل داده ها

    داده های ورودی خام برای مدل به طور کلی با قالب داده ورودی که توسط مدل انتظار می رود مطابقت ندارد. به عنوان مثال ، ممکن است لازم باشد اندازه تصویر را تغییر دهید یا قالب تصویر را تغییر دهید تا با مدل سازگار باشد.

  3. استنباط در حال اجرا

    این مرحله شامل استفاده از TensorFlow Lite API برای اجرای مدل است. این شامل چند مرحله مانند ساخت مفسر و اختصاص حسگرها است ، همانطور که در بخشهای بعدی شرح داده شده است.

  4. تفسیر خروجی

    هنگامی که از استنباط مدل نتیجه دریافت می کنید ، باید حسگرها را به روشی معنی دار که در برنامه شما مفید است تفسیر کنید.

    به عنوان مثال ، یک مدل ممکن است فقط لیستی از احتمالات را برگرداند. این شما هستید که باید احتمالات را به دسته های مربوطه ترسیم کرده و آن را به کاربر نهایی خود ارائه دهید.

سیستم عامل های پشتیبانی شده

API های استنباطی TensorFlow برای رایج ترین سیستم عامل های تلفن همراه / جاسازی شده مانند Android ، iOS و Linux در چندین زبان برنامه نویسی ارائه شده است.

در بیشتر موارد ، طراحی API نشان دهنده اولویت عملکرد نسبت به سهولت استفاده است. TensorFlow Lite برای استنباط سریع در دستگاه های کوچک طراحی شده است ، بنابراین جای تعجب نیست که API ها با هزینه راحتی سعی در جلوگیری از کپی غیر ضروری دارند. به همین ترتیب ، سازگاری با TensorFlow API یک هدف صریح نبوده و انتظار می رود اختلاف بین زبانها وجود داشته باشد.

در سراسر کتابخانه ها ، TensorFlow Lite API شما را قادر می سازد مدل ها را بارگیری کنید ، ورودی های خوراک را بارگیری کنید و خروجی های استنباط را بازیابی کنید.

سیستم عامل اندروید

در Android ، استنباط TensorFlow Lite با استفاده از Java یا C ++ API قابل انجام است. Java API راحت است و می تواند مستقیماً در کلاس های Android Activity شما استفاده شود. CI + API انعطاف پذیری و سرعت بیشتری را ارائه می دهد ، اما ممکن است برای انتقال داده ها بین لایه های جاوا و C ++ نیاز به نوشتن لفاف های JNI باشد.

برای اطلاعات بیشتر در مورد استفاده از C ++ و Java به زیر مراجعه کنید یا برای شروع آموزش و کد مثال ، شروع سریع Android را دنبال کنید.

TensorFlow Lite آندروید ژنراتور کد بسته بندی

برای مدل TensorFlow Lite که با فراداده افزایش یافته است ، توسعه دهندگان می توانند از مولد کد پوششی Android TensorFlow Lite برای ایجاد کد بسته بندی مخصوص پلت فرم استفاده کنند. کد بسته بندی نیازی به تعامل مستقیم با ByteBuffer در Android را ByteBuffer . در عوض ، توسعه دهندگان می توانند با اشیای تایپ شده مانند Bitmap و Rect با مدل TensorFlow Lite تعامل داشته باشند. برای اطلاعات بیشتر ، به تولید کننده کد پوششی Android TensorFlow Lite مراجعه کنید.

سیستم عامل iOS

در iOS ، TensorFlow Lite با کتابخانه های بومی iOS در Swift و Objective-C نوشته شده است . همچنین می توانید از C API مستقیماً در کدهای Objective-C استفاده کنید.

برای اطلاعات بیشتر در مورد استفاده از Swift ، Objective-C و C API به زیر مراجعه کنید یا برای شروع آموزش و کد مثال ، شروع سریع iOS را دنبال کنید.

سیستم عامل لینوکس

در سیستم عامل های لینوکس (از جمله Raspberry Pi ) ، می توانید با استفاده از TensorFlow Lite API های موجود در ++ C و پایتون ، نتیجه گیری کنید ، همانطور که در بخش های زیر نشان داده شده است.

در حال اجرا یک مدل

اجرای یک مدل TensorFlow Lite شامل چند مرحله ساده است:

  1. مدل را در حافظه بارگیری کنید.
  2. یک Interpreter بر اساس یک مدل موجود بسازید.
  3. مقادیر تنسور ورودی را تنظیم کنید. (در صورت عدم تمایل اندازه های از پیش تعیین شده به صورت اختیاری ، اندازه گیرهای ورودی را تغییر دهید)
  4. استنباط را استناد کنید.
  5. مقادیر تنسور خروجی را بخوانید.

بخشهای زیر توضیح می دهد که چگونه می توان این مراحل را به هر زبان انجام داد.

یک مدل را در جاوا بارگیری و اجرا کنید

بستر های نرم افزاری: اندروید

Java API برای اجرای استنتاج با TensorFlow Lite در درجه اول برای استفاده با Android طراحی شده است ، بنابراین به عنوان یک وابستگی به کتابخانه Android در دسترس است: org.tensorflow:tensorflow-lite .

در جاوا ، از کلاس Interpreter برای بارگذاری یک مدل و استنتاج مدل درایو استفاده خواهید کرد. در بسیاری از موارد ، این ممکن است تنها API مورد نیاز شما باشد.

می توانید یک Interpreter با استفاده از یک فایل .tflite مقداردهی اولیه کنید:

public Interpreter(@NotNull File modelFile);

یا با یک MappedByteBuffer :

public Interpreter(@NotNull MappedByteBuffer mappedByteBuffer);

در هر دو مورد ، شما باید یک مدل معتبر TensorFlow Lite ارائه دهید یا API IllegalArgumentException . اگر شما استفاده از MappedByteBuffer برای آماده سازی Interpreter ، باید آن را بدون تغییر برای تمام عمر باقی می ماند Interpreter .

برای استفاده از مدل ، می توانید 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 ورودی است و map_of_indices_to_outputs ها شاخص های map_of_indices_to_outputs خروجی را به داده های خروجی مربوطه نشان می دهد.

در هر دو مورد ، شاخص های تنسور باید با مقادیری که هنگام ایجاد مدل به TensorFlow Lite Converter داده اید ، مطابقت داشته باشند. توجه داشته باشید که ترتیب تانسور در input باید با نظم داده شده به مبدل TensorFlow Lite مطابقت داشته باشد.

کلاس Interpreter همچنین توابع مناسبی را برای شما فراهم می کند تا شاخص هر ورودی یا خروجی مدل را با استفاده از یک نام عملیات بدست آورید:

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

اگر opName یک عمل معتبر در مدل نباشد ، یک IllegalArgumentException .

همچنین مواظب باشید که Interpreter منابع داشته باشد. برای جلوگیری از نشت حافظه ، منابع باید پس از استفاده توسط:

interpreter.close();

برای نمونه پروژه با جاوا ، به نمونه طبقه بندی تصویر Android مراجعه کنید .

انواع داده های پشتیبانی شده (به زبان جاوا)

برای استفاده از TensorFlow Lite ، انواع داده سنسورهای ورودی و خروجی باید یکی از انواع ابتدایی زیر باشد:

  • float
  • int
  • long
  • byte

انواع String ها نیز پشتیبانی می شوند ، اما آنها متفاوت از انواع اولیه رمزگذاری می شوند. به طور خاص ، شکل یک رشته تنسور تعداد و ترتیب رشته ها را در تنسور حکم می کند ، هر عنصر خود یک رشته طول متغیر است. به این معنا ، اندازه (بایت) تنسور را نمی توان فقط از شکل و نوع محاسبه کرد و در نتیجه رشته ها را نمی توان به عنوان یک آرگومان ByteBuffer مسطح ارائه داد.

اگر از انواع داده های دیگر ، از جمله انواع جعبه ای مانند Integer و Float استفاده شود ، یک IllegalArgumentException پرتاب می شود.

ورودی ها

هر ورودی باید یک آرایه یا آرایه چند بعدی از انواع ابتدایی پشتیبانی شده یا یک ByteBuffer خام در اندازه مناسب باشد. اگر ورودی آرایه ای یا آرایه ای چند بعدی باشد ، در زمان استنتاج ، تانسور ورودی مرتبط به طور ضمنی در ابعاد آرایه تغییر اندازه می یابد. اگر ورودی ByteBuffer باشد ، تماس گیرنده ابتدا باید قبل از اجرای استنتاج ، اندازه دستی تانسور مربوطه را (از طریق Interpreter.resizeInput() ) تغییر اندازه دهد.

هنگام استفاده از ByteBuffer ، استفاده از بافرهای مستقیم بایت را ترجیح دهید ، زیرا این اجازه می دهد تا Interpreter از نسخه برداری های غیر ضروری جلوگیری کند. اگر ByteBuffer یک بافر مستقیم بایت است ، ترتیب آن باید ByteOrder.nativeOrder() باشد. بعد از اینکه برای استنتاج مدل استفاده شد ، باید تا پایان استنتاج مدل بدون تغییر باقی بماند.

خروجی ها

هر خروجی باید یک آرایه یا آرایه چند بعدی از انواع ابتدایی پشتیبانی شده یا یک ByteBuffer با اندازه مناسب باشد. توجه داشته باشید که برخی از مدل ها دارای خروجی های دینامیکی هستند که در آن شکل سنسورهای خروجی بسته به ورودی متفاوت است. هیچ روشی ساده برای مدیریت این مورد با API استنتاج جاوا وجود ندارد ، اما برنامه های افزودنی برنامه ریزی شده این امکان را فراهم می کنند.

یک مدل را در Swift بارگیری و اجرا کنید

بستر های نرم افزاری: iOS

API سویفت در دسترس است TensorFlowLiteSwift غلاف از 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

API زبان 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...

// Copy the input data to the input `TFLTensor`.
[interpreter copyData:inputData toInputTensorAtIndex:0 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:&amp;error];
if (error != nil) { /* Error handling... */ }

استفاده از C API در کد Objective-C

در حال حاضر API Objective-C از نمایندگان پشتیبانی نمی کند. برای استفاده از نمایندگان دارای کد Objective-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 . بیش از یک Interpreter می تواند به طور همزمان از یک FlatBufferModel استفاده کند.

قطعات مهم از 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 .

یک مدل را در پایتون بارگیری و اجرا کنید

سیستم عامل: لینوکس

Python API برای اجرای استنتاج در ماژول tf.lite ارائه شده است. برای بارگذاری یک مدل و اجرای استنباط ، بیشتر از این فقط به tf.lite.Interpreter نیاز دارید.

مثال زیر نحوه استفاده از مفسر Python برای بارگذاری یک پرونده .tflite و اجرای استنتاج با داده های ورودی تصادفی را نشان می دهد:

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 ( tf.lite.TFLiteConverter ) ترکیب کنید ، به شما امکان می دهد مدل TensorFlow خود را به قالب TensorFlow Lite تبدیل کنید و سپس استنباط را اجرا کنید:

import numpy as np
import tensorflow as tf

img = tf.placeholder(name="img", dtype=tf.float32, shape=(1, 64, 64, 3))
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
with tf.Session() as sess:
  converter = tf.lite.TFLiteConverter.from_session(sess, [img], [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...

برای اطلاعات بیشتر کد پایتون ، به label_image.py مراجعه کنید.

نکته: برای دریافت مستندات دقیق در مورد مفسر ، help(tf.lite.Interpreter) در ترمینال پایتون اجرا کنید.

عملیات پشتیبانی شده

TensorFlow Lite با برخی محدودیت ها از زیر مجموعه ای از عملیات TensorFlow پشتیبانی می کند. برای لیست کامل عملیات و محدودیت ها ، به صفحه TF Lite Ops مراجعه کنید .