Google Tensor'da LiteRT'yi uygulama

1. Genel Bakış

Google Tensor SDK, Pixel cihazlar için LiteRT modellerini derlemek üzere kullanılır. Derlenen modeller, makine öğrenimi çıkarımı performansını artırmak için Pixel cihazlarda dağıtılabilir. SDK'yı kullanmak için öncelikle modelinizi LiteRT (tflite) modeline dönüştürmeniz gerekir.

Bu codelab, GitHub'daki genel Colab'e dayanmaktadır: LiteRT AOT Derleme Eğitimi Colab:.

Hedef

LiteRT AOT (önceden derleme) derleyicisini kullanarak TFLite modelinden selfie segmentasyon modelini cihaz üzerinde EdgeTPU'lar için optimize edilmiş ve derlenmiş bir LiteRT modeline nasıl derleyeceğinizi öğrenin.

Bu Colab, Play for cihaz üzerinde AI (PODAI) ile modelleri hazırlama adımlarını da açıklar.

PODAI, cihaz üzerindeki yapay zeka özellikleri için özel modelleri daha verimli bir şekilde sunar. Yapay zeka modellerinizi başlatma, hedefleme, sürüm oluşturma ve indirme sürecini basitleştirir. LiteRT EdgeTPU AOT derlemesiyle birlikte kullanıldığında, geliştiricilerin son kullanıcının telefonunda hangi EdgeTPU'ların bulunduğunu bilmesine gerek kalmadan çeşitli cihazlar için derlenmiş makine öğrenimi modelleri sunmasına olanak tanır.

Kullanılan modeller

Kullandığımız modeller, aslen MediaPipe Görüntü segmentasyonu kılavuzunda yayınlanmıştır. Bu codelab'de kullanılan modelle ilgili bazı ayrıntıları aşağıda bulabilirsiniz:

• SelfieMulticlass: Bir kişinin resmini alıp saç, ten ve kıyafet gibi alanları bulan ve bu öğeler için bir resim segmentasyonu haritası oluşturan LiteRT modeli.

2. Başlayın

Google Tensor SDK'ya erişmek ve bu SDK'yı kullanmaya başlamak için aşağıdaki adımları uygulayın:

1. Google Tensor SDK'ya erişmek için kaydolun. Devam etmeden önce, derleyici eklentisinin indirme bağlantısını içeren Google'dan gelen e-postayı beklemeniz gerekir.
2. Derleyici eklentisini (litert_plugin_compiler.tar.gz) indirip istediğiniz bir klasöre yerleştirin.
3. Ortam değişkenini, indirilen dosyanın yerel sistem yoluna (GOOGLE_TENSOR_SDK_BETA) ayarlayın.
   Bu komutu bash terminalinizde çalıştırabilirsiniz:

   export GOOGLE_TENSOR_SDK_BETA=/path/to/downloaded/compiler
   

   Alternatif olarak, bu kodu Colab not defterinizde çalıştırabilirsiniz:

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

4. Ardından paketi yüklemek için şu komutu çalıştırın:

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

3. Gerekli paketleri yükleme

EdgeTPU AOT derleyicisini içeren ai-edge-litert-nightly ve model dönüştürme için kullandığınız diğer kitaplıklar da dahil olmak üzere gerekli paketleri yükleyerek başlayın.

Google Tensor için LiteRT arka ucunu yüklemek üzere bu paketi kullanın: ai-edge-litert-sdk-google-tensor.

Paketleri yükledikten sonra oturumu yeniden başlatın ve yükleme adımlarından devam edin. Yükleme işlemini tekrarlamayın.

Önemli: Colab not defteri veya Jupyter not defteri kullanmayı planlıyorsanız her pip install ve pip uninstall komutundan önce ünlem işareti ! ekleyin. Bunu, pip komutunu bir Colab hücresine kopyalayıp yapıştırdığınızda yapın.

Kurulumu sisteminizde yapmayı planlıyorsanız Python sanal ortamı (venv) kullanmanızı ve bu komutları sanal ortamda çalıştırmanızı öneririz.

Belirli paketlerin yüklemesini kaldırma

Bunun için öncelikle Colab çalışma zamanıyla birlikte gelen varsayılan tensorflow'u kaldırın.

Not: Bu adımda, paketlerin yüklenmediğiyle ilgili uyarılarla karşılaşabilirsiniz. Bunları güvenle yoksayabilirsiniz.

pip uninstall -y tensorflow ai-edge-litert

Tüm kitaplıkları yükleme

Google Tensor için LiteRT arka ucunu yükleme

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

Kalan paketleri yükleme

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

Önemli: Colab veya Jupyter not defteri kullanıyorsanız:

• Yükleme tamamlandıktan sonra Colab çalışma zamanını yeniden başlatın.
• Yüklenen paketlerin doğru şekilde yansıtılması için menü çubuğundan Çalışma zamanı > Oturumu yeniden başlat'ı tıklayarak Colab'in çalışma zamanını yeniden başlatın. Yeniden başlatma işlemi yalnızca tüm yüklemeler tamamlandıktan sonra yapılmalıdır.
• Çalışma zamanını yeniden başlattıktan sonra yalnızca aşağıdaki komutları çalıştırın . Önceki komutları tekrar çalıştırmanız gerekmez.

