গুগল আই/ও একটি মোড়ক! TensorFlow সেশনগুলি দেখুন সেশনগুলি দেখুন

TensorFlow লাইট অনুমান

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

এই পৃষ্ঠাটি কিভাবে TensorFlow লাইট অনুবাদক প্রবেশের বর্ণনা এবং অনুমান প্রত্যেকের জন্য অন্যান্য সম্পদ সি ++, জাভা, পাইথন, প্লাস লিঙ্ক ব্যবহার সঞ্চালন সমর্থিত প্ল্যাটফর্ম

গুরুত্বপূর্ণ ধারণা

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

  1. একটি মডেল লোড হচ্ছে

    আপনি লোড করা উচিত .tflite মেমরিতে মডেল, যা মডেল বলবৎকরণের গ্রাফ রয়েছে।

  2. ডেটা রূপান্তর

    মডেলের জন্য কাঁচা ইনপুট ডেটা সাধারণত মডেল দ্বারা প্রত্যাশিত ইনপুট ডেটা বিন্যাসের সাথে মেলে না। উদাহরণস্বরূপ, মডেলের সাথে সামঞ্জস্যপূর্ণ হওয়ার জন্য আপনাকে একটি চিত্রের আকার পরিবর্তন করতে হবে অথবা ছবির বিন্যাস পরিবর্তন করতে হতে পারে।

  3. অনুমান চলছে

    এই ধাপে মডেলটি চালানোর জন্য TensorFlow Lite API ব্যবহার করা জড়িত। এতে দোভাষী নির্মাণ, এবং টেন্সর বরাদ্দ করার মতো কয়েকটি ধাপ জড়িত, যেমনটি নিম্নলিখিত বিভাগে বর্ণিত হয়েছে।

  4. আউটপুট ব্যাখ্যা

    যখন আপনি মডেল অনুমান থেকে ফলাফল পান, তখন আপনাকে অবশ্যই টেনসারগুলিকে একটি অর্থপূর্ণ উপায়ে ব্যাখ্যা করতে হবে যা আপনার অ্যাপ্লিকেশনে দরকারী।

    উদাহরণস্বরূপ, একটি মডেল শুধুমাত্র সম্ভাব্যতার একটি তালিকা ফেরত দিতে পারে। প্রাসঙ্গিক বিভাগগুলির সম্ভাব্যতাগুলি ম্যাপ করা এবং এটি আপনার শেষ ব্যবহারকারীর কাছে উপস্থাপন করা আপনার উপর নির্ভর করে।

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

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

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

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

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

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

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

TensorFlow Lite অ্যান্ড্রয়েড রেপার কোড জেনারেটর

জন্য TensorFlow লাইট মডেল সঙ্গে উন্নত মেটাডাটা , ডেভেলপারদের প্ল্যাটফর্ম নির্দিষ্ট মোড়কের কোড তৈরি করতে TensorFlow লাইট অ্যান্ড্রয়েড মোড়কের কোড জেনারেটরের ব্যবহার করতে পারেন। মোড়কের কোড সহ সরাসরি যোগাযোগ করার জন্য প্রয়োজন সরিয়ে ফেলা হবে ByteBuffer Android এর উপর। পরিবর্তে, ডেভেলপারদের যেমন টাইপ বস্তুর সঙ্গে TensorFlow লাইট মডেল সাথে ইন্টারঅ্যাক্ট করতে পারবেন Bitmap এবং Rect । আরো তথ্যের জন্য, পড়ুন দয়া TensorFlow লাইট অ্যান্ড্রয়েড মোড়কের কোড জেনারেটরের

আইওএস প্ল্যাটফর্ম

IOS এ, TensorFlow লাইট নেটিভ iOS এর লেখা লাইব্রেরি পাওয়া যায় সুইফট এবং উদ্দেশ্য সি । এছাড়াও আপনি ব্যবহার করতে পারেন সি এপিআই উদ্দেশ্য সি কোড সরাসরি।

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

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

লিনাক্স প্ল্যাটফর্মের (তত্সহ উপর রাস্পবেরী Pi ), আপনি মতামতে উপনীত TensorFlow লাইট API গুলি পাওয়া ব্যবহার চালাতে পারেন সি ++ এবং পাইথন , যেমন নিম্নলিখিত বিভাগে দেখানো।

একটি মডেল চালাচ্ছেন

একটি TensorFlow লাইট মডেল চালানো কিছু সহজ পদক্ষেপ জড়িত:

  1. স্মৃতিতে মডেলটি লোড করুন।
  2. একটি তৈরি করুন Interpreter একটি বিদ্যমান মডেলের উপর ভিত্তি করে।
  3. ইনপুট টেন্সর মান সেট করুন। (পূর্বনির্ধারিত মাপগুলি পছন্দ না হলে inputচ্ছিকভাবে ইনপুট টেনসারের আকার পরিবর্তন করুন।)
  4. অনুমান আহ্বান।
  5. আউটপুট টেন্সর মান পড়ুন।

