গুগল এআই এজ পোর্টাল পেশ করা হচ্ছে : বেঞ্চমার্ক এজ এআই স্কেলে। ব্যক্তিগত পূর্বরূপের সময় অ্যাক্সেসের অনুরোধ করতে সাইন আপ করুন ৷

এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

LiteRT দিয়ে শুরু করুন

এই নির্দেশিকা আপনাকে ইনপুট ডেটার উপর ভিত্তি করে ভবিষ্যদ্বাণী করার জন্য ডিভাইসে LiterRT (লাইট রানটাইমের সংক্ষিপ্ত রূপ) মডেল চালানোর প্রক্রিয়ার সাথে পরিচয় করিয়ে দেবে। LiterRT ইন্টারপ্রেটারের মাধ্যমে এটি অর্জন করা হয়, যা ন্যূনতম লোড, ইনিশিয়ালাইজেশন এবং এক্সিকিউশন লেটেন্সি নিশ্চিত করার জন্য একটি স্ট্যাটিক গ্রাফ অর্ডারিং এবং একটি কাস্টম (কম-গতিশীল) মেমরি অ্যালোকেটর ব্যবহার করে।

LiterRT অনুমান সাধারণত নিম্নলিখিত ধাপগুলি অনুসরণ করে:

একটি মডেল লোড করা হচ্ছে : .tflite মডেলটি মেমরিতে লোড করুন, যাতে মডেলের এক্সিকিউশন গ্রাফ থাকে।
ডেটা রূপান্তর : ইনপুট ডেটাকে প্রত্যাশিত ফর্ম্যাট এবং মাত্রায় রূপান্তর করুন। মডেলের জন্য কাঁচা ইনপুট ডেটা সাধারণত মডেলের প্রত্যাশিত ইনপুট ডেটা ফর্ম্যাটের সাথে মেলে না। উদাহরণস্বরূপ, মডেলের সাথে সামঞ্জস্যপূর্ণ করার জন্য আপনাকে একটি ছবির আকার পরিবর্তন করতে হতে পারে অথবা ছবির ফর্ম্যাট পরিবর্তন করতে হতে পারে।
অনুমান চালানো : ভবিষ্যদ্বাণী করার জন্য LiterRT মডেলটি কার্যকর করুন। এই ধাপে মডেলটি কার্যকর করার জন্য LiterRT API ব্যবহার করা জড়িত। এতে ইন্টারপ্রেটার তৈরি করা এবং টেনসর বরাদ্দ করার মতো কয়েকটি ধাপ জড়িত।
আউটপুট ব্যাখ্যা করা : আউটপুট টেনসরগুলিকে এমন অর্থপূর্ণ উপায়ে ব্যাখ্যা করুন যা আপনার অ্যাপ্লিকেশনে কার্যকর হবে। উদাহরণস্বরূপ, একটি মডেল কেবল সম্ভাব্যতার একটি তালিকা প্রদান করতে পারে। সম্ভাব্যতাগুলিকে প্রাসঙ্গিক বিভাগগুলিতে ম্যাপ করা এবং আউটপুট ফর্ম্যাট করা আপনার উপর নির্ভর করে।

এই নির্দেশিকাটি বর্ণনা করে কিভাবে LiterRT ইন্টারপ্রেটার অ্যাক্সেস করতে হয় এবং C++, জাভা এবং পাইথন ব্যবহার করে একটি অনুমান করতে হয়।

সমর্থিত প্ল্যাটফর্মগুলি

টেনসরফ্লো ইনফারেন্স এপিআইগুলি অ্যান্ড্রয়েড , আইওএস এবং লিনাক্সের মতো বেশিরভাগ সাধারণ মোবাইল এবং এমবেডেড প্ল্যাটফর্মের জন্য একাধিক প্রোগ্রামিং ভাষায় সরবরাহ করা হয়।

বেশিরভাগ ক্ষেত্রে, API ডিজাইন ব্যবহারের সহজতার চেয়ে কর্মক্ষমতাকে বেশি প্রাধান্য দেয়। LiterRT ছোট ডিভাইসে দ্রুত অনুমানের জন্য ডিজাইন করা হয়েছে, তাই API গুলি সুবিধার বিনিময়ে অপ্রয়োজনীয় কপি এড়ায়।

সমস্ত লাইব্রেরি জুড়ে, LiterRT API আপনাকে মডেল লোড করতে, ইনপুট ফিড করতে এবং ইনফারেন্স আউটপুট পুনরুদ্ধার করতে দেয়।

