Google Tensor-এ LiteRT প্রয়োগ করা হচ্ছে

১. সংক্ষিপ্ত বিবরণ

পিক্সেল ডিভাইসের জন্য LiteRT মডেল কম্পাইল করতে গুগল টেনসর এসডিকে (Google Tensor SDK) ব্যবহার করা হয়। উন্নত এমএল ইনফারেন্স পারফরম্যান্সের জন্য কম্পাইল করা মডেলগুলো পিক্সেল ডিভাইসে স্থাপন করা যায়। এসডিকে ব্যবহার করার জন্য, আপনাকে প্রথমে আপনার মডেলটিকে একটি LiteRT ( tflite ) মডেলে রূপান্তর করতে হবে।

এই কোডল্যাবটি গিটহাবের সাধারণ কোলাব, LiteRT AOT Compilation Tutorial Colab-এর উপর ভিত্তি করে তৈরি। .

উদ্দেশ্য

শিখুন কিভাবে LiteRT AOT (এহেড অফ টাইম) কম্পাইলার ব্যবহার করে একটি TFLite মডেল থেকে সেলফি সেগমেন্টেশন মডেলকে এমন একটি LiteRT মডেলে কম্পাইল করা যায়, যা অন-ডিভাইস EdgeTPU-এর জন্য অপ্টিমাইজ ও কম্পাইল করা হয়েছে।

এই কোলাবটি আপনাকে প্লে ফর অন-ডিভাইস এআই ( PODAI ) ব্যবহার করে মডেল প্রস্তুত করার ধাপগুলোও দেখিয়ে দেবে।

PODAI ডিভাইসের AI ফিচারগুলোর জন্য কাস্টম মডেল আরও দক্ষতার সাথে সরবরাহ করে। এটি আপনার AI মডেলগুলো চালু করা, টার্গেট করা, ভার্সনিং করা এবং ডাউনলোড করার প্রক্রিয়াকে সহজ করে তোলে। LiteRT EdgeTPU AOT কম্পাইলেশনের সাথে মিলিত হলে, এটি ডেভেলপারদেরকে শেষ ব্যবহারকারীর ফোনে কোন EdgeTPU রয়েছে তা না জেনেই বিভিন্ন ডিভাইসের জন্য কম্পাইল করা ML মডেল সরবরাহ করতে দেয়।

ব্যবহৃত মডেলগুলি

আমরা যে মডেলগুলো ব্যবহার করছি, সেগুলো মূলত মিডিয়াপাইপ ইমেজ সেগমেন্টেশন গাইড- এ প্রকাশিত। এই কোডল্যাবে ব্যবহৃত মডেলটি সম্পর্কে কিছু বিবরণ নিচে দেওয়া হলো:

• SelfieMulticlass : একটি LiteRT মডেল যা কোনো ব্যক্তির ছবি থেকে চুল, ত্বক এবং পোশাকের মতো অংশগুলো শনাক্ত করে এবং এই উপাদানগুলোর জন্য একটি ইমেজ সেগমেন্টেশন ম্যাপ আউটপুট হিসেবে দেয়।

২. শুরু করুন

Google Tensor SDK-তে অ্যাক্সেস পেতে এবং এটি ব্যবহার শুরু করতে এই ধাপগুলো অনুসরণ করুন:

1. গুগল টেনসর এসডিকে-তে অ্যাক্সেস পেতে সাইন-আপ করুন । আরও অগ্রসর হওয়ার আগে, আপনাকে গুগলের পাঠানো একটি ইমেলের জন্য অপেক্ষা করতে হবে, যেটিতে কম্পাইলার প্লাগইনটির ডাউনলোড লিঙ্ক থাকবে।
2. কম্পাইলার প্লাগইনটি ( litert_plugin_compiler.tar.gz ) ডাউনলোড করে আপনার পছন্দের একটি ফোল্ডারে রাখুন।
3. এনভায়রনমেন্ট ভেরিয়েবলটি ডাউনলোড করা ফাইল GOOGLE_TENSOR_SDK_BETA এর লোকাল সিস্টেম পাথে সেট করুন।
   আপনি আপনার ব্যাশ টার্মিনালে এই কমান্ডটি চালাতে পারেন:

   export GOOGLE_TENSOR_SDK_BETA=/path/to/downloaded/compiler
   

   অথবা আপনি আপনার কোলাব নোটবুকে এটি চালাতে পারেন:

   %env GOOGLE_TENSOR_SDK_BETA=/path/to/downloaded/compiler
   

