Halaman ini diterjemahkan oleh Cloud Translation API.

Kompatibilitas StableHLO

StableHLO adalah operasi komputasi ML yang kompatibel dengan versi lama yang terinspirasi oleh HLO/MHLO. Dokumen ini menjelaskan jenis dan tingkat jaminan kompatibilitas yang diberikan StableHLO, berdasarkan proses yang ditetapkan dalam RFC kompatibilitas.

Versions

Versi StableHLO saat ini dapat ditemukan di Version.h.

Dalam seri 0.x.x, versi minor ditambahkan setiap kali terjadi perubahan pada opset StableHLO atau format serialisasi StableHLO yang dibuat, dan versi patch akan ditambahkan setiap kali kami mengintegrasikan downstream StableHLO, yaitu ke repositori openxla/xla.

Jaminan

Kompatibilitas mundur selama 6 bulan: Artefak portabel yang diserialisasi oleh libStablehlo versi lama memiliki semantik yang sama* saat di-deserialisasi dengan versi baru libStablehlo jika versi tersebut dibuat dari commit openxla/stablehlo dengan selang waktu kurang dari 6 bulan.

Kompatibilitas dengan versi baru selama 1 bulan: Artefak portabel yang diserialisasi oleh versi baru libStablehlo memiliki semantik yang sama* saat di-deserialisasi oleh versi lama libStablehlo jika versi ini dibuat dari commit openxla/stablehlo dengan selisih kurang dari 1 bulan, kecuali jika program menggunakan fitur baru yang diperkenalkan sejak versi lama.

* Program StableHLO dikonversi ke/dari artefak portabel melalui API kompatibilitas, dan semantik program ini ditentukan oleh spesifikasi StableHLO. Lihat bagian "Di luar cakupan" untuk melihat contoh hal yang tidak tercakup dalam definisi kompatibilitas ini.

API

Artefak portabel dapat dibuat menggunakan alat stablehlo-translate, atau langsung di C++ atau Python API. Serialisasi memerlukan versi target StableHLO untuk menulis artefak yang ditulis dalam format #.#.# (Lihat Version.h untuk versi saat ini). Deserialisasi menggunakan versi StableHLO saat ini untuk membaca artefak.

`stablehlo-translate`

Ini adalah cara termudah untuk membuat dan membaca artefak portabel.

# Write a StableHLO program to a portable artifact
$ stablehlo-translate --serialize file.mlir --target=0.9.0 > portable_artifact.mlir.bc

# Read StableHLO portable artifact
$ stablehlo-translate --deserialize portable_artifact.mlir.bc

C++

Untuk alur kerja terprogram, StableHLO menyediakan API kompatibilitas berikut:

// From: #include "stablehlo/api/PortableApi.h"

// Get the current StableHLO version.
//
// This value can be used as the `targetVersion` argument to
// `serializePortableArtifact`.
std::string getCurrentVersion();

// Get the minimum supported StableHLO version.
//
// This value can be used as the `targetVersion` argument to
// `serializePortableArtifact`.
std::string getMinimumVersion();

// From: #include "stablehlo/dialect/Serialization.h"

// Write a StableHLO program to a portable artifact
// Writes a stable payload for `module` to `os`. If compatibility with a
// previous version of StableHLO is required, provide the required version
// string `#.#.#` for `targetVersion`.
//
// Can fail if `module` cannot be expressed in the `targetVersion` version of
// StableHLO, e.g. if it's using new or removed features, or if it involves
// unsupported dialects.
LogicalResult serializePortableArtifact(ModuleOp module,
                                        StringRef targetVersion,
                                        raw_ostream& os);

// Read StableHLO portable artifact
//
// Can fail if `sourceStr` cannot be expressed in the current version of
// StableHLO, e.g. if it's using incompatible features. Returns nullptr if
// `sourceStr` is invalid or fails to deserialize.
OwningOpRef<ModuleOp> deserializePortableArtifact(StringRef sourceStr,
                                                  MLIRContext* context);

Lihat stablehlo/api/PortableApi.h dan stablehlo/dialect/Serialization.h untuk API lengkap.

