LiteRT Accelerator Test Suite (ATS)

LiteRT Accelerator Test Suite (ATS) adalah alat komprehensif yang digunakan untuk memvalidasi kebenaran fungsional dan mengukur performa implementasi akselerator kustom yang terintegrasi dengan framework LiteRT.

Ringkasan dan Fungsi Inti

Fungsi utama ATS adalah menjalankan model machine learning yang telah ditentukan sebelumnya terhadap akselerator target dan membandingkan hasilnya dengan backend CPU standar LiteRT.

• Validasi: Suite ini melakukan validasi numerik dengan membandingkan tensor output (aktivasi) yang dihasilkan oleh akselerator dengan tensor yang dihasilkan oleh backend CPU yang berfungsi dengan baik. Hal ini memastikan penerapan akselerator mempertahankan presisi dan kebenaran yang diperlukan.
• Metrik Performa: Metrik ini otomatis mengambil dan merekam detail performa penting, termasuk latensi dan metrik relevan lainnya, yang tersedia bagi pengguna.
• Eksekusi: Pengujian biasanya dijalankan di perangkat target (misalnya, ponsel Android) dan dikelola oleh wrapper skrip shell yang menangani transfer file dan penyiapan menggunakan alat adb (Android Debug Bridge).

Data Pengujian (Model)

Rangkaian ATS menggunakan kumpulan model .tflite yang banyak digunakan sebagai data pengujiannya. Data input dibuat secara acak berdasarkan jenis data dan dapat di-seed sesuai kebutuhan.

Model yang Disertakan

Model berikut disertakan dan didownload secara otomatis untuk pengujian (dapat berubah):

• hf_all_minilm_l6_v2
• hf_mobilevit_small
• qai_hub_midas
• qai_hub_real_esrgan_x4plus
• torchvision_mobilenet_v2
• torchvision_resnet18
• torchvision_squeezenet1_1
• u2net_lite
• whisper_tiny_decoder
• whisper_tiny_encoder
• yamnet
• yolo11n

Pengambilan Model Manual

Meskipun model didownload secara otomatis selama bazel run, Anda dapat mengambil seluruh set model secara manual menggunakan wget:

wget -p -O <target_file> https://storage.googleapis.com/litert/ats_models.tar.gz

Menentukan Kumpulan ATS dengan Bazel

Gunakan makro Bazel litert_define_ats untuk mengonfigurasi dan menentukan target pengujian ATS khusus untuk akselerator mereka.

Makro akan otomatis membuat dua target yang dapat dijalankan:

1. Pengujian JIT di perangkat standar (untuk eksekusi dan validasi).
2. Pengujian mode AOT "compile only" khusus (untuk kompilasi host).

Contoh Penggunaan litert_define_ats

Contoh ini menentukan rangkaian ATS bernama example_ats untuk akselerator dengan nama backend example:

# Emits aot-mode and jit-mode test targets, one for running compilation test on host
# and another for running JIT and inference on device
# These targets are named with their respective suffix attribute.
litert_define_ats(
    name = "example_ats",
    backend = "example",
    compile_only_suffix = "_aot",
    do_register = [
        "*mobilenet*",
    ],
    extra_flags = ["--limit=1"],
    jit_suffix = "",
)

Eksekusi

Untuk menjalankan pengujian standar yang ditujukan untuk Android (yang menangani semua operasi adb):

# Handles environment setup, and build + push of library and data dependencies to the device,
# executes the suite on the target.
bazel run -c opt --config=android_arm64 :example_ats

Untuk menjalankan pengujian kompilasi AOT:

# Handle environment setup, and builds library dependencies for host platform.
# Executes the ats compile only flow. The "--compile_mode" flag is already
# bound to the program arguments.
bazel run :example_ats_aot

Eksekusi Linux (Host)

Untuk eksekusi Linux, jika ATS dijalankan di mesin yang sama yang melakukan build, pengguna harus menggunakan biner :ats secara langsung:

bazel run -c opt :ats

Eksekusi IoT

Untuk eksekusi IoT, pengguna harus membuat biner di host dan mendorongnya ke perangkat secara manual.

Tanda Command Line

Dapat dieksekusi ats menerima beberapa tanda untuk kontrol terperinci atas pengujian dan pelaporan.

Menggunakan utilitas build litert_device_script untuk ATS

Target ATS yang dijalankan pengguna secara otomatis mencakup titik entri shell yang menangani semua penyiapan lingkungan, dan setiap pengiriman library yang diperlukan saat perangkat target berbeda dengan host tempat build diselesaikan (misalnya, adb push).

Fungsi ini disediakan secara umum melalui utilitas litert_device_script yang digunakan ATS di balik layar. Ada proses pendaftaran yang harus dilakukan akselerator untuk mengakses fungsi build ini. Selain mendukung ats, utilitas ini dapat digunakan secara mandiri untuk menyimulasikan cc_binary dan cc_test yang dimaksudkan untuk dieksekusi di perangkat yang berbeda dari host build yang memerlukan dependensi yang didorong.