4. Tüm kitaplıkları içe aktarın.

Yükleme tamamlandıktan sonra ana yürütmeye geçin.

Öneri: Bu ve sonraki bölümler için Jupyter not defteri kullanın veya komutları bir Python komut dosyasına ekleyin.

Gerekli paketleri içe aktarın:

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

Not: ai-edge-litert-nightly yerine kararlı sürüm paketi ai-edge-litert kullanıyorsanız bu ortam değişkenini tüm içe aktarma ifadelerinden önce (komut dosyasının her çalıştırılması için) ayarlamanız gerekir: GOOGLE_TENSOR_BACKEND_ENABLED=1. Aynı işlem için Python kod snippet'i:

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

VEYA (kabuk)

export GOOGLE_TENSOR_BACKEND_ENABLED=1

5. LiteRT modeli derleme

Bu bölümde, doğrudan LiteRT (TFLite) modeli derleme gibi gelişmiş kullanım alanları ele alınmaktadır.

TFLite modelinden EdgeTPU derlemesi

Bu adım için bir TFLite modeli gerekir. TFLite modeliniz yoksa modelinizi TFLite biçimine dönüştürün.

TFLite modelini alma

Bu kullanım alanında MediaPipe MultiClass Segmentation modelini kullanıyoruz.

TFLite modeli, MediaPipe Image segmentation sayfasında mevcuttur.

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 Python API'yi kullanarak TfLite modelini hızlıca doğrulama

Aşağıdaki örnekte hem maske görüntüsünü hem de karıştırılmış sonucu göreceksiniz.

# 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 derlemesiyle LiteRT modeline dönüştürün.

Modeli derlemek için ai_edge_litert.aot API'lerini kullanırız.

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

Derleme tamamlandığında tüm modelleri diske aktarmak için model.export yöntemini kullanın.

Varsayılan olarak, modeller çıkış dizininde düz bir yapıda saklanır ve her model adına arka uç kimliği eklenir.

Örneğin:

Modelin dosya adı	Arka uç	Çip üzerinde sistem (SoC)	Not
selfie_segmentation_fallback.tflite	CPU/GPU	Yok	Yok
selfie_segmentation_Google_Tensor_G3.tflite	Google	Tensor_G3	Google Tensor G3
selfie_segmentation_Google_Tensor_G4.tflite	Google	Tensor_G4	Google Tensor G4
selfie_segmentation_Google_Tensor_G5.tflite	Google	Tensor_G5	Google Tensor G5

6. CPU'da dışa aktarma ve doğrulama

Derleme tamamlandıktan sonra TFLite modelini CPU'da doğrulayın. Bunu, derleme sırasında oluşturulan "yedek model"i kullanarak yapın.

# 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()

7. PODAI için modelleri dışa aktarma

Modelleriniz doğrulandıktan sonraki önemli adım, bunları dağıtıma hazırlamaktır. Bu bölümde, derlenmiş modellerinizi Google Play'e yüklemek üzere nasıl paketleyeceğiniz ayrıntılı olarak açıklanmaktadır. Bu sayede, Google Play On-Device AI (PODAI) çerçevesi aracılığıyla kullanıcı cihazlarına teslimat yapılabilir.

AiEdgeLiteRT AOT (Ahead-of-Time) modülü, bu amaç için özel olarak ai_pack yardımcı programı sağlar. Bu yardımcı programlar, önemli bir veri varlığı olan Yapay Zeka Paketi oluşturur. Yapay Zeka Paketi, derlenmiş modellerinizi cihaz hedefleme yapılandırmalarıyla birlikte paketleyerek doğru modellerin ve öğelerin uygun kullanıcı cihazlarına teslim edilmesini sağlar. Bu, özellikle NPU (Sinir Ağı İşleme Birimi) derlemeleri için çok önemlidir. Çünkü belirli bir çip üzerinde sistem (SoC) için optimize edilmiş modellerin yalnızca bu SoC ile donatılmış cihazlara ulaşmasını sağlar.

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

Yapay zeka paketi kaynağını inceleme

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)

8. Gelişmiş seçenekleri yapılandırma

Belirli bir cihaz veya EdgeTPU için NPU derlemesi

Varsayılan olarak, LiteRT AOT derlemesi tüm kayıtlı arka uçlara derlenir. Yerel geliştirme için yalnızca geliştirme telefonları gibi belirli cihazlar için derleme yapmak isteyebilirsiniz. Derleme hedeflerini açıkça belirterek bunu sağlayabilirsiniz.

Aşağıdaki örnek, Google Tensor G5'te derlenir.

# 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 için derleme işaretleri

Derleme işaretleri aracılığıyla derleme sürecini özelleştirin. Burada şu işaret kullanılır: google_tensor_truncation_type="half"

TFLite modeli derlenirken

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

9. Sonraki adımlar

Tebrikler!

Modelleriniz PODAI tarafından tüketilmeye hazır.

Şimdi aşağıdaki adımlar için Android Studio'ya geçin. Ayrıntılar için LiteRT görüntü segmentasyonu örnekleri bölümüne bakın.