অ্যান্ড্রয়েড প্ল্যাটফর্ম

অ্যান্ড্রয়েডে, LiterRT ইনফারেন্স জাভা অথবা C++ API ব্যবহার করে করা যেতে পারে। জাভা API গুলি সুবিধা প্রদান করে এবং সরাসরি আপনার অ্যান্ড্রয়েড অ্যাক্টিভিটি ক্লাসের মধ্যে ব্যবহার করা যেতে পারে। C++ API গুলি আরও নমনীয়তা এবং গতি প্রদান করে, তবে জাভা এবং C++ স্তরগুলির মধ্যে ডেটা স্থানান্তর করার জন্য JNI র‍্যাপার লেখার প্রয়োজন হতে পারে।

আরও তথ্যের জন্য C++ এবং জাভা বিভাগগুলি দেখুন, অথবা অ্যান্ড্রয়েড কুইকস্টার্ট অনুসরণ করুন।

iOS প্ল্যাটফর্ম

iOS-এ, LiterRT Swift এবং Objective-C iOS লাইব্রেরিতে পাওয়া যায়। আপনি Objective-C কোডেও সরাসরি C API ব্যবহার করতে পারেন।

Swift , Objective-C , এবং C API বিভাগগুলি দেখুন, অথবা iOS quickstart অনুসরণ করুন।

লিনাক্স প্ল্যাটফর্ম

লিনাক্স প্ল্যাটফর্মগুলিতে, আপনি C++ এ উপলব্ধ LiterRT API ব্যবহার করে অনুমান চালাতে পারেন।

একটি মডেল লোড করুন এবং চালান

একটি LiterRT মডেল লোড এবং চালানোর জন্য নিম্নলিখিত পদক্ষেপগুলি অন্তর্ভুক্ত থাকে:

মডেলটি মেমরিতে লোড করা হচ্ছে।
বিদ্যমান মডেলের উপর ভিত্তি করে একজন Interpreter তৈরি করা।
ইনপুট টেনসরের মান নির্ধারণ করা।
অনুমান আহ্বান করা।
টেনসরের মান আউটপুট করা হচ্ছে।

অ্যান্ড্রয়েড (জাভা)

LiterRT-এর মাধ্যমে ইনফারেন্স চালানোর জন্য জাভা API মূলত অ্যান্ড্রয়েডের সাথে ব্যবহারের জন্য ডিজাইন করা হয়েছে, তাই এটি একটি অ্যান্ড্রয়েড লাইব্রেরি নির্ভরতা হিসাবে উপলব্ধ: com.google.ai.edge.litert ।

জাভাতে, আপনি একটি মডেল এবং ড্রাইভ মডেল ইনফারেন্স লোড করতে Interpreter ক্লাস ব্যবহার করবেন। অনেক ক্ষেত্রে, এটিই আপনার প্রয়োজন হতে পারে একমাত্র API।

আপনি একটি FlatBuffers ( .tflite ) ফাইল ব্যবহার করে একটি Interpreter আরম্ভ করতে পারেন:

public Interpreter(@NotNull File modelFile);

অথবা একটি MappedByteBuffer সহ:

public Interpreter(@NotNull MappedByteBuffer mappedByteBuffer);

উভয় ক্ষেত্রেই, আপনাকে একটি বৈধ LiterRT মডেল প্রদান করতে হবে, নাহলে API IllegalArgumentException ব্যবহার করবে। যদি আপনি একটি Interpreter শুরু করার জন্য MappedByteBuffer ব্যবহার করেন, তাহলে 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 আউটপুট টেনসরের সূচকগুলিকে সংশ্লিষ্ট আউটপুট ডেটার সাথে ম্যাপ করে।

উভয় ক্ষেত্রেই, টেনসর সূচকগুলি মডেল তৈরি করার সময় LiterRT কনভার্টারে আপনি যে মানের দিয়েছিলেন তার সাথে মিলিত হওয়া উচিত। মনে রাখবেন যে input টেনসরের ক্রম LiterRT কনভার্টারে প্রদত্ত ক্রমের সাথে মিলিত হওয়া উচিত।

Interpreter ক্লাসটি আপনাকে একটি অপারেশন নাম ব্যবহার করে যেকোনো মডেল ইনপুট বা আউটপুটের সূচক পেতে সুবিধাজনক ফাংশন প্রদান করে:

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

যদি opName মডেলটিতে একটি বৈধ অপারেশন না হয়, তাহলে এটি একটি IllegalArgumentException ছুঁড়ে দেয়।