Lihat StablehloTranslateMain.cpp untuk mengetahui contoh penggunaan API ini.

Python

StableHLO juga menyediakan binding Python ke API kompatibilitas C++:

def get_current_version() -> str: ...
def get_minimum_version() -> str: ...
def serialize_portable_artifact(module: ir.Module, target_version: str) -> bytes: ...
def serialize_portable_artifact(module: str, target_version: str) -> bytes: ...
def deserialize_portable_artifact(context: ir.Context, artifact: bytes) -> ir.Module: ...
def deserialize_portable_artifact(artifact: bytes) -> str: ...

Lihat StablehloModule.cpp untuk Python API selengkapnya.

Lihat stablehlo.py > test_serialization_apis untuk mengetahui contoh bolak-balik penggunaan Python Serialization API.

Pengujian

Kami memiliki suite kompatibilitas dalam stablehlo/tests yang melibatkan ringkasan komprehensif operasi StableHLO yang diserialisasi untuk semua versi StableHLO yang didukung. Untuk setiap permintaan pull, kami menguji kompatibilitas mundur dan maju - yaitu bahwa suite ini dapat dideserialisasi penargetan HEAD (kompatibilitas mundur), bahwa ringkasan dapat diserialisasi dengan menargetkan semua versi StableHLO yang didukung (kompatibilitas maju), dan bahwa hasilnya secara sintaksis identik dengan program StableHLO asli.

Pekerjaan di masa mendatang

Membuat suite kompatibilitas di MLIR upstream: Dengan menggunakan pembelajaran dari menetapkan dan mempertahankan jaminan StableHLO, kami berencana untuk memberikan rangkaian kompatibilitas ke upstream MLIR guna memberikan deteksi awal untuk kerusakan kompatibilitas yang tidak disengaja dalam infrastruktur bytecode MLIR (#1632).

Gunakan implementasi referensi: Saat ini, pengujian kompatibilitas terdiri dari deserialisasi suite kompatibilitas yang diserialisasi oleh versi lama libStablehlo dan memastikan bahwa deserialisasi menghasilkan program yang identik secara sintaksis. Kami juga berencana untuk menggunakan implementasi referensi dalam pengujian ini, melonggarkan persyaratan identitas sintaksis yang terlalu berat dan menguji penerapan referensi secara komprehensif (#1245).

Di luar cakupan

Artefak non-portabel: Jaminan kompatibilitas hanya diberikan untuk artefak portabel yang dibuat dengan cara yang sangat spesifik. Jenis artefak lainnya, misalnya representasi yang cukup bagus dari dialek StableHLO atau bahkan representasi bytecode dari dialek StableHLO, tidak memiliki jaminan kompatibilitas.

Fitur yang tidak spesifik: Kami dapat membuat perubahan yang tidak kompatibel pada fitur yang secara historis didukung dalam program StableHLO tetapi belum menjadi bagian dari spesifikasi StableHLO, misalnya, kami tidak memberikan jaminan kompatibilitas untuk atribut yang tidak terdaftar.

Kompatibilitas bug: Kami dapat membuat perubahan yang tidak kompatibel jika implementasi di libStablehlo bertentangan dengan spesifikasi StableHLO, misalnya jika definisi dalam dialek VHLO salah, atau jika pemverifikasi dalam dialek StableHLO tidak cocok dengan spesifikasi.

Akurasi numerik: StableHLO memiliki beberapa operasi yang memiliki akurasi yang ditentukan implementasi untuk seluruh konsumen dan bahkan dalam konsumen yang sama di seluruh versi. Hasilnya, StableHLO tidak bertujuan untuk memberikan jaminan tentang akurasi numerik, meskipun hal ini dapat berubah pada masa mendatang (#1156).

Kompatibilitas sumber untuk API C, C++, dan Python dalam libStablehlo merupakan tujuan aspiratif. Saat ini, kami tidak menawarkan jaminan kompatibilitas sumber, tetapi harap beri tahu kami jika ini adalah kasus penggunaan yang penting bagi Anda, dan kita dapat berdiskusi untuk mendukungnya (#1247).