নিম্নোক্ত বিভাগগুলি বর্ণনা করে যে কিভাবে প্রতিটি ভাষায় এই পদক্ষেপগুলি করা যায়।

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

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

TensorFlow লাইট সঙ্গে একটি অনুমান চালানোর জন্য জাভা এপিআই প্রাথমিকভাবে, অ্যান্ড্রয়েড সাথে ব্যবহারের জন্য পরিকল্পিত, তাই এটি একটি Android গ্রন্থাগার নির্ভরতা হিসাবে উপলব্ধ সেটি হল: org.tensorflow:tensorflow-lite

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

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

public Interpreter(@NotNull File modelFile);

অথবা একটি সঙ্গে MappedByteBuffer :

public Interpreter(@NotNull MappedByteBuffer mappedByteBuffer);

উভয় ক্ষেত্রেই, আপনি একটি বৈধ TensorFlow লাইট মডেল প্রদান করতে হবে বা এপিআই ছোঁড়ার IllegalArgumentException । আপনি ব্যবহার করেন তাহলে MappedByteBuffer একটি আরম্ভ করতে Interpreter , এটা গোটা জীবনকাল জন্য অপরিবর্তিত থাকতে হবে Interpreter

একটি মডেলে অনুমান চালানোর পছন্দের উপায় হল স্বাক্ষর ব্যবহার করা - টেন্সরফ্লো 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 সংশ্লিষ্ট আউটপুট তথ্য আউটপুট tensors সূচকের মানচিত্র তৈরী করে।

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

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

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

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

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

interpreter.close();

জাভা সঙ্গে একটি উদাহরণ প্রকল্পের জন্য, দেখুন অ্যানড্রইড ইমেজ শ্রেণীবিন্যাস নমুনা

সমর্থিত ডেটা প্রকার (জাভাতে)

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

  • float
  • int
  • long
  • byte

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

মত বাক্সযুক্ত ধরনের সহ অন্যান্য ধরনের তথ্য যদি Integer এবং Float , ব্যবহার করা হয়, একটি IllegalArgumentException ফেলে দেওয়া হবে।

ইনপুট

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

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

আউটপুট

প্রতিটি আউটপুট সমর্থিত আদিম ধরনের একটি অ্যারে বা বহুমাত্রিক অ্যারে, বা উপযুক্ত আকারের একটি বাইটবফার হওয়া উচিত। লক্ষ্য করুন যে কিছু মডেলের গতিশীল আউটপুট রয়েছে, যেখানে ইনপুটের উপর নির্ভর করে আউটপুট টেন্সরের আকৃতি পরিবর্তিত হতে পারে। বিদ্যমান জাভা অনুমান 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...
}

উদ্দেশ্য-সি-তে একটি মডেল লোড করুন এবং চালান

প্ল্যাটফর্ম: আইওএস

উদ্দেশ্য সি এপিআই পাওয়া যায় 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... */ }

Objective-C কোডে C API ব্যবহার করা

বর্তমানে 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 ++ এ একটি মডেল লোড করুন এবং চালান

প্ল্যাটফর্ম: অ্যান্ড্রয়েড, আইওএস এবং লিনাক্স

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

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 কোড দেখানো হয় নিচের snippet। এটা লক্ষ করা উচিত যে:

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

C ++ সহ TensorFlow Lite এর সহজ ব্যবহার এইরকম দেখাচ্ছে:

// 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

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

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

একটি অনুমান চালানোর জন্য পাইথন এপিআই সরবরাহ করা হয় tf.lite মডিউল। যা থেকে আপনি বেশিরভাগই শুধুমাত্র প্রয়োজন tf.lite.Interpreter একটি মডেল লোড এবং একটি অনুমান চালানোর জন্য।

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

এই উদাহরণটি সুপারিশ করা হয় যদি আপনি একটি সংজ্ঞায়িত SignatureDef দিয়ে SavedModel থেকে রূপান্তর করছেন। 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 লাইট কনভার্টার পাইথন এপিআই ( tf.lite.TFLiteConverter ), আপনি TensorFlow লাইট বিন্যাসে আপনার TensorFlow মডেল রূপান্তর এবং তারপর যার ফলে অনুমান চালান:

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 অপারেশনের একটি উপসেট সমর্থন করে। অপারেশন ও সীমাবদ্ধতা পূর্ণ তালিকার জন্য দেখুন মেমরি লাইট অপস পৃষ্ঠা