4. এরপর প্যাকেজটি ইনস্টল করতে এই কমান্ডটি চালান:

   pip install ai-edge-litert-sdk-google-tensor
   

৩. প্রয়োজনীয় প্যাকেজগুলো ইনস্টল করুন

প্রথমে প্রয়োজনীয় প্যাকেজগুলো ইনস্টল করুন, যার মধ্যে রয়েছে ai-edge-litert-nightly , যেটিতে EdgeTPU AOT কম্পাইলার রয়েছে, এবং মডেল রূপান্তরের জন্য আপনার ব্যবহৃত অন্যান্য লাইব্রেরিগুলোও ইনস্টল করুন।

Google Tensor-এর জন্য LiteRT ব্যাকএন্ড ইনস্টল করতে এই প্যাকেজটি ব্যবহার করুন: ai-edge-litert-sdk-google-tensor ।

প্যাকেজগুলো ইনস্টল করার পর, সেশনটি পুনরায় চালু করুন এবং ইনস্টলেশনের ধাপগুলো অনুসরণ করুন। ইনস্টলেশনটি পুনরাবৃত্তি করবেন না ।

গুরুত্বপূর্ণ: আপনি যদি কোলাব নোটবুক বা জুপিটার নোটবুক ব্যবহার করার পরিকল্পনা করেন, তাহলে প্রতিটি pip install এবং pip uninstall কমান্ডের আগে একটি বিস্ময়সূচক চিহ্ন ! যোগ করুন। যখন আপনি pip কমান্ডটি কোনো কোলাব সেলে কপি-পেস্ট করবেন, তখন এটি করুন।

আপনি যদি আপনার সিস্টেমে সেটআপটি সম্পন্ন করার পরিকল্পনা করেন, তবে আমরা আপনাকে একটি পাইথন ভার্চুয়াল এনভায়রনমেন্ট (venv) ব্যবহার করার এবং সেই ভার্চুয়াল এনভায়রনমেন্টের মধ্যেই এই কমান্ডগুলো চালানোর পরামর্শ দিই।

নির্দিষ্ট প্যাকেজ আনইনস্টল করুন

তার আগে, কোলাব রানটাইমের সাথে ডিফল্টভাবে আসা টেনসরফ্লো আনইনস্টল করুন।

দ্রষ্টব্য: এই ধাপে, আপনি প্যাকেজ ইনস্টল না থাকা সংক্রান্ত সতর্কবার্তা দেখতে পারেন। আপনি নিরাপদে এগুলো উপেক্ষা করতে পারেন।

pip uninstall -y tensorflow ai-edge-litert

সমস্ত লাইব্রেরি ইনস্টল করুন

Google Tensor-এর জন্য LiteRT ব্যাকএন্ড ইনস্টল করুন

pip install ai-edge-litert-sdk-google-tensor

বাকি প্যাকেজগুলি ইনস্টল করুন

pip install matplotlib huggingface-hub ai-edge-litert-nightly

গুরুত্বপূর্ণ: আপনি যদি কোলাব বা জুপিটার নোটবুক ব্যবহার করেন:

• ইনস্টলেশন সম্পন্ন হলে কোলাব-রানটাইম পুনরায় চালু করুন।
• ইনস্টল করা প্যাকেজগুলো সঠিকভাবে প্রতিফলিত হওয়ার জন্য, মেনু বার থেকে Runtime > Restart session-এ ক্লিক করে Colab-এর রানটাইম রিস্টার্ট করুন। সমস্ত ইনস্টলেশন সম্পূর্ণ হওয়ার পরেই কেবল এই রিস্টার্টটি করা উচিত।
• রানটাইম পুনরায় চালু করার পর, শুধুমাত্র নিম্নলিখিত কমান্ডগুলো চালান । আগের কমান্ডগুলো আবার চালানোর প্রয়োজন নেই ।

৪. সকল লাইব্রেরি ইম্পোর্ট করুন

ইনস্টলেশন সম্পন্ন হলে মূল কার্য সম্পাদনে অগ্রসর হোন।

পরামর্শ: এই এবং পরবর্তী অংশগুলোর জন্য, একটি জুপিটার নোটবুক ব্যবহার করুন অথবা কমান্ডগুলো একটি পাইথন স্ক্রিপ্টে যুক্ত করুন।

প্রয়োজনীয় প্যাকেজগুলো ইম্পোর্ট করুন:

import os
import shutil