এছাড়াও মনে রাখবেন যে Interpreter কাছে রিসোর্স আছে। মেমোরি লিক এড়াতে, রিসোর্সগুলি ব্যবহারের পরে রিলিজ করতে হবে:

interpreter.close();

জাভা সহ একটি উদাহরণ প্রকল্পের জন্য, অ্যান্ড্রয়েড অবজেক্ট সনাক্তকরণ উদাহরণ অ্যাপটি দেখুন।

সমর্থিত ডেটা প্রকার

LiterRT ব্যবহার করার জন্য, ইনপুট এবং আউটপুট টেনসরের ডেটা টাইপগুলি নিম্নলিখিত আদিম টাইপগুলির মধ্যে একটি হতে হবে:

float
int
long
byte

String টাইপগুলিও সমর্থিত, তবে সেগুলি আদিম টাইপগুলির চেয়ে আলাদাভাবে এনকোড করা হয়। বিশেষ করে, একটি স্ট্রিংয়ের আকৃতি টেনসরের স্ট্রিংগুলির সংখ্যা এবং বিন্যাস নির্ধারণ করে, প্রতিটি উপাদান নিজেই একটি পরিবর্তনশীল দৈর্ঘ্যের স্ট্রিং। এই অর্থে, টেনসরের (বাইট) আকার শুধুমাত্র আকৃতি এবং টাইপ থেকে গণনা করা যায় না, এবং ফলস্বরূপ স্ট্রিংগুলিকে একটি একক, সমতল ByteBuffer আর্গুমেন্ট হিসাবে সরবরাহ করা যায় না।

যদি Integer এবং Float মতো বক্সযুক্ত ডেটা টাইপ সহ অন্যান্য ডেটা টাইপ ব্যবহার করা হয়, তাহলে একটি IllegalArgumentException নিক্ষেপ করা হবে।

ইনপুট

প্রতিটি ইনপুট সমর্থিত আদিম ধরণের একটি অ্যারে বা বহু-মাত্রিক অ্যারে, অথবা উপযুক্ত আকারের একটি কাঁচা ByteBuffer হওয়া উচিত। যদি ইনপুটটি একটি অ্যারে বা বহু-মাত্রিক অ্যারে হয়, তাহলে ইনফারেন্সের সময় সংশ্লিষ্ট ইনপুট টেনসরটি পরোক্ষভাবে অ্যারের মাত্রা অনুসারে আকার পরিবর্তন করা হবে। যদি ইনপুটটি একটি বাইটবাফার হয়, তাহলে ইনফারেন্স চালানোর আগে কলারকে প্রথমে সংশ্লিষ্ট ইনপুট টেনসরটি ( Interpreter.resizeInput() এর মাধ্যমে) ম্যানুয়ালি আকার পরিবর্তন করতে হবে।

ByteBuffer ব্যবহার করার সময়, ডাইরেক্ট বাইট বাফার ব্যবহার করা পছন্দ করুন, কারণ এটি Interpreter অপ্রয়োজনীয় কপি এড়াতে সাহায্য করে। যদি ByteBuffer একটি ডাইরেক্ট বাইট বাফার হয়, তাহলে এর ক্রম অবশ্যই ByteOrder.nativeOrder() হতে হবে। এটি একটি মডেল ইনফারেন্সের জন্য ব্যবহার করার পরে, মডেল ইনফারেন্স শেষ না হওয়া পর্যন্ত এটি অপরিবর্তিত থাকতে হবে।

আউটপুট

প্রতিটি আউটপুট সমর্থিত আদিম ধরণের একটি অ্যারে বা বহুমাত্রিক অ্যারে, অথবা উপযুক্ত আকারের একটি বাইটবাফার হওয়া উচিত। মনে রাখবেন যে কিছু মডেলের গতিশীল আউটপুট থাকে, যেখানে আউটপুট টেনসরের আকার ইনপুটের উপর নির্ভর করে পরিবর্তিত হতে পারে। বিদ্যমান জাভা ইনফারেন্স API দিয়ে এটি পরিচালনা করার কোনও সহজ উপায় নেই, তবে পরিকল্পিত এক্সটেনশনগুলি এটি সম্ভব করবে।

আইওএস (সুইফট)

কোকোপডসের TensorFlowLiteSwift পডে সুইফট এপিআই পাওয়া যাচ্ছে।

প্রথমে, আপনাকে 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...
}

iOS (উদ্দেশ্য-C)

কোকোপডসের LiteRTObjC পডে অবজেক্টিভ-সি API পাওয়া যাচ্ছে।