Pendaftaran Backend

Untuk mengaktifkan akselerator baru agar dapat digunakan dengan litert_device_script (dan oleh karena itu ATS), library yang diperlukan harus didaftarkan dalam file Bazel litert_device_common.bzl. Pendaftaran didasarkan pada "backend" name unik yang dipetakan ke serangkaian library yang dapat dibangun atau telah dikompilasi sebelumnya yang diperlukan agar LiteRT dapat beroperasi dengan akselerator tersebut.

Langkah-Langkah Pendaftaran

1. Tentukan fungsi BackendSpec: Buat fungsi yang menampilkan kamus yang berisi spesifikasi akselerator baru Anda.

2. Tentukan Library (libs): Ini adalah daftar tuple yang menjelaskan jalur target Bazel untuk library bersama dan variabel lingkungan (LD_LIBRARY_PATH) yang diperlukan agar linker perangkat dapat menemukannya.

   • Dispatch Library: Diperlukan untuk eksekusi runtime.
   • Library Plugin Compiler: Diperlukan untuk mode kompilasi AOT.

3. Tentukan Nama Library (plugin, dispatch): Berikan nama file plugin dan library pengiriman.

4. Daftarkan Spesifikasi: Gabungkan fungsi spesifikasi baru Anda ke dalam fungsi _Specs utama agar tersedia berdasarkan ID backend uniknya.

Contoh Pendaftaran (_ExampleSpec)

Kode berikut dari litert_device_common.bzl mengilustrasikan cara mendaftarkan akselerator "example":

def _ExampleSpec():
    return {
        # The unique backend ID
        "example": BackendSpec(
            id = "example",
            libs = [
                # Dispatch Library and how to find it on device
                ("//third_party/odml/litert/litert/vendors/examples:libLiteRtDispatch_Example.so", "LD_LIBRARY_PATH"),
                # Compiler Plugin Library
                ("//third_party/odml/litert/litert/vendors/examples:libLiteRtCompilerPlugin_Example.so", "LD_LIBRARY_PATH"),
            ],
            plugin = "libLiteRtCompilerPlugin_Example.so",
            dispatch = "libLiteRtDispatch_Example.so",
        ),
    }

# ... (Other specs are defined here)

def _Specs(name):
    # Your new spec function must be included here
    return (_QualcommSpec() | _GoogleTensorSpec() | _MediatekSpec() | _CpuSpec() | _GpuSpec() | _ExampleSpec())[name]

Memanfaatkan Pendaftaran dengan litert_device_exec

Setelah terdaftar, gunakan litert_device_exec dan makro terkait dengan backend_id baru. Makro ini secara otomatis menggabungkan library yang diperlukan dan file data yang ditentukan dengan biner target.

cc_binary(
    name = "example_bin",
    srcs = ["example_bin.cc"],
)

litert_device_exec(
    name = "example_bin_device",
    backend_id = "example",  # Uses the libraries registered under "example"
    data = [
        "//third_party/odml/litert/litert/test:testdata/constant_output_tensor.tflite",
    ],
    target = ":example_bin",
)

Menjalankan target ini (bazel run ... :example_bin_device) akan:

1. Buat biner C++ example_bin.
2. Kirim file biner, libLiteRtDispatch_Example.so, libLiteRtCompilerPlugin_Example.so, dan .tflite ke perangkat.
3. Jalankan biner menggunakan adb shell.

Catatan tentang Jalur Perangkat: Lokasi kanonis untuk file di perangkat mencerminkan hierarki runfile Bazel, khususnya /data/local/tmp/runfiles/runfiles_relative_path. Skrip perangkat secara otomatis menangani penetapan jalur yang sesuai untuk penaut dinamis.

Mode Kompilasi (AOT)

Untuk akselerator yang mendukung langkah kompilasi Ahead-of-Time (AOT), ATS dapat dieksekusi dalam "mode kompilasi" khusus.

• Tujuan: Mode ini dirancang untuk dijalankan di workstation (mesin host), bukan perangkat target. Model ini mengompilasi model untuk hardware target yang ditentukan tanpa menjalankannya.
• Output: Semua model yang dikompilasi akan di-output ke direktori yang ditentukan di workstation.
• Aktivasi: Makro build ATS akan memancarkan target tertentu untuk AOT tempat library dibangun untuk platform host. Alur ini dapat diaktifkan di biner apa pun dengan tanda --compile_mode, tetapi secara otomatis terikat ke argumen build aot.

Pengembangan di Masa Mendatang

Rangkaian ini direncanakan akan diperluas untuk menyertakan pengujian khusus untuk operasi (ops) tunggal, selain model lengkap.