from ai_edge_litert.aot import aot_compile as aot_lib
from ai_edge_litert.aot.ai_pack import export_lib as ai_pack_export
from ai_edge_litert.aot.vendors.google_tensor import target as gt_target
import huggingface_hub
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
import requests

দ্রষ্টব্য: আপনি যদি ai ai-edge-litert ai-edge-litert-nightly litert স্টেবল রিলিজ প্যাকেজটি ব্যবহার করেন, তাহলে আপনাকে সমস্ত ইম্পোর্ট স্টেটমেন্টের আগে (স্ক্রিপ্টের প্রতিটি রানের জন্য) এই এনভায়রনমেন্ট ভেরিয়েবলটি সেট করতে হবে: GOOGLE_TENSOR_BACKEND_ENABLED=1 । এর জন্য পাইথন কোড স্নিপেট নিচে দেওয়া হলো:

import os
os.environ['GOOGLE_TENSOR_BACKEND_ENABLED'] = '1'

অথবা (খোলস)

export GOOGLE_TENSOR_BACKEND_ENABLED=1

৫. একটি LiteRT মডেল কম্পাইল করুন

এই বিভাগে সরাসরি LiteRT (TFLite) মডেল কম্পাইল করার মতো উন্নত ব্যবহারগুলো আলোচনা করা হয়েছে।

TFLite মডেল থেকে EdgeTPU কম্পাইলেশন

এই ধাপটির জন্য একটি TFLite মডেল প্রয়োজন। যদি আপনার কাছে TFLite মডেল না থাকে, তবে আপনার মডেলটিকে TFLite ফরম্যাটে রূপান্তর করুন।

TFLite মডেলটি নিন

এই ব্যবহারের ক্ষেত্রে আমরা মিডিয়াপাইপ মাল্টিক্লাস সেগমেন্টেশন মডেলটি ব্যবহার করি।

TFLite মডেলটি MediaPipe ইমেজ সেগমেন্টেশন পেজ থেকে পাওয়া যায়।

work_dir = '.'

model_url = 'https://storage.googleapis.com/mediapipe-models/image_segmenter/selfie_multiclass_256x256/float32/latest/selfie_multiclass_256x256.tflite'
tflite_model_path = os.path.join(work_dir, 'selfie_multiclass_256x256.tflite')

model_content = requests.get(model_url)

with open(tflite_model_path, 'wb') as fout:
  fout.write(model_content.content)

LiteRT পাইথন API ব্যবহার করে দ্রুত TfLite মডেলটি যাচাই করুন

নিচের উদাহরণে আপনি মাস্ক ইমেজ এবং ব্লেন্ড করা ফলাফল উভয়ই দেখতে পাবেন।

# Downloading Testing image

test_image = huggingface_hub.hf_hub_download(
    repo_id="litert-community/MediaPipe-Selfie-Segmentation",
    filename="test_img.png",
)
pil_image = Image.open(test_image).convert("RGB").resize((256, 256))

from ai_edge_litert.compiled_model import CompiledModel

SEGMENT_COLORS = [
    (0, 0, 0),
    (255, 0, 0),
    (0, 255, 0),
    (0, 0, 255),
    (255, 255, 0),
    (255, 0, 255),
]
INPUT_SIZE = (256, 256)
NUM_CLASSES = 6

# Load the model and image
model = CompiledModel.from_file(tflite_model_path)
original_image = np.array(Image.open(test_image).convert('RGB'))
img_array = np.array(pil_image).astype(np.float32)

# Normalize the image
normalized = (img_array - 127.5) / 127.5
normalized = np.ascontiguousarray(normalized, dtype=np.float32)

# Run inference
sig_idx = 0
input_buffers = model.create_input_buffers(sig_idx)
output_buffers = model.create_output_buffers(sig_idx)
input_data = normalized.reshape(-1)
input_buffers[0].write(input_data)
model.run_by_index(sig_idx, input_buffers, output_buffers)

# Get output data
height, width = INPUT_SIZE
output_size = height * width * NUM_CLASSES
output_data = output_buffers[0].read(output_size, np.float32)
output_data = output_data.reshape(height, width, NUM_CLASSES)
mask = np.argmax(output_data, axis=2).astype(np.uint8)

# Create colored mask
colored_mask = np.zeros((height, width, 3), dtype=np.uint8)
for label_idx in range(NUM_CLASSES):
  class_mask = mask == label_idx
  color = SEGMENT_COLORS[label_idx]
  colored_mask[class_mask] = color