প্রথমে, আপনাকে TensorFlowLiteObjC মডিউলটি আমদানি করতে হবে।

@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... */ }

অবজেক্টিভ-সি কোডে সি এপিআই

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);

সি++

LiterRT-এর সাথে ইনফারেন্স চালানোর জন্য C++ API অ্যান্ড্রয়েড, iOS এবং Linux প্ল্যাটফর্মের সাথে সামঞ্জস্যপূর্ণ। iOS-এ C++ API শুধুমাত্র bazel ব্যবহার করার সময় উপলব্ধ।

C++ তে, মডেলটি FlatBufferModel ক্লাসে সংরক্ষণ করা হয়। এটি একটি LiterRT মডেলকে ধারণ করে এবং আপনি এটিকে কয়েকটি ভিন্ন উপায়ে তৈরি করতে পারেন, মডেলটি কোথায় সংরক্ষণ করা হয়েছে তার উপর নির্ভর করে:

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() কল করে ট্রিগার করতে হবে।

C++ এর সাথে LiterRT এর সহজতম ব্যবহারটি এরকম দেখাচ্ছে:

// 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 needed.
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 দেখুন।

পাইথন

ইনফারেন্স চালানোর জন্য পাইথন API একটি মডেল লোড করতে এবং ইনফারেন্স চালানোর জন্য Interpreter ব্যবহার করে।

LiterRT প্যাকেজটি ইনস্টল করুন:

$ python3 -m pip install ai-edge-litert

LiterRT ইন্টারপ্রেটার আমদানি করুন

from ai_edge_litert.interpreter import Interpreter
Interpreter = Interpreter(model_path=args.model.file)

নিম্নলিখিত উদাহরণে দেখানো হয়েছে কিভাবে পাইথন ইন্টারপ্রেটার ব্যবহার করে একটি FlatBuffers ( .tflite ) ফাইল লোড করতে হয় এবং র‍্যান্ডম ইনপুট ডেটা দিয়ে ইনফারেন্স চালাতে হয়:

যদি আপনি SavedModel থেকে একটি সংজ্ঞায়িত SignatureDef দিয়ে রূপান্তর করেন, তাহলে এই উদাহরণটি সুপারিশ করা হয়।

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 LiteRT model in LiteRT Interpreter
from ai_edge_litert.interpreter import Interpreter
interpreter = 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 LiteRT model and allocate tensors.
from ai_edge_litert.interpreter import Interpreter
interpreter = Interpreter(TFLITE_FILE_PATH)
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 ফাইল হিসেবে লোড করার বিকল্প হিসেবে, আপনি আপনার কোডটি LiterT কম্পাইলারের সাথে একত্রিত করতে পারেন, যার ফলে আপনি আপনার Keras মডেলটিকে LiterT ফর্ম্যাটে রূপান্তর করতে পারবেন এবং তারপর ইনফারেন্স চালাতে পারবেন:

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 LiteRT format
converter = tf.lite.TFLiteConverter.from_keras_model(tf.keras.models.Model(inputs=[img], outputs=[out]))
tflite_model = converter.convert()

# Load the LiteRT model and allocate tensors.
from ai_edge_litert.interpreter import Interpreter
interpreter = Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()

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

আরও পাইথন নমুনা কোডের জন্য, label_image.py দেখুন।

গতিশীল আকৃতির মডেল দিয়ে অনুমান চালান

যদি আপনি একটি গতিশীল ইনপুট আকৃতির মডেল চালাতে চান, তাহলে ইনফারেন্স চালানোর আগে ইনপুট আকৃতির আকার পরিবর্তন করুন। অন্যথায়, Tensorflow মডেলগুলিতে None আকৃতি LiterT মডেলগুলিতে 1 এর স্থানধারক দ্বারা প্রতিস্থাপিত হবে।

নিম্নলিখিত উদাহরণগুলি দেখায় যে বিভিন্ন ভাষায় অনুমান চালানোর আগে ইনপুট আকৃতির আকার পরিবর্তন কিভাবে করা যায়। সমস্ত উদাহরণ ধরে নেয় যে ইনপুট আকৃতি [1/None, 10] হিসাবে সংজ্ঞায়িত করা হয়েছে, এবং এটি [3, 10] এ আকার পরিবর্তন করা প্রয়োজন।

সি++ উদাহরণ:

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

পাইথনের উদাহরণ:

# Load the LiteRT model in LiteRT Interpreter
from ai_edge_litert.interpreter import Interpreter
interpreter = 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()