# Blend with original image
# Resize colored mask to match original image if necessary
if original_image.shape[:2] != colored_mask.shape[:2]:
  colored_mask_pil = Image.fromarray(colored_mask)
  colored_mask_pil = colored_mask_pil.resize(
      (original_image.shape[1], original_image.shape[0])
  )
  colored_mask = np.array(colored_mask_pil)

# Blend images with alpha 0.5
alpha = 0.5
blended_image = (
    original_image * (1 - alpha) + colored_mask * alpha
).astype(np.uint8)

# Display them
fig, axes = plt.subplots(1, 3, figsize=(9, 3))

for idx, (title, image) in enumerate([
    ('Original Image', original_image),
    ('Colored Mask', colored_mask),
    ('Blended Image', blended_image),
]):
  axes[idx].imshow(image)
  axes[idx].set_title(title)
  axes[idx].axis('off')

plt.tight_layout()
plt.show()

EdgeTPU AOT কম্পাইলেশনের মাধ্যমে LiteRT মডেলে রূপান্তর করুন।

মডেলটি কম্পাইল করার জন্য আমরা ai_edge_litert.aot এর এপিআইগুলো ব্যবহার করি।

compiled_models = aot_lib.aot_compile(tflite_model_path, keep_going=True)

# This variable will be used later to create the AI Pack.
all_google_tensor_compiled_models = compiled_models

# Print Compilation Report
print(all_google_tensor_compiled_models.compilation_report())

# Saving compiled models to disk. This saves all the compiled models, and a CPU
# fallback model.
all_google_tensor_compiled_models.export(
    work_dir, model_name='selfie_segmentation'
)

কম্পাইলেশন শেষ হলে, model.export মেথড ব্যবহার করে সমস্ত মডেল ডিস্কে এক্সপোর্ট করুন।

ডিফল্টরূপে, মডেলগুলো আউটপুট ডিরেক্টরিতে একটি ফ্ল্যাট কাঠামোতে সংরক্ষিত হয়, যেখানে প্রতিটি মডেলের নামের শেষে ব্যাকএন্ড আইডি যুক্ত থাকে।

উদাহরণস্বরূপ:

মডেল ফাইলের নাম	ব্যাকএন্ড	SoC	দ্রষ্টব্য
selfie_segmentation_fallback.tflite	সিপিইউ/জিপিইউ	প্রযোজ্য নয়	প্রযোজ্য নয়
selfie_segmentation_Google_Tensor_G3.tflite	গুগল	Tensor_G3	গুগল টেনসর জি৩
selfie_segmentation_Google_Tensor_G4.tflite	গুগল	Tensor_G4	গুগল টেনসর জি৪
selfie_segmentation_Google_Tensor_G5.tflite	গুগল	Tensor_G5	গুগল টেনসর জি৫

৬. সিপিইউ-তে রপ্তানি ও যাচাই করুন

কম্পাইলেশন সম্পন্ন হলে, সিপিইউ-তে TFLite মডেলটি যাচাই করুন। কম্পাইলেশনের সময় তৈরি হওয়া 'ফলব্যাক মডেল' ব্যবহার করে এটি করুন।

# Run LiteRT with test image
from ai_edge_litert.compiled_model import CompiledModel

# Normalize the image to [-1, 1]
img_array = np.array(pil_image, dtype=np.float32)
normalized = (img_array - 127.5) / 127.5
numpy_array = np.ascontiguousarray(normalized)[None, ...]

cpu_model_path = os.path.join(work_dir, "selfie_segmentation_fallback.tflite")
cm_model = CompiledModel.from_file(cpu_model_path)
sig_idx = 0
input_buffers = cm_model.create_input_buffers(sig_idx)
output_buffers = cm_model.create_output_buffers(sig_idx)
input_buffers[0].write(numpy_array)
cm_model.run_by_index(sig_idx, input_buffers, output_buffers)

# Read the 6-channel output and apply argmax
output_data = output_buffers[0].read(256 * 256 * 6, np.float32)
output_data = output_data.reshape((256, 256, 6))
mask = np.argmax(output_data, axis=2).astype(np.uint8)

# Create a colored mask using the previously defined SEGMENT_COLORS
colored_mask = np.zeros((256, 256, 3), dtype=np.uint8)
for label_idx in range(6):
  class_mask = mask == label_idx
  color = SEGMENT_COLORS[label_idx]
  colored_mask[class_mask] = color

mask_image = Image.fromarray(colored_mask)

# Show output results
fig, axes = plt.subplots(1, 2, figsize=(9, 3))

for idx, (title, image) in enumerate([
    ('Test Image', pil_image),
    ('TFLite Mask Image', mask_image),
]):
  axes[idx].imshow(image)
  axes[idx].set_title(title)
  axes[idx].axis('off')

plt.tight_layout()
plt.show()

৭. PODAI-এর জন্য মডেল রপ্তানি করুন

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

AiEdgeLiteRT AOT (অহেড-অফ-টাইম) মডিউলটি বিশেষভাবে এই উদ্দেশ্যে ai_pack ইউটিলিটি প্রদান করে। এই ইউটিলিটিগুলো একটি AI Pack তৈরি করে, যা একটি অত্যন্ত গুরুত্বপূর্ণ ডেটা অ্যাসেট। একটি AI Pack আপনার কম্পাইল করা মডেলগুলোকে ডিভাইস-টার্গেটিং কনফিগারেশনের সাথে একত্রিত করে, যা নিশ্চিত করে যে সঠিক মডেল এবং অ্যাসেটগুলো উপযুক্ত ব্যবহারকারীর ডিভাইসে পৌঁছে দেওয়া হয়। এটি NPU (নিউরাল প্রসেসিং ইউনিট) কম্পাইলেশনের জন্য বিশেষভাবে গুরুত্বপূর্ণ, কারণ এটি নিশ্চিত করে যে একটি নির্দিষ্ট সিস্টেম-অন-চিপ (SoC)-এর জন্য অপ্টিমাইজ করা মডেলগুলো শুধুমাত্র সেই SoC-যুক্ত ডিভাইসগুলোতেই পৌঁছায়।

# Configuring the AI Pack
os.makedirs('selfie_multiclass', exist_ok=True)
ai_pack_dir = os.path.join(work_dir, 'ai_pack')
ai_pack_name = 'selfie_segmentation'
litert_model_name = 'segmentation_model'

# Clean up
shutil.rmtree(ai_pack_dir, ignore_errors=True)

# Export
ai_pack_export.export(
    all_google_tensor_compiled_models,
    ai_pack_dir,
    ai_pack_name,
    litert_model_name
)

এআই প্যাক উৎস পরিদর্শন করা হচ্ছে

def list_files(startpath):
  """Function to print out the tree structure of a directory."""
  for root, dirs, files in os.walk(startpath):
    level = root.replace(startpath, '').count(os.sep)
    indent = ' ' * 4 * (level)
    print('{}{}/'.format(indent, os.path.basename(root)))
    subindent = ' ' * 4 * (level + 1)
    for f in files:
      print('{}{}'.format(subindent, f))
"""View the files generated within the AI pack directory"""
list_files(ai_pack_dir)

৮. উন্নত বিকল্পগুলি কনফিগার করুন

নির্দিষ্ট ডিভাইস বা EdgeTPU-এর জন্য NPU কম্পাইলেশন

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

নিম্নলিখিত উদাহরণটি কম্পাইল হয়ে গুগল টেনসর জি৫ (Google Tensor G5) তৈরি করে।

# Specifying the compilation target
tensor_g5_target = gt_target.Target(gt_target.SocModel.TENSOR_G5)

# Compile from the TFLite model for a specific target
compiled_models = aot_lib.aot_compile(
    tflite_model_path,
    target=[tensor_g5_target],
    keep_going=False,  # We want to error out when there's failure.
)

print(compiled_models.compilation_report())

গুগল টেনসরের জন্য কম্পাইলেশন ফ্ল্যাগ

কম্পাইলেশন ফ্ল্যাগের মাধ্যমে কম্পাইলেশন প্রক্রিয়াটি কাস্টমাইজ করুন। এখানে এই ফ্ল্যাগটি ব্যবহৃত হয়েছে: google_tensor_truncation_type="half"

একটি TFLite মডেল সংকলন করার সময়

compiled_models = aot_lib.aot_compile(
    tflite_model_path,
    target=[tensor_g5_target],
    keep_going=False,
    google_tensor_truncation_type="half"
)

৯. পরবর্তী পদক্ষেপ

অভিনন্দন!

আপনার মডেলগুলো PODAI-এর ব্যবহারের জন্য প্রস্তুত!

এবার পরবর্তী ধাপগুলোর জন্য অ্যান্ড্রয়েড স্টুডিওতে যান; বিস্তারিত জানতে LiteRT ইমেজ সেগমেন্টেশন স্যাম্পলগুলো দেখুন।